std::cos(std::valarray)(3)

💖 std::cos(std::valarray)(3) 💖

Okay bestie, welcome to the C++ Standard Libary manual page for std::cos(std::valarray)(3). It’s giving element-wise cosine energy, and we’re gonna get through every detail together. ✨

🌸 NAME 🌸

std::cos(std::valarray) — std::cos(std::valarray). That’s the whole name, no cap. 💅

✨ Synopsis ✨

Defined in header <valarray>

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

For each element in va computes cosine of the value of the element. Literally every element gets the cosine treatment. 🎀

🧡 Parameters 🧡

• va — value array to apply the operation to

🍓 Return value 🍓

Value array containing cosines of the values in va. Slay. 🍓

🦋 Notes 🦋

Unqualified function (cos) is used to perform the computation. If such function is not available, std::cos is used due to argument-dependent lookup. iykyk. 🦋

The function can be implemented with the return type different from std::valarray. In this case, the replacement type has the following properties:

• All const member functions of std::valarray are provided.
• std::valarray, std::slice_array, std::gslice_array, std::mask_array and std::indirect_array can be constructed from the replacement type.
• For every function taking a const std::valarray<T>& except begin() and end() (since C++11), identical functions taking the replacement types shall be added;
• For every function taking two const std::valarray<T>& arguments, identical functions taking every combination of const std::valarray<T>& and replacement types shall be added.
• The return type does not add more than two levels of template nesting over the most deeply-nested argument type.

🔥 Possible implementation 🔥

This is the possible-implementation vibe check, bestie — code is exactly this:

template<class T>
valarray<T> cos(const valarray<T>& va)
{
    valarray<T> other = va;
    for (T& i : other)
        i = cos(i);

    return other; // proxy object may be returned
}

🌈 Example 🌈

// Run this code

#include <cmath>
#include <iomanip>
#include <iostream>
#include <valarray>

void show(const char* title, const std::valarray<float>& data)
{
    const int w{9};
    std::cout << std::setw(w) << title << " | ";
    for (float x : data)
        std::cout << std::setw(w) << x << " | ";
    std::cout << '\n';
}

int main()
{
    const std::valarray<float> x{.1, .2, .3, .4};
    const auto sin = std::sin(x);
    const auto cos = std::cos(x);
    const auto z = (sin * sin) + (cos * cos);

    show("x", x);
    show("sin(x)", sin);
    show("cos(x)", cos);
    show("z", z);
}

📤 Output 📤

And the output is serving consistency, periodt:

                x |       0.1 |       0.2 |       0.3 |       0.4 |
           sin(x) | 0.0998334 |  0.198669 |   0.29552 |  0.389418 |
           cos(x) |  0.995004 |  0.980067 |  0.955337 |  0.921061 |
                z |         1 |         1 |         1 |         1 |

👑 See also 👑

Related-function glow-up list:

• sin(std::valarray) — applies the function std::sin to each element of valarray (function template)
• tan(std::valarray) — applies the function std::tan to each element of valarray (function template)
• acos(std::valarray) — applies the function std::acos to each element of valarray (function template)
• cos
• cosf — computes cosine (({\small\cos{x}})cos(x))
• cosl — (function)
• (C++11)
• (C++11)
• cos(std::complex) — computes cosine of a complex number (({\small\cos{z}})cos(z)) (function template)

Yes, the source really has cos sitting there all mysterious and then two floating (C++11) markers. We keep every detail in this group chat. 💀

🙈 Hidden category 🙈

• Pages with unreviewed LWG DR marker

---

mwah 💋 — source: http://cppreference.com, version/date: 2024.06.10, manual page: std::cos(std::valarray)(3). periodt. 🫶