Trigonometric Function

Specified trigonometric function on input

Library:
Simulink / Math Operations
HDL Coder / Math Operations

Description

The Trigonometric Function block performs common trigonometric functions and outputs the result in rad.

Supported Functions

You can select one of these functions from the Function parameter list.

Function	Description	Mathematical Expression	MATLAB^® Equivalent
`sin`	Sine of the input	`sin(u)`	`sin`
`cos`	Cosine of the input	`cos(u)`	`cos`
`tan`	Tangent of the input	`tan(u)`	`tan`
`asin`	Inverse sine of the input	`asin(u)`	`asin`
`acos`	Inverse cosine of the input	`acos(u)`	`acos`
`atan`	Inverse tangent of the input	`atan(u)`	`atan`
`atan2`	Four-quadrant inverse tangent of the input	`atan2(u)`	`atan2`
`sinh`	Hyperbolic sine of the input	`sinh(u)`	`sinh`
`cosh`	Hyperbolic cosine of the input	`cosh(u)`	`cosh`
`tanh`	Hyperbolic tangent of the input	`tanh(u)`	`tanh`
`asinh`	Inverse hyperbolic sine of the input	`asinh(u)`	`asinh`
`acosh`	Inverse hyperbolic cosine of the input	`acosh(u)`	`acosh`
`atanh`	Inverse hyperbolic tangent of the input	`atanh(u)`	`atanh`
`sincos`	Sine of the input; cosine of the input	—	—
`cos + jsin`	Complex exponential of the input	—	—

CORDIC Approximation Method

If you use the CORDIC approximation method (see More About), the block input has some further requirements.

When you set Function to sin, cos, sincos, or cos + jsin, and set the Approximation method to CORDIC, the block has these limitations:

When you use signed fixed-point types, the input angle must fall within the range [–2π, 2π) rad.
When you use unsigned fixed-point types, the input angle must fall within the range [0, 2π) rad.

When you set Function to atan2 and the Approximation method to CORDIC, the block has these limitations:

Inputs must be the same size, or at least one value must be a scalar value.
Both inputs must have the same data type.
When you use signed fixed-point types, the word length must be 126 or less.
When you use unsigned fixed-point types, the word length must be 125 or less.

This table summarizes what happens for an invalid input.

Block Usage	Effect of Invalid Input
Simulation modes	An error appears.
Generated code	Undefined behavior occurs. Avoid relying on undefined behavior for generated code.

Ports

Input

expand all

`Port_1` — Input signal
scalar | vector | matrix

Input specified as a scalar, vector, or matrix. The block accepts input signals of the following data types:

Functions	Input Data Types
`sin` `cos` `sincos` `cos + jsin` `atan2`	Floating point Fixed point (only when Approximation method is `CORDIC`)
`tan` `asin` `acos` `atan` `sinh` `cosh` `tanh` `asinh` `acosh` `atanh`	Floating point

Dependencies

When you set Function to atan2, the block shows two input ports. The first input (Port_1) is the y-axis or imaginary part of the function argument. The second input (Port_2) is the x-axis or real part of the function argument.

You can use floating-point input signals when you set Approximation method to None or CORDIC. However, the block output data type depends on which of these approximation method options you choose.

Input Data Type	Approximation Method	Output Data Type
Floating point	`None`	Depends on your selection for Output signal type. Options are `auto` (same data type as input), `real`, or `complex`.
Floating point	`CORDIC`	Same as input. Output signal type is not available when you use the CORDIC approximation method to compute the block output.

For CORDIC approximations:

Input must be real for the sin, cos, sincos, cos + jsin, and atan2 functions.
Output is real for the sin, cos, sincos, and atan2 functions.
Output is complex for the cos + jsin function.

Limitations

Complex input signals are supported for all functions in this block, except atan2.

You can use fixed-point input signals only when Approximation method is set to CORDIC. The CORDIC approximation is available for the sin, cos, sincos, cos + jsin, and atan2 functions. For the atan2 function, the relationship between input and output data types depends also on whether the fixed-point input is signed or unsigned.

Input Data Type Function Output Data Type

Input Data Type	Function	Output Data Type
Fixed point, signed or unsigned	`sin`, `cos`, `sincos`, and `cos + jsin`	`fixdt(1, WL, WL - 2)` where `WL` is the input word length This fixed-point type provides the best precision for the CORDIC algorithm.
Fixed point, signed	`atan2`	`fixdt(1, WL, WL – 3)`
Fixed point, unsigned	`atan2`	`fixdt(1, WL, WL – 2)`

