---

WithUE.h

Go to the documentation of this file.

/* -*- Mode: C++ -*-
 * $Id: WithUE.h,v 1.5 2005/09/19 17:00:06 frehe Exp $
 *
 *
 * COPYRIGHT INFORMATION
 *
 * This file is part of RoboSoc created by Fredrik Heintz <frehe@ida.liu.se>
 * Copyright (C) 1999, 2000 Fredrik Heintz, Linköping University, Sweden
 *
 * You are allowed to modify and use this code as long as you retain this
 * notice. If you make any changes or have any comments I would appreciate
 * it if you send me a message. For more information, please see
 * http://www.ida.liu.se/~frehe/RoboCup/RoboSoc/
 *
 *
 * IDENTIFICATION
 *
 * Filename: WithUE.h
 * Unitname: Library
 * $Revision: 1.5 $
 * Created by: David Rosén 2002-06-18
 * Last modified by $Author: frehe $ $Date: 2005/09/19 17:00:06 $
 *
 *
 * HISTORY
 *
 * $Log: WithUE.h,v $
 * Revision 1.5  2005/09/19 17:00:06  frehe
 * Fixed bugs and made WithError work.
 *
 * Revision 1.4  2005/08/13 13:31:18  frehe
 * Fixed several errors to make it compile with gcc-3.4.3
 *
 * Revision 1.3  2002/09/26 13:52:17  s02davro
 * Fixed the improve method
 *
 * Revision 1.2  2002/08/31 14:56:49  s02davro
 * Corrected some small bugs
 *
 * Revision 1.1  2002/08/02 21:37:48  s02davro
 * Created template class to handle unknown values with error.
 *
 *
 */

#ifndef WITHUE_H
#define WITHUE_H

#include "machine_dependent_types.h"
#include "UnknownValueException.h"
#include "WithUnknown.h"
#include "WithError.h"

#define UE_HEAD std::string("#UE")

RS_BEGIN_NAMESPACE

template<typename T>
class WithUE : protected WithUnknown<WithError<T> > {
public:
  WithUE();

  WithUE(const T& def_value);

  WithUE(const WithUnknown<T>& obj);

  WithUE(const WithError<T>& obj);

  WithUE(const WithUnknown<WithError<T> >& obj);

  WithUE(const WithUE<T>& obj);  

  WithUE(const T& def_value, const T& def_plus, const T& def_minus);

  WithUE(const ErrorType c, const T& value,
   const Float64 quant_step1 = 0.1, const T& distance = T(),
   const Float64 quant_step2 = 0.02);

  WithUE<T>& operator= (const WithUE<T>& op);  

  WithUE<T>& operator++ ();
  WithUE<T>& operator-- ();
  WithUE<T> operator- () const;
  WithUE<T>& operator+= (const WithUE<T>& op);
  WithUE<T>& operator-= (const WithUE<T>& op);
  WithUE<T>& operator*= (const WithUE<T>& op);
  WithUE<T>& operator/= (const WithUE<T>& op);
  WithUE<T> operator+ (const WithUE<T>& op) const;
  WithUE<T> operator- (const WithUE<T>& op) const;
  WithUE<T> operator* (const WithUE<T>& op) const;
  WithUE<T> operator/ (const WithUE<T>& op) const;

  bool operator== (const WithUE<T>& op) const;
  bool operator!= (const WithUE<T>& op) const;
  bool operator< (const WithUE<T>& op) const;
  bool operator<= (const WithUE<T>& op) const;
  bool operator> (const WithUE<T>& op) const;
  bool operator>= (const WithUE<T>& op) const;
  bool operator!  () const;
  
  WithUE<T>& improve (const WithUE<T>& op);

  WithUE<T>& disimprove (const WithUE<T>& op);

  WithUE<T>& makeUnknown();

  bool isKnown() const;

  bool isUnknown() const;

  T getValue() const throw(UnknownValueException);

  WithError<T> getValueWithError() const throw(UnknownValueException);

  WithUnknown<T> getValueWithUnknown() const;

  T getMin() const throw(UnknownValueException);

  T getMax() const throw(UnknownValueException);

  T getPlus() const throw(UnknownValueException);

  T getMinus() const throw(UnknownValueException);
};

template<typename T>
WithUE<T>::WithUE()
  : WithUnknown<WithError<T> >() {
}

template<typename T>
WithUE<T>::WithUE(const T& def_value)
  : WithUnknown<WithError<T> >(WithError<T> (def_value)) {
} 

template<typename T>
WithUE<T>::WithUE(const WithUnknown<T>& def_value)
  : WithUnknown<WithError<T> >() {
  if (def_value.isKnown()) {
    WithUnknown<WithError<T> >::operator=(WithError<T>(def_value.getValue()));
  }
}

