Mastering Trigonometry with STL in Visual C++: A Practical Guide

Updated: 18 Jun, 2025 • 0 • min read

Table of Contents

The C++ Standard Template Library (STL) provides a powerful set of tools for various programming tasks. Among these tools are mathematical functions, including a comprehensive suite for trigonometric calculations. While these functions are commonly used with scalar values, the STL also offers specialized support for applying these operations element-wise to sequences of numbers, particularly through the valarray container. This article explores how to leverage the trigonometric functions provided in the STL, specifically designed to work efficiently with valarray, within the context of unmanaged Visual C++ development. Understanding these features is crucial for developers working on numerical computations, signal processing, or any application requiring bulk trigonometric calculations.

Mastering Trigonometry with STL in Visual C++

Understanding `valarray` for Numerical Computing¶

The std::valarray container in C++ is a class template specifically designed to support high-speed, element-wise operations on arrays of values. Unlike std::vector, which is a general-purpose dynamic array, valarray is optimized for numerical operations, allowing mathematical functions and operators to be applied to the entire array simultaneously. This design makes valarray particularly well-suited for scientific and engineering computations where operations like applying a trigonometric function to every element of a dataset are common. When you apply an operation like sin(my_valarray), the function is effectively applied to each element in my_valarray, returning a new valarray containing the results. This element-wise application is a core strength of the valarray container and simplifies code for numerical tasks compared to iterating through elements manually.

Essential Headers¶

To utilize the STL trigonometric functions with valarray, you need to include the appropriate header files. The primary header for the valarray container itself is <valarray>. This header defines the valarray class template and its associated types.

The mathematical functions, including the trigonometric ones and their valarray overloads, are primarily found in the <cmath> header. Including both <valarray> and <cmath> provides access to the necessary container and the specialized functions designed to operate on it efficiently.

The STL Trigonometry Functions¶

The STL provides a set of common trigonometric and hyperbolic functions with overloads specifically for std::valarray. These functions operate element by element, taking one or two valarray arguments (or a valarray and a scalar) and returning a new valarray of the same size and element type, where each element is the result of applying the function to the corresponding element(s) of the input.

Below are the standard prototypes for these functions when used with valarray<T>, where T is typically a floating-point type like float, double, or long double.

`acos` (Arc Cosine)¶

The acos function calculates the principal value of the arc cosine (inverse cosine) for each element in the input valarray. The input values must be within the range [-1, 1]. The returned values are in the range of [0, pi] radians.

template <class T>
inline valarray<T> acos(const valarray<T>& x);

`asin` (Arc Sine)¶

The asin function computes the principal value of the arc sine (inverse sine) for each element in the input valarray. Similar to acos, the input values must fall within the domain [-1, 1]. The results are in the range of [-pi/2, pi/2] radians.

template <class T>
inline valarray<T> asin(const valarray<T>& x);

`atan` (Arc Tangent)¶

The atan function determines the principal value of the arc tangent (inverse tangent) for each element in the input valarray. This function accepts any real number as input. The calculated values are in the range of [-pi/2, pi/2] radians.

template <class T>
inline valarray<T> atan(const valarray<T>& x);

`atan2` (Arc Tangent with Two Arguments)¶

The atan2 function calculates the arc tangent of y/x for corresponding elements y[I] and x[I] from two input valarrays, or for elements y[I] and a scalar x, or a scalar y and elements x[I]. It correctly handles the signs of both arguments to determine the quadrant of the result, returning a value in the range of [-pi, pi] radians. This function is particularly useful for converting Cartesian coordinates (x, y) to polar coordinates (r, theta).

template <class T>
inline valarray<T> atan2(const valarray<T>& x, const valarray<T>& y);

template <class T>
inline valarray<T> atan2(const valarray<T> x, const T& y);

template <class T>
inline valarray<T> atan2(const T& x, const valarray<T>& y);

Note that the parameter order in the atan2 template prototypes above differs slightly from the standard mathematical convention (where it’s often atan2(y, x)) and the sample code. It’s crucial to refer to your specific compiler’s library documentation for the exact parameter order of atan2’s valarray overloads to ensure correct usage. The sample code below follows the convention atan2(y, x).

`cos` (Cosine)¶

The cos function computes the cosine of each element in the input valarray. The input values are interpreted as angles in radians. The output values are in the range [-1, 1].

template <class T>
inline valarray<T> cos(const valarray<T>& x);

`cosh` (Hyperbolic Cosine)¶

