|| ||           || Doxygen's  

---

HxScalarDouble.h

/*
 *  Copyright (c) 1997, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *
 *  Author(s):
 *  Dennis Koelma (koelma@wins.uva.nl)
 *  Edo Poll (poll@wins.uva.nl)
 */

#ifndef HxScalarDouble_h
#define HxScalarDouble_h

#include "HxIoFwd.h"
#include "HxMath.h"
#include "HxString.h"

#undef min
#undef max

class HxScalarInt;
class HxVec2Int;
class HxVec2Double;
class HxVec3Int;
class HxVec3Double;
class HxComplex;


class L_HXBASIS HxScalarDouble {
public:


                            HxScalarDouble();

                            HxScalarDouble(double v);
                            
                            HxScalarDouble(const HxScalarDouble& rhs);

    void*                   operator new(size_t, void* = 0);

    HxScalarDouble&         operator=(const double& v);
    HxScalarDouble&         operator=(const HxScalarDouble& rhs);


    int                     dim() const;
    
    double                  x() const;

    double                  getValue(int dimension) const; // dimension: 1
    void                    setValue(int dimension, double value); // dimension: 1

/** \name Conversion*/
                            //operator double() const;

                            operator HxScalarInt() const;

                            operator HxVec2Int() const;

                            operator HxVec2Double() const;

                            operator HxVec3Int() const;

                            operator HxVec3Double() const;

                            operator HxComplex() const;


    int                     operator==(const HxScalarDouble& v) const;

    int                     operator!=(const HxScalarDouble& v) const;

    int                     operator< (const HxScalarDouble& v) const;

    int                     operator<=(const HxScalarDouble& v) const;

    int                     operator> (const HxScalarDouble& v) const;

    int                     operator>=(const HxScalarDouble& v) const;

    static const HxScalarDouble SMALL_VAL;

    static const HxScalarDouble LARGE_VAL;


    HxScalarDouble          operator-() const;

    HxScalarDouble          complement() const;

    HxScalarDouble          abs() const;

    HxScalarDouble          ceil() const;

    HxScalarDouble          floor() const;

    HxScalarDouble          round() const;

    HxScalarDouble          sum() const;
    
    HxScalarDouble          product() const;

    HxScalarDouble          min() const;

    HxScalarDouble          max() const;

    HxScalarDouble          norm1() const;

    HxScalarDouble          norm2() const;

    HxScalarDouble          normInf() const;

    HxScalarDouble          sqrt() const;

    HxScalarDouble          sin() const;

    HxScalarDouble          cos() const;

    HxScalarDouble          tan() const;

    HxScalarDouble          asin() const;

    HxScalarDouble          acos() const;

    HxScalarDouble          atan() const;

    HxScalarDouble          atan2() const;

    HxScalarDouble          sinh() const;

    HxScalarDouble          cosh() const;

    HxScalarDouble          tanh() const;

    HxScalarDouble          exp() const;

    HxScalarDouble          log() const;

    HxScalarDouble          log10() const;


    HxScalarDouble&         operator+=(const HxScalarDouble& v);

    HxScalarDouble&         operator-=(const HxScalarDouble& v);

    HxScalarDouble&         operator*=(const HxScalarDouble& v);

    HxScalarDouble&         operator/=(const HxScalarDouble& v);


    friend HxScalarDouble   operator+(const HxScalarDouble& v1,
                                      const HxScalarDouble& v2);

    friend HxScalarDouble   operator-(const HxScalarDouble& v1,
                                      const HxScalarDouble& v2);

    friend HxScalarDouble   operator*(const HxScalarDouble& v1,
                                      const HxScalarDouble& v2);

    friend HxScalarDouble   operator/(const HxScalarDouble& v1,
                                      const HxScalarDouble& v2);


    HxScalarDouble          min(const HxScalarDouble& v) const;

    HxScalarDouble&         minAssign(const HxScalarDouble& v);

    HxScalarDouble          max(const HxScalarDouble& v) const;

    HxScalarDouble&         maxAssign(const HxScalarDouble& v);

    HxScalarDouble          inf(const HxScalarDouble& v) const;

    HxScalarDouble&         infAssign(const HxScalarDouble& v);

    HxScalarDouble          sup(const HxScalarDouble& v) const;

    HxScalarDouble&         supAssign(const HxScalarDouble& v);

    HxScalarDouble          pow(const HxScalarDouble& v) const;

    HxScalarDouble          mod(const HxScalarDouble& v) const;

    HxScalarDouble          and(const HxScalarDouble& v) const;

    HxScalarDouble          or(const HxScalarDouble& v) const;

    HxScalarDouble          xor(const HxScalarDouble& v) const;

