Compiler Explorer

Source code

/*
 * vector.h
 *
 *  Created on: 6 окт. 2018 г.
 *      Author: disba1ancer
 */

#ifndef VEC_H_
#define VEC_H_

#include <cstddef>
#include <type_traits>
#include <concepts>
#include <memory>

namespace dse::math {

template <typename value_t, std::size_t size>
struct vec;

namespace impl {

template <typename value_t>
concept no_cvref =
	!std::is_reference_v<value_t> &&
	!std::is_const_v<std::remove_reference_t<value_t>> &&
	!std::is_volatile_v<std::remove_reference_t<value_t>>;

template <typename value_t>
concept ref_or_val =
	std::is_lvalue_reference_v<value_t> ||
	no_cvref<value_t>;

template <typename>
constexpr bool is_vector = false;

template <typename type_t, std::size_t size>
constexpr bool is_vector<vec<type_t, size>> = true;

template <typename type_t>
concept scalar_type = !is_vector<std::remove_cv_t<type_t>>;

constexpr auto character_to_index(char ch) -> std::size_t {
	return (ch - 'x') & 3;
}

} // namespace impl

template <typename value_t, std::size_t size>
requires(
	!std::is_const_v<value_t> &&
	!std::is_volatile_v<value_t> &&
	!std::is_reference_v<value_t> &&
	size > 1
)
struct vec<value_t, size> {
	using value_type = value_t;
	using reference_type = value_t&;
	using const_reference_type = const value_t&;

value_t elements[size];

constexpr auto at_ptr(std::size_t index) -> value_t* { return elements + index; }
	constexpr auto at_ptr(std::size_t index) const -> const value_t* { return elements + index; }
	constexpr auto at(std::size_t index) -> reference_type { return elements[index]; }
	constexpr auto at(std::size_t index) const -> const_reference_type { return elements[index]; }
	constexpr auto operator[](std::size_t index) -> reference_type { return at(index); }
	constexpr auto operator[](std::size_t index) const -> const_reference_type { return at(index); }
private:
	template <typename dst_value_t, std::size_t... seq>
	requires(
		!std::is_reference_v<dst_value_t> && !std::is_const_v<dst_value_t> && !std::is_volatile_v<dst_value_t>
	)
	constexpr auto cast_impl(std::index_sequence<seq...>) const -> vec<dst_value_t, size> {
		return {static_cast<dst_value_t>(at(seq))...};
	}
public:
	template <typename dst_value_t>
	requires(
		!std::is_reference_v<dst_value_t> && !std::is_const_v<dst_value_t> && !std::is_volatile_v<dst_value_t>
	)
	constexpr operator vec<dst_value_t, size>() const {
		return cast_impl<dst_value_t>(std::make_index_sequence<size>{});
	}
private:
	template <std::size_t... seq>
	constexpr auto cast_impl(std::index_sequence<seq...>) const -> vec<const_reference_type, size> {
		return {at_ptr(seq)...};
	}
public:
	constexpr operator vec<const_reference_type, size>() const {
		return cast_impl(std::make_index_sequence<size>{});
	}
private:
	template <std::size_t... seq>
	constexpr auto cast_impl(std::index_sequence<seq...>) -> vec<reference_type, size> {
		return {at_ptr(seq)...};
	}
public:
	constexpr operator vec<reference_type, size>() {
		return cast_impl(std::make_index_sequence<size>{});
	}
private:
	template <std::size_t swizzle_length, std::size_t... seq>
	constexpr auto swizzle_impl(const char(&swizzle)[swizzle_length], std::index_sequence<seq...>) const
		-> vec<const_reference_type, swizzle_length - 1>
	{
		return {at_ptr(impl::character_to_index(swizzle[seq]))...};
	}
public:
	template <std::size_t swizzle_length>
	requires(2 < swizzle_length && swizzle_length <= 5)
	constexpr auto operator[](const char(&swizzle)[swizzle_length]) const
		-> vec<const_reference_type, swizzle_length - 1>
	{
		return swizzle_impl(swizzle, std::make_index_sequence<swizzle_length - 1>{});
	}
private:
	template <std::size_t swizzle_length, std::size_t... seq>
	constexpr auto swizzle_impl(const char(&swizzle)[swizzle_length], std::index_sequence<seq...>)
		-> vec<reference_type, swizzle_length - 1>
	{
		return {at_ptr(impl::character_to_index(swizzle[seq]))...};
	}
public:
	template <std::size_t swizzle_length>
	requires(2 < swizzle_length && swizzle_length <= 5)
	constexpr auto operator[](const char(&swizzle)[swizzle_length]) -> vec<reference_type, swizzle_length - 1> {
		return swizzle_impl(swizzle, std::make_index_sequence<swizzle_length - 1>{});
	}

constexpr auto operator[](const char(&swizzle)[2]) const -> const_reference_type {
		return at(impl::character_to_index(swizzle[0]));
	}

constexpr auto operator[](const char(&swizzle)[2]) -> reference_type {
		return at(impl::character_to_index(swizzle[0]));
	}
private:
	template <typename T>
	void assign_impl(const T& right) {
		for (std::size_t i = 0; i < size; ++i) {
			at(i) = right[i];
		}
	}
public:
//	auto operator=(const vec<value_type, size>& right) -> vec<value_type, size>&
//	{
//		assign_impl(right);
//		return *this;
//	}

auto operator=(const vec<reference_type, size>& right) -> vec<value_type, size>&
	{
		assign_impl(right);
		return *this;
	}

auto operator=(const vec<const_reference_type, size>& right) -> vec<value_type, size>&
	{
		assign_impl(right);
		return *this;
	}

constexpr auto x() -> reference_type requires(size >= 1) { return at(0); }
	constexpr auto x() const -> const_reference_type requires(size >= 1) { return at(0); }
	constexpr auto y() -> reference_type requires(size >= 2) { return at(1); }
	constexpr auto y() const -> const_reference_type requires(size >= 2) { return at(1); }
	constexpr auto z() -> reference_type requires(size >= 3) { return at(2); }
	constexpr auto z() const -> const_reference_type requires(size >= 3) { return at(2); }
	constexpr auto w() -> reference_type requires(size >= 4) { return at(3); }
	constexpr auto w() const -> const_reference_type requires(size >= 4) { return at(3); }
};

template <impl::scalar_type value_t, std::size_t size>
struct vec<value_t&, size> {
	using value_type = std::remove_cv_t<value_t>;
	using reference_type = value_t&;
	using const_reference_type = const value_t&;

value_t* elements[size];

constexpr auto at_ptr(std::size_t index) const -> value_t* { return elements[index]; }
	constexpr auto at(std::size_t index) const -> reference_type { return *at_ptr(index); }
	constexpr auto operator[](std::size_t index) const -> reference_type { return at(index); }
private:
	template <typename dst_value_t, std::size_t... seq>
	requires(!std::is_reference_v<dst_value_t> && !std::is_const_v<dst_value_t> && !std::is_volatile_v<dst_value_t>)
	constexpr auto cast_impl(std::index_sequence<seq...>) const -> vec<dst_value_t, size> {
		return {static_cast<dst_value_t>(at(seq))...};
	}
public:
	template <typename dst_value_t>
	requires(!std::is_reference_v<dst_value_t> && !std::is_const_v<dst_value_t> && !std::is_volatile_v<dst_value_t>)
	constexpr operator vec<dst_value_t, size>() const {
		return cast_impl<dst_value_t>(std::make_index_sequence<size>{});
	}
private:
	template <std::size_t... seq>
	constexpr auto cast_impl_val(std::index_sequence<seq...>) const -> vec<value_type, size> {
		return {at(seq)...};
	}
public:
	constexpr operator vec<value_type, size>() const {
		return cast_impl_val(std::make_index_sequence<size>{});
	}
private:
	template <std::size_t... seq>
	constexpr auto cast_impl_ref(std::index_sequence<seq...>) const -> vec<const_reference_type, size> {
		return {at_ptr(seq)...};
	}

constexpr operator vec<const_reference_type, size>() const {
		return cast_impl_ref(std::make_index_sequence<size>{});
	}
private:
	template <std::size_t swizzle_length, std::size_t... seq>
	auto swizzle_impl(const char(&swizzle)[swizzle_length], std::index_sequence<seq...>) const
		-> vec<reference_type, swizzle_length - 1>
	{
		return {at_ptr(impl::character_to_index(swizzle[seq]))...};
	}
public:
	template <std::size_t swizzle_length>
	requires(2 < swizzle_length && swizzle_length <= 5)
	auto operator[](const char(&swizzle)[swizzle_length]) const -> vec<reference_type, swizzle_length - 1> {
		return swizzle_impl(swizzle, std::make_index_sequence<swizzle_length - 1>{});
	}

auto operator[](const char(&swizzle)[2]) const -> reference_type {
		return at(impl::character_to_index(swizzle[0]));
	}
private:
	template <typename T>
	void assign_impl(const T& right) const requires (!std::is_const_v<value_t>) {
		for (std::size_t i = 0; i < size; ++i) {
			at(i) = right[i];
		}
	}
public:
	auto operator=(const vec<value_type, size>& right) const -> const vec<reference_type, size>&
	requires (!std::is_const_v<value_t>)
	{
		assign_impl(right);
		return *this;
	}

auto operator=(const vec<value_type&, size>& right) const -> const vec<reference_type, size>&
	requires (!std::is_const_v<value_t>)
	{
		assign_impl(right);
		return *this;
	}

auto operator=(const vec<const value_type&, size>& right) const -> const vec<reference_type, size>&
	requires (!std::is_const_v<value_t>)
	{
		assign_impl(right);
		return *this;
	}

constexpr auto x() const -> reference_type requires(size >= 1) { return at(0); }
    constexpr auto y() const -> reference_type requires(size >= 2) { return at(1); }
    constexpr auto z() const -> reference_type requires(size >= 3) { return at(2); }
    constexpr auto w() const -> reference_type requires(size >= 4) { return at(3); }
};

using uvec2 = vec<unsigned, 2>;
using uvec3 = vec<unsigned, 3>;
using uvec4 = vec<unsigned, 4>;

using ivec2 = vec<int, 2>;
using ivec3 = vec<int, 3>;
using ivec4 = vec<int, 4>;

using vec2 = vec<float, 2>;
using vec3 = vec<float, 3>;
using vec4 = vec<float, 4>;

/*template <typename type_t, std::size_t sizeA, std::size_t sizeB>
struct vec<vec<type_t, sizeA>, sizeB>;*/

} // namespace math::dse

