linalg.hpp File Reference

#include <cyqlone/config.hpp>
#include <cyqlone/reduce.hpp>
#include <batmat/assume.hpp>
#include <batmat/linalg/copy.hpp>
#include <batmat/linalg/shift.hpp>
#include <batmat/linalg/simdify.hpp>
#include <batmat/ops/rotate.hpp>
#include <batmat/simd.hpp>
#include <array>
#include <cmath>
#include <concepts>
#include <tuple>
#include <utility>

Go to the source code of this file.

Single-batch operations
template<simdifiable Vx>
norms< simdified_value_t< Vx > >::result	cyqlone::linalg::norms_all (Vx &&x)
	Compute the norms (max, 1-norm, and 2-norm) of a vector.
template<simdifiable Vx>
simdified_value_t< Vx >	cyqlone::linalg::norm_inf (Vx &&x)
	Compute the infinity norm of a vector.
template<simdifiable Vx>
simdified_value_t< Vx >	cyqlone::linalg::norm_1 (Vx &&x)
	Compute the 1-norm of a vector.
template<simdifiable Vx>
simdified_value_t< Vx >	cyqlone::linalg::norm_2_squared (Vx &&x)
	Compute the squared 2-norm of a vector.
template<simdifiable Vx>
simdified_value_t< Vx >	cyqlone::linalg::norm_2 (Vx &&x)
	Compute the 2-norm of a vector.
template<simdifiable Vx, simdifiable Vy>
simdified_value_t< Vx >	cyqlone::linalg::dot (Vx &&x, Vy &&y)
	Compute the dot product of two vectors.
template<simdifiable Vx, simdifiable Vz, std::convertible_to< simdified_value_t< Vx > > T>
void	cyqlone::linalg::scale (T alpha, Vx &&x, Vz &&z)
	Multiply a vector by a scalar z = αx.
template<simdifiable Vx, std::convertible_to< simdified_value_t< Vx > > T>
void	cyqlone::linalg::scale (T alpha, Vx &&x)
	Multiply a vector by a scalar x = αx.
template<simdifiable Vx, simdifiable Vy, simdifiable Vz>
void	cyqlone::linalg::hadamard (Vx &&x, Vy &&y, Vz &&z)
	Compute the Hadamard (elementwise) product of two vectors z = x ⊙ y.
template<simdifiable Vx, simdifiable Vy>
void	cyqlone::linalg::hadamard (Vx &&x, Vy &&y)
	Compute the Hadamard (elementwise) product of two vectors x = x ⊙ y.
template<simdifiable Vx, simdifiable Vlo, simdifiable Vhi, simdifiable Vz>
void	cyqlone::linalg::clamp (Vx &&x, Vlo &&lo, Vhi &&hi, Vz &&z)
	Elementwise clamping z = max(lo, min(x, hi)).
template<simdifiable Vx, simdifiable Vlo, simdifiable Vhi, simdifiable Vz>
void	cyqlone::linalg::clamp_resid (Vx &&x, Vlo &&lo, Vhi &&hi, Vz &&z)
	Elementwise clamping residual z = x - max(lo, min(x, hi)).
template<simdifiable Vx, simdifiable Vy, simdifiable Vz, std::convertible_to< simdified_value_t< Vx > > Ta, std::convertible_to< simdified_value_t< Vx > > Tb>
void	cyqlone::linalg::axpby (Ta alpha, Vx &&x, Tb beta, Vy &&y, Vz &&z)
	Add scaled vector z = αx + βy.
template<simdifiable Vx, simdifiable Vy, std::convertible_to< simdified_value_t< Vx > > Ta, std::convertible_to< simdified_value_t< Vx > > Tb>
void	cyqlone::linalg::axpby (Ta alpha, Vx &&x, Tb beta, Vy &&y)
	Add scaled vector y = αx + βy.
template<auto Beta = 1, simdifiable Vy, simdifiable... Vx>
void	cyqlone::linalg::axpy (Vy &&y, const std::array< simdified_value_t< Vy >, sizeof...(Vx)> &alphas, Vx &&...x)
	Add scaled vector y = ∑ᵢ αᵢxᵢ + βy.
template<simdifiable Vx, simdifiable Vy, simdifiable Vz, std::convertible_to< simdified_value_t< Vx > > Ta>
void	cyqlone::linalg::axpy (Ta alpha, Vx &&x, Vy &&y, Vz &&z)
	Add scaled vector z = αx + y.
template<auto Beta = 1, simdifiable Vx, simdifiable Vy, std::convertible_to< simdified_value_t< Vx > > Ta>
void	cyqlone::linalg::axpy (Ta alpha, Vx &&x, Vy &&y)
	Add scaled vector y = αx + βy (where β is a compile-time constant).
template<simdifiable VA, simdifiable VB, int Rotate = 0>
void	cyqlone::linalg::negate (VA &&A, VB &&B, with_rotate_t< Rotate >={})
	Negate a matrix or vector B = -A.
template<simdifiable VA, int Rotate = 0>
void	cyqlone::linalg::negate (VA &&A, with_rotate_t< Rotate >={})
	Negate a matrix or vector A = -A.
