Struct Vector 

pub struct Vector<T> { /* private fields */ }

The Vector struct.

Can be instantiated with any type.

Implementations

impl<T> Vector<T>

pub fn new<U>(data: U) -> Vector<T>

where U: Into<Vec<T>>,

Constructor for Vector struct.

Requires the vector data.

Examples

use rulinalg::vector::Vector;

let vec = Vector::new(vec![1.0,2.0,3.0,4.0]);

Examples found in repository

examples/svm-sign_learner.rs (lines 26-29)

fn main() {
    println!("Sign learner sample:");

    println!("Training...");
    // Training data
    let inputs = Matrix::new(11, 1, vec![
                             -0.1, -2., -9., -101., -666.7,
                             0., 0.1, 1., 11., 99., 456.7
                             ]);
    let targets = Vector::new(vec![
                              -1., -1., -1., -1., -1.,
                              1., 1., 1., 1., 1., 1.
                              ]);

    // Trainee
    let mut svm_mod = SVM::new(HyperTan::new(100., 0.), 0.3);
    // Our train function returns a Result<(), E>
    svm_mod.train(&inputs, &targets).unwrap();

    println!("Evaluation...");
    let mut hits = 0;
    let mut misses = 0;
    // Evaluation
    //   Note: We could pass all input values at once to the `predict` method!
    //         Here, we use a loop just to count and print logs.
    for n in (-1000..1000).filter(|&x| x % 100 == 0) {
        let nf = n as f64;
        let input = Matrix::new(1, 1, vec![nf]);
        let out = svm_mod.predict(&input).unwrap();
        let res = if out[0] * nf > 0. {
            hits += 1;
            true
        } else if nf == 0. {
            hits += 1;
            true
        } else {
            misses += 1;
            false
        };

        println!("{} -> {}: {}", Matrix::data(&input)[0], out[0], res);
    }

    println!("Performance report:");
    println!("Hits: {}, Misses: {}", hits, misses);
    let hits_f = hits as f64;
    let total = (hits + misses) as f64;
    println!("Accuracy: {}", (hits_f / total) * 100.);
}

pub fn size(&self) -> usize

Returns the size of the Vector.

pub fn data(&self) -> &Vec<T>

Returns a non-mutable reference to the underlying data.

Examples found in repository

examples/k-means_generating_cluster.rs (line 72)

fn main() {
    println!("K-Means clustering example:");

    const SAMPLES_PER_CENTROID: usize = 2000;

    println!("Generating {0} samples from each centroids:",
             SAMPLES_PER_CENTROID);
    // Choose two cluster centers, at (-0.5, -0.5) and (0, 0.5).
    let centroids = Matrix::new(2, 2, vec![-0.5, -0.5, 0.0, 0.5]);
    println!("{}", centroids);

    // Generate some data randomly around the centroids
    let samples = generate_data(&centroids, SAMPLES_PER_CENTROID, 0.4);

    // Create a new model with 2 clusters
    let mut model = KMeansClassifier::new(2);

    // Train the model
    println!("Training the model...");
    // Our train function returns a Result<(), E>
    model.train(&samples).unwrap();

    let centroids = model.centroids().as_ref().unwrap();
    println!("Model Centroids:\n{:.3}", centroids);

    // Predict the classes and partition into
    println!("Classifying the samples...");
    let classes = model.predict(&samples).unwrap();
    let (first, second): (Vec<usize>, Vec<usize>) = classes.data().iter().partition(|&x| *x == 0);

    println!("Samples closest to first centroid: {}", first.len());
    println!("Samples closest to second centroid: {}", second.len());
}

pub fn mut_data(&mut self) -> &mut [T]

Returns a mutable slice of the underlying data.

pub fn into_vec(self) -> Vec<T>

Consumes the Vector and returns the Vec of data.

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the Vector’s data.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator over mutable references to the Vector’s data.

impl<T> Vector<T>

where T: Copy,

pub fn apply(self, f: &dyn Fn(T) -> T) -> Vector<T>

Applies a function to each element in the vector.

Examples

use rulinalg::vector::Vector;
fn add_two(a: f64) -> f64 {
    a + 2f64
}

let a = Vector::new(vec![0.;4]);

let b = a.apply(&add_two);

assert_eq!(b.into_vec(), vec![2.0; 4]);

impl<T> Vector<T>

where T: Copy + PartialOrd,

