Version:

Last Modified: March 15, 2017

Computes the Discrete Sine Transform (DST) of a sequence.

A real vector.

This input can be a 1D or 2D array of double-precision, floating-point numbers.

The length of the DST you want to perform.

If **DST size** is greater than the number of elements in **x**, this node adds zeros to the end of **x** to match the size of **DST size**. If **DST size** is less than the number of elements in **x**, this node uses only the leading **DST size** elements in **x** to perform the DST. If **DST size** is less than or equal to zero, this node uses the length of **x** as the **DST size**.

This input is available only if you wire a 1D array of double-precision, floating-point numbers to **x**.

Error conditions that occur before this node runs.

The node responds to this input according to standard error behavior.

Standard Error Behavior

Many nodes provide an **error in** input and an **error out** output so that the node can respond to and communicate errors that occur while code is running. The value of **error in** specifies whether an error occurred before the node runs. Most nodes respond to values of **error in** in a standard, predictable way.

**Default: **No error

The DST of the input sequence.

Error information.

The node produces this output according to standard error behavior.

Standard Error Behavior

**error in** input and an **error out** output so that the node can respond to and communicate errors that occur while code is running. The value of **error in** specifies whether an error occurred before the node runs. Most nodes respond to values of **error in** in a standard, predictable way.

The one-dimensional Discrete Sine Transform **DST{x}** of a 1D array **x** is defined as:

${Y}_{k}=\underset{n=0}{\overset{N-1}{\sum}}{x}_{n}\mathrm{sin}\frac{\pi (k+1)(n+1)}{N+1},\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}k=0,\text{\hspace{0.17em}}1,\text{\hspace{0.17em}}2,\text{\hspace{0.17em}}\mathrm{...},\text{\hspace{0.17em}}N-1$

where

*N*is the length of the input sequence**x***y*_{k}is the*k*^{th}element of**DST{x}***x*_{n}is the*n*^{th}element of**x**

This node applies a fast DST algorithm instead of calculating the Discrete Sine Transform directly. This node implements the fast DST algorithm using an FFT-based technique.

The two-dimensional Discrete Sine Transform **DST{x}** of a 2D array **x** is defined as:

$y(u,\text{\hspace{0.17em}}v)=\underset{m=0}{\overset{M-1}{\sum}}\underset{n=0}{\overset{N-1}{\sum}}x(m,\text{\hspace{0.17em}}n)\mathrm{sin}\frac{\pi (u+1)(m+1)}{M+1}\mathrm{sin}\frac{\pi (v+1)(n+1)}{N+1}$

where

*M*is the number of rows of**x***N*is the number of columns of**x**- x(m, n) is the element of the input matrix
**x**with row number*m*and column number*n* - y(u, v) is the element of the output matrix
**DST{x}**with row number*u*and column number*v*

This node performs a two-dimensional DST using the following two steps:

**Where This Node Can Run: **

Desktop OS: Windows

FPGA: This product does not support FPGA devices