[−][src]Trait concrete_lib::operators::math::fft::FFT

pub trait FFT: Sized {
    fn reconstruct_half(slice: &mut [CTorus], big_n: usize);

    fn split_in_mut_mut(
        sli: &mut [CTorus], 
        big_n: usize
    ) -> (&mut [CTorus], &mut [CTorus]);

    fn split_in_imut_mut(
        sli: &mut [CTorus], 
        big_n: usize
    ) -> (&[CTorus], &mut [CTorus]);

    fn split_in_mut_imut(
        sli: &mut [CTorus], 
        big_n: usize
    ) -> (&mut [CTorus], &[CTorus]);

    fn put_in_fft_domain_storus(
        fft_b: &mut AlignedVec<CTorus>, 
        tmp: &mut AlignedVec<CTorus>, 
        coeff_b: &[Self], 
        twiddles: &[CTorus], 
        fft: &mut C2CPlanTorus
    );

    fn put_in_fft_domain_torus(
        fft_b: &mut AlignedVec<CTorus>, 
        tmp: &mut AlignedVec<CTorus>, 
        coeff_b: &[Self], 
        twiddles: &[CTorus], 
        fft: &mut C2CPlanTorus
    );

    fn put_2_in_fft_domain_torus(
        fft_a: &mut AlignedVec<CTorus>, 
        fft_b: &mut AlignedVec<CTorus>, 
        coeff_a: &[Self], 
        coeff_b: &[Self], 
        twiddles: &[CTorus], 
        fft: &mut C2CPlanTorus
    );

    fn put_2_in_fft_domain_storus(
        fft_a: &mut AlignedVec<CTorus>, 
        fft_b: &mut AlignedVec<CTorus>, 
        coeff_a: &[Self], 
        coeff_b: &[Self], 
        twiddles: &[CTorus], 
        fft: &mut C2CPlanTorus
    );

    fn put_in_coeff_domain(
        coeff_b: &mut [Self], 
        tmp: &mut AlignedVec<CTorus>, 
        fft_b: &mut AlignedVec<CTorus>, 
        inverse_twiddles: &[CTorus], 
        ifft: &mut C2CPlanTorus
    );

    fn put_2_in_coeff_domain(
        coeff_a: &mut [Self], 
        coeff_b: &mut [Self], 
        fft_a: &mut AlignedVec<CTorus>, 
        fft_b: &mut AlignedVec<CTorus>, 
        inverse_twiddles: &[CTorus], 
        ifft: &mut C2CPlanTorus
    );

    fn schoolbook_multiply(
        p_res: &mut [Self], 
        p_tor: &[Self], 
        p_int: &[Self], 
        degree: usize
    );

    fn compute_monomial_polynomial_prod_torus(
        degree: usize, 
        p_tor: &[Self], 
        p_int: &[Self], 
        monomial: usize
    ) -> Self;
}

Required methods

fn reconstruct_half(slice: &mut [CTorus], big_n: usize)

fn split_in_mut_mut(
    sli: &mut [CTorus],
    big_n: usize
) -> (&mut [CTorus], &mut [CTorus])

fn split_in_imut_mut(
    sli: &mut [CTorus],
    big_n: usize
) -> (&[CTorus], &mut [CTorus])

fn split_in_mut_imut(
    sli: &mut [CTorus],
    big_n: usize
) -> (&mut [CTorus], &[CTorus])

fn put_in_fft_domain_storus(
    fft_b: &mut AlignedVec<CTorus>,
    tmp: &mut AlignedVec<CTorus>,
    coeff_b: &[Self],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)

fn put_in_fft_domain_torus(
    fft_b: &mut AlignedVec<CTorus>,
    tmp: &mut AlignedVec<CTorus>,
    coeff_b: &[Self],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)

fn put_2_in_fft_domain_torus(
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    coeff_a: &[Self],
    coeff_b: &[Self],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)

fn put_2_in_fft_domain_storus(
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    coeff_a: &[Self],
    coeff_b: &[Self],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)

fn put_in_coeff_domain(
    coeff_b: &mut [Self],
    tmp: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    inverse_twiddles: &[CTorus],
    ifft: &mut C2CPlanTorus
)