#endif /* VEC_H_ */

/*
 * vmath.h
 *
 *  Created on: 6 мар. 2020 г.
 *      Author: disba1ancer
 */

#ifndef MATH_VMATH_H_
#define MATH_VMATH_H_

#include <cmath>

namespace dse::math {

namespace impl {

template <typename left_t, typename right_t>
concept same_storage_type = std::is_same_v<std::remove_cvref_t<left_t>, std::remove_cvref_t<right_t>>;

template <typename left_t, typename right_t, std::size_t size, typename Ret, std::size_t ... seq>
constexpr auto bin_op_impl(
    const vec<left_t, size>& left,
    const vec<right_t, size>& right,
    Ret(&func)(const std::remove_cvref_t<left_t>&, const std::remove_cvref_t<right_t>&),
    std::index_sequence<seq...>
) -> vec<Ret, size> {
    return {func(left[seq], right[seq])...};
}

template <typename left_t, typename right_t, std::size_t size, typename Ret, std::size_t ... seq>
constexpr auto bin_op_impl(
    const vec<left_t, size>& left,
    const right_t& right,
    Ret(&func)(const std::remove_cvref_t<left_t>&, const right_t&),
    std::index_sequence<seq...>
) -> vec<Ret, size> {
    return {func(left[seq], right)...};
}

template <typename left_t, typename right_t, std::size_t size, typename Ret, std::size_t ... seq>
constexpr auto bin_op_impl(
    const left_t& left,
    const vec<right_t, size>& right,
    Ret(&func)(const left_t&, const std::remove_cvref_t<right_t>&),
    std::index_sequence<seq...>
) -> vec<Ret, size> {
    return {func(left, right[seq])...};
}

template <typename right_t, std::size_t size, std::size_t ... seq>
constexpr auto negate_impl(
    const vec<right_t, size>& right,
    std::index_sequence<seq...>
) -> vec<std::remove_cvref_t<right_t>, size> {
    return {(-(right[seq]))...};
}

template <typename right_t, std::size_t size, std::size_t ... seq>
constexpr auto positive_impl(
    const vec<right_t, size>& right,
    std::index_sequence<seq...>
) -> vec<std::remove_cvref_t<right_t>, size> {
    return {(+(right[seq]))...};
}

} // namespace impl

#define GENERATE(op)\
template <typename left_t, typename right_t, std::size_t size>\
requires(\
	requires(left_t left, right_t right) {\
		left op right;\
	} &&\
	!impl::is_vector<std::remove_cvref_t<left_t>> &&\
	!impl::is_vector<std::remove_cvref_t<right_t>>\
)\
constexpr auto operator op(const vec<left_t, size>& left, const vec<right_t, size>& right) {\
	return impl::bin_op_impl(\
		left, right,\
		*+[](const left_t& left, const right_t& right) { return left op right; },\
		std::make_index_sequence<size>{}\
	);\
}\
template <typename left_t, typename right_t, std::size_t size>\
requires(\
	requires(left_t left, right_t right) {\
		left op right;\
	} &&\
	!impl::is_vector<std::remove_cvref_t<left_t>> &&\
	!impl::is_vector<std::remove_cvref_t<right_t>>\
)\
constexpr auto operator op(const vec<left_t, size>& left, const right_t& right) {\
	return impl::bin_op_impl(\
		left, right,\
		*+[](const left_t& left, const right_t& right) { return left op right; },\
		std::make_index_sequence<size>{}\
	);\
}\
template <typename left_t, typename right_t, std::size_t size>\
requires(\
	requires(left_t left, right_t right) {\
		left op right;\
	} &&\
	!impl::is_vector<std::remove_cvref_t<left_t>> &&\
	!impl::is_vector<std::remove_cvref_t<right_t>>\
)\
constexpr auto operator op(const left_t& left, const vec<right_t, size>& right) {\
	return impl::bin_op_impl(\
		left, right,\
		*+[](const left_t& left, const right_t& right) { return left op right; },\
		std::make_index_sequence<size>{}\
	);\
}\
template <typename left_t, typename right_t, std::size_t size>\
auto operator op##=(vec<left_t, size>& left, const vec<right_t, size>& right) -> vec<left_t, size>&\
requires(\
	requires(left_t left, right_t right) {\
		left op##= right;\
	} &&\
	!impl::is_vector<std::remove_cvref_t<left_t>> &&\
	!impl::is_vector<std::remove_cvref_t<right_t>>\
)\
{\
	for (std::size_t i = 0; i < size; ++i) {\
		left[i] op##= right[i];\
	}\
	return left;\
}\
template <typename left_t, typename right_t, std::size_t size>\
auto operator op##=(vec<left_t, size>& left, const right_t& right) -> vec<left_t, size>&\
requires(\
	requires(left_t left, right_t right) {\
		left op##= right;\
	} &&\
	!impl::is_vector<std::remove_cvref_t<left_t>> &&\
	!impl::is_vector<std::remove_cvref_t<right_t>>\
)\
{\
	for (std::size_t i = 0; i < size; ++i) {\
		left[i] op##= right[i];\
	}\
	return left;\
}

GENERATE(+)
GENERATE(-)
GENERATE(*)
GENERATE(/)

#undef GENERATE

template <typename right_t, std::size_t size>
constexpr auto operator -(const vec<right_t, size>& right)
requires (
	requires(right_t right) { -right; }
) {
	return impl::negate_impl(right, std::make_index_sequence<size>{});
}

template <typename right_t, std::size_t size>
constexpr auto operator +(const vec<right_t, size>& right)
requires (
	requires(right_t right) { +right; }
) {
	return impl::negate_impl(right, std::make_index_sequence<size>{});
}

template <typename left_t, typename right_t, std::size_t size>
requires(impl::same_storage_type<left_t, right_t>)
constexpr bool operator !=(const vec<left_t, size>& left, const vec<right_t, size>& right) {
	for (unsigned i = 0; i < size; ++i) {
		if (left[i] != right[i]) {
			return true;
		}
	}
	return false;
}

template <typename left_t, typename right_t, std::size_t size>
requires(impl::same_storage_type<left_t, right_t>)
constexpr bool operator ==(const vec<left_t, size>& left, const vec<right_t, size>& other) {
	return !(left != other);
}

//template <typename type_t, std::size_t size>
//vec<type_t, size> operator *(const type_t& c, const vec<type_t, size>& v) {
//	vec<type_t, size> result = v;
//	result *= c;
//	return result;
//}

template <typename left_t, typename right_t>
requires(impl::same_storage_type<left_t, right_t>)
constexpr auto cross(const vec<left_t, 3>& a, const vec<right_t, 3>& b) -> vec<std::remove_cvref_t<left_t>, 3> {
	return a["yzx"] * b["zxy"] - a["zxy"] * b["yzx"];
}

template <typename left_t, typename right_t, std::size_t size>
requires(impl::same_storage_type<left_t, right_t>)
constexpr auto dot(const vec<left_t, size>& a, const vec<right_t, size>& b) {
	std::remove_cvref_t<left_t> result{};
	for (std::size_t i = 0; i < size; ++i) {
		result += a[i] * b[i];
	}
	return result;
}

template <typename T, std::size_t size>
constexpr vec<std::remove_cvref_t<T>, size> norm(const vec<T, size>& a) {
	return a / std::sqrt(dot(a, a));
}

} // namespace dse::math

