Struct Vector 

pub struct Vector<T> {
    pub vec: Vec<T>,
    pub norm: Option<T>,
}

Generic n-vectors used to represent a basis

Examples

use svp::{Vector, nvec};

// Build an integer vector
let u = Vector{ vec: vec![0i64; 3], norm: None};
let v = Vector{ vec: vec![0, 1, 0], norm: None};

// Shorthand notation
let u = nvec![0i64; 3];
let v = nvec![0, 1, 0];

Vector multiplication corresponds to the scalar product

use svp::{Vector, nvec};

let u = nvec![1, 0, 0];
let v = nvec![0, 1, 0];

assert_eq!(&u * &v, 0);

It can be useful to keep track of the squared norm

use svp::{Vector, nvec};

// Build an integer vector
let mut u = nvec![1, 0, 0];

// Compute the squared norm (inner product)
u.norm = Some(&u * &u);

assert_eq!(u.norm.unwrap(), 1);

As a special case, big integers can be used for arbitrary precision

use rug::Integer;
use svp::{Vector, nvec};

// Big Integers with gmp
let p = "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f";
let u = nvec![Integer::from_str_radix(p, 16).unwrap(); 3];

let v = nvec![Integer::new(), Integer::from(1), Integer::new()];
assert_eq!(&v * &v, Integer::from(1));

Fields

vec: Vec<T>

norm: Option<T>

Trait Implementations

impl<T: Clone> Clone for Vector<T>

fn clone(&self) -> Vector<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Vector<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl GaussReduce<Integer> for Vector<Integer>

fn reduce(&mut self, v: &Vector<Integer>) -> bool

GaussReduce with respect to v

impl GaussReduce<i64> for Vector<i64>

fn reduce(&mut self, v: &Vector<i64>) -> bool

GaussReduce with respect to v

impl Mul<&Vector<Float>> for &Lattice<Integer>

Right multiply basis matrix by a vector with arbitrary precision

type Output = Vector<Integer>

The resulting vector type of the matrix product

fn mul(self, _rhs: &Vector<Float>) -> Vector<Integer>

Compute the matrix product with v

impl Mul<&Vector<Float>> for &Vector<Integer>

type Output = Float

The resulting scalar type of the inner product

fn mul(self, _rhs: &Vector<Float>) -> Float

Compute the inner product of two arbitrary precision n-vectors

impl Mul<&Vector<Integer>> for &Lattice<Integer>

Right multiply basis matrix by a vector with arbitrary precision

type Output = Vector<Integer>

The resulting vector type of the matrix product

fn mul(self, _rhs: &Vector<Integer>) -> Vector<Integer>

Compute the matrix product with v

impl Mul<&Vector<f64>> for &Lattice<i64>

Right multiply basis matrix by a vector

type Output = Vector<i64>

The resulting vector type of the matrix product

fn mul(self, _rhs: &Vector<f64>) -> Vector<i64>

Compute the matrix product with v

impl Mul<&Vector<f64>> for &Vector<i64>

type Output = f64

The resulting scalar type of the inner product

fn mul(self, _rhs: &Vector<f64>) -> f64

Compute the (truncated) inner product of two n-vectors

impl Mul<&Vector<i64>> for &Lattice<i64>

Right multiply basis matrix by a vector

type Output = Vector<i64>

The resulting vector type of the matrix product

fn mul(self, _rhs: &Vector<i64>) -> Vector<i64>

Compute the matrix product with v

impl Mul for &Vector<Float>

type Output = Float

The resulting scalar type of the inner product

fn mul(self, _rhs: &Vector<Float>) -> Float

Compute the inner product of two arbitrary precision n-vectors

impl Mul for &Vector<Integer>

type Output = Integer

The resulting scalar type of the inner product

fn mul(self, _rhs: &Vector<Integer>) -> Integer

Compute the inner product of two arbitrary precision n-vectors

impl Mul for &Vector<f64>

type Output = f64

The resulting scalar type of the inner product

fn mul(self, _rhs: &Vector<f64>) -> f64

Compute the inner product of two n-vectors

impl Mul for &Vector<i64>

type Output = i64

The resulting scalar type of the inner product

fn mul(self, _rhs: &Vector<i64>) -> i64

Compute the inner product of two n-vectors