fn put_2_in_coeff_domain(
    coeff_a: &mut [Self],
    coeff_b: &mut [Self],
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    inverse_twiddles: &[CTorus],
    ifft: &mut C2CPlanTorus
)

fn schoolbook_multiply(
    p_res: &mut [Self],
    p_tor: &[Self],
    p_int: &[Self],
    degree: usize
)

fn compute_monomial_polynomial_prod_torus(
    degree: usize,
    p_tor: &[Self],
    p_int: &[Self],
    monomial: usize
) -> Self

Loading content...

Implementations on Foreign Types

impl FFT for u32[src]

fn reconstruct_half(slice: &mut [CTorus], big_n: usize)[src]

When dealing with real polynomial of degree big_n - 1, we only need to store half of its fourier transform as one half is the conjuagate of the other half This function reconstruct a vector of size big_n using big_n / 2 values and the conjugate relationship.

Arguments

  • slice - fourier representation of a real polynomial
  • big_n - number of coefficients of the polynomial e.g. degree + 1

fn split_in_mut_mut(
    s: &mut [CTorus],
    big_n: usize
) -> (&mut [CTorus], &mut [CTorus])[src]

Split a slice of CTorus elements in two mutable references

Comments

  • This function uses unsafe slice::from_raw_parts_mut and as_mut_ptr

Arguments

  • s - slice of CTorus elements to be split
  • big_n - length of the slice s

Example

use concrete_lib::operators::math::FFT;
use concrete_lib::types::CTorus;
type Torus = u32;

let big_n: usize = 1024 ;
let mut c: Vec<CTorus> = vec![CTorus::new(0., 0.); big_n] ;

let (first, second) = <Torus as FFT>::split_in_mut_mut(&mut c, big_n) ;

fn split_in_imut_mut(
    sli: &mut [CTorus],
    big_n: usize
) -> (&[CTorus], &mut [CTorus])[src]

Split a slice of CTorus elements in a immutable reference and a mutable reference

Comments

  • This function uses unsafe slice::from_raw_parts_mut and as_mut_ptr

Arguments

  • s - slice of CTorus elements to be split
  • big_n - length of the slice s

Example

use concrete_lib::operators::math::FFT;
use concrete_lib::types::CTorus;
type Torus = u32;

let big_n: usize = 1024 ;
let mut c: Vec<CTorus> = vec![CTorus::new(0., 0.); big_n] ;

let (first, second) = <Torus as FFT>::split_in_imut_mut(&mut c, big_n) ;

fn split_in_mut_imut(
    sli: &mut [CTorus],
    big_n: usize
) -> (&mut [CTorus], &[CTorus])[src]

Split a slice of CTorus elements in a mutable reference and a immutable reference

Comments

  • This function uses unsafe slice::from_raw_parts_mut and as_mut_ptr

Arguments

  • s - slice of CTorus elements to be split
  • big_n - length of the slice s

Example

use concrete_lib::operators::math::FFT;
use concrete_lib::types::CTorus;
type Torus = u32;

let big_n: usize = 1024 ;
let mut c: Vec<CTorus> = vec![CTorus::new(0., 0.); big_n] ;

let (first, second) = <Torus as FFT>::split_in_mut_imut(&mut c, big_n) ;

fn put_in_fft_domain_storus(
    fft_b: &mut AlignedVec<CTorus>,
    tmp: &mut AlignedVec<CTorus>,
    coeff_b: &[u32],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)[src]

Put a Torus polynomial into the FFT using fftw's c2C algorithm

Arguments

  • fft_b - Aligned Vector of FFT(coeff_b) (output)
  • tmp - Aligned Vector used as temporary variable
  • coeff_b - Torus slice representing a signed polynomial with Torus coefficients
  • twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • fft - FFTW Plan

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::TWIDDLES_TORUS_external;

type Torus = u32;

let big_n: usize = 1024;
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut tmp: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut fft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Forward, Flag::Measure).unwrap();

// Create and fill a vector with Torus element
let mut coeff_b: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_b) ;

