java.lang.Object
- org.apache.commons.math.transform.FastHadamardTransformer

All Implemented Interfaces:

RealTransformer
```
public class FastHadamardTransformer
extends java.lang.Object
implements RealTransformer
```
Implements the Fast Hadamard Transform (FHT). Transformation of an input vector x to the output vector y.
In addition to transformation of real vectors, the Hadamard transform can transform integer vectors into integer vectors. However, this integer transform cannot be inverted directly. Due to a scaling factor it may lead to rational results. As an example, the inverse transform of integer vector (0, 1, 0, 1) is rational vector (1/2, -1/2, 0, 0).

Since:

2.0

Version:

$Revision: 1070725 $ $Date: 2011-02-15 02:31:12 +0100 (mar. 15 févr. 2011) $

Constructor Summary

Constructors
Constructor Description

FastHadamardTransformer()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected double[]`	`fht(double[] x)`	The FHT (Fast Hadamard Transformation) which uses only subtraction and addition.
`protected int[]`	`fht(int[] x)`	The FHT (Fast Hadamard Transformation) which uses only subtraction and addition.
`double[]`	`inversetransform(double[] f)`	Inversely transform the given real data set.
`double[]`	`inversetransform(UnivariateRealFunction f, double min, double max, int n)`	Inversely transform the given real function, sampled on the given interval.
`double[]`	`transform(double[] f)`	Transform the given real data set.
`int[]`	`transform(int[] f)`	Transform the given real data set.
`double[]`	`transform(UnivariateRealFunction f, double min, double max, int n)`	Transform the given real function, sampled on the given interval.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - FastHadamardTransformer
```
public FastHadamardTransformer()
```
- Method Detail
  - transform
```
public double[] transform(double[] f)
                   throws java.lang.IllegalArgumentException
```
    Transform the given real data set.
    
    Specified by:
    
    transform in interface RealTransformer
    
    Parameters:
    
    f - the real data array to be transformed (signal)
    
    Returns:
    
    the real transformed array (spectrum)
    
    Throws:
    
    java.lang.IllegalArgumentException - if any parameters are invalid
  - transform
```
public double[] transform(UnivariateRealFunction f,
                          double min,
                          double max,
                          int n)
                   throws FunctionEvaluationException,
                          java.lang.IllegalArgumentException
```
    Transform the given real function, sampled on the given interval.
    
    Specified by:
    
    transform in interface RealTransformer
    
    Parameters:
    
    f - the function to be sampled and transformed
    
    min - the lower bound for the interval
    
    max - the upper bound for the interval
    
    n - the number of sample points
    
    Returns:
    
    the real transformed array
    
    Throws:
    
    FunctionEvaluationException - if function cannot be evaluated at some point
    
    java.lang.IllegalArgumentException - if any parameters are invalid
  - inversetransform
```
public double[] inversetransform(double[] f)
                          throws java.lang.IllegalArgumentException
```
    Inversely transform the given real data set.
    
    Specified by:
    
    inversetransform in interface RealTransformer
    
    Parameters:
    
    f - the real data array to be inversely transformed (spectrum)
    
    Returns:
    
    the real inversely transformed array (signal)
    
    Throws:
    
    java.lang.IllegalArgumentException - if any parameters are invalid
  - inversetransform
```
public double[] inversetransform(UnivariateRealFunction f,
                                 double min,
                                 double max,
                                 int n)
                          throws FunctionEvaluationException,
                                 java.lang.IllegalArgumentException
```
    Inversely transform the given real function, sampled on the given interval.
    
    Specified by:
    
    inversetransform in interface RealTransformer
    
    Parameters:
    
    f - the function to be sampled and inversely transformed
    
    min - the lower bound for the interval
    
    max - the upper bound for the interval
    
    n - the number of sample points
    
    Returns:
    
    the real inversely transformed array
    
    Throws:
    
    FunctionEvaluationException - if function cannot be evaluated at some point
    
    java.lang.IllegalArgumentException - if any parameters are invalid
  - transform
```
public int[] transform(int[] f)
                throws java.lang.IllegalArgumentException