pub fn argmax(&self) -> (usize, T)

Find the argmax of the Vector.

Returns the index of the largest value in the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,0.0,5.0]);
let b = a.argmax();
assert_eq!(b.0, 3);
assert_eq!(b.1, 5.0);

pub fn argmin(&self) -> (usize, T)

Find the argmin of the Vector.

Returns the index of the smallest value in the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,0.0,5.0]);
let b = a.argmin();
assert_eq!(b.0, 2);
assert_eq!(b.1, 0.0);

pub fn select(&self, idxs: &[usize]) -> Vector<T>

Select elements from the Vector and form a new Vector from them.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0,5.0]);

let a_lower = a.select(&[2,3,4]);

// Prints [3,4,5]
println!("{:?}", a_lower.data());

impl<T> Vector<T>

where T: Clone + Zero,

pub fn zeros(size: usize) -> Vector<T>

Constructs Vector of all zeros.

Requires the size of the vector.

Examples

use rulinalg::vector::Vector;

let vec = Vector::<f64>::zeros(10);

impl<T> Vector<T>

where T: Clone + One,

pub fn ones(size: usize) -> Vector<T>

Constructs Vector of all ones.

Requires the size of the vector.

Examples

use rulinalg::vector::Vector;

let vec = Vector::<f64>::ones(10);

impl<T> Vector<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

pub fn dot(&self, v: &Vector<T>) -> T

Compute dot product with specified Vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0]);
let b = Vector::new(vec![2.0; 4]);

let c = a.dot(&b);
assert_eq!(c, 20.0);

impl<T> Vector<T>

where T: Copy + Zero<Output = T> + Add,

pub fn sum(&self) -> T

The sum of the vector.

Returns the sum of all elements in the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0]);

let c = a.sum();
assert_eq!(c, 10.0);

impl<T> Vector<T>

where T: Copy + Mul<Output = T>,

pub fn elemul(&self, v: &Vector<T>) -> Vector<T>

The elementwise product of two vectors.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0]);
let b = Vector::new(vec![1.0,2.0,3.0,4.0]);

let c = &a.elemul(&b);
assert_eq!(*c.data(), vec![1.0, 4.0, 9.0, 16.0]);

impl<T> Vector<T>

where T: Copy + Div<Output = T>,

pub fn elediv(&self, v: &Vector<T>) -> Vector<T>

The elementwise division of two vectors.

Examples

use rulinalg::vector::Vector;

let a = Vector::new(vec![1.0,2.0,3.0,4.0]);
let b = Vector::new(vec![1.0,2.0,3.0,4.0]);

let c = &a.elediv(&b);
assert_eq!(*c.data(), vec![1.0; 4]);

impl<T> Vector<T>

where T: Float + FromPrimitive,

pub fn mean(&self) -> T

The mean of the vector.

Returns the arithmetic mean of the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::<f32>::new(vec![1.0,2.0,3.0,4.0]);

let c = a.mean();
assert_eq!(c, 2.5);

pub fn variance(&self) -> T

The variance of the vector.

Returns the unbiased sample variance of the vector.

Examples

use rulinalg::vector::Vector;

let a = Vector::<f32>::new(vec![1.0,2.0,3.0,4.0]);

let c = a.variance();
assert_eq!(c, 5.0/3.0);

Trait Implementations

impl<'a, 'b, T> Add<&'b T> for &'a Vector<T>

where T: Copy + Add<Output = T>,

Adds scalar to vector.

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, f: &T) -> Vector<T>

Performs the + operation.

impl<'a, T> Add<&'a T> for Vector<T>

where T: Copy + Add<Output = T>,

Adds scalar to vector.

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, f: &T) -> Vector<T>

Performs the + operation.

impl<'a, 'b, T> Add<&'b Vector<T>> for &'a Vector<T>

where T: Copy + Add<Output = T>,

Adds vector to vector.

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, v: &Vector<T>) -> Vector<T>

Performs the + operation.

impl<'a, T> Add<&'a Vector<T>> for Vector<T>

where T: Copy + Add<Output = T>,

Adds vector to vector.

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, v: &Vector<T>) -> Vector<T>

Performs the + operation.

impl<'a, T> Add<T> for &'a Vector<T>

where T: Copy + Add<Output = T>,

Adds scalar to vector.

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, f: T) -> Vector<T>

Performs the + operation.

