Type Alias Vector 

pub type Vector<T, const N: usize> = Matrix<T, 1, N>;

A row vector (1×N matrix).

Vectors support single-index access (v[i]), dot products, norms, and cross products (3-element vectors). Use ColumnVector for column vectors.

Examples

use numeris::Vector;

let v = Vector::from_array([3.0_f64, 4.0]);
assert_eq!(v[0], 3.0);
assert_eq!(v.dot(&v), 25.0);
assert!((v.norm() - 5.0).abs() < 1e-12);

Aliased Type

pub struct Vector<T, const N: usize> { /* private fields */ }

Implementations

impl<T: Scalar, const N: usize> Vector<T, N>

pub fn head<const P: usize>(&self) -> Vector<T, P>

Extract the first P elements.

use numeris::Vector;
let v = Vector::from_array([10, 20, 30, 40, 50]);
let h: Vector<i32, 3> = v.head();
assert_eq!(h[0], 10);
assert_eq!(h[2], 30);

pub fn tail<const P: usize>(&self) -> Vector<T, P>

Extract the last P elements.

use numeris::Vector;
let v = Vector::from_array([10, 20, 30, 40, 50]);
let t: Vector<i32, 2> = v.tail();
assert_eq!(t[0], 40);
assert_eq!(t[1], 50);

pub fn segment<const P: usize>(&self, i: usize) -> Vector<T, P>

Extract P elements starting at index i.

impl<T: Scalar, const N: usize> Vector<T, N>

pub fn norm_squared(&self) -> T

Squared L2 norm (dot product with self). No sqrt, works with integers.

use numeris::Vector;
let v = Vector::from_array([3.0, 4.0]);
assert_eq!(v.norm_squared(), 25.0);

let vi = Vector::from_array([3, 4]);
assert_eq!(vi.norm_squared(), 25);

impl<T: LinalgScalar, const N: usize> Vector<T, N>

pub fn norm(&self) -> T::Real

L2 (Euclidean) norm.

For complex vectors, this is sqrt(sum(|x_i|^2)).

use numeris::Vector;
let v = Vector::from_array([3.0_f64, 4.0]);
assert!((v.norm() - 5.0).abs() < 1e-12);

pub fn norm_l1(&self) -> T::Real

L1 norm (sum of absolute values / moduli).

use numeris::Vector;
let v = Vector::from_array([1.0_f64, -2.0, 3.0]);
assert!((v.norm_l1() - 6.0).abs() < 1e-12);

pub fn normalize(&self) -> Self

Return a unit vector in the same direction.

Panics if the norm is zero.

use numeris::Vector;
let v = Vector::from_array([3.0_f64, 4.0]);
let u = v.normalize();
assert!((u.norm() - 1.0).abs() < 1e-12);
assert!((u[0] - 0.6).abs() < 1e-12);

impl<T: FloatScalar, const N: usize> Vector<T, N>

pub fn scaled_norm(&self) -> T

Scaled norm: norm() / sqrt(N).

Makes the error metric independent of state dimension, used by ODE solvers for step size control.

use numeris::Vector;
let v = Vector::from_array([3.0_f64, 4.0]);
let sn = v.scaled_norm();
assert!((sn - 5.0 / 2.0_f64.sqrt()).abs() < 1e-12);

impl<T: Scalar, const N: usize> Vector<T, N>

pub fn from_array(data: [T; N]) -> Self

Create a vector from a 1D array.

use numeris::Vector;
let v = Vector::from_array([1.0, 2.0, 3.0]);
assert_eq!(v[0], 1.0);

Examples found in repository

docs/examples/gen_plots.rs (line 149)

fn make_ode_plot() -> String {
    let tau = 4.0 * PI;
    let y0 = Vector::from_array([1.0_f64, 0.0]);
    let settings = AdaptiveSettings {
        dense_output: true,
        ..AdaptiveSettings::default()
    };
    let sol = RKTS54::integrate(
        0.0,
        tau,
        &y0,
        |_t, y| Vector::from_array([y[1], -y[0]]),
        &settings,
    )
    .expect("ODE integration failed");

    const N: usize = 300;
    let mut t = vec![0.0; N];
    let mut x = vec![0.0; N];
    let mut v = vec![0.0; N];
    for i in 0..N {
        let ti = tau * i as f64 / (N - 1) as f64;
        let yi = RKTS54::interpolate(ti, &sol).unwrap();
        t[i] = ti;
        x[i] = yi[0];
        v[i] = yi[1];
    }

    let traces = format!(
        "[{{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"position x(t)\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"velocity v(t)\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5,\"dash\":\"dash\"}}}}]",
        fmt_arr(&t),
        fmt_arr(&x),
        fmt_arr(&t),
        fmt_arr(&v),
    );

    let layout = decorate_layout(
        "Harmonic Oscillator — RKTS54 Dense Output",
        "t",
        "Value",
        "",
    );

    plotly_snippet("plot-ode", &traces, &layout, 420)
}