Fixed point, signed or unsigned

sin, cos, sincos, and

cos +
												jsin

fixdt(1, WL, WL - 2) where WL is the input word length

This fixed-point type provides the best precision for the CORDIC algorithm.

Fixed point, signed

atan2

fixdt(1, WL, WL – 3)

Fixed point, unsigned

atan2

fixdt(1, WL, WL – 2)

When you set Function to sin, cos, sincos, or cos + jsin, and set the Approximation method to CORDIC, the block has these limitations:

When you use signed fixed-point types, the input angle must fall within the range [–2π, 2π) rad.
When you use unsigned fixed-point types, the input angle must fall within the range [0, 2π) rad.

When you set Function to atan2 and the Approximation method to CORDIC, the block has these limitations:

Inputs must be the same size, or at least one value must be a scalar value.
Both inputs must have the same data type.
When you use signed fixed-point types, the word length must be 126 or less.
When you use unsigned fixed-point types, the word length must be 125 or less.

`Port_2` — x-axis or real part of the function argument for `atan2`
scalar | vector | matrix

Input the x-axis or real part of the function argument for atan2. When you set Function to atan2, the block shows two input ports. The first input (Port_1) is the y-axis or imaginary part of the function argument. The second input (Port_2) is the x-axis or real part of the function argument. (See Port Location After Rotating or Flipping for a description of the port order for various block orientations.)

Dependencies

To enable this port, set Function to atan2.

Limitations

Fixed-point input signals are supported only when you set Approximation method to CORDIC.
When you set Function to atan2 and Approximation method to CORDIC:
- Inputs must be the same size, or at least one value must be a scalar value.
- Both inputs must have the same data type.
- When you use signed fixed-point types, the word length must be 126 or less.
- When you use unsigned fixed-point types, the word length must be 125 or less.

Output

expand all

`Port_1` — Specified trigonometric function of input
scalar | vector | matrix

Result of applying the specified trigonometric function to one or more inputs in rad. Each function supports:

Scalar operations
Element-wise vector and matrix operations

`sin` — Sine of input signal
scalar | vector | matrix

Sine of the input signal, in rad.

Dependencies

To enable this port, set Function to sincos.

Limitations

Fixed-point input signals are supported only when you set Approximation method to CORDIC.

`cos` — Cosine of input signal
scalar | vector | matrix

Cosine of the input signal, in rad.

Dependencies

To enable this port, set Function to sincos.

Limitations

Fixed-point input signals are supported only when you set Approximation method to CORDIC.

Parameters

expand all

`Function` — Trigonometric function
`sin` (default) | `cos` | `tan` | `asin` | `acos` | `atan` | `atan2` | `sinh` | `cosh` | `tanh` | `asinh` | `acosh` | `atanh` | `sincos` | `cos + jsin`

Specify the trigonometric function. The name of the function on the block icon changes to match your selection.

Limitations

When you set Function to sin, cos, sincos, or cos + jsin, and set the Approximation method to CORDIC, the block has these limitations:

When you use signed fixed-point types, the input angle must fall within the range [–2π, 2π) rad.
When you use unsigned fixed-point types, the input angle must fall within the range [0, 2π) rad.

When you set Function to atan2 and the Approximation method to CORDIC, the block has these limitations:

Inputs must be the same size, or at least one value must be a scalar value.
Both inputs must have the same data type.
When you use signed fixed-point types, the word length must be 126 or less.
When you use unsigned fixed-point types, the word length must be 125 or less.

Programmatic Use

Block Parameter: Operator

Type: character vector

Values:

'sin' | 'cos' | 'tan' | 'asin' | 'acos' | 'atan' | 'atan2'
									| 'sinh' | 'cosh' | 'tanh' | 'asinh' | 'acosh' | 'atanh' |
									'sincos' | 'cos + jsin'

Default: 'sin'

`Approximation method` — CORDIC or none
`None` (default) | `CORDIC`

Specify the type of approximation for computing output.

Approximation Method	Data Types Supported	When to Use This Method
`None` (default)	Floating point	You want to use the default Taylor series algorithm.
`CORDIC`	Floating point and fixed point	You want a fast, approximate calculation.

If you select CORDIC and enlarge the block from the default size, the block icon changes:

Function	Block Icon
`sin`
`cos`
`sincos`
`cos + jsin`
`atan2`

Dependencies

To enable this parameter, set Function to sin, cos, sincos, cos + jsin, or atan2.