The cosh function calculates the hyperbolic cosine of each element in the input valarray. Hyperbolic functions are analogous to ordinary trigonometric functions but are defined using the hyperbola rather than the circle. The cosh(x) function is defined as (e^x + e^-x) / 2.

template <class T>
inline valarray<T> cosh(const valarray<T>& x);

`sin` (Sine)¶

The sin function calculates the sine of each element in the input valarray. The input values represent angles in radians. The output values fall within the range [-1, 1].

template <class T>
inline valarray<T> sin(const valarray<T>& x);

`sinh` (Hyperbolic Sine)¶

The sinh function computes the hyperbolic sine of each element in the input valarray. The sinh(x) function is defined as (e^x - e^-x) / 2.

template <class T>
inline valarray<T> sinh(const valarray<T>& x);

`tan` (Tangent)¶

The tan function determines the tangent of each element in the input valarray. Input values are treated as angles in radians. The tangent function has singularities at pi/2 + n*pi, where n is an integer, so care should be taken with input values near these points.

template <class T>
inline valarray<T> tan(const valarray<T>& x);

`tanh` (Hyperbolic Tangent)¶

The tanh function calculates the hyperbolic tangent of each element in the input valarray. The tanh(x) function is defined as sinh(x) / cosh(x). As the input value x approaches positive or negative infinity, tanh(x) approaches 1 or -1, respectively.

template <class T>
inline valarray<T> tanh(const valarray<T>& x);

It’s important to remember that the exact template parameter names (T, x, y) in these prototypes are illustrative. The actual names might vary in the specific header files provided by different compilers, but the structure and purpose remain consistent.

Practical Demonstration: Sample Code Analysis¶

Let’s dissect the provided sample code to understand how these functions are used in practice with std::valarray. The code demonstrates the application of all the mentioned trigonometric and hyperbolic functions to one or two valarray objects.

//////////////////////////////////////////////////////////////////////
// Compile options needed: /GX
// main.cpp : Illustrates the use of STL trigonometry functions.
// Functions:
// acos, asin, atan, atan2, cos, cosh, sin, sinh, tan, tanh
// Copyright (c) 1996 Microsoft Corporation. All rights reserved.
//////////////////////////////////////////////////////////////////////

#include <iostream> // for i/o functions
#include <valarray> // for valarray
#include <cmath>    // for trigonometry functions

#if _MSC_VER > 1020  // if VC++ version is > 4.2
using namespace std; // std c++ libs implemented in std
#endif

#define ARRAY_SIZE 3 // array size

void main()
{
    // Initialize val_array to values -1, 0 and 1.
    valarray<double> val_array(ARRAY_SIZE);
    for (int i = 0; i < ARRAY_SIZE; i++)
        val_array[i] = i - 1;

    // Display the size of val_array.
    cout << "Size of val_array = " << val_array.size() << endl;

    // Display the values of val_array before calling any trigonometry
    // functions.
    cout << "The values in val_array:" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << val_array[i] << " ";
    cout << endl << endl;

    // Initialize rev_valarray that is the reverse of val_array.
    valarray<double> rev_valarray(ARRAY_SIZE);
    for (int i = 0; i < ARRAY_SIZE; i++)
        rev_valarray[i] = val_array[ARRAY_SIZE - i - 1];

    // Display the size of rev_valarray.
    cout << "Size of rev_valarray = " << rev_valarray.size() << endl;

    // Display the values of rev_valarray.
    cout << "The values in rev_valarray:" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rev_valarray[i] << " ";
    cout << endl << endl;

    // rvalue_array to hold the return value from calling the trigonometry
    // functions.
    valarray<double> rvalue_array;

    // acos() - display the result of rvalue_array
    rvalue_array = acos(val_array);
    cout << "The result after calling acos():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // asin() - display the result of rvalue_array
    rvalue_array = asin(val_array);
    cout << "The result after calling asin():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // atan() - display the result of rvalue_array
    rvalue_array = atan(val_array);
    cout << "The result after calling atan():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // atan2() - display the result of rvalue_array

    // This template function returns an object of class valarray<T>,
    // each of whose elements at I is the arctangent of x[I] / y[I].
    rvalue_array = atan2(val_array, rev_valarray);
    cout << "The result after calling atan2(val_array, rev_valarray):"
         << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // This template function stores in element I the arctangent of
    // x[I] / y.
    rvalue_array = atan2(val_array, 3.1416);
    cout << "The result after calling atan2(val_array, 3.1416):" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // This template function stores in element I the arctangent of
    // x / y[I].
    rvalue_array = atan2(3.1416, val_array);
    cout << "The result after calling atan2(3.1416, val_array):" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // cos() - display the result of rvalue_array
    rvalue_array = cos(val_array);
    cout << "The result after calling cos():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // cosh() - display the result of rvalue_array
    rvalue_array = cosh(val_array);
    cout << "The result after calling cosh():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // sin() - display the result of val_array
    rvalue_array = sin(val_array);
    cout << "The result after calling sin():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // sinh() - display the result of val_array
    rvalue_array = sinh(val_array);
    cout << "The result after calling sinh():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // tan() - display the result of val_array
    rvalue_array = tan(val_array);
    cout << "The result after calling tan():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;

    // tanh() - display the result of val_array
    rvalue_array = tanh(val_array);
    cout << "The result after calling tanh():" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << " ";
    cout << endl << endl;
}