template<typename T>
WithUE<T>::WithUE(const WithError<T>& def_value)
  : WithUnknown<WithError<T> >(def_value) {
}

template<typename T>
WithUE<T>::WithUE(const WithUnknown<WithError<T> >& obj)
  : WithUnknown<WithError<T> >(obj) {
}

template<typename T>
WithUE<T>::WithUE(const WithUE<T>& wc)
  : WithUnknown<WithError<T> >(wc) {
}

template<typename T>
WithUE<T>::WithUE(const ErrorType c, const T& value, 
      const Float64 quant_step1,
      const T& distance, const Float64 quant_step2)
  : WithUnknown<WithError<T> >(WithError<T>(c, value, quant_step1, 
              distance, quant_step2)) {
}

template<typename T>
WithUE<T>::WithUE(const T& def_value, const T& def_plus, const T& def_minus) 
  : WithUnknown<WithError<T> >(WithError<T> (def_value, def_plus, def_minus, T())) {
}

template<typename T>
WithUE<T>& WithUE<T>::operator= (const WithUE<T>& op) {
  if (&op != this) {
    if (op.isKnown()) {
      WithUnknown<WithError<T> >::operator=(op.getValueWithError());
    } else {
      WithUnknown<WithError<T> >::makeUnknown();
    }
  }
  return *this;
}

template <typename T>
WithUE<T>& WithUE<T>::operator+= (const WithUE<T>& op) {
  WithUnknown<WithError<T> >::operator+= (op);
  return *this;
}

template <typename T>
WithUE<T>& WithUE<T>::operator-= (const WithUE<T>& op) {
  WithUnknown<WithError<T> >::operator-= (op);
  return *this;
}

template <typename T>
WithUE<T>& WithUE<T>::operator*= (const WithUE<T>& op) {
  WithUnknown<WithError<T> >::operator*= (op);
  return *this;
}

template <typename T>
WithUE<T>& WithUE<T>::operator/= (const WithUE<T>& op) {
  WithUnknown<WithError<T> >::operator/= (op);
  return *this;
}

template<typename T>
WithUE<T> WithUE<T>::operator+ (const WithUE<T>& op) const {
  return WithUE<T>(WithUnknown<WithError<T> >::operator+ (op));
}

template<typename T>
WithUE<T> WithUE<T>::operator- (const WithUE<T>& op) const {
  return WithUE<T>(WithUnknown<WithError<T> >::operator- (op));
}

template<typename T>
WithUE<T> WithUE<T>::operator* (const WithUE<T>& op) const {
  return WithUE<T>(WithUnknown<WithError<T> >::operator* (op));
}

template<typename T>
WithUE<T> WithUE<T>::operator/ (const WithUE<T>& op) const {
  return WithUE<T>(WithUnknown<WithError<T> >::operator/ (op));
}

template<typename T>
bool WithUE<T>::operator== (const WithUE<T>& op) const {
  if ( &op != this)
    return WithUnknown<WithError<T> >::operator== (op);
  return true;
}

template<typename T>
bool WithUE<T>::operator!= (const WithUE<T>& op) const {
  return !(*this == op);
}

template<typename T>
bool WithUE<T>::operator< (const WithUE<T>& op) const {
  return WithUnknown<WithError<T> >::operator< (op);
}

template<typename T>
bool WithUE<T>::operator<= (const WithUE<T>& op) const {
  return WithUnknown<WithError<T> >::operator<= (op);
}

template<typename T>
bool WithUE<T>::operator> (const WithUE<T>& op) const {
  return WithUnknown<WithError<T> >::operator> (op);
}

template<typename T>
bool WithUE<T>::operator>= (const WithUE<T>& op) const {
  return WithUnknown<WithError<T> >::operator>= (op);
}

template<typename T>
bool WithUE<T>::operator! () const {
  return WithUnknown<WithError<T> >::operator! ();
}

template <typename T>
WithUE<T>& WithUE<T>::operator++ () {
  WithUnknown<WithError<T> >::operator++ ();
  return *this;
}

template <typename T>
WithUE<T>& WithUE<T>::operator-- () {
  WithUnknown<WithError<T> >::operator-- ();
  return *this;
}

template <typename T>
WithUE<T> WithUE<T>::operator- () const {
  return WithUE<T>(WithUnknown<WithError<T> >::operator- ());
}