FFT::put_in_fft_domain_storus(
    &mut fft_b,
    &mut tmp,
    &coeff_b,
    TWIDDLES_TORUS_external!(big_n),
    &mut fft,
);

fn put_in_fft_domain_torus(
    fft_b: &mut AlignedVec<CTorus>,
    tmp: &mut AlignedVec<CTorus>,
    coeff_b: &[u32],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)[src]

Put a Torus polynomial into the FFT using fftw's c2C algorithm

Arguments

  • fft_b - Aligned Vector of FFT(coeff_b) (output)
  • tmp - Aligned Vector used as temporary variable
  • coeff_b - Torus slice representing a unsigned polynomial with Torus coefficients
  • twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • fft - FFTW Plan

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::TWIDDLES_TORUS_external;

type Torus = u32;

let big_n: usize = 1024;
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut tmp: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut fft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Forward, Flag::Measure).unwrap();

// Create and fill a vector with Torus element
let mut coeff_b: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_b) ;

FFT::put_in_fft_domain_torus(
    &mut fft_b,
    &mut tmp,
    &coeff_b,
    TWIDDLES_TORUS_external!(big_n),
    &mut fft,
);

fn put_2_in_fft_domain_torus(
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    coeff_a: &[u32],
    coeff_b: &[u32],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)[src]

Put two Torus polynomials into the FFT using fftw's c2C algorithm

Arguments

  • fft_a - Aligned Vector of FFT(coeff_a) (output)
  • fft_b - Aligned Vector of FFT(coeff_b) (output)
  • coeff_a - Torus slice representing a polynomial
  • coeff_b - Torus slice representing a polynomial
  • twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • fft - FFTW Plan

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::TWIDDLES_TORUS_external;

type Torus = u32;

let big_n: usize = 1024;
let mut fft_a: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut fft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Forward, Flag::Measure).unwrap();

// Create and fill a vector with Torus element
let mut coeff_a: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_a) ;
let mut coeff_b: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_b) ;

FFT::put_2_in_fft_domain_torus(
    &mut fft_a,
    &mut fft_b,
    &coeff_a,
    &coeff_b,
    TWIDDLES_TORUS_external!(big_n),
    &mut fft,
);

fn put_2_in_fft_domain_storus(
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    coeff_a: &[u32],
    coeff_b: &[u32],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)[src]

Put two Torus polynomials into the FFT using fftw's c2C algorithm

Arguments

  • fft_a - Aligned Vector of FFT(coeff_a) (output)
  • fft_b - Aligned Vector of FFT(coeff_b) (output)
  • coeff_a - Torus slice representing a polynomial
  • coeff_b - Torus slice representing a polynomial
  • twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • fft - FFTW Plan

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::TWIDDLES_TORUS_external;

type Torus = u32;

let big_n: usize = 1024;
let mut fft_a: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut fft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Forward, Flag::Measure).unwrap();

// Create and fill a vector with Torus element
let mut coeff_a: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_a) ;
let mut coeff_b: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_b) ;

FFT::put_2_in_fft_domain_storus(
    &mut fft_a,
    &mut fft_b,
    &coeff_a,
    &coeff_b,
    TWIDDLES_TORUS_external!(big_n),
    &mut fft,
);

fn put_in_coeff_domain(
    coeff_b: &mut [u32],
    tmp: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    inverse_twiddles: &[CTorus],
    ifft: &mut C2CPlanTorus
)[src]

Perform the IFFT using fftw's c2C algorithm

Arguments

  • coeff_b - Torus slice representing a polynomial (output)
  • tmp - Aligned Vector used as temporary variable
  • fft_b - Aligned Vector of FFT(coeff_b)
  • inverse_twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • ifft - FFTW Plan for backward FFT

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::INVERSE_TWIDDLES_TORUS_external;

type Torus = u32;

let big_n: usize = 1024;
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut tmp: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut ifft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Backward, Flag::Measure).unwrap();

let mut coeff_b: Vec<Torus> = vec![0; big_n];

FFT::put_in_coeff_domain(
    &mut coeff_b,
    &mut tmp,
    &mut fft_b,
    INVERSE_TWIDDLES_TORUS_external!(big_n),
    &mut ifft,
);

