FGColumnVector3.h

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
Header: FGColumnVector3.h
Author: Originally by Tony Peden [formatted and adapted here by Jon Berndt]
Date started: Unknown
 
 ------ Copyright (C) 2001 by Tony Peden and Jon S. Berndt (jon@jsbsim.org)
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the Free
 Software Foundation; either version 2 of the License, or (at your option) any
 later version.
 
 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 details.
 
 You should have received a copy of the GNU Lesser General Public License along
 with this program; if not, write to the Free Software Foundation, Inc., 59
 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 Further information about the GNU Lesser General Public License can also be
 found on the world wide web at http://www.gnu.org.
 
HISTORY
--------------------------------------------------------------------------------
??/??/???? ??   Initial version and more.
03/06/2004 MF   Rework, document and do much inlineing.
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SENTRY
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#ifndef FGCOLUMNVECTOR3_H
#define FGCOLUMNVECTOR3_H
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#include <iosfwd>
#include <string>
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FORWARD DECLARATIONS
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
namespace JSBSim {
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DOCUMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS DECLARATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class FGColumnVector3
{
public:
  FGColumnVector3(void);
 
  FGColumnVector3(const double X, const double Y, const double Z) {
    data[0] = X;
    data[1] = Y;
    data[2] = Z;
  }
 
  FGColumnVector3(const FGColumnVector3& v) {
    data[0] = v.data[0];
    data[1] = v.data[1];
    data[2] = v.data[2];
  }
 
  ~FGColumnVector3(void) { }
 
  double operator()(const unsigned int idx) const { return data[idx-1]; }
 
  double& operator()(const unsigned int idx) { return data[idx-1]; }
 
  double Entry(const unsigned int idx) const { return data[idx-1]; }
 
  double& Entry(const unsigned int idx) { return data[idx-1]; }
 
  std::string Dump(const std::string& delimeter) const;
 
  FGColumnVector3& operator=(const FGColumnVector3& b) {
    data[0] = b.data[0];
    data[1] = b.data[1];
    data[2] = b.data[2];
    return *this;
  }
 
  FGColumnVector3& operator=(std::initializer_list<double> lv) {
    double *v = data;
    for(auto &x : lv)
      *(v++) = x;
 
    return *this;
  }
 
  bool operator==(const FGColumnVector3& b) const {
    return data[0] == b.data[0] && data[1] == b.data[1] && data[2] == b.data[2];
  }
 
  bool operator!=(const FGColumnVector3& b) const { return ! operator==(b); }
 
  FGColumnVector3 operator*(const double scalar) const {
    return FGColumnVector3(scalar*data[0], scalar*data[1], scalar*data[2]);
  }
 
  FGColumnVector3 operator/(const double scalar) const;
 
  FGColumnVector3 operator*(const FGColumnVector3& V) const {
    return FGColumnVector3( data[1] * V.data[2] - data[2] * V.data[1],
                            data[2] * V.data[0] - data[0] * V.data[2],
                            data[0] * V.data[1] - data[1] * V.data[0] );
  }
 
  FGColumnVector3 operator+(const FGColumnVector3& B) const {
    return FGColumnVector3( data[0] + B.data[0], data[1] + B.data[1],
                            data[2] + B.data[2] );
  }
 
  FGColumnVector3 operator-(const FGColumnVector3& B) const {
    return FGColumnVector3( data[0] - B.data[0], data[1] - B.data[1],
                            data[2] - B.data[2] );
  }
 
  FGColumnVector3& operator-=(const FGColumnVector3 &B) {
    data[0] -= B.data[0];
    data[1] -= B.data[1];
    data[2] -= B.data[2];
    return *this;
  }
 
  FGColumnVector3& operator+=(const FGColumnVector3 &B) {
    data[0] += B.data[0];
    data[1] += B.data[1];
    data[2] += B.data[2];
    return *this;
  }
 
  FGColumnVector3& operator*=(const double scalar) {
    data[0] *= scalar;
    data[1] *= scalar;
    data[2] *= scalar;
    return *this;
  }
 
  FGColumnVector3& operator/=(const double scalar);
 
  void InitMatrix(void) { data[0] = data[1] = data[2] = 0.0; }
  void InitMatrix(const double a) { data[0] = data[1] = data[2] = a; }
  void InitMatrix(const double a, const double b, const double c) {
    data[0]=a; data[1]=b; data[2]=c;
  }
 
  double Magnitude(void) const;
 
  double Magnitude(const int idx1, const int idx2) const;
 
  FGColumnVector3& Normalize(void);
 
private:
  double data[3];
};
 
inline double DotProduct(const FGColumnVector3& v1, const FGColumnVector3& v2) {
  return v1(1)*v2(1) + v1(2)*v2(2) + v1(3)*v2(3);
}
 
inline FGColumnVector3 operator*(double scalar, const FGColumnVector3& A) {
  // use already defined operation.
  return A*scalar;
}
 
std::ostream& operator<<(std::ostream& os, const FGColumnVector3& col);
 
} // namespace JSBSim
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
#endif