To use fixed-point input signals, you must set Approximation method to CORDIC.

Limitations

When you set Function to sin, cos, sincos, or cos + jsin, and set the Approximation method to CORDIC, the block has these limitations:

When you use signed fixed-point types, the input angle must fall within the range [–2π, 2π) rad.
When you use unsigned fixed-point types, the input angle must fall within the range [0, 2π) rad.

When you set Function to atan2 and the Approximation method to CORDIC, the block has these limitations:

Inputs must be the same size, or at least one value must be a scalar value.
Both inputs must have the same data type.
When you use signed fixed-point types, the word length must be 126 or less.
When you use unsigned fixed-point types, the word length must be 125 or less.

Programmatic Use

Block Parameter: ApproximationMethod

Type: character vector

Values: 'None' | 'CORDIC'

Default: 'None'

`Number of iterations` — Number of iterations for CORDIC algorithm
`11` (default) | positive integer, less than or equal to word length of fixed-point input

Specify the number of iterations to perform the CORDIC algorithm. The default value is 11.

When the block input uses a floating-point data type, the number of iterations can be a positive integer.
When the block input is a fixed-point data type, the number of iterations cannot exceed the word length.
For example, if the block input is fixdt(1,16,15), the word length is 16. In this case, the number of iterations cannot exceed 16.

Dependencies

To enable this parameter, you must set the Function and Approximation method parameters as follows:

Set Function to sin, cos, sincos, cos + jsin, or atan2.
Set Approximation method to CORDIC.

Programmatic Use

Block Parameter: NumberOfIterations

Type: character vector

Values: positive integer, less than or equal to word length of fixed-point input

Default: '11'

`Output signal type` — complexity of output signal
`auto` (default) | `real` | `complex`

Specify the output signal type of the Trigonometric Function block as auto, real, or complex.

Function	Input Signal Type	Output Signal Type
Function	Input Signal Type	Auto	Real	Complex
Any selection for the Function parameter	real	real	real	complex
Any selection for the Function parameter	complex	complex	error	complex

Dependencies

Setting Approximation method to CORDIC disables this parameter.

Note

When Function is atan2, complex input signals are not supported for simulation or code generation.

Programmatic Use

Block Parameter: OutputSignalType

Type: character vector

Values: 'auto' | 'real' | 'complex'

Default: 'auto'

`Sample time` — Specify sample time as a value other than `-1`
`-1` (default) | scalar | vector

Specify the sample time as a value other than -1. For more information, see Specify Sample Time.

Dependencies

This parameter is not visible unless it is explicitly set to a value other than -1. To learn more, see Blocks for Which Sample Time Is Not Recommended.

Programmatic Use

Block Parameter: SampleTime

Type: character vector

Values: scalar or vector

Default: '-1'

Model Examples

sin Function with Floating-Point Input

Use the Trigonometric Function block to compute the sine of a floating-point input.

Open Model

sincos Function with Fixed-Point Input

Use the Trigonometric Function block to compute the CORDIC approximation of sincos for a fixed-point input signal.

Open Model

Trigonometric Function Block Behavior for Complex Exponential Output

Compares the complex exponential output for two different configurations of the Trigonometric Function block.

Open Model

Block Characteristics

Data Types	`double` \| `fixed point^[a]` \| `half` \| `integer^[a]` \| `single`
Direct Feedthrough	`yes`
Multidimensional Signals	`yes`
Variable-Size Signals	`yes`
Zero-Crossing Detection	`no`
^[a] This block supports fixed-point and base integer data types for 'Approximation method' CORDIC.

More About

expand all

CORDIC

CORDIC is an acronym for COordinate Rotation DIgital Computer. The Givens rotation-based CORDIC algorithm is one of the most hardware-efficient algorithms available because it requires only iterative shift-add operations (see References). The CORDIC algorithm eliminates the need for explicit multipliers. Using CORDIC, you can calculate various functions, such as sine, cosine, arc sine, arc cosine, arc tangent, and vector magnitude. You can also use this algorithm for divide, square root, hyperbolic, and logarithmic functions.

Increasing the number of CORDIC iterations can produce more accurate results, but doing so also increases the expense of the computation and adds latency.

References

[1] Volder, JE. “The CORDIC Trigonometric Computing Technique.” IRE Transactions on Electronic Computers EC-8 (1959); 330–334.