impl<T> Add<T> for Vector<T>

where T: Copy + Add<Output = T>,

Adds scalar to vector.

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, f: T) -> Vector<T>

Performs the + operation.

impl<'a, T> Add<Vector<T>> for &'a Vector<T>

where T: Copy + Add<Output = T>,

Adds vector to vector.

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, v: Vector<T>) -> Vector<T>

Performs the + operation.

impl<T> Add for Vector<T>

where T: Copy + Add<Output = T>,

Adds vector to vector.

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, v: Vector<T>) -> Vector<T>

Performs the + operation.

impl<'a, T> AddAssign<&'a T> for Vector<T>

where T: Copy + Add<Output = T>,

Performs addition assignment between a vector and a scalar.

fn add_assign(&mut self, _rhs: &T)

Performs the += operation.

impl<'a, T> AddAssign<&'a Vector<T>> for Vector<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two vectors.

fn add_assign(&mut self, _rhs: &Vector<T>)

Performs the += operation.

impl<T> AddAssign<T> for Vector<T>

where T: Copy + Add<Output = T>,

Performs addition assignment between a vector and a scalar.

fn add_assign(&mut self, _rhs: T)

Performs the += operation.

impl<T> AddAssign for Vector<T>

where T: Copy + Add<Output = T>,

Performs elementwise addition assignment between two vectors.

fn add_assign(&mut self, _rhs: Vector<T>)

Performs the += operation.

impl<T> Clone for Vector<T>

where T: Clone,

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

Clones the Vector.

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

Performs copy-assignment from source.

impl CostFunc<Vector<f64>> for CrossEntropyError

fn cost(outputs: &Vector<f64>, targets: &Vector<f64>) -> f64

The cost function.

fn grad_cost(outputs: &Vector<f64>, targets: &Vector<f64>) -> Vector<f64>

The gradient of the cost function.

impl CostFunc<Vector<f64>> for MeanSqError

fn cost(outputs: &Vector<f64>, targets: &Vector<f64>) -> f64

The cost function.

fn grad_cost(outputs: &Vector<f64>, targets: &Vector<f64>) -> Vector<f64>

The gradient of the cost function.

impl<T> Debug for Vector<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Display for Vector<T>

where T: Display,

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

Displays the Vector.

impl<'a, 'b, T> Div<&'b T> for &'a Vector<T>

where T: Copy + Zero + PartialEq + Div<Output = T>,

Divides vector by scalar.

type Output = Vector<T>

The resulting type after applying the / operator.

fn div(self, f: &T) -> Vector<T>

Performs the / operation.

impl<'a, T> Div<&'a T> for Vector<T>

where T: Copy + Zero + PartialEq + Div<Output = T>,

Divides vector by scalar.

type Output = Vector<T>

The resulting type after applying the / operator.

fn div(self, f: &T) -> Vector<T>

Performs the / operation.

impl<'a, T> Div<T> for &'a Vector<T>

where T: Copy + Zero + PartialEq + Div<Output = T>,

Divides vector by scalar.

type Output = Vector<T>

The resulting type after applying the / operator.

fn div(self, f: T) -> Vector<T>

Performs the / operation.

impl<T> Div<T> for Vector<T>

where T: Copy + Zero + PartialEq + Div<Output = T>,

Divides vector by scalar.

type Output = Vector<T>

The resulting type after applying the / operator.

fn div(self, f: T) -> Vector<T>

Performs the / operation.

impl<'a, T> DivAssign<&'a T> for Vector<T>

where T: Copy + Div<Output = T>,

Performs division assignment between a vector and a scalar.

fn div_assign(&mut self, _rhs: &T)

Performs the /= operation.

impl<T> DivAssign<T> for Vector<T>

where T: Copy + Div<Output = T>,

Performs division assignment between a vector and a scalar.

fn div_assign(&mut self, _rhs: T)

Performs the /= operation.

impl<'a, T> From<&'a [T]> for Vector<T>

where T: Clone,

