chromium/third_party/eigen3/src/Eigen/src/Core/RandomImpl.h

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2024 Charles Schlosser <[email protected]>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_RANDOM_IMPL_H
#define EIGEN_RANDOM_IMPL_H

// IWYU pragma: private
#include "./InternalHeaderCheck.h"

namespace Eigen {

namespace internal {

/****************************************************************************
 * Implementation of random                                               *
 ****************************************************************************/

template <typename Scalar, bool IsComplex, bool IsInteger>
struct random_default_impl { … };

template <typename Scalar>
struct random_impl : random_default_impl<Scalar, NumTraits<Scalar>::IsComplex, NumTraits<Scalar>::IsInteger> { … };

template <typename Scalar>
struct random_retval { … };

template <typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random(const Scalar& x, const Scalar& y) { … }

template <typename Scalar>
inline EIGEN_MATHFUNC_RETVAL(random, Scalar) random() { … }

// TODO: replace or provide alternatives to this, e.g. std::random_device
struct eigen_random_device { … };

// Fill a built-in unsigned integer with numRandomBits beginning with the least significant bit
template <typename Scalar>
struct random_bits_impl { … };

template <typename BitsType>
EIGEN_DEVICE_FUNC inline BitsType getRandomBits(int numRandomBits) { … }

// random implementation for a built-in floating point type
template <typename Scalar, bool BuiltIn = std::is_floating_point<Scalar>::value>
struct random_float_impl { … };
// random implementation for a custom floating point type
// uses double as the implementation with a mantissa with a size equal to either the target scalar's mantissa or that of
// double, whichever is smaller
random_float_impl<Scalar, false>;

// random implementation for long double
// this specialization is not compatible with double-double scalars
template <bool Specialize = (sizeof(long double) == 2 * sizeof(uint64_t)) &&
                            ((std::numeric_limits<long double>::digits != (2 * std::numeric_limits<double>::digits)))>
struct random_longdouble_impl { … };
template <>
struct random_longdouble_impl<false> { … };
template <>
struct random_float_impl<long double> : random_longdouble_impl<> { … };

random_default_impl<Scalar, false, false>;

template <typename Scalar, bool IsSigned = NumTraits<Scalar>::IsSigned, bool BuiltIn = std::is_integral<Scalar>::value>
struct random_int_impl;

// random implementation for a built-in unsigned integer type
random_int_impl<Scalar, false, true>;

// random implementation for a built-in signed integer type
random_int_impl<Scalar, true, true>;

// todo: custom integers
random_int_impl<Scalar, IsSigned, false>;

random_default_impl<Scalar, false, true>;

template <>
struct random_impl<bool> { … };

random_default_impl<Scalar, true, false>;

}  // namespace internal
}  // namespace Eigen

#endif  // EIGEN_RANDOM_IMPL_H