template<simdifiable VA, simdifiable VB, simdifiable VC, int Rotate = 0>
void	cyqlone::linalg::sub (VA &&A, VB &&B, VC &&C, with_rotate_t< Rotate >={})
	Subtract two matrices or vectors C = A - B. Rotate affects B.
template<simdifiable VA, simdifiable VB, int Rotate = 0>
void	cyqlone::linalg::sub (VA &&A, VB &&B, with_rotate_t< Rotate >={})
	Subtract two matrices or vectors A = A - B. Rotate affects B.
template<simdifiable VA, simdifiable VB, simdifiable VC, int Rotate = 0>
void	cyqlone::linalg::add (VA &&A, VB &&B, VC &&C, with_rotate_t< Rotate >={})
	Add two matrices or vectors C = A + B. Rotate affects B.
template<simdifiable VA, simdifiable VB, int Rotate = 0>
void	cyqlone::linalg::add (VA &&A, VB &&B, with_rotate_t< Rotate >={})
	Add two matrices or vectors A = A + B. Rotate affects B.
template<class F, simdifiable VA, simdifiable... VAs>
void	cyqlone::linalg::for_each_elementwise (F &&fun, VA &&A, VAs &&...As)
	Apply a function to all elements of the given matrices or vectors.
template<class F, simdifiable VA, simdifiable... VAs>
void	cyqlone::linalg::transform_elementwise (F &&fun, VA &&A, VAs &&...As)
	Apply a function to all elements of the given matrices or vectors, storing the result in the first argument.
template<class F, simdifiable VA, simdifiable VB, simdifiable... VAs>
void	cyqlone::linalg::transform2_elementwise (F &&fun, VA &&A, VB &&B, VAs &&...As)
	Apply a function to all elements of the given matrices or vectors, storing the results in the first two arguments.
template<class F, simdifiable... VAs, simdifiable... VBs>
void	cyqlone::linalg::transform_n_elementwise (F &&fun, std::tuple< VAs... > As, VBs &&...Bs)
	Apply a function to all elements of the given matrices or vectors, storing the results in the tuple of matrices given as the first argument.

Multi-batch operations
template<simdifiable_multi Vx>
norms< simdified_value_t< Vx > >::result	cyqlone::linalg::multi::norms_all (Vx &&x)
	Compute the norms (max, 1-norm, and 2-norm) of a vector.
template<simdifiable_multi Vx>
simdified_value_t< Vx >	cyqlone::linalg::multi::norm_inf (Vx &&x)
	Compute the infinity norm of a vector.
template<simdifiable_multi Vx>
simdified_value_t< Vx >	cyqlone::linalg::multi::norm_1 (Vx &&x)
	Compute the 1-norm of a vector.
template<simdifiable_multi Vx>
simdified_value_t< Vx >	cyqlone::linalg::multi::norm_2_squared (Vx &&x)
	Compute the squared 2-norm of a vector.
template<simdifiable_multi Vx>
simdified_value_t< Vx >	cyqlone::linalg::multi::norm_2 (Vx &&x)
	Compute the 2-norm of a vector.
template<simdifiable_multi Vx, simdifiable_multi Vy>
simdified_value_t< Vx >	cyqlone::linalg::multi::dot (Vx &&x, Vy &&y)
	Compute the dot product of two vectors.
template<simdifiable_multi Vx, simdifiable_multi Vz, std::convertible_to< simdified_value_t< Vx > > T>
void	cyqlone::linalg::multi::scale (T alpha, Vx &&x, Vz &&z)
	Multiply a vector by a scalar z = αx.
template<simdifiable_multi Vx, std::convertible_to< simdified_value_t< Vx > > T>
void	cyqlone::linalg::multi::scale (T alpha, Vx &&x)
	Multiply a vector by a scalar x = αx.
template<simdifiable_multi Vx, simdifiable_multi Vy, simdifiable_multi Vz>
void	cyqlone::linalg::multi::hadamard (Vx &&x, Vy &&y, Vz &&z)
	Compute the Hadamard (elementwise) product of two vectors z = x ⊙ y.
template<simdifiable_multi Vx, simdifiable_multi Vy>
void	cyqlone::linalg::multi::hadamard (Vx &&x, Vy &&y)
	Compute the Hadamard (elementwise) product of two vectors x = x ⊙ y.
template<simdifiable_multi Vx, simdifiable_multi Vlo, simdifiable_multi Vhi, simdifiable_multi Vz>
void	cyqlone::linalg::multi::clamp (Vx &&x, Vlo &&lo, Vhi &&hi, Vz &&z)
	Elementwise clamping z = max(lo, min(x, hi)).
template<simdifiable_multi Vx, simdifiable_multi Vlo, simdifiable_multi Vhi, simdifiable_multi Vz>
void	cyqlone::linalg::multi::clamp_resid (Vx &&x, Vlo &&lo, Vhi &&hi, Vz &&z)
	Elementwise clamping residual z = x - max(lo, min(x, hi)).