fn from(slice: &'a [T]) -> Vector<T>

Converts to this type from the input type.

impl<T> From<Vec<T>> for Vector<T>

fn from(vec: Vec<T>) -> Vector<T>

Converts to this type from the input type.

impl<T> From<Vector<T>> for Matrix<T>

fn from(vector: Vector<T>) -> Matrix<T>

Converts to this type from the input type.

impl<T> Hash for Vector<T>

where T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Index<usize> for Vector<T>

Indexes vector.

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for Vector<T>

Indexes mutable vector.

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

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

impl<T> Into<Vec<T>> for Vector<T>

fn into(self) -> Vec<T>

Converts this type into the (usually inferred) input type.

impl<'a, T> IntoIterator for &'a Vector<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Vector<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Vector<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Vector<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> Metric<T> for Vector<T>

where T: Float,

fn norm(&self) -> T

Compute euclidean norm for vector.

Examples

use rulinalg::vector::Vector;
use rulinalg::Metric;

let a = Vector::new(vec![3.0,4.0]);
let c = a.norm();

assert_eq!(c, 5.0);

impl<'a, 'b, T> Mul<&'b T> for &'a Vector<T>

where T: Copy + Mul<Output = T>,

Multiplies vector by scalar.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, f: &T) -> Vector<T>

Performs the * operation.

impl<'a, T> Mul<&'a T> for Vector<T>

where T: Copy + Mul<Output = T>,

Multiplies vector by scalar.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, f: &T) -> Vector<T>

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Vector<T>> for &'a Matrix<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, v: &Vector<T>) -> Vector<T>

Performs the * operation.

impl<'a, T> Mul<&'a Vector<T>> for Matrix<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, m: &Vector<T>) -> Vector<T>

Performs the * operation.

impl<'a, T> Mul<T> for &'a Vector<T>

where T: Copy + Mul<Output = T>,

Multiplies vector by scalar.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, f: T) -> Vector<T>

Performs the * operation.

impl<T> Mul<T> for Vector<T>

where T: Copy + Mul<Output = T>,

Multiplies vector by scalar.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, f: T) -> Vector<T>

Performs the * operation.

impl<'a, T> Mul<Vector<T>> for &'a Matrix<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, m: Vector<T>) -> Vector<T>

Performs the * operation.

impl<T> Mul<Vector<T>> for Matrix<T>

where T: Zero<Output = T> + Mul<Output = T> + Add + Copy,

Multiplies matrix by vector.

type Output = Vector<T>

The resulting type after applying the * operator.

fn mul(self, m: Vector<T>) -> Vector<T>

Performs the * operation.

impl<'a, T> MulAssign<&'a T> for Vector<T>

where T: Copy + Mul<Output = T>,

Performs multiplication assignment between a vector and a scalar.

fn mul_assign(&mut self, _rhs: &T)

Performs the *= operation.

impl<T> MulAssign<T> for Vector<T>

where T: Copy + Mul<Output = T>,

Performs multiplication assignment between a vector and a scalar.

fn mul_assign(&mut self, _rhs: T)

Performs the *= operation.

impl<'a, T> Neg for &'a Vector<T>

where T: Neg<Output = T> + Copy,

Gets negative of vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn neg(self) -> Vector<T>

Performs the unary - operation.

impl<T> Neg for Vector<T>

where T: Neg<Output = T> + Copy,

Gets negative of vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn neg(self) -> Vector<T>

Performs the unary - operation.

impl<T> PartialEq for Vector<T>

where T: PartialEq,

fn eq(&self, other: &Vector<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b, T> Sub<&'b T> for &'a Vector<T>

where T: Copy + Sub<Output = T>,

Subtracts scalar from vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, f: &T) -> Vector<T>

Performs the - operation.

impl<'a, T> Sub<&'a T> for Vector<T>

where T: Copy + Sub<Output = T>,

Subtracts scalar from vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, f: &T) -> Vector<T>

Performs the - operation.

impl<'a, 'b, T> Sub<&'b Vector<T>> for &'a Vector<T>

where T: Copy + Sub<Output = T>,

Subtracts vector from vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, v: &Vector<T>) -> Vector<T>

Performs the - operation.

impl<'a, T> Sub<&'a Vector<T>> for Vector<T>

where T: Copy + Sub<Output = T>,

Subtracts vector from vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, v: &Vector<T>) -> Vector<T>

Performs the - operation.

impl<'a, T> Sub<T> for &'a Vector<T>

where T: Copy + Sub<Output = T>,

Subtracts scalar from vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, f: T) -> Vector<T>

Performs the - operation.

impl<T> Sub<T> for Vector<T>

where T: Copy + Sub<Output = T>,

Subtracts scalar from vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, f: T) -> Vector<T>

Performs the - operation.

