attitudemath.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.
******************************************************************************/
/*
Matrix math header file
-----------------------
This file defines basic functions for mathematical operations on
the matrix 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.
 
Note: The naming convention observed for matrix math is as follows:
- Capital letters represent matrices
- Lowercase letters represent scalars
- All vectors are 1-dimensional matrices for the purpose of math
- Pass by reference return values are all named "result"
- The letter used in math indicates the order of operations - A/a
  comes first, then B/b. A/a or B/b always represent the "other"
  value in an operation
 
Author: Alex Reynolds
*/
 
#ifndef ATTITUDEMATH_HPP
#define ATTITUDEMATH_HPP
 
#include "core/Matrix.hpp"
#include "core/clockwerkerrors.h"
#include "core/matrixmath.hpp"
#include "core/vectormath.hpp"
#include "DCM.hpp"
#include "Quaternion.hpp"
#include "Euler321.hpp"
#include "MRP.hpp"
 
namespace clockwerk {
 
    /// ------------------------------------------------------------------------------------------------------
    /// 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 DCM multiplication - Two DCMs
    /// @note    Returns value -- less efficient in some cases
    template<typename T>
    DCM<T> operator*(const DCM<T> &A, const DCM<T> &B) {
        DCM<T> result;
        multiply(A, B, result);
        return result;
    }
    /// @brief   Overload of Quaternion multiplication - Two Quaternions
    /// @note    Returns value -- less efficient in some cases
    /// @note    TODO: Update with more efficient multiplication rather than using DCM
    template<typename T>
    Quaternion<T> operator*(const Quaternion<T> &a, const Quaternion<T> &b) {
        /// Call our function to add two matrices and return the result
        DCM<T> result;
        multiply(a.toDCM(), b.toDCM(), result);
        return result.toQuaternion();
    }
    /// @brief   Overload of Euler321 multiplication - Two Euler321s
    /// @note    Returns value -- less efficient in some cases
    /// @note    TODO: Update with more efficient multiplication rather than using DCM
    template<typename T>
    MRP<T> operator*(const Euler321<T> &a, const Euler321<T> &b) {
        DCM<T> result;
        multiply(a.toDCM(), b.toDCM(), result);
        return result.toEuler321();
    }
    /// @brief   Overload of MRP multiplication - Two MRPs
    /// @note    Returns value -- less efficient in some cases
    /// @note    TODO: Update with more efficient multiplication rather than using DCM
    template<typename T>
    MRP<T> operator*(const MRP<T> &a, const MRP<T> &b) {
        DCM<T> result;
        multiply(a.toDCM(), b.toDCM(), result);
        return result.toMRP();
    }
 
    /// @brief   Attitude rotation of vector via DCM
    /// @note    Returns value -- less efficient in some cases
    template<typename T>
    CartesianVector<T, 3> operator*(const DCM<T> &A, const CartesianVector<T, 3> &b) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, 3> result;
        multiply(A, b, result);
        return result;
    }
    /// @brief   Attitude rotation of vector via Quaternion
    /// @note    Returns value -- less efficient in some cases
    template<typename T>
    CartesianVector<T, 3> operator*(const Quaternion<T> &a, const CartesianVector<T, 3> &b) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, 3> result;
        multiply(a.toDCM(), b, result);
        return result;
    }
    /// @brief   Attitude rotation of vector via Euler321
    /// @note    Returns value -- less efficient in some cases
    template<typename T>
    CartesianVector<T, 3> operator*(const Euler321<T> &a, const CartesianVector<T, 3> &b) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, 3> result;
        multiply(a.toDCM(), b, result);
        return result;
    }
    /// @brief   Attitude rotation of vector via MRP
    /// @note    Returns value -- less efficient in some cases
    template<typename T>
    CartesianVector<T, 3> operator*(const MRP<T> &a, const CartesianVector<T, 3> &b) {
        /// Call our function to add two matrices and return the result
        CartesianVector<T, 3> result;
        multiply(a.toDCM(), b, result);
        return result;
    }
 
}
 
#endif