    HxScalarDouble          leftShift(const HxScalarDouble& v) const;

    HxScalarDouble          rightShift(const HxScalarDouble& v) const;

    HxScalarDouble          dot(const HxScalarDouble& v) const;

    HxScalarDouble          cross(const HxScalarDouble& v) const;


    STD_OSTREAM&            put(STD_OSTREAM& os) const;

    HxString                toString() const;

private:
    double                  _value;
};

typedef HxScalarDouble (*HxUpoScalarDouble)(const HxScalarDouble& a);
typedef HxScalarDouble (*HxBpoScalarDouble)(const HxScalarDouble& a1, const HxScalarDouble& a2);

inline STD_OSTREAM&
operator<<(STD_OSTREAM& os, const HxScalarDouble v)
{
    return v.put(os);
}

inline
HxScalarDouble::HxScalarDouble() 
{ 
}

inline
HxScalarDouble::HxScalarDouble(double v)
    : _value(v)
{ 
}

inline
HxScalarDouble::HxScalarDouble(const HxScalarDouble& rhs)
    : _value(rhs._value)
{
}

inline void*
HxScalarDouble::operator new(size_t size, void *m) 
{
    return m ? m : new char[size];
}

inline HxScalarDouble&
HxScalarDouble::operator=(const double& v)
{
    _value = v;
    return *this;
}

inline HxScalarDouble&
HxScalarDouble::operator=(const HxScalarDouble& rhs)
{
    _value = rhs._value;
    return *this;
}

inline int
HxScalarDouble::dim() const 
{ 
    return 1; 
}

inline double
HxScalarDouble::x() const 
{ 
    return _value; 
}

inline double
HxScalarDouble::getValue(int) const
{ 
    return _value; 
}

inline void
HxScalarDouble::setValue(int, double value)
{ 
    _value = value; 
}
/*
inline
HxScalarDouble::operator double() const
{
    return _value;
}
*/
inline int
HxScalarDouble::operator==(const HxScalarDouble& v) const
{
    return (_value == v._value);
}

inline int
HxScalarDouble::operator!=(const HxScalarDouble& v) const
{
    return (_value != v._value);
}

inline int
HxScalarDouble::operator<(const HxScalarDouble& v) const
{
    return (_value < v._value);
}

inline int
HxScalarDouble::operator<=(const HxScalarDouble& v) const
{
    return (_value <= v._value);
}

inline int
HxScalarDouble::operator>(const HxScalarDouble& v) const
{
    return (_value > v._value);
}

inline int
HxScalarDouble::operator>=(const HxScalarDouble& v) const
{
    return (_value >= v._value);
}

inline HxScalarDouble
HxScalarDouble::operator-() const
{
    return HxScalarDouble(-_value);
}

inline HxScalarDouble
HxScalarDouble::complement() const
{
    return HxScalarDouble(-_value);
}

inline HxScalarDouble
HxScalarDouble::abs() const
{
    return HxScalarDouble(fabs(_value));
}

inline HxScalarDouble
HxScalarDouble::ceil() const
{
    return HxScalarDouble(::ceil(_value));
}

inline HxScalarDouble
HxScalarDouble::floor() const
{
    return HxScalarDouble(::floor(_value));
}

inline HxScalarDouble
HxScalarDouble::round() const
{
    return HxScalarDouble((int) (_value + ((_value >= 0) ? 0.5 : -0.5)));
}

inline HxScalarDouble
HxScalarDouble::sum() const
{
    return *this;
}

inline HxScalarDouble
HxScalarDouble::product() const
{
    return *this;
}

inline HxScalarDouble
HxScalarDouble::min() const
{
    return *this;
}

inline HxScalarDouble
HxScalarDouble::max() const
{
    return *this;
}

inline HxScalarDouble
HxScalarDouble::norm1() const
{
    return HxScalarDouble(fabs(_value));
}

inline HxScalarDouble
HxScalarDouble::normInf() const
{
    return HxScalarDouble(fabs(_value));
}

inline HxScalarDouble
HxScalarDouble::sqrt() const
{
    return HxScalarDouble(::sqrt(_value));
}

inline HxScalarDouble
HxScalarDouble::sin() const
{
    return HxScalarDouble(::sin(_value));
}

inline HxScalarDouble
HxScalarDouble::cos() const
{
    return HxScalarDouble(::cos(_value));
}

inline HxScalarDouble
HxScalarDouble::tan() const
{
    return HxScalarDouble(::tan(_value));
}

inline HxScalarDouble
HxScalarDouble::asin() const
{
    return HxScalarDouble(::asin(_value));
}

