Struct DoubleHadamard 

pub struct DoubleHadamard<A>
where
    A: Allocator,
{ /* private fields */ }

A Double Hadamard transform that applies the signed Hadamard Transform to a head of the vector and then the tail.

This struct performs the transformation

[I 0; 0 H/sqrt(t)] · D1 · [H/sqrt(t) 0; 0 I] · zeropad(D0 · x)

• n is the dimensionality of the input vector.
• m is the desired output dimensionality.
• o = max(n, m) is an intermediate dimension.
• t is the largest power of 2 less than or equal to o.
• H is a Hadamard Matrix of dimension t,
• I is the identity matrix of dimension n - t
• D0 and D1 are diagonal matrices with diagonal entries in {-1, +1} drawn uniformly at random with lengths n and o respectively.
• x is the input vector of dimension n
• [A 0; 0 B] represents a block diagonal matrix with blocks A and B.
• zeropad indicates that the result D0 · x is zero-padded to the dimension o if needed.

As indicated above, if o is a power of two, then only a single transformation is applied. Further, if o exceeds n, then the input vector is zero padded at the end to o dimensions.

Implementations

impl<A> DoubleHadamard<A>

where A: Allocator,

pub fn new<R>( dim: NonZeroUsize, target_dim: TargetDim, rng: &mut R, allocator: A, ) -> Result<Self, AllocatorError>

where R: Rng + ?Sized,

Construct a new DoubleHadamard that transforms input vectors of dimension dim.

The parameter rng is used to randomly initialize the diagonal matrices portion of the transform.

The following dimensionalities will be configured depending on the value of target:

• TargetDim::Same
  • self.input_dim() == dim.get()
  • self.output_dim() == dim.get()
• TargetDim::Natural
  • self.input_dim() == dim.get()
  • self.output_dim() == dim.get()
• TargetDim::Override
  • self.input_dim() == dim.get()
  • self.output_dim(): The value provided by the override.

Subsampling occurs if self.output_dim() is smaller than self.input_dim().

pub fn try_from_parts( signs0: Poly<[u32], A>, signs1: Poly<[u32], A>, subsample: Option<Poly<[u32], A>>, ) -> Result<Self, DoubleHadamardError>

pub fn input_dim(&self) -> usize

Return the input dimension for the transformation.

pub fn output_dim(&self) -> usize

Return the output dimension for the transformation.

pub fn preserves_norms(&self) -> bool

Return whether or not the transform preserves norms.

For this transform, norms are not preserved when the output dimensionality is less than the input dimensionality.

pub fn transform_into( &self, dst: &mut [f32], src: &[f32], allocator: ScopedAllocator<'_>, ) -> Result<(), TransformFailed>

Perform the transformation of the src vector into the dst vector.

Errors

Returns an error if

• src.len() != self.input_dim().
• dst.len() != self.output_dim().

Trait Implementations

impl<A> Debug for DoubleHadamard<A>

where A: Allocator + Debug,

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

Formats the value using the given formatter.