#pragma once #include #include "data.hpp" #include "data_math.hpp" #include "unit.hpp" namespace kel { namespace lbm { namespace math { /** * Builds a scalar from its native value. Shorthand for the two step * data{value} -> data>{...} conversion, which the language won't * do implicitly. */ template constexpr data, Encoding> make_scalar(typename native_data_type::type value) { return data, Encoding>{data{value}}; } /** * Builds a vector from its native component values. The dimension is deduced * from the argument count. */ template constexpr data, Encoding> make_vector(Args... args) { return data, Encoding>{ data, Encoding>{ std::array, sizeof...(Args)>{data{ static_cast::type>(args)}...}}}; } template data, Encoding> dot(const data, Encoding> &left, const data, Encoding> &right) { data, Encoding> val; auto &inner = val.flat_at(0u); for (uint64_t i = 0u; i < D; ++i) { inner = inner + left.flat_at(i) * right.flat_at(i); } return val; } template data, Encoding> sqrt(const data, Encoding> &inp) { data, Encoding> out; out.flat_at(0u).set(std::sqrt(inp.flat_at(0u).get())); return out; } /** * Euclidean length of a vector. */ template data, Encoding> norm(const data, Encoding> &input) { return sqrt(dot(input, input)); } /** * Unit length copy of a vector. A zero vector has no direction to preserve, so * it is returned unchanged rather than divided by zero. */ template data, Encoding> normalize(const data, Encoding> &input) { auto inp_dot = dot(input, input); if (inp_dot.flat_at(0u).get() <= 0) { return input; } auto sqrt_inp_dot = sqrt(inp_dot); data, Encoding> out; for (uint64_t i = 0u; i < D; ++i) { out.flat_at(i) = input.flat_at(i) / sqrt_inp_dot.flat_at(0u); } return out; } /** * Square root of a unit carrying scalar: the exponents halve, so the root of * an area is a length. * * Only defined when every exponent is even -- a half power of a base unit is * not expressible here, and silently truncating would be worse than refusing. */ template data, sch::UnitElement...>, Encoding> sqrt(const data, sch::UnitElement...>, Encoding> &inp) { static_assert(((E % 2 == 0) && ...), "sqrt of a unit needs even exponents"); return data, sch::UnitElement...>, Encoding>{sqrt(inp.handle())}; } /** * Unit aware vector algebra. * * A unit belongs to the vector as a whole (see unit.hpp), so each of these * recovers the raw vector, reuses the plain implementation above, and then * re-attaches the unit the result actually carries. The result unit is * computed rather than copied: the dot product of two lengths is an area, and * a normalised vector is a direction and therefore dimensionless. */ template auto dot(const data, EleL...>, Encoding> &left, const data, EleR...>, Encoding> &right) { using ResultSchema = typename kel::lbm::unit_multiplication, EleL...>, sch::Unit, EleR...>>::Schema; return data{ dot(left.handle(), right.handle())}; } /** * Length of a unit carrying vector. sqrt of an area is a length, so the unit * is unchanged. */ template data, Ele...>, Encoding> norm(const data, Ele...>, Encoding> &input) { return data, Ele...>, Encoding>{ sqrt(dot(input.handle(), input.handle()))}; } /** * A direction is dimensionless, and dimensionless is spelled Pure -- a bare * Vector would only mean "carries no annotation", which is a different claim. */ template data>, Encoding> normalize(const data, Ele...>, Encoding> &input) { return data>, Encoding>{ normalize(input.handle())}; } /** * Reinterprets a plain fixed array as a vector, so the algebra below applies * to it. */ template data, Encoding> vectorize_data(const data, Encoding> &dat) { data, Encoding> vec_data; for (uint64_t i = 0u; i < D; ++i) { vec_data.flat_at(i) = dat.flat_at(i); } return vec_data; } template data, Encoding> multiply(const data, Encoding> &left, const data, Encoding> &right) { data, Encoding> lr; for (uint64_t i = 0u; i < M; ++i) { for (uint64_t j = 0u; j < N; ++j) { auto &target = lr.at({{i, j}}); for (uint64_t k = 0u; k < K; ++k) { target = target + left.at({{i, k}}) * right.at({{k, j}}); } } } return lr; } template data, Encoding> multiply(const data, Encoding> &left, const data, Encoding> &right) { data, Encoding> lr; for (uint64_t i = 0u; i < M; ++i) { auto &target = lr.flat_at(i); for (uint64_t j = 0u; j < N; ++j) { target = target + left.at({{i, j}}) * right.flat_at(j); } } return lr; } template data, Encoding> cross(const data, Encoding> &lh, const data, Encoding> &rh) { data, Encoding> cross_prod; cross_prod.flat_at(0u) = lh.flat_at(1u) * rh.flat_at(2u) - lh.flat_at(2u) * rh.flat_at(1u); cross_prod.flat_at(1u) = lh.flat_at(2u) * rh.flat_at(0u) - lh.flat_at(0u) * rh.flat_at(2u); cross_prod.flat_at(2u) = lh.flat_at(0u) * rh.flat_at(1u) - lh.flat_at(1u) * rh.flat_at(0u); return cross_prod; } /** * In two dimensions the cross product has only the component normal to the * plane, so it comes back as a scalar. */ template data, Encoding> cross(const data, Encoding> &lh, const data, Encoding> &rh) { data, Encoding> cross_prod; cross_prod.flat_at(0u) = lh.flat_at(0u) * rh.flat_at(1u) - lh.flat_at(1u) * rh.flat_at(0u); return cross_prod; } /** * Cross product of an out of plane scalar with an in plane vector, which is * the rotation of that vector by a quarter turn, scaled. */ template data, Encoding> cross(const data, Encoding> &lh, const data, Encoding> &rh) { data, Encoding> cross_prod; cross_prod.flat_at(0u) = -(lh.flat_at(0u) * rh.flat_at(1u)); cross_prod.flat_at(1u) = lh.flat_at(0u) * rh.flat_at(0u); return cross_prod; } template data, Encoding> cos(const data, Encoding> &val) { data, Encoding> ret; ret.flat_at(0u).set(std::cos(val.flat_at(0u).get())); return ret; } template data, Encoding> sin(const data, Encoding> &val) { data, Encoding> ret; ret.flat_at(0u).set(std::sin(val.flat_at(0u).get())); return ret; } /** * Angle of a 2d vector measured counter clockwise from the positive x axis. * Inverse of unit_vector(). */ template data, Encoding> angle(const data, Encoding> &vec) { data, Encoding> ret; ret.flat_at(0u).set(std::atan2(vec.flat_at(1u).get(), vec.flat_at(0u).get())); return ret; } /** * Unit length 2d vector pointing along the given angle. Inverse of angle(). */ template data, Encoding> unit_vector(const data, Encoding> &rot) { data, Encoding> ret; ret.flat_at(0u) = cos(rot).flat_at(0u); ret.flat_at(1u) = sin(rot).flat_at(0u); return ret; } /** * Rotates a 2d vector counter clockwise by the given angle. */ template data, Encoding> rotate(const data, Encoding> &vec, const data, Encoding> &rot) { data, Encoding> rot_vec; auto c = cos(rot).flat_at(0u); auto s = sin(rot).flat_at(0u); rot_vec.flat_at(0u) = vec.flat_at(0u) * c - vec.flat_at(1u) * s; rot_vec.flat_at(1u) = vec.flat_at(0u) * s + vec.flat_at(1u) * c; return rot_vec; } template data, Encoding> scale(const data, Encoding> &vec, const data, Encoding> &scale_) { data, Encoding> sc_vec; for (uint64_t i = 0u; i < D; ++i) { sc_vec.flat_at(i) = vec.flat_at(i) * scale_.flat_at(0u); } return sc_vec; } template void fill(data, Encoding> &tbf, const data &filler) { constexpr uint64_t flat = ct_multiply::value; for (uint64_t i = 0u; i < flat; ++i) { tbf.flat_at(i) = filler; } } template data, Encoding> sum(const data, Encoding> &tens) { data, Encoding> s; constexpr uint64_t flat = ct_multiply::value; for (uint64_t i = 0u; i < flat; ++i) { s.flat_at(0u) = s.flat_at(0u) + tens.flat_at(i); } return s; } } // namespace math } // namespace lbm } // namespace kel