[2] Andraka, R. “A survey of CORDIC algorithm for FPGA based computers.” Proceedings of the 1998 ACM/SIGDA sixth international symposium on Field programmable gate arrays. Feb. 22–24 (1998): 191–200.

[3] Walther, J.S. “A Unified Algorithm for Elementary Functions.” Hewlett-Packard Company, Palo Alto. Spring Joint Computer Conference (1971): 379–386. (from the collection of the Computer History Museum). www.computer.org/csdl/proceedings/afips/1971/5077/00/50770379.pdf

[4] Schelin, Charles W. “Calculator Function Approximation.” The American Mathematical Monthly 90, no. 5 (1983): 317–325.

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using Simulink® Coder™.

Not all compilers support the asinh, acosh, and atanh functions. If you use a compiler that does not support those functions, a warning appears and the generated code fails to link.

HDL Code Generation
Generate Verilog and VHDL code for FPGA and ASIC designs using HDL Coder™.

HDL Coder™ provides additional configuration options that affect HDL implementation and synthesized logic.

HDL Architecture

You can generate HDL code for all functions of the block with floating-point data types and architecture set to Trigonometric in native floating-point mode. The native floating-point mode does not support double data types for the block.

This block has multi-cycle implementations that introduce additional latency in the generated code. To see the added latency, view the generated model or validation model. See Generated Model and Validation Model (HDL Coder).

The Trigonometric Function block supports HDL code generation for these functions in this table with CORDIC approximation method and Cordic HDL architecture for fixed-point data types.

sin
cos
sincos
cos+jsin
atan2

The latency calculation depends on the word length and LatencyStrategy settings. To learn more, open the HDLMathLib library.

HDLMathLib

HDL Block Properties

General
ConstrainedOutputPipeline	Number of registers to place at the outputs by moving existing delays within your design. Distributed pipelining does not redistribute these registers. The default is `0`. For more details, see ConstrainedOutputPipeline (HDL Coder).
InputPipeline	Number of input pipeline stages to insert in the generated code. Distributed pipelining and constrained output pipelining can move these registers. The default is `0`. For more details, see InputPipeline (HDL Coder).
OutputPipeline	Number of output pipeline stages to insert in the generated code. Distributed pipelining and constrained output pipelining can move these registers. The default is `0`. For more details, see OutputPipeline (HDL Coder).
LatencyStrategy	To enable this property for fixed-point types, set Function as `sin`, `cos`, `sincos`, `cos+jsin`, or `atan2` and Approximation method as `CORDIC`. Specify whether to map the blocks in your design to `MAX`, `CUSTOM`, or `ZERO` latency for fixed-point and floating-point types. The default is `MAX`. See also LatencyStrategy (HDL Coder).
CustomLatency	To enable this property for fixed-point types, set Function as `sin`, `cos`, `sincos`, `cos+jsin`, or `atan2` and Approximation method as `CORDIC`. When LatencyStrategy is set to `CUSTOM`, use this property to specify a custom latency value between `ZERO` and `MAX` for fixed-point types. See also LatencyStrategy (HDL Coder).

Native Floating Point
InputRangeReduction	Use this property for the sin, cos, tan, sincos, and cos+jsin functions. If your input range is unbounded, enable this property for HDL Coder to insert additional logic to reduce the range of inputs to `[-pi, pi]`. See also InputRangeReduction (HDL Coder).
HandleDenormals	Specify whether you want HDL Coder to insert additional logic to handle denormal numbers in your design. Denormal numbers are numbers that have magnitudes less than the smallest floating-point number that can be represented without leading zeros in the mantissa. The default is `inherit`. See also HandleDenormals (HDL Coder).
LatencyStrategy	Specify whether to map the blocks in your design to `inherit`, `Max`, `Min`, or `Zero` for the floating-point operator. The default is `inherit`. See also LatencyStrategy (HDL Coder).
NFPCustomLatency	To enable this property for fixed-point types, set Function as `sin`, `cos`, `sincos`, `cos+jsin`, or `atan2` and Approximation method as `CORDIC`. When LatencyStrategy is set to `CUSTOM`, use this property to specify a custom latency value between `ZERO` and `MAX` for fixed-point types. See also LatencyStrategy (HDL Coder).
MultiplyStrategy	Use this property for the sin, cos, tan, sincos, and cos+jsin functions. The default is `inherit`. Specify whether you want to use `FullMultiplier` or `PartMultiplierPartAddShift`. See also MantissaMultiplyStrategy (HDL Coder).

To see the latency calculation for fixed-point types with the block, at the MATLAB command prompt, enter:

