include/ewalena/base/point.h

Go to the documentation of this file.

// -------------------------------------------------------------------
// @author Toby D. Young
// @version $Id: point.h 988 2012-11-26 19:09:39Z oneliefleft $
//
// Copyright 2012 namespace ewalena authors. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above
//    copyright notice, this list of conditions and the following
//    disclaimer in the documentation and/or other materials provided
//    with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE NAMEPSACE EWALENA AUTHORS ``AS
// IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// NAMESPACE EWALENA AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.
//
// The views and conclusions contained in the software and
// documentation are those of the authors and should not be
// interpreted as representing official policies, either expressed or
// implied, of the namespace ewalena authors.
// -------------------------------------------------------------------

#include <cassert>
#include <cstdarg>
#include <cstring>
#include <cmath>
#include <iostream>

#ifndef __ewalena_point_h
#define __ewalena_point_h

#ifdef EWALENA_HAVE_CONFIG_H
#include <ewalena/base/config.h>
#endif

#include <ewalena/base/utilities.h>
#include <ewalena/base/tensor.h>

namespace ewalena
{
  
  template <int dim, typename ValueType = double>
    class Point
    :
    public ewalena::Tensor<dim, 1, ValueType>
    {
    public:
    
    Point () 
    :
    Tensor<dim, 1, ValueType> () 
    {}
    
    explicit Point (const ValueType x);
    
    explicit Point (const ValueType x,
                    const ValueType y);
    
    explicit Point (const ValueType x,
                    const ValueType y,
                    const ValueType z);
    
    ~Point ();
    
    void clone (const Point<dim, ValueType> &p);
    
    ValueType l2_norm (const Point<dim, ValueType> &p = Point<dim, ValueType> ()) const;
    
    ValueType operator = (const unsigned int i);
    
    const ValueType operator = (const unsigned int i) const;
    
    void operator *= (const ValueType &scalar);

    void operator /= (const ValueType &scalar);
    
    void operator -= (const Point<dim, ValueType> &p);
    
    void operator += (const Point<dim, ValueType> &p);
    
    protected:
    
    inline  
    ewalena::Tensor<dim, 1, ValueType> operator* ()
    {  
      return *this;  
    }
    
    inline  
    const ewalena::Tensor<dim, 1, ValueType> operator* () const  
    {  
      return *this;  
    }
    
    private:
    
    }; /* Point */

  /*-------------- Inline and Other Functions -----------------------*/

  template <int dim, typename ValueType>
    inline 
    Point<dim, ValueType>::Point (const ValueType x) 
    {
      assert (dim == 1);
      
      (*this)(0) = x;
    }

  template <int dim, typename ValueType>
    inline 
    Point<dim, ValueType>::Point (const ValueType x,
                                  const ValueType y) 
    {
      assert (dim == 2);

      (*this)(0) = x;
      (*this)(1) = y;
    }

  template <int dim, typename ValueType>
    inline 
    Point<dim, ValueType>::Point (const ValueType x,
                                  const ValueType y,
                                  const ValueType z) 
    {
      assert (dim == 3);

      (*this)(0) = x;
      (*this)(1) = y;
      (*this)(2) = z;
    }

  template <int dim, typename ValueType>
    inline
    void
    Point<dim, ValueType>::clone (const Point<dim, ValueType> &p)
    {
      /* Clone the underlying Tensor with the Tensor::clone (Tensor)
         function. @todo This is buggy. */
      
      /* (**this).clone (*p); */
      for (unsigned int i=0; i<dim; ++i)     
        (*this)(i) = (*p)(i); 
    }
  
  template <int dim, typename ValueType>
    inline 
    ValueType
    Point<dim, ValueType>::operator = (const unsigned int i) 
    {
      return (*this)(i);
    }
  
  template <int dim, typename ValueType>
    inline 
    const ValueType
    Point<dim, ValueType>::operator = (const unsigned int i) const
    {
      return (*this)(i);
    }
  
  template <int dim, typename ValueType>
    inline 
    void
    Point<dim, ValueType>::operator *= (const ValueType &scalar) 
    {
      (*this) *= scalar;
    }

  template <int dim, typename ValueType>
    inline 
    void
    Point<dim, ValueType>::operator /= (const ValueType &scalar) 
    {
      (*this) /= scalar;
    }

  template <int dim, typename ValueType>
    inline 
    void
    Point<dim, ValueType>::operator -= (const Point<dim, ValueType> &p) 
    {
      for (unsigned int i=0; i<dim; ++i)
        (*this)(i) -= (*p)(i);
    }

  template <int dim, typename ValueType>
    inline 
    void
    Point<dim, ValueType>::operator += (const Point<dim, ValueType> &p) 
    {
      for (unsigned int i=0; i<dim; ++i)
        (*this)(i) += (*p)(i);
    }

} /* namespace ewalena */
  
#endif /* __ewalena_point_h */