// ─── Interpolation plot ───────────────────────────────────────────────────

fn make_interp_plot() -> String {
    let tau = 2.0 * PI;
    let kx: [f64; 6] = core::array::from_fn(|i| tau * i as f64 / 5.0);
    let ky: [f64; 6] = core::array::from_fn(|i| kx[i].sin());
    let kd: [f64; 6] = core::array::from_fn(|i| kx[i].cos());

    let linear = LinearInterp::new(kx, ky).unwrap();
    let hermite = HermiteInterp::new(kx, ky, kd).unwrap();
    let lagrange = LagrangeInterp::new(kx, ky).unwrap();
    let spline = CubicSpline::new(kx, ky).unwrap();

    const N: usize = 200;
    let mut xv = vec![0.0; N];
    let mut y_true = vec![0.0; N];
    let mut y_lin = vec![0.0; N];
    let mut y_her = vec![0.0; N];
    let mut y_lag = vec![0.0; N];
    let mut y_spl = vec![0.0; N];
    for i in 0..N {
        let xi = tau * i as f64 / (N - 1) as f64;
        xv[i] = xi;
        y_true[i] = xi.sin();
        y_lin[i] = linear.eval(xi);
        y_her[i] = hermite.eval(xi);
        y_lag[i] = lagrange.eval(xi);
        y_spl[i] = spline.eval(xi);
    }

    let traces = format!(
        "[{{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"sin(x) exact\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5,\"color\":\"rgba(120,120,120,0.6)\",\"dash\":\"dot\"}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"Linear\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"Hermite\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"Lagrange\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"Cubic Spline\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2}}}},\
         {{\"type\":\"scatter\",\"mode\":\"markers\",\"name\":\"knots\",\
          \"x\":{},\"y\":{},\"marker\":{{\"size\":9,\"color\":\"black\",\"symbol\":\"diamond\"}}}}]",
        fmt_arr(&xv), fmt_arr(&y_true),
        fmt_arr(&xv), fmt_arr(&y_lin),
        fmt_arr(&xv), fmt_arr(&y_her),
        fmt_arr(&xv), fmt_arr(&y_lag),
        fmt_arr(&xv), fmt_arr(&y_spl),
        fmt_arr(&kx), fmt_arr(&ky),
    );

    let layout = decorate_layout(
        "Interpolation Methods on sin(x) — 6 Knots",
        "x",
        "y",
        "",
    );

    plotly_snippet("plot-interp", &traces, &layout, 440)
}

// ─── Control: Butterworth frequency response ──────────────────────────────

fn biquad_cascade_freq_response<const N: usize>(
    cascade: &BiquadCascade<f64, N>,
    freq: f64,
    fs: f64,
) -> f64 {
    let omega = 2.0 * PI * freq / fs;
    let (sin_w, cos_w) = omega.sin_cos();
    let cos_2w = 2.0 * cos_w * cos_w - 1.0;
    let sin_2w = 2.0 * sin_w * cos_w;

    let mut mag_sq = 1.0;
    for section in &cascade.sections {
        let (b, a) = section.coefficients();
        let nr = b[0] + b[1] * cos_w + b[2] * cos_2w;
        let ni = -b[1] * sin_w - b[2] * sin_2w;
        let dr = a[0] + a[1] * cos_w + a[2] * cos_2w;
        let di = -a[1] * sin_w - a[2] * sin_2w;
        mag_sq *= (nr * nr + ni * ni) / (dr * dr + di * di);
    }
    mag_sq.sqrt()
}