```
    Transform the given real data set.
    The integer transform cannot be inverted directly, due to a scaling factor it may lead to double results.
    
    Parameters:
    
    f - the integer data array to be transformed (signal)
    
    Returns:
    
    the integer transformed array (spectrum)
    
    Throws:
    
    java.lang.IllegalArgumentException - if any parameters are invalid
  - fht
```
protected double[] fht(double[] x)
                throws java.lang.IllegalArgumentException
```
    The FHT (Fast Hadamard Transformation) which uses only subtraction and addition.
    Requires Nlog2N = n2ⁿ additions.
    
    Short Table of manual calculation for N=8:
    
    x is the input vector we want to transform
    
    y is the output vector which is our desired result
    
    a and b are just helper rows
    
    +----+----------+---------+----------+ | x | a | b | y | +----+----------+---------+----------+ | x₀ | a₀=x₀+x₁ | b₀=a₀+a₁ | y₀=b₀+b₁ | +----+----------+---------+----------+ | x₁ | a₁=x₂+x₃ | b₀=a₂+a₃ | y₀=b₂+b₃ | +----+----------+---------+----------+ | x₂ | a₂=x₄+x₅ | b₀=a₄+a₅ | y₀=b₄+b₅ | +----+----------+---------+----------+ | x₃ | a₃=x₆+x₇ | b₀=a₆+a₇ | y₀=b₆+b₇ | +----+----------+---------+----------+ | x₄ | a₀=x₀-x₁ | b₀=a₀-a₁ | y₀=b₀-b₁ | +----+----------+---------+----------+ | x₅ | a₁=x₂-x₃ | b₀=a₂-a₃ | y₀=b₂-b₃ | +----+----------+---------+----------+ | x₆ | a₂=x₄-x₅ | b₀=a₄-a₅ | y₀=b₄-b₅ | +----+----------+---------+----------+ | x₇ | a₃=x₆-x₇ | b₀=a₆-a₇ | y₀=b₆-b₇ | +----+----------+---------+----------+
    How it works
    
    Construct a matrix with N rows and n+1 columns
    hadm[n+1][N]
    (If I use [x][y] it always means [row-offset][column-offset] of a Matrix with n rows and m columns. Its entries go from M[0][0] to M[n][m])
    
    Place the input vector x[N] in the first column of the matrix hadm
    
    The entries of the submatrix D_top are calculated as follows.
    D_top goes from entry [0][1] to [N/2-1][n+1].
    The columns of D_top are the pairwise mutually exclusive sums of the previous column
    
    The entries of the submatrix D_bottom are calculated as follows.
    D_bottom goes from entry [N/2][1] to [N][n+1].
    The columns of D_bottom are the pairwise differences of the previous column
    
    How D_top and D_bottom you can understand best with the example for N=8 above.
    The output vector y is now in the last column of hadm
    
    Algorithm from: http://www.archive.chipcenter.com/dsp/DSP000517F1.html
    
    Visually
    +--------+---+---+---+-----+---+ | 0 | 1 | 2 | 3 | ... |n+1| +------+--------+---+---+---+-----+---+ |0 | x₀ | /\ | |1 | x₁ | || | |2 | x₂ | <= D_top => | |... | ... | || | |N/2-1 | x_N/2-1 | \/ | +------+--------+---+---+---+-----+---+ |N/2 | x_N/2 | /\ | |N/2+1 | x_N/2+1 | || | |N/2+2 | x_N/2+2 | <= D_bottom => | which is in the last column of the matrix |... | ... | || | |N | x_N/2 | \/ | +------+--------+---+---+---+-----+---+
    Parameters:
    
    x - input vector
    
    Returns:
    
    y output vector
    
    Throws:
    
    java.lang.IllegalArgumentException - if input array is not a power of 2
  - fht
```
protected int[] fht(int[] x)
             throws java.lang.IllegalArgumentException
```
    The FHT (Fast Hadamard Transformation) which uses only subtraction and addition.
    
    Parameters:
    
    x - input vector
    
    Returns:
    
    y output vector
    
    Throws:
    
    java.lang.IllegalArgumentException - if input array is not a power of 2

Class FastHadamardTransformer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FastHadamardTransformer

Method Detail

transform

transform

inversetransform

inversetransform

transform

fht

fht