Programming

/// \file
///
///

#ifndef __VECT2_HH__
#define __VECT2_HH__

#include <iostream>
#include <assert.h>
#include <cmath>

#include "common.hh"

////////////////////////////////////////////////////////////////////////////////////////////////////

///
/// \class Vect2 vect2.hh
/// \brief
///

struct Vect2 {

// -- Attributes -----------------------------------------------------------------------------------

public:

  Real  X;    ///< The x-component of a cartesian vector
  Real  Z;    ///< The z-component of a cartesian vector

// -- Operations -----------------------------------------------------------------------------------

public:

  // Constructors:

  ///
  /// \fn Vect2
  /// \brief Initializes a new instance of a cartesian vector, setting its component to zero.
  ///

  Vect2():
    X(0.0),
    Z(0.0) { }

  ///
  /// \fn Vect2
  /// \brief Initializes a new instance of a cartesian vector, using the specified x- and z-components.
  ///
  /// \param x
  /// \param z
  ///
  Vect2(
    const Real  x,
    const Real  z ):
    X(x),
    Z(z) { }

  ///
  /// \fn Vect2
  /// \brief Initializes a new instance of a cartesian vector, using two scalar values.
  ///
  /// \param r
  ///
  Vect2(
    const Real*  r ):
    X(r[0]),
    Z(r[1]) { }

  ///
  /// \fn Vect2
  /// \brief Initializes a new instance of a cartesian vector, using the specified cartesian vector.
  ///
  /// \param V
  ///
  Vect2(
    const Vect2&  V );

  ///
  /// \fn Mod
  /// \brief Return the modulus (absolute value) of a cartesian vector.
  ///
  /// \return Real
  ///
  Real  Mod() const;

//  Vect2  Vers() const;

  ///
  /// \fn Normalize
  /// \brief Normalize a cartesian vector.
  ///
  /// \return Vect2
  ///
  Vect2  Normalize() const;

  ///
  /// \fn operator []
  /// \brief
  ///
  /// \param i
  /// \return Real &operator
  ///
  Real&  operator [] (
    const int  i );

  ///
  /// \fn operator =
  /// \brief Assignment to a cartesian vector.
  ///
  /// \param V
  /// \return Vect2 &operator
  ///
  Vect2&  operator = (
    const Vect2&  V );

  ///
  /// \fn operator =
  /// \brief Assignment to a scalar.
  ///
  /// \param r
  /// \return Vect2 &operator
  ///
  Vect2&  operator = (
    const Real  r );

  // Compound assignments:

  ///
  /// \fn operator +=
  /// \brief Compound addition assignment with a cartesian vector.
  ///
  /// \param V
  /// \return Vect2 &operator
  ///
  Vect2&  operator += (
    const Vect2&  V );

  ///
  /// \fn operator -=
  /// \brief Compound subtraction assignment with a cartesian vector.
  ///
  /// \param V
  /// \return Vect2 &operator
  ///
  Vect2&  operator -= (
    const Vect2&  V );

  ///
  /// \fn operator *=
  /// \brief Compound multiplication assignment with a scalar.
  ///
  /// \param r
  /// \return Vect2 &operator
  ///
  Vect2&  operator *= (
    const Real  r );

  ///
  /// \fn operator /=
  /// \brief Compound division assignment with a scalar.
  ///
  /// \param r
  /// \return Vect2 &operator
  ///
  Vect2&  operator /= (
    const Real  r );

  ///
  /// \fn operator ^
  /// \brief
  ///
  /// \param V
  /// \return Real operator
  ///
  Real  operator ^ (
    const Vect2&  V ) const;

  ///
  /// \fn Mod
  /// \brief Return the modulus (absolute value) of a cartesian vector.
  ///
  /// \param V
  /// \return Real
  ///
  friend Real  Mod(
    const Vect2&  V );

//  friend Vect2  Vers(
//    const Vect2&  V );

  ///
  /// \fn Normalize
  /// \brief Normalize a cartesian vector.
  ///
  /// \param V Cartesian vector
  /// \return Vect2
  ///
  friend Vect2  Normalize(
    const Vect2&  V );

  ///
  /// \fn operator -
  /// \brief Unary minus.
  ///
  /// \param V Cartesian vector
  /// \return Vect2 operator
  ///
  friend Vect2  operator  - (
    const Vect2&  V );

  ///
  /// \fn operator +
  /// \brief Add two cartesian vectors.
  ///
  /// \param V Cartesian vector
  /// \param W Cartesian vector
  /// \return Vect2 operator
  ///
  friend Vect2  operator  + (
    const Vect2&  V,
    const Vect2&  W );

  ///
  /// \fn operator -
  /// \brief Subtract two cartesian vectors.
  ///
  /// \param V Cartesian vector
  /// \param W Cartesian vector
  /// \return Vect2 operator
  ///
  friend Vect2  operator  - (
    const Vect2&  V,
    const Vect2&  W );

  ///
  /// \fn operator *
  /// \brief Multiply cartesian vector with a scalar.
  ///
  /// \param V Cartesian vector
  /// \param r Scalar
  /// \return Vect2 operator
  ///
  friend Vect2  operator  * (
    const Vect2&  V,
    const Real  r );

  ///
  /// \fn operator *
  /// \brief Multiply a scalar with a cartesian vector.
  ///
  /// \param r Scalar
  /// \param V Cartesian vector
  /// \return Vect2 operator
  ///
  friend Vect2  operator  * (
    const Real  r,
    const Vect2&  V );

  ///
  /// \fn operator *
  /// \brief Multiply two cartesian vectors.
  ///
  /// \param V Cartesian vector
  /// \param W Cartesian vector
  /// \return Real operator
  ///
  friend Real  operator  * (
    const Vect2&  V,
    const Vect2&  W );

  ///
  /// \fn operator /
  /// \brief Divide a cartesian vector by a scalar.
  ///
  /// \param V Cartesian vector
  /// \param r
  /// \return Vect2 operator
  ///
  friend Vect2  operator  / (
    const Vect2&  V,
    const Real  r );

  ///
  /// \fn operator ==
  /// \brief Compares two cartesian vectors for equality.
  ///
  /// \param V Cartesian vector
  /// \param W Cartesian vector
  /// \return bool operator
  ///
  friend bool  operator  == (
    const Vect2&  V,
    const Vect2&  W );

  ///
  /// \fn operator !=
  /// \brief Compares two cartesian vectors for inequality.
  ///
  /// \param V Cartesian vector
  /// \param W Cartesian vector
  /// \return bool operator
  ///
  friend bool  operator  != (
    const Vect2&  V,
    const Vect2&  W );

  ///
  /// \fn operator >>
  /// \brief
  ///
  /// \param is
  /// \param V Cartesian vector
  /// \return istream &operator >>
  ///
  friend istream&  operator  >> (
    istream&  is,
    Vect2&  V );

  ///
  /// \fn operator <<
  /// \brief
  ///
  /// \param os output stream
  /// \param V Cartesian vector
  /// \return ostream &operator
  ///
  friend ostream&  operator  << (
    ostream&  os,
    const Vect2&  V );

};

////////////////////////////////////////////////////////////////////////////////////////////////////