fn put_2_in_coeff_domain(
    coeff_a: &mut [u32],
    coeff_b: &mut [u32],
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    inverse_twiddles: &[CTorus],
    ifft: &mut C2CPlanTorus
)[src]

Perform the IFFT of two polynomials using fftw's c2C algorithm

Arguments

  • coeff_a - Torus slice representing a polynomial (output)
  • coeff_b - Torus slice representing a polynomial (output)
  • fft_a - Aligned Vector of FFT(coeff_a)
  • fft_b - Aligned Vector of FFT(coeff_b)
  • inverse_twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • ifft - FFTW Plan for backward FFT

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::INVERSE_TWIDDLES_TORUS_external;

type Torus = u32;

let big_n: usize = 1024;
let mut fft_a: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut ifft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Backward, Flag::Measure).unwrap();

let mut coeff_a: Vec<Torus> = vec![0; big_n];
let mut coeff_b: Vec<Torus> = vec![0; big_n];

FFT::put_2_in_coeff_domain(
    &mut coeff_a,
    &mut coeff_b,
    &mut fft_a,
    &mut fft_b,
    INVERSE_TWIDDLES_TORUS_external!(big_n),
    &mut ifft,
);

fn schoolbook_multiply(
    p_res: &mut [u32],
    p_tor: &[u32],
    p_int: &[u32],
    degree: usize
)[src]

stores in p_res (torus polynomial) the result of p_tor * p_int (without FFT, quotient X^big_n + 1) p_tor : torus polynomial p_int : integer polynomial

fn compute_monomial_polynomial_prod_torus(
    degree: usize,
    p_tor: &[u32],
    p_int: &[u32],
    monomial: usize
) -> u32[src]

computes the coefficient of the monomial-th monomial of the product of p_tor and p_int (without FFT, quotient X^big_n + 1)

impl FFT for u64[src]

fn reconstruct_half(slice: &mut [CTorus], big_n: usize)[src]

When dealing with real polynomial of degree big_n - 1, we only need to store half of its fourier transform as one half is the conjuagate of the other half This function reconstruct a vector of size big_n using big_n / 2 values and the conjugate relationship.

Arguments

  • slice - fourier representation of a real polynomial
  • big_n - number of coefficients of the polynomial e.g. degree + 1

fn split_in_mut_mut(
    s: &mut [CTorus],
    big_n: usize
) -> (&mut [CTorus], &mut [CTorus])[src]

Split a slice of CTorus elements in two mutable references

Comments

  • This function uses unsafe slice::from_raw_parts_mut and as_mut_ptr

Arguments

  • s - slice of CTorus elements to be split
  • big_n - length of the slice s

Example

use concrete_lib::operators::math::FFT;
use concrete_lib::types::CTorus;
type Torus = u64;

let big_n: usize = 1024 ;
let mut c: Vec<CTorus> = vec![CTorus::new(0., 0.); big_n] ;

let (first, second) = <Torus as FFT>::split_in_mut_mut(&mut c, big_n) ;

fn split_in_imut_mut(
    sli: &mut [CTorus],
    big_n: usize
) -> (&[CTorus], &mut [CTorus])[src]

Split a slice of CTorus elements in a immutable reference and a mutable reference

Comments

  • This function uses unsafe slice::from_raw_parts_mut and as_mut_ptr

Arguments

  • s - slice of CTorus elements to be split
  • big_n - length of the slice s

Example

use concrete_lib::operators::math::FFT;
use concrete_lib::types::CTorus;
type Torus = u64;

let big_n: usize = 1024 ;
let mut c: Vec<CTorus> = vec![CTorus::new(0., 0.); big_n] ;

let (first, second) = <Torus as FFT>::split_in_imut_mut(&mut c, big_n) ;

fn split_in_mut_imut(
    sli: &mut [CTorus],
    big_n: usize
) -> (&mut [CTorus], &[CTorus])[src]

Split a slice of CTorus elements in a mutable reference and a immutable reference

Comments

  • This function uses unsafe slice::from_raw_parts_mut and as_mut_ptr

Arguments

  • s - slice of CTorus elements to be split
  • big_n - length of the slice s