fn make_control_plot() -> String {
    let fs = 8000.0;
    let fc = 1000.0;

    let bw2: BiquadCascade<f64, 1> = butterworth_lowpass(2, fc, fs).unwrap();
    let bw4: BiquadCascade<f64, 2> = butterworth_lowpass(4, fc, fs).unwrap();
    let bw6: BiquadCascade<f64, 3> = butterworth_lowpass(6, fc, fs).unwrap();

    const N: usize = 500;
    let mut freqs = vec![0.0; N];
    let mut db2 = vec![0.0; N];
    let mut db4 = vec![0.0; N];
    let mut db6 = vec![0.0; N];

    let f_min: f64 = 10.0;
    let f_max: f64 = 3900.0;
    for i in 0..N {
        let f = f_min * (f_max / f_min).powf(i as f64 / (N - 1) as f64);
        freqs[i] = f;
        db2[i] = 20.0 * biquad_cascade_freq_response(&bw2, f, fs).log10();
        db4[i] = 20.0 * biquad_cascade_freq_response(&bw4, f, fs).log10();
        db6[i] = 20.0 * biquad_cascade_freq_response(&bw6, f, fs).log10();
    }

    let traces = format!(
        "[{{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"2nd order\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"4th order\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"6th order\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5}}}}]",
        fmt_arr(&freqs), fmt_arr(&db2),
        fmt_arr(&freqs), fmt_arr(&db4),
        fmt_arr(&freqs), fmt_arr(&db6),
    );

    let layout = decorate_layout_ex(
        "Butterworth Lowpass — f<sub>c</sub> = 1 kHz, f<sub>s</sub> = 8 kHz",
        "Frequency (Hz)",
        ",\"type\":\"log\"",
        "Magnitude (dB)",
        ",\"range\":[-80,5]",
        &format!(
            ",\"shapes\":[{{\"type\":\"line\",\"x0\":{f_min},\"x1\":{f_max},\
             \"y0\":-3,\"y1\":-3,\"line\":{{\"dash\":\"dot\",\"color\":\"rgba(160,80,80,0.5)\",\"width\":1.5}}}}]"
        ),
    );

    plotly_snippet("plot-control", &traces, &layout, 420)
}

// ─── Control: Lead/Lag compensator Bode ───────────────────────────────────

fn biquad_freq_response(b: &[f64; 3], a: &[f64; 3], freq: f64, fs: f64) -> (f64, f64) {
    let omega = 2.0 * PI * freq / fs;
    let (sin_w, cos_w) = omega.sin_cos();
    let cos_2w = 2.0 * cos_w * cos_w - 1.0;
    let sin_2w = 2.0 * sin_w * cos_w;
    let nr = b[0] + b[1] * cos_w + b[2] * cos_2w;
    let ni = -b[1] * sin_w - b[2] * sin_2w;
    let dr = a[0] + a[1] * cos_w + a[2] * cos_2w;
    let di = -a[1] * sin_w - a[2] * sin_2w;
    let mag = ((nr * nr + ni * ni) / (dr * dr + di * di)).sqrt();
    let phase = (ni.atan2(nr) - di.atan2(dr)).to_degrees();
    (mag, phase)
}

fn make_lead_lag_plot() -> String {
    let fs = 1000.0;
    let lead = lead_compensator(std::f64::consts::FRAC_PI_4, 50.0, 1.0, fs).unwrap();
    let lag = lag_compensator(10.0, 5.0, fs).unwrap();

    let (b_lead, a_lead) = lead.coefficients();
    let (b_lag, a_lag) = lag.coefficients();

    const N: usize = 400;
    let f_min: f64 = 0.1;
    let f_max: f64 = 490.0;
    let mut freqs = vec![0.0; N];
    let mut lead_db = vec![0.0; N];
    let mut lead_ph = vec![0.0; N];
    let mut lag_db = vec![0.0; N];
    let mut lag_ph = vec![0.0; N];

    for i in 0..N {
        let f = f_min * (f_max / f_min).powf(i as f64 / (N - 1) as f64);
        freqs[i] = f;
        let (m, p) = biquad_freq_response(&b_lead, &a_lead, f, fs);
        lead_db[i] = 20.0 * m.log10();
        lead_ph[i] = p;
        let (m, p) = biquad_freq_response(&b_lag, &a_lag, f, fs);
        lag_db[i] = 20.0 * m.log10();
        lag_ph[i] = p;
    }

    // Magnitude plot
    let traces_mag = format!(
        "[{{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"Lead (45° @ 50 Hz)\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"Lag (10× DC @ 5 Hz)\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5}}}}]",
        fmt_arr(&freqs), fmt_arr(&lead_db),
        fmt_arr(&freqs), fmt_arr(&lag_db),
    );
    let layout_mag = decorate_layout_ex(
        "Lead / Lag Compensators — Magnitude",
        "Frequency (Hz)",
        ",\"type\":\"log\"",
        "Magnitude (dB)",
        "",
        "",
    );

    // Phase plot
    let traces_ph = format!(
        "[{{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"Lead phase\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5}}}},\
         {{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"Lag phase\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2.5}}}}]",
        fmt_arr(&freqs), fmt_arr(&lead_ph),
        fmt_arr(&freqs), fmt_arr(&lag_ph),
    );
    let layout_ph = decorate_layout_ex(
        "Lead / Lag Compensators — Phase",
        "Frequency (Hz)",
        ",\"type\":\"log\"",
        "Phase (°)",
        "",
        "",
    );

    let mut html = plotly_snippet("plot-lead-lag-mag", &traces_mag, &layout_mag, 380);
    html.push_str(&plotly_snippet(
        "plot-lead-lag-phase",
        &traces_ph,
        &layout_ph,
        380,
    ));
    html
}