impl<'a, T> Sub<Vector<T>> for &'a Vector<T>

where T: Copy + Sub<Output = T>,

Subtracts vector from vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, v: Vector<T>) -> Vector<T>

Performs the - operation.

impl<T> Sub for Vector<T>

where T: Copy + Sub<Output = T>,

Subtracts vector from vector.

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, v: Vector<T>) -> Vector<T>

Performs the - operation.

impl<'a, T> SubAssign<&'a T> for Vector<T>

where T: Copy + Sub<Output = T>,

Performs subtraction assignment between a vector and a scalar.

fn sub_assign(&mut self, _rhs: &T)

Performs the -= operation.

impl<'a, T> SubAssign<&'a Vector<T>> for Vector<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two vectors.

fn sub_assign(&mut self, _rhs: &Vector<T>)

Performs the -= operation.

impl<T> SubAssign<T> for Vector<T>

where T: Copy + Sub<Output = T>,

Performs subtraction assignment between a vector and a scalar.

fn sub_assign(&mut self, _rhs: T)

Performs the -= operation.

impl<T> SubAssign for Vector<T>

where T: Copy + Sub<Output = T>,

Performs elementwise subtraction assignment between two vectors.

fn sub_assign(&mut self, _rhs: Vector<T>)

Performs the -= operation.

impl<T: Kernel, U: MeanFunc> SupModel<Matrix<f64>, Vector<f64>> for GaussianProcess<T, U>

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output from inputs.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the model using data and outputs.

impl<C: Criterion> SupModel<Matrix<f64>, Vector<f64>> for GenLinearModel<C>

Supervised model trait for the GLM.

Predictions are made from the model by computing g^-1(Xb).

The model is trained using Iteratively Re-weighted Least Squares.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output from inputs.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the model using inputs and targets.

impl SupModel<Matrix<f64>, Vector<f64>> for LinRegressor

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the linear regression model.

Takes training data and output values as input.

Examples

use rusty_machine::learning::lin_reg::LinRegressor;
use rusty_machine::linalg::Matrix;
use rusty_machine::linalg::Vector;
use rusty_machine::learning::SupModel;

let mut lin_mod = LinRegressor::default();
let inputs = Matrix::new(3,1, vec![2.0, 3.0, 4.0]);
let targets = Vector::new(vec![5.0, 6.0, 7.0]);

lin_mod.train(&inputs, &targets).unwrap();

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output value from input data.

Model must be trained before prediction can be made.

impl<A> SupModel<Matrix<f64>, Vector<f64>> for LogisticRegressor<A>

where A: OptimAlgorithm<BaseLogisticRegressor>,

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the logistic regression model.

Takes training data and output values as input.

Examples

use rusty_machine::learning::logistic_reg::LogisticRegressor;
use rusty_machine::linalg::Matrix;
use rusty_machine::linalg::Vector;
use rusty_machine::learning::SupModel;

let mut logistic_mod = LogisticRegressor::default();
let inputs = Matrix::new(3,2, vec![1.0, 2.0, 1.0, 3.0, 1.0, 4.0]);
let targets = Vector::new(vec![5.0, 6.0, 7.0]);

logistic_mod.train(&inputs, &targets).unwrap();

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output value from input data.

Model must be trained before prediction can be made.

impl<K: Kernel> SupModel<Matrix<f64>, Vector<f64>> for SVM<K>

Train the model using the Pegasos algorithm and predict the model output from new data.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<f64>>

Predict output from inputs.

fn train( &mut self, inputs: &Matrix<f64>, targets: &Vector<f64>, ) -> LearningResult<()>

Train the model using inputs and targets.

impl UnSupModel<Matrix<f64>, Vector<Option<usize>>> for DBSCAN

fn train(&mut self, inputs: &Matrix<f64>) -> LearningResult<()>

Train the classifier using input data.

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<Option<usize>>>

Predict output from inputs.

impl<InitAlg: Initializer> UnSupModel<Matrix<f64>, Vector<usize>> for KMeansClassifier<InitAlg>

fn predict(&self, inputs: &Matrix<f64>) -> LearningResult<Vector<usize>>

Predict classes from data.

Model must be trained.

fn train(&mut self, inputs: &Matrix<f64>) -> LearningResult<()>

Train the classifier using input data.

impl<T> Eq for Vector<T>

where T: Eq,

impl<T> StructuralPartialEq for Vector<T>