HDLMathLib

Restrictions

For the sin and cos functions, only signed fixed-point data types are supported for CORDIC approximations.
For functions that have the CORDIC mode such as sin, cos, sincos, atan2, and cos+jsin, fixed-point data types greater than 127 bits are not supported for HDL code generation.
HDL Coder displays an error when you select these settings for a Trigonometric Function block inside a feedback loop:
- HDL architecture as SinCosCordic
- UsePipelinedKernel as On
The error occurs because the block is in a feedback loop and the code generator is unable to insert additional latency. To avoid this error, add a delay of length equal to the Number of iterations + 3 adjacent to the block. The code generator then absorbs this delay to meet the additional latency of the Trigonometric Function block.
For example, this Trigonometric Function block has Number of iterations set to 30. A Delay of length 33 adjacent to the block meets the additional latency.

PLC Code Generation
Generate Structured Text code using Simulink® PLC Coder™.

Fixed-Point Conversion
Design and simulate fixed-point systems using Fixed-Point Designer™.

This block supports fixed-point and base integer data types when you set the Function to sin, cos, sincos, cos + jsin, or atan2, and set the Approximation method to CORDIC.

Documentation

Trigonometric Function

Description

Supported Functions

CORDIC Approximation Method

Ports

Input

Port_1 — Input signal scalar | vector | matrix

Dependencies

Limitations

Port_2 — x-axis or real part of the function argument for atan2 scalar | vector | matrix

Dependencies

Limitations

Output

Port_1 — Specified trigonometric function of input scalar | vector | matrix

sin — Sine of input signal scalar | vector | matrix

Dependencies

Limitations

cos — Cosine of input signal scalar | vector | matrix

Dependencies

Limitations

Parameters

Function — Trigonometric function sin (default) | cos | tan | asin | acos | atan | atan2 | sinh | cosh | tanh | asinh | acosh | atanh | sincos | cos + jsin

Limitations

Programmatic Use

Approximation method — CORDIC or none None (default) | CORDIC

Dependencies

Limitations

Programmatic Use

Number of iterations — Number of iterations for CORDIC algorithm 11 (default) | positive integer, less than or equal to word length of fixed-point input

Dependencies

Programmatic Use

Output signal type — complexity of output signal auto (default) | real | complex

Dependencies

Programmatic Use

Sample time — Specify sample time as a value other than -1 -1 (default) | scalar | vector

Dependencies

Programmatic Use

Model Examples

sin Function with Floating-Point Input

sincos Function with Fixed-Point Input

Trigonometric Function Block Behavior for Complex Exponential Output

Block Characteristics

More About

CORDIC

References

Extended Capabilities

C/C++ Code Generation Generate C and C++ code using Simulink® Coder™.

HDL Code Generation Generate Verilog and VHDL code for FPGA and ASIC designs using HDL Coder™.

PLC Code Generation Generate Structured Text code using Simulink® PLC Coder™.

Fixed-Point Conversion Design and simulate fixed-point systems using Fixed-Point Designer™.

See Also

Blocks

Functions

Simulink Documentation

Support

`Port_1` — Input signal
scalar | vector | matrix

`Port_2` — x-axis or real part of the function argument for `atan2`
scalar | vector | matrix

`Port_1` — Specified trigonometric function of input
scalar | vector | matrix

`sin` — Sine of input signal
scalar | vector | matrix

`cos` — Cosine of input signal
scalar | vector | matrix

`Function` — Trigonometric function
`sin` (default) | `cos` | `tan` | `asin` | `acos` | `atan` | `atan2` | `sinh` | `cosh` | `tanh` | `asinh` | `acosh` | `atanh` | `sincos` | `cos + jsin`

`Approximation method` — CORDIC or none
`None` (default) | `CORDIC`

`Number of iterations` — Number of iterations for CORDIC algorithm
`11` (default) | positive integer, less than or equal to word length of fixed-point input

`Output signal type` — complexity of output signal
`auto` (default) | `real` | `complex`

`Sample time` — Specify sample time as a value other than `-1`
`-1` (default) | scalar | vector

C/C++ Code Generation
Generate C and C++ code using Simulink® Coder™.

HDL Code Generation
Generate Verilog and VHDL code for FPGA and ASIC designs using HDL Coder™.

PLC Code Generation
Generate Structured Text code using Simulink® PLC Coder™.

Fixed-Point Conversion
Design and simulate fixed-point systems using Fixed-Point Designer™.