template<typename T>
WithUE<T>& WithUE<T>::improve(const WithUE<T>& op) {
  if (isKnown() && op.isKnown())
    WithUnknown<WithError<T> >::operator=(WithUnknown<WithError<T> >::getValue().improve(op.getValueWithError()));
  else if (op.isKnown()) {
    WithUnknown<WithError<T> >::operator=(op.getValue());
  }
  return *this;
}

template<typename T>
WithUE<T>& WithUE<T>::disimprove(const WithUE<T>& op) {
  if (isKnown() && op.isKnown()) {
    WithUnknown<WithError<T> >::operator=(WithUnknown<WithError<T> >::getValue().disimprove(op.getValueWithError()));
  } else if (op.isKnown()) {
    WithUnknown<WithError<T> >::operator=(op.getValue());
  }
  return *this;
}

template<typename T>
WithUE<T>& WithUE<T>::makeUnknown() {
  WithUnknown<WithError<T> >::makeUnknown();
  return *this;
}

template<typename T>
bool WithUE<T>::isKnown() const {
  return WithUnknown<WithError<T> >::isKnown();
}

template<typename T>
bool WithUE<T>::isUnknown() const {
  return WithUnknown<WithError<T> >::isUnknown();
}

template<typename T>
T WithUE<T>::getValue() const throw(UnknownValueException) {
  return WithUnknown<WithError<T> >::getValue().getValue();
}

template<typename T>
T WithUE<T>::getMin() const throw(UnknownValueException) {
  return WithUnknown<WithError<T> >::getValue().getMin();
}

template<typename T>
T WithUE<T>::getMax() const throw(UnknownValueException) {
  return WithUnknown<WithError<T> >::getValue().getMax();
}

template<typename T>
T WithUE<T>::getMinus() const throw(UnknownValueException) {
  return WithUnknown<WithError<T> >::getValue().getMinus();
}

template<typename T>
T WithUE<T>::getPlus() const throw (UnknownValueException) {
  return WithUnknown<WithError<T> >::getValue().getPlus();
}

template<typename T>
WithError<T> 
WithUE<T>::getValueWithError() const throw (UnknownValueException) {
  return WithUnknown<WithError<T> >::getValue();
}

template<typename T>
WithUnknown<T> WithUE<T>::getValueWithUnknown() const {
  if (isKnown())
    return WithUnknown<T>(getValue());
  return WithUnknown<T>();
}

template<typename T>
WithUE<T> operator- (const T& op1, const WithUE<T>& op2) {
  return -(op2) + op1;
}

template<typename T>
WithUE<T> operator- (const WithUnknown<T>& op1, const WithUE<T>& op2) {
  return -(op2) + op1;
}

template<typename T>
WithUE<T> operator- (const WithError<T>& op1, const WithUE<T>& op2) {
  return -(op2) + op1;
}

template<typename T>
WithUE<T> operator- (const WithUnknown<WithError<T> >& op1, 
         const WithUE<T>& op2) {
  return -(op2) + op1;
}

template<typename T>
WithUE<T> operator+ (const T& op1, const WithUE<T>& op2) {
  return op2 + op1;
}

template<typename T>
WithUE<T> operator+ (const WithUnknown<T>& op1, const WithUE<T>& op2) {
  return op2 + op1;
}

template<typename T>
WithUE<T> operator+ (const WithError<T>& op1, const WithUE<T>& op2) {
  return op2 + op1;
}

template<typename T>
WithUE<T> operator+ (const WithUnknown<WithError<T> >& op1, 
         const WithUE<T>& op2) {
  return op2 + op1;
}

template<typename T>
WithUE<T> operator* (const T& op1, const WithUE<T>& op2) {
  return op2 * op1;
}

template<typename T>
WithUE<T> operator* (const WithUnknown<T>& op1, const WithUE<T>& op2) {
  return op2 * op1;
}

template<typename T>
WithUE<T> operator* (const WithError<T>& op1, const WithUE<T>& op2) {
  return op2 * op1;
}

template<typename T>
WithUE<T> operator* (const WithUnknown<WithError<T> >& op1, 
         const WithUE<T>& op2) {
  return op2 * op1;
}

template<typename T>
WithUE<T> operator/ (const T& op1, const WithUE<T>& op2) {
  return WithUE<T>(op1) / op2;
}

template<typename T>
WithUE<T> operator/ (const WithUnknown<T>& op1, const WithUE<T>& op2) {
  return WithUE<T>(op1) / op2;
}

template<typename T>
WithUE<T> operator/ (const WithError<T>& op1, const WithUE<T>& op2) {
  return WithUE<T>(op1) / op2;
}

template<typename T>
WithUE<T> operator/ (const WithUnknown<WithError<T> >& op1, 
         const WithUE<T>& op2) {
  return WithUE<T>(op1) / op2;
}