template<simdifiable_multi Vx, simdifiable_multi Vy, simdifiable_multi Vz, std::convertible_to< simdified_value_t< Vx > > Ta, std::convertible_to< simdified_value_t< Vx > > Tb>
void	cyqlone::linalg::multi::axpby (Ta alpha, Vx &&x, Tb beta, Vy &&y, Vz &&z)
	Add scaled vector z = αx + βy.
template<simdifiable_multi Vx, simdifiable_multi Vy, std::convertible_to< simdified_value_t< Vx > > Ta, std::convertible_to< simdified_value_t< Vx > > Tb>
void	cyqlone::linalg::multi::axpby (Ta alpha, Vx &&x, Tb beta, Vy &&y)
	Add scaled vector y = αx + βy.
template<auto Beta = 1, simdifiable_multi Vy, simdifiable_multi... Vx>
void	cyqlone::linalg::multi::axpy (Vy &&y, const std::array< simdified_value_t< Vy >, sizeof...(Vx)> &alphas, Vx &&...x)
	Add scaled vector y = ∑ᵢ αᵢxᵢ + βy.
template<simdifiable_multi Vx, simdifiable_multi Vy, simdifiable_multi Vz, std::convertible_to< simdified_value_t< Vx > > Ta>
void	cyqlone::linalg::multi::axpy (Ta alpha, Vx &&x, Vy &&y, Vz &&z)
	Add scaled vector z = αx + y.
template<auto Beta = 1, simdifiable_multi Vx, simdifiable_multi Vy, std::convertible_to< simdified_value_t< Vx > > Ta>
void	cyqlone::linalg::multi::axpy (Ta alpha, Vx &&x, Vy &&y)
	Add scaled vector y = αx + βy (where β is a compile-time constant).
template<simdifiable_multi VA, simdifiable_multi VB, int Rotate = 0>
void	cyqlone::linalg::multi::negate (VA &&A, VB &&B, with_rotate_t< Rotate > rot={})
	Negate a matrix or vector B = -A.
template<simdifiable_multi VA, int Rotate = 0>
void	cyqlone::linalg::multi::negate (VA &&A, with_rotate_t< Rotate > rot={})
	Negate a matrix or vector A = -A.
template<simdifiable_multi VA, simdifiable_multi VB, simdifiable_multi VC, int Rotate = 0>
void	cyqlone::linalg::multi::sub (VA &&A, VB &&B, VC &&C, with_rotate_t< Rotate > rot={})
	Subtract two matrices or vectors C = A - B. Rotate affects B.
template<simdifiable_multi VA, simdifiable_multi VB, int Rotate = 0>
void	cyqlone::linalg::multi::sub (VA &&A, VB &&B, with_rotate_t< Rotate > rot={})
	Subtract two matrices or vectors A = A - B. Rotate affects B.
template<simdifiable_multi VA, simdifiable_multi VB, simdifiable_multi VC, int Rotate = 0>
void	cyqlone::linalg::multi::add (VA &&A, VB &&B, VC &&C, with_rotate_t< Rotate > rot={})
	Add two matrices or vectors C = A + B. Rotate affects B.
template<simdifiable_multi VA, simdifiable_multi VB, int Rotate = 0>
void	cyqlone::linalg::multi::add (VA &&A, VB &&B, with_rotate_t< Rotate > rot={})
	Add two matrices or vectors A = A + B. Rotate affects B.
template<class F, simdifiable_multi VA, simdifiable_multi... VAs>
void	cyqlone::linalg::multi::for_each_elementwise (F &&fun, VA &&A, VAs &&...As)
	Apply a function to all elements of the given matrices or vectors.
template<class F, simdifiable_multi VA, simdifiable_multi... VAs>
void	cyqlone::linalg::multi::transform_elementwise (F &&fun, VA &&A, VAs &&...As)
	Apply a function to all elements of the given matrices or vectors, storing the result in the first argument.
template<class F, simdifiable_multi VA, simdifiable_multi VB, simdifiable_multi... VAs>
void	cyqlone::linalg::multi::transform2_elementwise (F &&fun, VA &&A, VB &&B, VAs &&...As)
	Apply a function to all elements of the given matrices or vectors, storing the results in the first two arguments.
template<class F, simdifiable_multi... VAs, simdifiable_multi... VBs>
void	cyqlone::linalg::multi::transform_n_elementwise (F &&fun, std::tuple< VAs... > As, VBs &&...Bs)
	Apply a function to all elements of the given matrices or vectors, storing the results in the tuple of matrices given as the first argument.
template<simdifiable_multi VA, simdifiable_multi VB, batmat::linalg::rotate_opt... Opts>
void	cyqlone::linalg::multi::copy (VA &&A, VB &&B, Opts... opts)
	Copy a matrix or vector B = A.
template<MatrixStructure S, simdifiable_multi VA, simdifiable_multi VB, batmat::linalg::rotate_opt... Opts>
void	cyqlone::linalg::multi::copy (Structured< VA, S > A, Structured< VB, S > B, Opts... opts)
	Copy a matrix or vector B = A.

Namespaces
namespace	cyqlone
namespace	cyqlone::linalg
namespace	cyqlone::linalg::multi