psychlops/core/math/psychlops_m_interval.cpp

   1 /*
   2  *  psychlops_math_range.cpp
   3  *  Psychlops Standard Library (Universal)
   4  *
   5  *  Last Modified 2005/07/04 by Kenchi HOSOKAWA
   6  *  (C) 2005 Kenchi HOSOKAWA, Kazushi MARUYA, Takao SATO
   7  */
   8
   9 #include <Math.h>
  10 #include "../ApplicationInterfaces/psychlops_code.h"
  11 #include "psychlops_m_interval.h"
  12
  13 namespace Psychlops {
  14
  15
  16         Interval::Interval() : begin(NINF), end(INF) {}
  17         Interval::Interval(double floor_val, double ceil_val) : begin(floor_val, OPEN), end(ceil_val, OPEN) {}
  18         Interval::Interval(double floor_val, OPERATOR floor_op, double ceil_val, OPERATOR ceil_op) : begin(floor_val, floor_op), end(ceil_val, ceil_op) {}
  19         Interval::~Interval() {}\r
  20
  21         Interval& Interval::set(double floor_val, double ceil_val) { end.set(floor_val,OPEN); begin.set(ceil_val,OPEN); return *this; }
  22         Interval& Interval::set(double floor_val, OPERATOR floor_op, double ceil_val, OPERATOR ceil_op) { end.set(floor_val, floor_op); begin.set(ceil_val, ceil_op); return *this; }
  23
  24         Interval& Interval::operator <(double value) { end.set(value,OPEN); begin.set(NINF,CLOSE); return *this; }
  25         Interval& Interval::operator <=(double value) { end.set(value,CLOSE); begin.set(NINF,CLOSE); return *this; }
  26         Interval& Interval::operator >(double value) { begin.set(value,OPEN); end.set(INF,CLOSE); return *this; }
  27         Interval& Interval::operator >=(double value) { begin.set(value,CLOSE); end.set(INF,CLOSE); return *this; }
  28         Interval& Interval::operator <(TYPES value) { end.set(value,OPEN); begin.set(NINF,CLOSE); return *this; }
  29         Interval& Interval::operator <=(TYPES value) { end.set(value,CLOSE); begin.set(NINF,CLOSE); return *this; }
  30         Interval& Interval::operator >(TYPES value) { begin.set(value,OPEN); end.set(INF,CLOSE); return *this; }
  31         Interval& Interval::operator >=(TYPES value) { begin.set(value,CLOSE); end.set(INF,CLOSE); return *this; }
  32
  33
  34         Interval_acc::Interval_acc(Interval &rng) : _range(rng) { begin=rng.begin; end=rng.end; }
  35         Interval_acc::~Interval_acc() {}
  36
  37         Interval& Interval_acc::operator <(double value) { _range.end.set(value, OPEN); return _range; }
  38         Interval& Interval_acc::operator <=(double value) { _range.end.set(value, CLOSE); return _range; }
  39         Interval& Interval_acc::operator >(double value) { _range.begin.set(value, OPEN); return _range; }
  40         Interval& Interval_acc::operator >=(double value) { _range.begin.set(value, CLOSE); return _range; }
  41         Interval& Interval_acc::operator <(TYPES value) { _range.end.set(value, OPEN); return _range; }
  42         Interval& Interval_acc::operator <=(TYPES value) { _range.end.set(value, CLOSE); return _range; }
  43         Interval& Interval_acc::operator >(TYPES value) { _range.begin.set(value, OPEN); return _range; }
  44         Interval& Interval_acc::operator >=(TYPES value) { _range.begin.set(value, CLOSE); return _range; }
  45
  46         int Interval::int_floor() const {
  47                 if(begin.type!=NORMAL) throw begin.type;
  48                 double v = ceil(begin.value);
  49                 if(begin.op==OPEN && v==begin.value) { return (int)v+1; }
  50                 else return int(v);
  51         }
  52         int Interval::int_floor(int minval) const {
  53                 if(begin.type==NaN) throw end.type;
  54                 if(begin.type==NINF || begin.value<minval) return minval;
  55                 double v = ceil(begin.value);
  56                 if(begin.op==OPEN && v==begin.value) { return (int)v+1; }
  57                 else return int(v);
  58         }
  59         int Interval::int_ceil() const {
  60                 if(begin.type!=NORMAL) throw end.type;
  61                 double v = floor(end.value);
  62                 if(end.op==OPEN && v==end.value) { return (int)v-1; }
  63                 else return int(v);
  64         }
  65         int Interval::int_ceil(int maxval) const {
  66                 if(begin.type==NaN) throw end.type;
  67                 if(end.type==INF || end.value>maxval) return maxval;
  68                 double v = floor(end.value);
  69                 if(end.op==OPEN && v==end.value) { return (int)v-1; }
  70                 else return int(v);
  71         }
  72
  73         bool Interval::includes(double value_) const {
  74                 if(begin.type==NaN || end.type==NaN) throw end.type;
  75                 if(begin.type!=NINF) if((begin.op==CLOSE && begin.value>value_) || (begin.op==OPEN && begin.value>=value_)) return false;
  76                 if(end.type!=INF) if((end.op==CLOSE && end.value<value_) || (end.op==OPEN && end.value<=value_)) return false;
  77                 return true;
  78         }
  79         bool Interval::bounded() const {
  80                 return (begin.type==NORMAL && end.type==NORMAL);
  81         }
  82
  83         Interval_acc operator <(double value, Interval &rng) { rng.begin.set(value, Interval::OPEN); rng.end.set(Interval::INF,Interval::CLOSE); return Interval_acc(rng); }
  84         Interval_acc operator <=(double value, Interval &rng) { rng.begin.set(value, Interval::CLOSE); rng.end.set(Interval::INF,Interval::CLOSE); return Interval_acc(rng); }
  85         Interval_acc operator >(double value, Interval &rng) { rng.end.set(value, Interval::OPEN); rng.begin.set(Interval::NINF,Interval::CLOSE); return Interval_acc(rng); }
  86         Interval_acc operator >=(double value, Interval &rng) { rng.end.set(value, Interval::CLOSE); rng.begin.set(Interval::NINF,Interval::CLOSE); return Interval_acc(rng); }
  87         Interval_acc operator <(Interval::TYPES value, Interval &rng) { rng.begin.set(value, Interval::OPEN); rng.end.set(Interval::INF,Interval::CLOSE); return Interval_acc(rng); }
  88         Interval_acc operator <=(Interval::TYPES value, Interval &rng) { rng.begin.set(value, Interval::CLOSE); rng.end.set(Interval::INF,Interval::CLOSE); return Interval_acc(rng); }
  89         Interval_acc operator >(Interval::TYPES value, Interval &rng) { rng.end.set(value, Interval::OPEN); rng.begin.set(Interval::NINF,Interval::CLOSE); return Interval_acc(rng); }
  90         Interval_acc operator >=(Interval::TYPES value, Interval &rng) { rng.end.set(value, Interval::CLOSE); rng.begin.set(Interval::NINF,Interval::CLOSE); return Interval_acc(rng); }
  91
  92
  93 }       /*      <- namespace Psycholops         */