Trait FPVector

pub trait FPVector {
    type Scalar;

    // Required methods
    fn fmap<F>(&self, f: F) -> Self
       where F: Fn(Self::Scalar) -> Self::Scalar;
    fn reduce<F, T>(&self, init: T, f: F) -> Self::Scalar
       where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar,
             T: Into<Self::Scalar> + Copy;
    fn zip_with<F>(&self, f: F, other: &Self) -> Self
       where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar;
    fn filter<F>(&self, f: F) -> Self
       where F: Fn(Self::Scalar) -> bool;
    fn take(&self, n: usize) -> Self;
    fn skip(&self, n: usize) -> Self;
    fn sum(&self) -> Self::Scalar;
    fn prod(&self) -> Self::Scalar;
}

Functional Programming tools for Vector

Required Associated Types

type Scalar

Required Methods

fn fmap<F>(&self, f: F) -> Self

where F: Fn(Self::Scalar) -> Self::Scalar,

fn reduce<F, T>(&self, init: T, f: F) -> Self::Scalar

where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar, T: Into<Self::Scalar> + Copy,

fn zip_with<F>(&self, f: F, other: &Self) -> Self

where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar,

fn filter<F>(&self, f: F) -> Self

where F: Fn(Self::Scalar) -> bool,

fn take(&self, n: usize) -> Self

fn skip(&self, n: usize) -> Self

fn sum(&self) -> Self::Scalar

fn prod(&self) -> Self::Scalar

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl FPVector for Vec<AD>

type Scalar = AD

fn fmap<F>(&self, f: F) -> Self

where F: Fn(Self::Scalar) -> Self::Scalar,

fn reduce<F, T>(&self, init: T, f: F) -> Self::Scalar

where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar, T: Into<Self::Scalar>,

fn zip_with<F>(&self, f: F, other: &Self) -> Self

where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar,

fn filter<F>(&self, f: F) -> Self

where F: Fn(Self::Scalar) -> bool,

fn take(&self, n: usize) -> Self

fn skip(&self, n: usize) -> Self

fn sum(&self) -> Self::Scalar

fn prod(&self) -> Self::Scalar

impl FPVector for Vec<f64>

fn fmap<F>(&self, f: F) -> Vec<f64>

where F: Fn(f64) -> f64,

fmap for Vec<f64>

Examples

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let a = c!(1,2,3,4,5);
    assert_eq!(a.fmap(|x| x*2f64), seq!(2,10,2));
}

fn reduce<F, T>(&self, init: T, f: F) -> f64

where F: Fn(f64, f64) -> f64, T: Into<f64> + Copy,

reduce for Vec<f64>

Examples

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let a = seq!(1,100,1);
    assert_eq!(a.reduce(0, |x,y| x + y), 5050f64);
}

fn filter<F>(&self, f: F) -> Vec<f64>

where F: Fn(f64) -> bool,

Filter for Vec<f64>

Examples

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let a = c!(1,2,3,4,5);
    let b = a.filter(|x| x > 3.);
    assert_eq!(b, c!(4,5));
}

fn take(&self, n: usize) -> Vec<f64>

Take for Vec<f64>

Examples

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let a = c!(1,2,3,4,5);
    let b = a.take(3);
    assert_eq!(b, c!(1,2,3));
}

fn skip(&self, n: usize) -> Vec<f64>

Skip for Vec<f64>

Examples

#[macro_use]
extern crate peroxide;
use peroxide::fuga::*;

fn main() {
    let a = c!(1,2,3,4,5);
    let b = a.skip(3);
    assert_eq!(b, c!(4,5));
}

type Scalar = f64

fn zip_with<F>(&self, f: F, other: &Vec<f64>) -> Vec<f64>

where F: Fn(f64, f64) -> f64,

fn sum(&self) -> f64

fn prod(&self) -> f64

impl FPVector for Vec<Complex<f64>>

type Scalar = Complex<f64>

fn fmap<F>(&self, f: F) -> Self

where F: Fn(Self::Scalar) -> Self::Scalar,

fn zip_with<F>(&self, f: F, other: &Self) -> Self

where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar,

fn reduce<F, T>(&self, init: T, f: F) -> Self::Scalar

where F: Fn(Self::Scalar, Self::Scalar) -> Self::Scalar, T: Into<Self::Scalar>,

fn filter<F>(&self, f: F) -> Self

where F: Fn(Self::Scalar) -> bool,

fn take(&self, n: usize) -> Self

fn skip(&self, n: usize) -> Self

fn sum(&self) -> Self::Scalar

fn prod(&self) -> Self::Scalar

Implementors