Setting up the Environment¶

The code begins with standard includes for I/O (<iostream>), the valarray container (<valarray>), and the math functions (<cmath>). The #if _MSC_VER > 1020 block is a common pattern in older Microsoft Visual C++ projects to conditionally use the std namespace, aligning with the standard library placement in later compiler versions. ARRAY_SIZE is defined as 3, determining the size of the valarray objects used in the example. The entry point is the main function.

Initializing `valarray` Objects¶

Two valarray<double> objects, val_array and rev_valarray, are created with a size of ARRAY_SIZE (3). val_array is initialized with values -1, 0, and 1 using a simple for loop. rev_valarray is then populated with the elements of val_array in reverse order, resulting in values 1, 0, and -1. The code prints the size and contents of both arrays to the console before proceeding to the trigonometric calculations.

Applying Trigonometric Functions¶

A third valarray<double>, rvalue_array, is declared to store the results of the function calls. For each trigonometric and hyperbolic function (acos, asin, atan, cos, cosh, sin, sinh, tan, tanh), the function is called with val_array as the argument. The result, which is a new valarray, is assigned to rvalue_array, and its contents are printed.

The atan2 function is demonstrated with all three of its valarray overloads:
1. atan2(val_array, rev_valarray): Calculates atan2(val_array[i], rev_valarray[i]) for each index i.
2. atan2(val_array, 3.1416): Calculates atan2(val_array[i], 3.1416) for each index i. Here, the scalar 3.1416 (an approximation of pi) is used as the second argument for all elements.
3. atan2(3.1416, val_array): Calculates atan2(3.1416, val_array[i]) for each index i. Here, the scalar 3.1416 is used as the first argument for all elements.

These calls showcase the flexibility of valarray functions to handle operations between two arrays or an array and a scalar value.

Interpreting the Results¶

When running this code, the output for each function call will be a sequence of numbers corresponding to the function applied to -1, 0, and 1 (or pairs of values for atan2).

For functions like cos, sin, tan, cosh, sinh, tanh, the output will be the respective function value for -1, 0, and 1.
For acos and asin, the inputs -1, 0, and 1 are within their valid domain [-1, 1], so the code will produce the corresponding arc cosine and arc sine values in radians.
For atan, all inputs are valid, and the arc tangent values will be calculated.
For atan2(val_array, rev_valarray), the pairs are (-1, 1), (0, 0), and (1, -1). The results will be atan2(-1, 1), atan2(0, 0), and atan2(1, -1) respectively. Note that atan2(0,0) is typically defined as 0 or might result in a NaN (Not-a-Number) depending on the implementation.
For atan2(val_array, 3.1416), the results will be atan2(-1, 3.1416), atan2(0, 3.1416), and atan2(1, 3.1416).
For atan2(3.1416, val_array), the results will be atan2(3.1416, -1), atan2(3.1416, 0), and atan2(3.1416, 1). atan2(positive, 0) should yield pi/2 radians.

The exact numerical output will depend on the floating-point precision of the system but will correspond to the mathematical values in radians.

Considerations and Best Practices¶

When working with these functions, several points are worth keeping in mind:

Floating-Point Accuracy¶

Numerical computations with floating-point types (float, double, long double) are subject to precision limitations. The results of trigonometric functions may not be exactly equal to their mathematical ideal values due to the inherent nature of representing real numbers in binary. Comparing floating-point results directly for equality should generally be avoided; instead, check if they are within a small epsilon tolerance.

Domain Errors¶

