CartesianVector.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.
******************************************************************************/
/*
Cartesian Vector header file
 
Author: Alex Reynolds
*/
#ifndef CORE_CARTESIAN_VECTOR_HPP
#define CORE_CARTESIAN_VECTOR_HPP
 
#include <cmath>
 
#include "Matrix.hpp"
#include "safemath.h"
 
namespace clockwerk {

    template<uint32 L>
    class CartesianVector : public Matrix<L, 1> {
    public:
        CartesianVector() : Matrix<L, 1>() {};

        CartesianVector(floating_point elements) : Matrix<L, 1>(elements) {};

        CartesianVector(const floating_point(&initial)[L]);

        CartesianVector(const CartesianVector<L> &initial);

        CartesianVector(const Matrix<L, 1> &initial);

        CartesianVector(const std::array<floating_point, L> &initial);

        ~CartesianVector() {}

        floating_point& operator [](uint32 idx);

        int set(uint32 idx, floating_point value) {return Matrix<L, 1>::set(idx, 0, value);}

        int get(uint32 idx, floating_point &result) const {return Matrix<L, 1>::get(idx, 0, result);}

        floating_point get(uint32 idx) const {return Matrix<L, 1>::get(idx, 0);}

        int16 norm(floating_point &result) const;

        floating_point norm() const {floating_point tmp; norm(tmp); return tmp;}

        int16 normSquared(floating_point &result) const;

        floating_point normSquared() const {floating_point tmp; normSquared(tmp); return tmp;}

        int16 unit(CartesianVector<L> &result) const; 

        int16 unitize();

        int16 normalize();
    };
 
    template <uint32 L> 
    CartesianVector<L>::CartesianVector(const floating_point(&initial)[L]) {
        
        for(uint32 i = 0; i < L; i++) {
            Matrix<L, 1>::values[i][0] = initial[i];
        }
    }
 
    template <uint32 L> 
    CartesianVector<L>::CartesianVector(const std::array<floating_point, L> &initial) {
        for(uint32 i = 0; i < L; i++) {
            Matrix<L, 1>::values[i][0] = initial[i];
        }
    }
 
    template <uint32 L>
    CartesianVector<L>::CartesianVector(const CartesianVector<L> &initial)
        : Matrix<L, 1>(initial) {}
    
    template <uint32 L>
    CartesianVector<L>::CartesianVector(const Matrix<L, 1> &initial)
        : Matrix<L, 1>(initial) {}
 
    template <uint32 L>
    floating_point& CartesianVector<L>::operator [](uint32 idx) {
        return Matrix<L, 1>::values[idx][0];
    }
 
    template <uint32 L> 
    int16 CartesianVector<L>::norm(floating_point &result) const {
        uint32 i;
        result = 0.0;
        for(i = 0; i < L; i++) {
            result += Matrix<L, 1>::values[i][0]*Matrix<L, 1>::values[i][0];
        }

        int err = safeSqrt(result, result);
 
        return err;
    }
 
    template <uint32 L> 
    int16 CartesianVector<L>::normSquared(floating_point &result) const {
        uint32 i;
        result = 0.0;
        for(i = 0; i < L; i++) {
            result += Matrix<L, 1>::values[i][0]*Matrix<L, 1>::values[i][0];
        }
 
        return NO_ERROR;
    }
 
    template <uint32 L> 
    int16 CartesianVector<L>::unit(CartesianVector<L> &result) const {
        floating_point mag = 0.0;
        norm(mag);

        if(mag < SAFE_MATH_ZERO_TOLERANCE) {
            return ERROR_DIVIDE_BY_ZERO;
        }
 
        for(uint32 i = 0; i < L; i++) {
            result.values[i][0] = Matrix<L, 1>::values[i][0]/mag;
        }
        return NO_ERROR;
    }
 
    template <uint32 L> 
    int16 CartesianVector<L>::unitize() {
        int err = unit(*this);
        if(err) {
            return err;
        } else {
            return NO_ERROR;
        }
    }
 
    template <uint32 L> 
    int16 CartesianVector<L>::normalize() {
        return unitize();
    }
}
 
#endif