template<typename T>
bool operator==(const T& op1, const WithUE<T> op2) {
  return op2 == op1;
}

template<typename T>
bool operator==(const WithUnknown<T>& op1, const WithUE<T> op2) {
  return op2 == op1;
}

template<typename T>
bool operator==(const WithError<T>& op1, const WithUE<T> op2) {
  return op2 == op1;
}

template<typename T>
bool operator==(const WithUnknown<WithError<T> >& op1, const WithUE<T> op2) {
  return op2 == op1;
}

template<typename T>
bool operator!=(const T& op1, const WithUE<T> op2) {
  return op2 != op1;
}

template<typename T>
bool operator!=(const WithUnknown<T>& op1, const WithUE<T> op2) {
  return op2 != op1;
}

template<typename T>
bool operator!=(const WithError<T>& op1, const WithUE<T> op2) {
  return op2 != op1;
}

template<typename T>
bool operator!=(const WithUnknown<WithError<T> >& op1, const WithUE<T> op2) {
  return op2 != op1;
}

template<typename T>
bool operator<(const T& op1, const WithUE<T> op2) {
  return op2 > op1;
}

template<typename T>
bool operator<(const WithUnknown<T>& op1, const WithUE<T> op2) {
  return op2 > op1;
}

template<typename T>
bool operator<(const WithError<T>& op1, const WithUE<T> op2) {
  return op2 > op1;
}

template<typename T>
bool operator<(const WithUnknown<WithError<T> >& op1, const WithUE<T> op2) {
  return op2 > op1;
}

template<typename T>
bool operator<=(const T& op1, const WithUE<T> op2) {
  return op2 >= op1;
}

template<typename T>
bool operator<=(const WithUnknown<T>& op1, const WithUE<T> op2) {
  return op2 >= op1;
}

template<typename T>
bool operator<=(const WithError<T>& op1, const WithUE<T> op2) {
  return op2 >= op1;
}

template<typename T>
bool operator<=(const WithUnknown<WithError<T> >& op1, const WithUE<T> op2) {
  return op2 >= op1;
}

template<typename T>
bool operator>(const T& op1, const WithUE<T> op2) {
  return op2 < op1;
}

template<typename T>
bool operator>(const WithUnknown<T>& op1, const WithUE<T> op2) {
  return op2 < op1;
}

template<typename T>
bool operator>(const WithError<T>& op1, const WithUE<T> op2) {
  return op2 < op1;
}

template<typename T>
bool operator>(const WithUnknown<WithError<T> >& op1, const WithUE<T> op2) {
  return op2 < op1;
}

template<typename T>
bool operator>=(const T& op1, const WithUE<T> op2) {
  return op2 <= op1;
}

template<typename T>
bool operator>=(const WithUnknown<T>& op1, const WithUE<T> op2) {
  return op2 <= op1;
}

template<typename T>
bool operator>=(const WithError<T>& op1, const WithUE<T> op2) {
  return op2 <= op1;
}

template<typename T>
bool operator>=(const WithUnknown<WithError<T> >& op1, const WithUE<T> op2) {
  return op2 <= op1;
}

template<typename T>
std::ostream& operator <<(std::ostream& os, const WithUE<T>& obj) {
#ifdef UE_HEAD
  if (obj.isKnown())
    return os << UE_HEAD << "(" << toString(obj.getValueWithError()) << ")";
  else
    return os << UE_HEAD << "(" << toString(obj.getValueWithUnknown()) << ")";
#else
  if (obj.isKnown())
    return os << toString(obj.getValueWithError());
  else
    return os << toString(obj.getValueWithUnknown());
#endif
}

template<typename T>
const std::string toString(const WithUE<T>& obj) {
#ifdef UE_HEAD
  if (obj.isKnown())
    return UE_HEAD + "(" + toString(obj.getValueWithError()) + ")";
  else
    return UE_HEAD + "(" + toString(obj.getValueWithUnknown()) + ")";
#else
  if (obj.isKnown())
    return toString(obj.getValueWithError());
  else
    return toString(obj.getValueWithUnknown());
#endif
}

template<typename T>
WithUE<T> sqr(const WithUE<T>& op) {
  if ( op.isUnknown() )
    return WithUE<T>();
  else
    return WithUE<T>(sqr(op.getValueWithError()));
}

template<typename T>
WithUE<T> sqrt(const WithUE<T>& op) {
  if ( op.isUnknown() )
    return WithUE<T>();
  else
    return WithUE<T>(sqrt(op.getValueWithError()));
}


RS_END_NAMESPACE

#endif // !WITHUE_H

---