Functions like acos and asin have restricted input domains ([-1, 1]). If any element in the input valarray falls outside this range, the behavior is undefined by the C++ standard prior to C++11. Since C++11, these functions typically return a NaN (Not-a-Number) value and might set floating-point error flags, but they are not required to throw exceptions for invalid inputs. For atan2, atan2(0, 0) might also be a special case resulting in NaN or zero depending on the implementation. It’s important to ensure your input data is valid if precise results are required.

Performance Aspects¶

std::valarray was designed with potential performance optimizations in mind, such as vectorization, where a single instruction can operate on multiple data elements simultaneously. Modern compilers and libraries can often vectorize operations applied to valarray, potentially leading to significant speedups compared to manual loops. However, the actual performance depends heavily on the compiler, the underlying hardware, and the complexity of the expression. For critical performance needs, benchmarking with specific data and hardware is always recommended.

Expanding the Example¶

The provided sample is a basic illustration. You can expand upon it in several ways:
* Use a larger ARRAY_SIZE to see the behavior on bigger datasets.
* Experiment with different input values, including those near the boundaries of the domains or values that might cause large or small results (e.g., very large inputs for cosh or sinh).
* Change the element type from double to float or long double to observe potential differences in precision and performance.
* Combine multiple operations, such as rvalue_array = sin(val_array) + cos(rev_valarray);, to see how valarray handles element-wise binary operations.
* Implement conversion functions between degrees and radians to apply these functions to angles specified in degrees.

Conclusion and Further Exploration¶

The STL trigonometric functions, especially when used with std::valarray, provide a convenient and potentially efficient way to perform element-wise mathematical operations on arrays of numbers in Visual C++. The valarray container’s design is tailored for such numerical tasks, offering a more expressive syntax for vector-like operations compared to standard algorithms on other containers. By understanding the available functions, their prototypes, and how they interact with valarray, developers can write cleaner and potentially faster code for various scientific and engineering applications.

Have you used valarray for numerical tasks in your C++ projects? Share your experiences or ask questions in the comments below!

Computacionvinchi

Mastering Trigonometry with STL in Visual C++: A Practical Guide

Understanding `valarray` for Numerical Computing¶

Essential Headers¶

The STL Trigonometry Functions¶

`acos` (Arc Cosine)¶

`asin` (Arc Sine)¶

`atan` (Arc Tangent)¶

`atan2` (Arc Tangent with Two Arguments)¶

`cos` (Cosine)¶

`cosh` (Hyperbolic Cosine)¶

`sin` (Sine)¶

`sinh` (Hyperbolic Sine)¶

`tan` (Tangent)¶

`tanh` (Hyperbolic Tangent)¶

Practical Demonstration: Sample Code Analysis¶

Setting up the Environment¶

Initializing `valarray` Objects¶

Applying Trigonometric Functions¶

Interpreting the Results¶

Considerations and Best Practices¶

Floating-Point Accuracy¶

Domain Errors¶

Performance Aspects¶

Expanding the Example¶

Conclusion and Further Exploration¶

Post a Comment

Mastering Trigonometry with STL in Visual C++: A Practical Guide

Understanding valarray for Numerical Computing¶

Essential Headers¶

The STL Trigonometry Functions¶

acos (Arc Cosine)¶

asin (Arc Sine)¶

atan (Arc Tangent)¶

atan2 (Arc Tangent with Two Arguments)¶

cos (Cosine)¶

cosh (Hyperbolic Cosine)¶

sin (Sine)¶

sinh (Hyperbolic Sine)¶

tan (Tangent)¶

tanh (Hyperbolic Tangent)¶

Practical Demonstration: Sample Code Analysis¶

Setting up the Environment¶

Initializing valarray Objects¶

Applying Trigonometric Functions¶

Interpreting the Results¶

Considerations and Best Practices¶

Floating-Point Accuracy¶

Domain Errors¶

Performance Aspects¶

Expanding the Example¶

Conclusion and Further Exploration¶

Post a Comment

Understanding `valarray` for Numerical Computing¶

`acos` (Arc Cosine)¶

`asin` (Arc Sine)¶

`atan` (Arc Tangent)¶

`atan2` (Arc Tangent with Two Arguments)¶

`cos` (Cosine)¶

`cosh` (Hyperbolic Cosine)¶

`sin` (Sine)¶

`sinh` (Hyperbolic Sine)¶

`tan` (Tangent)¶

`tanh` (Hyperbolic Tangent)¶

Initializing `valarray` Objects¶