// ─── ODE: Van der Pol (stiff, RODAS4) ─────────────────────────────────────

fn make_vanderpol_plot() -> String {
    let mu = 20.0_f64;
    let y0 = Vector::from_array([2.0, 0.0]);
    let t_end = 120.0;

    let settings = AdaptiveSettings {
        abs_tol: 1e-8,
        rel_tol: 1e-8,
        max_steps: 100_000,
        dense_output: true,
        ..AdaptiveSettings::default()
    };

    let sol = RODAS4::integrate(
        0.0,
        t_end,
        &y0,
        |_t, y| {
            Vector::from_array([y[1], mu * (1.0 - y[0] * y[0]) * y[1] - y[0]])
        },
        |_t, y| {
            numeris::Matrix::new([
                [0.0, 1.0],
                [-2.0 * mu * y[0] * y[1] - 1.0, mu * (1.0 - y[0] * y[0])],
            ])
        },
        &settings,
    )
    .expect("Van der Pol integration failed");

    // Downsample accepted step points to a fixed grid for a manageable HTML size.
    // The adaptive solver clusters points at sharp transitions; we keep enough
    // resolution by picking the nearest stored point for each output sample.
    let ds = sol.dense.as_ref().expect("no dense output");
    let n_out = 2000usize;
    let mut tv = Vec::with_capacity(n_out);
    let mut xv = Vec::with_capacity(n_out);
    let mut idx = 0usize;
    for i in 0..n_out {
        let t_want = t_end * i as f64 / (n_out - 1) as f64;
        // advance index to nearest stored point
        while idx + 1 < ds.t.len() && ds.t[idx + 1] <= t_want {
            idx += 1;
        }
        tv.push(t_want);
        xv.push(ds.y[idx][0]);
    }

    let traces = format!(
        "[{{\"type\":\"scatter\",\"mode\":\"lines\",\"name\":\"y₁(t)\",\
          \"x\":{},\"y\":{},\"line\":{{\"width\":2}}}}]",
        fmt_arr(&tv),
        fmt_arr(&xv),
    );

    let layout = decorate_layout(
        "Van der Pol Oscillator (μ = 20) — RODAS4",
        "t",
        "y₁",
        "",
    );

    plotly_snippet("plot-vanderpol", &traces, &layout, 420)
}

pub fn fill(value: T) -> Self

Create a vector filled with a single value.

pub const fn len(&self) -> usize

Number of elements.

pub fn dot(&self, rhs: &Self) -> T

Dot product of two vectors.

use numeris::Vector;
let a = Vector::from_array([1.0, 2.0, 3.0]);
let b = Vector::from_array([4.0, 5.0, 6.0]);
assert_eq!(a.dot(&b), 32.0); // 1*4 + 2*5 + 3*6

impl<T: Scalar, const N: usize> Vector<T, N>

pub fn outer<const P: usize>(&self, rhs: &Vector<T, P>) -> Matrix<T, N, P>

Outer product: v.outer(w) → N×P matrix where result[i][j] = v[i] * w[j].

use numeris::Vector;
let a = Vector::from_array([1.0, 2.0]);
let b = Vector::from_array([3.0, 4.0, 5.0]);
let m = a.outer(&b);
assert_eq!(m[(0, 0)], 3.0);  // 1*3
assert_eq!(m[(1, 2)], 10.0); // 2*5

Trait Implementations

impl<T, const N: usize> Index<usize> for Vector<T, N>

type Output = T

The returned type after indexing.

fn index(&self, i: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for Vector<T, N>

fn index_mut(&mut self, i: usize) -> &mut T

Performs the mutable indexing (container[index]) operation.