Forces and deflection along a member

const at = (x) => {
  const S = [-end[0], -end[1], -end[2]];
  const Ms = [-end[3], -(end[4] + x * end[2]), -(end[5] - x * end[1])];
  for (const pz of loads) {
    const c = pz.comp;
    const force = (s, q) => {   // q along local axis c at s ≤ x; r = (s − x, 0, 0)
      S[c] -= q;
      if (c === 1) Ms[2] -= (s - x) * q;
      else if (c === 2) Ms[1] += (s - x) * q;
    };
    if (pz.kind === 'point') { if (pz.a < x - 1e-9 || (pz.a <= x + 1e-9 && x >= L - 1e-9)) force(pz.a, pz.P); continue; }
    const a = pz.a, b = Math.min(pz.b, x);
    if (b <= a) continue;
    const h = (b - a) / 2;
    for (const [g, wt] of GAUSS4) { const s = a + h * (g + 1); force(s, (pz.w1 + (pz.w2 - pz.w1) * (s - pz.a) / (pz.b - pz.a)) * wt * h); }
  }
  return { N: S[0], Vy: S[1], Vz: S[2], T: Ms[0], My: -Ms[1], Mz: Ms[2], MSy: Ms[1], MSz: Ms[2] };
};

const nf = Math.max(8, n) * 16;
const xs = Array.from({ length: nf + 1 }, (_, k) => L * k / nf);
const acts = xs.map(at);
const integrate2 = (kappa) => { const th = [0], d = [0]; for (let k = 1; k <= nf; k++) { th.push(th[k - 1] + (kappa[k - 1] + kappa[k]) / 2 * (L / nf)); d.push(d[k - 1] + (th[k - 1] + th[k]) / 2 * (L / nf)); } return d; };
const integrate1 = (f) => { const d = [0]; for (let k = 1; k <= nf; k++) d.push(d[k - 1] + (f[k - 1] + f[k]) / 2 * (L / nf)); return d; };
const loc = (nd) => {
  const u = R.u.subarray(6 * nd, 6 * nd + 6), T = e.T;
  return [0, 1, 2].map((a) => T[a * 3] * u[0] + T[a * 3 + 1] * u[1] + T[a * 3 + 2] * u[2])
    .concat([0, 1, 2].map((a) => T[a * 3] * u[3] + T[a * 3 + 1] * u[4] + T[a * 3 + 2] * u[5]));
};
const ui = loc(e.i), uj = loc(e.j);
const dv = integrate2(acts.map((a) => a.MSz / (e.E * e.Iz)));
const dw = integrate2(acts.map((a) => -a.MSy / (e.E * e.Iy)));
const du = integrate1(acts.map((a) => a.N / (e.E * e.A)));
const fit = (d, a, b) => (k) => { const x = xs[k]; return a + (b - a - d[nf]) * x / L + d[k]; };
const vF = fit(dv, ui[1], uj[1]), wF = fit(dw, ui[2], uj[2]), uF = fit(du, ui[0], uj[0]);

for (let k = 0; k <= nf; k += nf / n) {
  const a = acts[k], x = xs[k];
  out.x.push(x); out.N.push(a.N); out.Vy.push(a.Vy); out.Vz.push(a.Vz); out.T.push(a.T); out.My.push(a.My); out.Mz.push(a.Mz);
  out.dx.push(uF(k)); out.dy.push(vF(k)); out.dz.push(wF(k));
  const rv = dv[k] - dv[nf] * x / L, rw = dw[k] - dw[nf] * x / L;
  out.rel.push(Math.hypot(rv, rw));
}

/** Largest and smallest of each action along a member, and its largest deflection off the chord. */
export function memberExtremes(prep, R, m, n = 40) {
  const d = diagram(prep, R, m, n);
  const ext = {};
  for (const key of ['N', 'Vy', 'Vz', 'T', 'My', 'Mz']) {
    let max = -Infinity, min = Infinity, xMax = 0, xMin = 0;
    d[key].forEach((v, k) => { if (v > max) { max = v; xMax = d.x[k]; } if (v < min) { min = v; xMin = d.x[k]; } });
    ext[key] = { max, min, xMax, xMin, abs: Math.max(Math.abs(max), Math.abs(min)) };
  }
  let v = 0, xv = 0;
  d.rel.forEach((r, k) => { if (r > v) { v = r; xv = d.x[k]; } });
  const L = prep.mem[m].ax.L;
  ext.defl = { value: v, x: xv, ratio: v > 1e-12 ? L / v : Infinity };
  return ext;
}