std::cosh(std::valarray)(3)

okay so bestie, welcome to the manual page for std::cosh(std::valarray)(3) from the C++ Standard Libary — yes, that's the manual name right there, and we're about to make hyperbolic cosine of a valarray feel like a whole group-chat moment. 💅✨

🌸 NAME 🌸

std::cosh(std::valarray) - std::cosh(std::valarray). Yes, the NAME section literally says the same thing twice, and honestly? iconic. 🎀

✨ Synopsis ✨

Defined in header <valarray>
template< class T >
valarray<T> cosh( const valarray<T>& va );

For each element in va, this computes the hyperbolic cosine of the value of the element. That's the assignment, and she ate. 🫶

🎀 Parameters 🎀

• va — the value array you're applying the operation to. That's the input, that's the moment, that's the whole vibe check.

🌈 Return value 🌈

You get back a value array containing the hyperbolic cosine of the values in va. Same energy, new numbers, slay. 💖

💀 Notes 💀

okay, important little lore drop:

• The unqualified function (cosh) is used to perform the computation. If that function is not available, std::cosh is used instead because of argument-dependent lookup. iykyk. 🧚
• The function can be implemented with a return type different from std::valarray. If that happens, the replacement type has these properties, and yes, this is the full checklist:
  • 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 🧚

bestie, this is the vibe:

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

    return other; // proxy object may be returned
}

🍓 Example 🍓

Run it, it's giving math class but cute:

// 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 sinh = std::sinh(x);
    const auto cosh = std::cosh(x);
    const auto z = (cosh * cosh) - (sinh * sinh);

    show("x", x);
    show("sinh(x)", sinh);
    show("cosh(x)", cosh);
    show("z", z);
}

💜 Output 💜

        x |       0.1 |       0.2 |       0.3 |       0.4 |
  sinh(x) |  0.100167 |  0.201336 |   0.30452 |  0.410752 |
  cosh(x) |     1.005 |   1.02007 |   1.04534 |   1.08107 |
        z |         1 |         1 |         1 |         1 |

👀 See also 👀

• sinh(std::valarray) — applies the function std::sinh to each element of valarray (function template)
• tanh(std::valarray) — applies the function std::tanh to each element of valarray (function template)
• cosh
• coshf — computes hyperbolic cosine (\({\small\cosh{x}}\)cosh(x))
• coshl — (function) (C++11) (C++11)
• cosh(std::complex) — computes hyperbolic cosine of a complex number (\({\small\cosh{z}}\)cosh(z)) (function template)

🙈 Hidden category 🙈

• Pages with unreviewed LWG DR marker

---

okay that's the whole page, bestie. source/version + date from the footer: http://cppreference.com — 2024.06.10 — std::cosh(std::valarray)(3). periodt. 💖✨🌈