Example

use concrete_lib::operators::math::FFT;
use concrete_lib::types::CTorus;
type Torus = u64;

let big_n: usize = 1024 ;
let mut c: Vec<CTorus> = vec![CTorus::new(0., 0.); big_n] ;

let (first, second) = <Torus as FFT>::split_in_mut_imut(&mut c, big_n) ;

fn put_in_fft_domain_storus(
    fft_b: &mut AlignedVec<CTorus>,
    tmp: &mut AlignedVec<CTorus>,
    coeff_b: &[u64],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)[src]

Put a Torus polynomial into the FFT using fftw's c2C algorithm

Arguments

  • fft_b - Aligned Vector of FFT(coeff_b) (output)
  • tmp - Aligned Vector used as temporary variable
  • coeff_b - Torus slice representing a signed polynomial with Torus coefficients
  • twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • fft - FFTW Plan

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::TWIDDLES_TORUS_external;

type Torus = u64;

let big_n: usize = 1024;
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut tmp: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut fft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Forward, Flag::Measure).unwrap();

// Create and fill a vector with Torus element
let mut coeff_b: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_b) ;

FFT::put_in_fft_domain_storus(
    &mut fft_b,
    &mut tmp,
    &coeff_b,
    TWIDDLES_TORUS_external!(big_n),
    &mut fft,
);

fn put_in_fft_domain_torus(
    fft_b: &mut AlignedVec<CTorus>,
    tmp: &mut AlignedVec<CTorus>,
    coeff_b: &[u64],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)[src]

Put a Torus polynomial into the FFT using fftw's c2C algorithm

Arguments

  • fft_b - Aligned Vector of FFT(coeff_b) (output)
  • tmp - Aligned Vector used as temporary variable
  • coeff_b - Torus slice representing a unsigned polynomial with Torus coefficients
  • twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • fft - FFTW Plan

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::TWIDDLES_TORUS_external;

type Torus = u64;

let big_n: usize = 1024;
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut tmp: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut fft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Forward, Flag::Measure).unwrap();

// Create and fill a vector with Torus element
let mut coeff_b: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_b) ;

FFT::put_in_fft_domain_torus(
    &mut fft_b,
    &mut tmp,
    &coeff_b,
    TWIDDLES_TORUS_external!(big_n),
    &mut fft,
);

fn put_2_in_fft_domain_torus(
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    coeff_a: &[u64],
    coeff_b: &[u64],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)[src]

Put two Torus polynomials into the FFT using fftw's c2C algorithm

Arguments

  • fft_a - Aligned Vector of FFT(coeff_a) (output)
  • fft_b - Aligned Vector of FFT(coeff_b) (output)
  • coeff_a - Torus slice representing a polynomial
  • coeff_b - Torus slice representing a polynomial
  • twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • fft - FFTW Plan

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::TWIDDLES_TORUS_external;

type Torus = u64;

let big_n: usize = 1024;
let mut fft_a: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut fft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Forward, Flag::Measure).unwrap();

// Create and fill a vector with Torus element
let mut coeff_a: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_a) ;
let mut coeff_b: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_b) ;

FFT::put_2_in_fft_domain_torus(
    &mut fft_a,
    &mut fft_b,
    &coeff_a,
    &coeff_b,
    TWIDDLES_TORUS_external!(big_n),
    &mut fft,
);

fn put_2_in_fft_domain_storus(
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    coeff_a: &[u64],
    coeff_b: &[u64],
    twiddles: &[CTorus],
    fft: &mut C2CPlanTorus
)[src]

Put two Torus polynomials into the FFT using fftw's c2C algorithm

Arguments

  • fft_a - Aligned Vector of FFT(coeff_a) (output)
  • fft_b - Aligned Vector of FFT(coeff_b) (output)
  • coeff_a - Torus slice representing a polynomial
  • coeff_b - Torus slice representing a polynomial
  • twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • fft - FFTW Plan

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::TWIDDLES_TORUS_external;

type Torus = u64;

let big_n: usize = 1024;
let mut fft_a: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut fft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Forward, Flag::Measure).unwrap();

