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() {}
  20
  21         Interval& Interval::operator <(double value) { end.set(value,OPEN); begin.set(NINF,CLOSE); return *this; }
  22         Interval& Interval::operator <=(double value) { end.set(value,CLOSE); begin.set(NINF,CLOSE); return *this; }
  23         Interval& Interval::operator >(double value) { begin.set(value,OPEN); end.set(INF,CLOSE); return *this; }
  24         Interval& Interval::operator >=(double value) { begin.set(value,CLOSE); end.set(INF,CLOSE); return *this; }
  25         Interval& Interval::operator <(TYPES value) { end.set(value,OPEN); begin.set(NINF,CLOSE); return *this; }
  26         Interval& Interval::operator <=(TYPES value) { end.set(value,CLOSE); begin.set(NINF,CLOSE); return *this; }
  27         Interval& Interval::operator >(TYPES value) { begin.set(value,OPEN); end.set(INF,CLOSE); return *this; }
  28         Interval& Interval::operator >=(TYPES value) { begin.set(value,CLOSE); end.set(INF,CLOSE); return *this; }
  29
  30
  31         Interval_acc::Interval_acc(Interval &rng) : _range(rng) { begin=rng.begin; end=rng.end; }
  32         Interval_acc::~Interval_acc() {}
  33
  34         Interval& Interval_acc::operator <(double value) { _range.end.set(value, OPEN); return _range; }
  35         Interval& Interval_acc::operator <=(double value) { _range.end.set(value, CLOSE); return _range; }
  36         Interval& Interval_acc::operator >(double value) { _range.begin.set(value, OPEN); return _range; }
  37         Interval& Interval_acc::operator >=(double value) { _range.begin.set(value, CLOSE); return _range; }
  38         Interval& Interval_acc::operator <(TYPES value) { _range.end.set(value, OPEN); return _range; }
  39         Interval& Interval_acc::operator <=(TYPES value) { _range.end.set(value, CLOSE); return _range; }
  40         Interval& Interval_acc::operator >(TYPES value) { _range.begin.set(value, OPEN); return _range; }
  41         Interval& Interval_acc::operator >=(TYPES value) { _range.begin.set(value, CLOSE); return _range; }
  42
  43         int Interval::int_floor() const {
  44                 if(begin.type!=NORMAL) throw begin.type;
  45                 double v = ceil(begin.value);
  46                 if(begin.op==OPEN && v==begin.value) { return (int)v+1; }
  47                 else return int(v);
  48         }
  49         int Interval::int_floor(int minval) const {
  50                 if(begin.type==NaN) throw end.type;
  51                 if(begin.type==NINF || begin.value<minval) return minval;
  52                 double v = ceil(begin.value);
  53                 if(begin.op==OPEN && v==begin.value) { return (int)v+1; }
  54                 else return int(v);
  55         }
  56         int Interval::int_ceil() const {
  57                 if(begin.type!=NORMAL) throw end.type;
  58                 double v = floor(end.value);
  59                 if(end.op==OPEN && v==end.value) { return (int)v-1; }
  60                 else return int(v);
  61         }
  62         int Interval::int_ceil(int maxval) const {
  63                 if(begin.type==NaN) throw end.type;
  64                 if(end.type==INF || end.value>maxval) return maxval;
  65                 double v = floor(end.value);
  66                 if(end.op==OPEN && v==end.value) { return (int)v-1; }
  67                 else return int(v);
  68         }
  69
  70         bool Interval::includes(double value_) const {
  71                 if(begin.type==NaN || end.type==NaN) throw end.type;
  72                 if(begin.type!=NINF) if((begin.op==CLOSE && begin.value>value_) || (begin.op==OPEN && begin.value>=value_)) return false;
  73                 if(end.type!=INF) if((end.op==CLOSE && end.value<value_) || (end.op==OPEN && end.value<=value_)) return false;
  74                 return true;
  75         }
  76         bool Interval::bounded() const {
  77                 return (begin.type==NORMAL && end.type==NORMAL);
  78         }
  79
  80         Interval_acc operator <(double value, Interval &rng) { rng.begin.set(value, Interval::OPEN); rng.end.set(Interval::INF,Interval::CLOSE); return Interval_acc(rng); }
  81         Interval_acc operator <=(double value, Interval &rng) { rng.begin.set(value, Interval::CLOSE); rng.end.set(Interval::INF,Interval::CLOSE); return Interval_acc(rng); }
  82         Interval_acc operator >(double value, Interval &rng) { rng.end.set(value, Interval::OPEN); rng.begin.set(Interval::NINF,Interval::CLOSE); return Interval_acc(rng); }
  83         Interval_acc operator >=(double value, Interval &rng) { rng.end.set(value, Interval::CLOSE); rng.begin.set(Interval::NINF,Interval::CLOSE); return Interval_acc(rng); }
  84         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); }
  85         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); }
  86         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); }
  87         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); }
  88
  89
  90 }       /*      <- namespace Psycholops         */