vectormath.hpp

Go to the documentation of this file.

/******************************************************************************
* 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 CORE_VECTORMATH_HPP
#define CORE_VECTORMATH_HPP
 
#include "Matrix.hpp"
#include "CartesianVector.hpp"
#include "clockwerkerrors.h"
#include "matrixmath.hpp"
 
namespace clockwerk {

    template<uint32 L>
    void dot(const CartesianVector<L> &a, const CartesianVector<L> &b, floating_point &result) {
        result = 0.0;
        for(uint32 i = 0; i < L; i++) {
            result += a.values[i][0]*b.values[i][0];
        }
    }
    template<uint32 L>
    floating_point dot(const CartesianVector<L> &a, const CartesianVector<L> &b) {
        floating_point tmp;
        dot(a, b, tmp);
        return tmp;
    }

    void cross(CartesianVector<3> a, CartesianVector<3> b, CartesianVector<3> &result);
    CartesianVector<3> cross(const CartesianVector<3> &a, const CartesianVector<3> &b);

    void tilde(const CartesianVector<3> &v, Matrix<3, 3> &t);
    Matrix<3, 3> tilde(const CartesianVector<3> &v);

    template<uint32 R1, uint32 C1R2>
    CartesianVector<R1> operator*(const Matrix<R1, C1R2> &A, const CartesianVector<C1R2> &B) {
        CartesianVector<R1> result;
        multiply(A, B, result);
        return result;
    }

    template<uint32 L>
    CartesianVector<L> operator*(const floating_point &a, const CartesianVector<L> &A) {
        CartesianVector<L> result;
        multiply(a, A, result);
        return result;
    }
    template<uint32 L>
    CartesianVector<L> operator*(const CartesianVector<L> &A, const floating_point &a) {
        CartesianVector<L> result;
        multiply(a, A, result);
        return result;
    }

    template<uint32 L>
    CartesianVector<L> operator+(const CartesianVector<L> &A, const CartesianVector<L> &B) {
        CartesianVector<L> result;
        eAdd(A, B, result);
        return result;
    }

    template<uint32 L>
    CartesianVector<L> operator+(const floating_point &a, const CartesianVector<L> &A) {
        CartesianVector<L> result;
        add(a, A, result);
        return result;
    }
    template<uint32 L>
    CartesianVector<L> operator+(const CartesianVector<L> &A, const floating_point &a) {
        CartesianVector<L> result;
        add(a, A, result);
        return result;
    }

    template<uint32 L>
    CartesianVector<L> operator-(const CartesianVector<L> &A, const CartesianVector<L> &B) {
        CartesianVector<L> result;
        eSubtract(A, B, result);
        return result;
    }
 
}
 
#endif