// Create and fill a vector with Torus element
let mut coeff_a: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_a) ;
let mut coeff_b: Vec<Torus> = vec![0; big_n];
Tensor::uniform_random_default(&mut coeff_b) ;

FFT::put_2_in_fft_domain_storus(
    &mut fft_a,
    &mut fft_b,
    &coeff_a,
    &coeff_b,
    TWIDDLES_TORUS_external!(big_n),
    &mut fft,
);

fn put_in_coeff_domain(
    coeff_b: &mut [u64],
    tmp: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    inverse_twiddles: &[CTorus],
    ifft: &mut C2CPlanTorus
)[src]

Perform the IFFT using fftw's c2C algorithm

Arguments

  • coeff_b - Torus slice representing a polynomial (output)
  • tmp - Aligned Vector used as temporary variable
  • fft_b - Aligned Vector of FFT(coeff_b)
  • inverse_twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • ifft - FFTW Plan for backward FFT

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::INVERSE_TWIDDLES_TORUS_external;

type Torus = u64;

let big_n: usize = 1024;
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut tmp: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut ifft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Backward, Flag::Measure).unwrap();

let mut coeff_b: Vec<Torus> = vec![0; big_n];

FFT::put_in_coeff_domain(
    &mut coeff_b,
    &mut tmp,
    &mut fft_b,
    INVERSE_TWIDDLES_TORUS_external!(big_n),
    &mut ifft,
);

fn put_2_in_coeff_domain(
    coeff_a: &mut [u64],
    coeff_b: &mut [u64],
    fft_a: &mut AlignedVec<CTorus>,
    fft_b: &mut AlignedVec<CTorus>,
    inverse_twiddles: &[CTorus],
    ifft: &mut C2CPlanTorus
)[src]

Perform the IFFT of two polynomials using fftw's c2C algorithm

Arguments

  • coeff_a - Torus slice representing a polynomial (output)
  • coeff_b - Torus slice representing a polynomial (output)
  • fft_a - Aligned Vector of FFT(coeff_a)
  • fft_b - Aligned Vector of FFT(coeff_b)
  • inverse_twiddles - CTorus slice containing correcting factor to work with an FFT on T[X] / (X^N-1) instead of T[X] /(X^N +1)
  • ifft - FFTW Plan for backward FFT

Example

#[macro_use]
use concrete_lib;
use fftw::array::AlignedVec;
use fftw::types::{Flag, Sign};
use fftw::plan::C2CPlan;
use concrete_lib::operators::math::{Tensor, FFT} ;
use concrete_lib::types::{CTorus, C2CPlanTorus};
use concrete_lib::INVERSE_TWIDDLES_TORUS_external;

type Torus = u64;

let big_n: usize = 1024;
let mut fft_a: AlignedVec<CTorus> = AlignedVec::new(big_n);
let mut fft_b: AlignedVec<CTorus> = AlignedVec::new(big_n);

// Creation of FFTW plan
let mut ifft: C2CPlanTorus =
    C2CPlan::aligned(&[big_n], Sign::Backward, Flag::Measure).unwrap();

let mut coeff_a: Vec<Torus> = vec![0; big_n];
let mut coeff_b: Vec<Torus> = vec![0; big_n];

FFT::put_2_in_coeff_domain(
    &mut coeff_a,
    &mut coeff_b,
    &mut fft_a,
    &mut fft_b,
    INVERSE_TWIDDLES_TORUS_external!(big_n),
    &mut ifft,
);

fn schoolbook_multiply(
    p_res: &mut [u64],
    p_tor: &[u64],
    p_int: &[u64],
    degree: usize
)[src]

stores in p_res (torus polynomial) the result of p_tor * p_int (without FFT, quotient X^big_n + 1) p_tor : torus polynomial p_int : integer polynomial

fn compute_monomial_polynomial_prod_torus(
    degree: usize,
    p_tor: &[u64],
    p_int: &[u64],
    monomial: usize
) -> u64[src]

computes the coefficient of the monomial-th monomial of the product of p_tor and p_int (without FFT, quotient X^big_n + 1)

Loading content...

Implementors

Loading content...