#endif /* MATH_VMATH_H_ */

/*
 * mat.h
 *
 *  Created on: 24 февр. 2019 г.
 *      Author: disba1ancer
 */

#ifndef MAT_H_
#define MAT_H_

namespace dse::math {

template <typename type_t, std::size_t cols, std::size_t rows>
using mat = vec<vec<type_t, rows>, cols>;

namespace impl {

} // namespace impl

#define GENERATE(op)\
template <typename left_t, typename right_t, std::size_t size>\
requires(\
	requires(left_t left, right_t right) {\
		left op right;\
	} &&\
	impl::is_vector<std::remove_cv_t<left_t>> &&\
	impl::is_vector<std::remove_cv_t<right_t>>\
)\
constexpr auto operator op(const vec<left_t, size>& left, const vec<right_t, size>& right) {\
	return impl::bin_op_impl(\
		left, right,\
		*[](const left_t& left, const right_t& right) { return left op right; },\
		std::make_index_sequence<size>{}\
	);\
}\
template <typename left_t, typename right_t, std::size_t size>\
requires(\
	requires(left_t left, right_t right) {\
		left op right;\
	} &&\
	impl::is_vector<std::remove_cv_t<left_t>> &&\
	impl::is_vector<std::remove_cv_t<right_t>>\
)\
constexpr auto operator op(const vec<left_t, size>& left, const right_t& right) {\
	return impl::bin_op_impl(\
		left, right,\
		*[](const left_t& left, const right_t& right) { return left op right; },\
		std::make_index_sequence<size>{}\
	);\
}\
template <typename left_t, typename right_t, std::size_t size>\
requires(\
	requires(left_t left, right_t right) {\
		left op right;\
	} &&\
	impl::is_vector<std::remove_cv_t<left_t>> &&\
	impl::is_vector<std::remove_cv_t<right_t>>\
)\
constexpr auto operator op(const left_t& left, const vec<right_t, size>& right) {\
	return impl::bin_op_impl(\
		left, right,\
		*[](const left_t& left, const right_t& right) { return left op right; },\
		std::make_index_sequence<size>{}\
	);\
}\
template <typename left_t, typename right_t, std::size_t size>\
auto operator op##=(vec<left_t, size>& left, const vec<right_t, size>& right) -> vec<left_t, size>&\
requires(\
	requires(left_t left, right_t right) {\
		left op##= right;\
	} &&\
	impl::is_vector<std::remove_cv_t<left_t>> &&\
	impl::is_vector<std::remove_cv_t<right_t>>\
)\
{\
	for (std::size_t i = 0; i < size; ++i) {\
		left[i] op##= right[i];\
	}\
	return left;\
}\
template <typename left_t, typename right_t, std::size_t size>\
auto operator op##=(vec<left_t, size>& left, const right_t& right) -> vec<left_t, size>&\
requires(\
	requires(left_t left, right_t right) {\
		left op##= right;\
	} &&\
	impl::is_vector<std::remove_cv_t<left_t>> &&\
	impl::is_vector<std::remove_cv_t<right_t>>\
)\
{\
	for (std::size_t i = 0; i < size; ++i) {\
		left[i] op##= right[i];\
	}\
	return left;\
}

GENERATE(+)
GENERATE(-)

#undef GENERATE

template <typename left_t, typename right_t, std::size_t rows, std::size_t shared, std::size_t cols>
auto operator*(const mat<left_t, shared, rows>& left, const mat<right_t, cols, shared>& right) {
    using ret_t = decltype(left_t{} * right_t{});
    mat<ret_t, shared, rows> result{};
    for (std::size_t col = 0; col < cols; ++col) {
        for (std::size_t row = 0; row < rows; ++row) {
            for (std::size_t i = 0; i < shared; ++i) {
                result[col][row] += left[i][row] * right[col][i];
            }
        }
    }
    return result;
}

template <typename left_t, typename right_t, std::size_t cols, std::size_t rows>
mat<left_t, cols, rows>& operator*=(mat<left_t, cols, rows>& left, const mat<right_t, cols, cols>& right) {
    left = left * right;
    return left;
}

template <typename right_t, std::size_t cols, std::size_t rows>
auto transpose(const mat<right_t, cols, rows>& right) {
    mat<std::remove_cvref_t<right_t>, rows, cols> result{};
    for (std::size_t i = 0; i < cols; ++i) {
        for (std::size_t j = 0; j < rows; ++j) {
            result[j][i] = right[i][j];
        }
    }
    return result;
}

typedef mat<float, 2, 2> mat2;
typedef mat<float, 2, 3> mat2x3;
typedef mat<float, 2, 4> mat2x4;
typedef mat<float, 3, 2> mat3x2;
typedef mat<float, 3, 3> mat3;
typedef mat<float, 3, 4> mat3x4;
typedef mat<float, 4, 2> mat4x2;
typedef mat<float, 4, 3> mat4x3;
typedef mat<float, 4, 4> mat4;

} /* namespace dse::math */

#endif /* MAT_H_ */

using dse::math::mat4;

auto op(const mat4& left, const mat4& right) {
    return left * right;
}