## org.apache.commons.math3.transform
Class FastSineTransformer

    java.lang.Object
      org.apache.commons.math3.transform.FastSineTransformer

All Implemented Interfaces:
  java.io.Serializable, RealTransformer

    public class FastSineTransformer

extends java.lang.Object
implements RealTransformer, java.io.Serializable

Implements the Fast Sine Transform for transformation of one-dimensional real data sets. For reference, see James S. Walker, Fast Fourier Transforms, chapter 3 (ISBN 0849371635).

There are several variants of the discrete sine transform. The present implementation corresponds to DST-I, with various normalization conventions, which are specified by the parameter `DstNormalization`. It should be noted that regardless to the convention, the first element of the dataset to be transformed must be zero.

DST-I is equivalent to DFT of an odd extension of the data series. More precisely, if x0, …, xN-1 is the data set to be sine transformed, the extended data set x0#, …, x2N-1# is defined as follows

- x0# = x0 = 0,
- xk# = xk if 1 ≤ k < N,
- xN# = 0,
- xk# = -x2N-k if N + 1 ≤ k < 2N.

Then, the standard DST-I y0, …, yN-1 of the real data set x0, …, xN-1 is equal to half of i (the pure imaginary number) times the N first elements of the DFT of the extended data set x0#, …, x2N-1#
yn = (i / 2) ∑k=02N-1 xk# exp[-2πi nk / (2N)] k = 0, …, N-1.

The present implementation of the discrete sine transform as a fast sine transform requires the length of the data to be a power of two. Besides, it implicitly assumes that the sampled function is odd. In particular, the first element of the data set must be 0, which is enforced in `transform(UnivariateFunction, double, double, int, TransformType)`, after sampling.

Since:
  1.2
Version:
  $Id: FastSineTransformer.java 1385310 2012-09-16 16:32:10Z tn $
See Also:
  Serialized Form

Field Summary
`private DstNormalization` `normalization` The type of DST to be performed.
`(package private) static long` `serialVersionUID` Serializable version identifier.

Constructor Summary
`FastSineTransformer(DstNormalization normalization)` Creates a new instance of this class, with various normalization conventions.

Method Summary
`protected double[]` `fst(double[] f)` Perform the FST algorithm (including inverse).
`double[]` `transform(double[] f, TransformType type)` Returns the (forward, inverse) transform of the specified real data set.
`double[]` `transform(UnivariateFunction f, double min, double max, int n, TransformType type)` Returns the (forward, inverse) transform of the specified real function, sampled on the specified interval.

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

Field Detail

### serialVersionUID

    static final long serialVersionUID

  Serializable version identifier.

  See Also:
    Constant Field Values

### normalization

    private final DstNormalization normalization

  The type of DST to be performed.

Constructor Detail

### FastSineTransformer

    public FastSineTransformer(DstNormalization normalization)

  Creates a new instance of this class, with various normalization conventions.

  Parameters:
    `normalization` - the type of normalization to be applied to the transformed data

Method Detail

### transform

    public double[] transform(double[] f,
                              TransformType type)

  Returns the (forward, inverse) transform of the specified real data set. The first element of the specified data set is required to be `0`.

  Specified by:
    `transform` in interface `RealTransformer`
  Parameters:
    `f` - the real data array to be transformed (signal)
    `type` - the type of transform (forward, inverse) to be performed
  Returns:
    the real transformed array (spectrum)
  Throws:
    `MathIllegalArgumentException` - if the length of the data array is not a power of two, or the first element of the data array is not zero

### transform

    public double[] transform(UnivariateFunction f,
                              double min,
                              double max,
                              int n,
                              TransformType type)

  Returns the (forward, inverse) transform of the specified real function, sampled on the specified interval. This implementation enforces `f(x) = 0.0` at `x = 0.0`.

  Specified by:
    `transform` in interface `RealTransformer`
  Parameters:
    `f` - the function to be sampled and transformed
    `min` - the (inclusive) lower bound for the interval
    `max` - the (exclusive) upper bound for the interval
    `n` - the number of sample points
    `type` - the type of transform (forward, inverse) to be performed
  Returns:
    the real transformed array
  Throws:
    `NonMonotonicSequenceException` - if the lower bound is greater than, or equal to the upper bound
    `NotStrictlyPositiveException` - if the number of sample points is negative
    `MathIllegalArgumentException` - if the number of sample points is not a power of two

### fst

    protected double[] fst(double[] f)
                    throws MathIllegalArgumentException

  Perform the FST algorithm (including inverse). The first element of the data set is required to be `0`.

  Parameters:
    `f` - the real data array to be transformed
  Returns:
    the real transformed array
  Throws:
    `MathIllegalArgumentException` - if the length of the data array is not a power of two, or the first element of the data array is not zero

Copyright (c) 2003-2013 Apache Software Foundation