inline HxScalarDouble
HxScalarDouble::acos() const
{
    return HxScalarDouble(::acos(_value));
}

inline HxScalarDouble
HxScalarDouble::atan() const
{
    return HxScalarDouble(::atan(_value));
}

inline HxScalarDouble
HxScalarDouble::sinh() const
{
    return HxScalarDouble(::sinh(_value));
}

inline HxScalarDouble
HxScalarDouble::cosh() const
{
    return HxScalarDouble(::cosh(_value));
}

inline HxScalarDouble
HxScalarDouble::tanh() const
{
    return HxScalarDouble(::tanh(_value));
}

inline HxScalarDouble
HxScalarDouble::exp() const
{
    return HxScalarDouble(::exp(_value));
}

inline HxScalarDouble
HxScalarDouble::log() const
{
    return HxScalarDouble(::log(_value));
}

inline HxScalarDouble
HxScalarDouble::log10() const
{
    return HxScalarDouble(::log10(_value));
}

inline HxScalarDouble&
HxScalarDouble::operator+=(const HxScalarDouble& v)
{
    _value += v._value;
    return *this;
}

inline HxScalarDouble&
HxScalarDouble::operator-=(const HxScalarDouble& v)
{
    _value -= v._value;
    return *this;
}

inline HxScalarDouble&
HxScalarDouble::operator*=(const HxScalarDouble& v)
{
    _value *= v._value;
    return *this;
}

inline HxScalarDouble&
HxScalarDouble::operator/=(const HxScalarDouble& v)
{
    _value /= v._value;
    return *this;
}

inline HxScalarDouble
operator+(const HxScalarDouble& v1, const HxScalarDouble& v2)
{
    return HxScalarDouble(v1._value + v2._value);
}

inline HxScalarDouble
operator-(const HxScalarDouble& v1, const HxScalarDouble& v2)
{
    return HxScalarDouble(v1._value - v2._value);
}

inline HxScalarDouble
operator*(const HxScalarDouble& v1, const HxScalarDouble& v2)
{
    return HxScalarDouble(v1._value * v2._value);
}

inline HxScalarDouble
operator/(const HxScalarDouble& v1, const HxScalarDouble& v2)
{
    return HxScalarDouble(v1._value / v2._value);
}

inline HxScalarDouble
HxScalarDouble::min(const HxScalarDouble& v) const
{
    return (operator<(v)) ? (*this) : v;
}

inline HxScalarDouble&
HxScalarDouble::minAssign(const HxScalarDouble& v)
{
    if (operator<(v))
        return *this;
    operator=(v);
    return *this;
}

inline HxScalarDouble
HxScalarDouble::max(const HxScalarDouble& v) const
{
    return (operator>(v)) ? (*this) : v;
}

inline HxScalarDouble&
HxScalarDouble::maxAssign(const HxScalarDouble& v)
{
    if (operator>(v))
        return *this;
    operator=(v);
    return *this;
}

inline HxScalarDouble
HxScalarDouble::inf(const HxScalarDouble& v) const
{
    return (operator<(v)) ? (*this) : v;
}

inline HxScalarDouble&
HxScalarDouble::infAssign(const HxScalarDouble& v)
{
    _value = (_value < v._value) ? _value : v._value;
    return *this;
}

inline HxScalarDouble
HxScalarDouble::sup(const HxScalarDouble& v) const
{
    return (operator>(v)) ? (*this) : v;
}

inline HxScalarDouble&
HxScalarDouble::supAssign(const HxScalarDouble& v)
{
    _value = (_value > v._value) ? _value : v._value;
    return *this;
}

inline HxScalarDouble
HxScalarDouble::pow(const HxScalarDouble& v) const
{
    return HxScalarDouble(::pow(_value, v._value));
}

inline HxScalarDouble
HxScalarDouble::mod(const HxScalarDouble&) const
{
    return (*this);
}

inline HxScalarDouble
HxScalarDouble::and(const HxScalarDouble&) const
{
    return (*this);
}

inline HxScalarDouble
HxScalarDouble::or(const HxScalarDouble&) const
{
    return (*this);
}

inline HxScalarDouble
HxScalarDouble::xor(const HxScalarDouble&) const
{
    return (*this);
}

inline HxScalarDouble
HxScalarDouble::leftShift(const HxScalarDouble&) const
{
    return (*this);
}

inline HxScalarDouble
HxScalarDouble::rightShift(const HxScalarDouble&) const
{
    return (*this);
}

inline HxScalarDouble
HxScalarDouble::cross(const HxScalarDouble&) const
{
    return HxScalarDouble(0.0);
}

inline HxString
HxScalarDouble::toString() const
{ 
    return makeString(_value); 
}

#endif

---