vectormath.hpp

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, LLC.
******************************************************************************/
/*
Vector math header file
-----------------------
This file defines basic functions for mathematical operations on
the vector class
Rather than raising an error on fail cases (i.e. divide by zero),
the following libraries are designed to check for errors and return
corresponding codes.
 
Author: Alex Reynolds
*/
 
#ifndef VECTORMATH_HPP
#define VECTORMATH_HPP
 
#include "Matrix.hpp"
#include "CartesianVector.hpp"
#include "clockwerkerrors.h"
#include "matrixmath.hpp"
 
namespace clockwerk {
 
    //// @brief   Function to take the dot product of two vectors
    //// @param   a   First vector in the dot operation
    //// @param   b   Second vector in the dot operation
    //// @param   result  PBR return of a dot b result
    //// @note    Overloaded function to return result
    template<typename T, unsigned int L>
    void dot(const CartesianVector<T, L> &a, const CartesianVector<T, L> &b, T &result) {
        result = T();
        for(unsigned int i = 0; i < L; i++) {
            result += a.values[i][0]*b.values[i][0];
        }
    }
    template<typename T, unsigned int L>
    T dot(const CartesianVector<T, L> &a, const CartesianVector<T, L> &b) {
        T tmp;
        dot(a, b, tmp);
        return tmp;
    }
 
    //// @brief   Function to take the cross product of two vectors with length 3
    //// @param   a   First vector in the cross operation
    //// @param   b   Second vector in the cross operation
    //// @param   result  PBR return of a cross b result
    //// @note    Overloaded function to return result
    template<typename T>
    void cross(CartesianVector<T, 3> a, CartesianVector<T, 3> b, CartesianVector<T, 3> &result) {
        result.values[0][0] = a.values[1][0]*b.values[2][0] - a.values[2][0]*b.values[1][0];
        result.values[1][0] = a.values[2][0]*b.values[0][0] - a.values[0][0]*b.values[2][0];
        result.values[2][0] = a.values[0][0]*b.values[1][0] - a.values[1][0]*b.values[0][0];
    }
    template<typename T>
    CartesianVector<T, 3> cross(const CartesianVector<T, 3> &a, const CartesianVector<T, 3> &b) {
        CartesianVector<T, 3> tmp;
        cross(a, b, tmp);
        return tmp;
    }
 
    //// @brief   Function to take the tilde operator of a vector with length 3
    //// @param   v   Vector to take the tilde operator of
    //// @param   t   Return of tilde matrix
    //// @note    Overloaded function returns t
    template <typename T>
    void tilde(const CartesianVector<T, 3> &v, Matrix<T, 3, 3> &t) {
        t.set(0, 1, -v.values[2][0]);
        t.set(0, 2, v.values[1][0]);
        t.set(1, 0, v.values[2][0]);
        t.set(1, 2, -v.values[0][0]);
        t.set(2, 0, -v.values[1][0]);
        t.set(2, 1, v.values[0][0]);
    }
    template <typename T>
    Matrix<T, 3, 3> tilde(const CartesianVector<T, 3> &v) {
        Matrix<T, 3, 3> t;
        tilde(v, t);
        return t;
    }
 
    /// ------------------------------------------------------------------------------------------------------
    /// Operator overloads -- NOTE: May be less efficient than equivalent PBR function in some cases due to 
    ///                             return by value. Where overload is less efficient, it is explicitly noted.
    /// ------------------------------------------------------------------------------------------------------
    /// @brief   Overload of matrix multiplication - Matrix and vector
    /// @note    Returns value -- less efficient in some cases
    template<typename T, unsigned int R1, unsigned int C1R2>
    CartesianVector<T, R1> operator*(const Matrix<T, R1, C1R2> &A, const CartesianVector<T, C1R2> &B) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, R1> result;
        multiply(A, B, result);
        return result;
    }
 
    /// @brief   Overload of vector multiplication - vector and scalar
    /// @note    Returns value -- less efficient in some cases
    template<typename T, unsigned int L>
    CartesianVector<T, L> operator*(const T &a, const CartesianVector<T, L> &A) {
        /// Call our function to multiply and return the result
        CartesianVector<T, L> result;
        multiply(a, A, result);
        return result;
    }
    template<typename T, unsigned int L>
    CartesianVector<T, L> operator*(const CartesianVector<T, L> &A, const T &a) {
        /// Call our function to multiply and return the result
        CartesianVector<T, L> result;
        multiply(a, A, result);
        return result;
    }
 
    /// @brief   Overload of matrix addition - Two matrices
    /// @note    Returns value -- less efficient in some cases
    template<typename T, unsigned int L>
    CartesianVector<T, L> operator+(const CartesianVector<T, L> &A, const CartesianVector<T, L> &B) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, L> result;
        eAdd(A, B, result);
        return result;
    }
 
    /// @brief   Overload of matrix addition - Matrix and scalar
    /// @note    Returns value -- less efficient in some cases
    template<typename T, unsigned int L>
    CartesianVector<T, L> operator+(const T &a, const CartesianVector<T, L> &A) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, L> result;
        add(a, A, result);
        return result;
    }
    template<typename T, unsigned int L>
    CartesianVector<T, L> operator+(const CartesianVector<T, L> &A, const T &a) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, L> result;
        add(a, A, result);
        return result;
    }
 
    /// Returns value -- less efficient in some cases
    template<typename T, unsigned int L>
    CartesianVector<T, L> operator-(const CartesianVector<T, L> &A, const CartesianVector<T, L> &B) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, L> result;
        eSubtract(A, B, result);
        return result;
    }
 
}
 
#endif