Menu
▾
▴
[Scstudio-commits] SF.net SVN: scstudio:[217] trunk
|
From: <koc...@us...> - 2009-04-14 13:22:49
|
Revision: 217
http://scstudio.svn.sourceforge.net/scstudio/?rev=217&view=rev
Author: kocianon
Date: 2009-04-14 13:22:47 +0000 (Tue, 14 Apr 2009)
Log Message:
-----------
adding time and interval data structure
Modified Paths:
--------------
trunk/src/data/CMakeLists.txt
trunk/tests/CMakeLists.txt
Added Paths:
-----------
trunk/src/data/time.h
trunk/tests/decimal_test.cpp
trunk/tests/interval_test.cpp
Modified: trunk/src/data/CMakeLists.txt
===================================================================
--- trunk/src/data/CMakeLists.txt 2009-04-14 08:18:04 UTC (rev 216)
+++ trunk/src/data/CMakeLists.txt 2009-04-14 13:22:47 UTC (rev 217)
@@ -22,6 +22,7 @@
dfs_instance_events_traverser.h
dfs_bmsc_graph_traverser.cpp
dfs_bmsc_graph_traverser.h
+ time.h
)
# build import-export formatters
Added: trunk/src/data/time.h
===================================================================
--- trunk/src/data/time.h (rev 0)
+++ trunk/src/data/time.h 2009-04-14 13:22:47 UTC (rev 217)
@@ -0,0 +1,813 @@
+/*
+ * scstudio - Sequence Chart Studio
+ * http://scstudio.sourceforge.net
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * Copyright (c) 2008
+ *
+ * $Id:
+ */
+
+#ifndef _TIME_H_
+#define _TIME_H_
+
+#include<limits.h>
+#include<algorithm>
+#include<exception>
+#include<list>
+#include<cstdlib>
+#include<cmath>
+#include<iostream>
+
+/*
+class MscIntervalCoupleException;
+class MscIntervalCouple;
+class MscTimeInterval;
+class DecScaled;
+*/
+//class MscTimeSet;
+
+
+class MscIntervalCoupleException:public std::exception
+{
+public:
+
+ const char* what()
+ {
+ return "undecidable case";
+ }
+};
+
+
+/**
+ * Decimal scaling structure, stands for:
+ * m_mant*10^m_exp;
+ */
+class DecScaled
+{
+private:
+ long m_exp; // exponent
+ long m_mant; // significand, coefficient or mantissa
+
+ void tidy()
+ {
+ while(m_mant%10==0)
+ {
+ m_mant/=10;
+ m_exp++;
+ }
+ }
+public:
+ DecScaled():m_exp(0),m_mant(0){}
+ DecScaled(long mant):m_exp(0),m_mant(mant){}
+ DecScaled(long mant,long exp):m_exp(exp),m_mant(mant)
+ {
+ tidy();
+ }
+
+ DecScaled& operator=(const DecScaled& right)
+ {
+ if(this==&right)
+ return *this;
+ m_mant = right.m_mant;
+ m_exp = right.m_exp;
+ return *this;
+ }
+
+ const DecScaled& operator+() const
+ {
+ return *this;
+ }
+
+ const DecScaled operator-() const
+ {
+ return DecScaled(-m_mant,m_exp);
+ }
+
+ const DecScaled operator+(const DecScaled& right) const
+ {
+ int division = abs(m_exp-right.m_exp);
+ DecScaled a = *this;
+ DecScaled b = right;
+
+ if(a.m_exp>b.m_exp)
+ {
+ a.m_mant*=pow(10,division);
+ a.m_exp-=division;
+ }
+ else
+ {
+ b.m_mant*=pow(10,division);
+ b.m_exp-=division;
+ }
+ return DecScaled(a.m_mant+b.m_mant,a.m_exp);
+ }
+
+ const DecScaled operator-(const DecScaled& right) const
+ {
+ long division = abs(m_exp-right.m_exp);
+ DecScaled a = *this;
+ DecScaled b = right;
+
+ if(a.m_exp>b.m_exp)
+ {
+ a.m_mant*=pow(10,division);
+ a.m_exp-=division;
+ }
+ else
+ {
+ b.m_mant*=pow(10,division);
+ b.m_exp-=division;
+ }
+
+ return DecScaled(a.m_mant-b.m_mant,a.m_exp);
+ }
+
+ const DecScaled operator*(const DecScaled& right) const
+ {
+ return DecScaled(m_mant*right.m_mant,m_exp+right.m_exp);
+ }
+/*
+ const DecScaled operator/(const DecScaled& right) const
+ {
+ return DecScaled(m_mant/right.m_mant,m_ext-right.m_exp,blebleble_tojetezke);
+ }
+*/
+ bool operator==(const DecScaled& right) const
+ {
+ return m_mant==right.m_mant && m_exp==right.m_exp;
+ }
+
+ bool operator!=(const DecScaled& right) const
+ {
+ return m_mant!=right.m_mant || m_exp!=right.m_exp;
+ }
+
+ bool operator>(const DecScaled& right) const
+ {
+ long division = abs(m_exp-right.m_exp);
+ DecScaled a = *this;
+ DecScaled b = right;
+
+ if(a.m_exp>b.m_exp)
+ {
+ a.m_mant*=pow(10,division);
+ a.m_exp-=division;
+ }
+ else
+ {
+ b.m_mant*=pow(10,division);
+ b.m_exp-=division;
+ }
+
+ return a.m_mant>b.m_mant;
+ }
+
+ bool operator<(const DecScaled& right) const
+ {
+ long division = abs(m_exp-right.m_exp);
+ DecScaled a = *this;
+ DecScaled b = right;
+
+ if(a.m_exp>b.m_exp)
+ {
+ a.m_mant*=pow(10,division);
+ a.m_exp-=division;
+ }
+ else
+ {
+ b.m_mant*=pow(10,division);
+ b.m_exp-=division;
+ }
+
+ return a.m_mant<b.m_mant;
+ }
+}; // end of DecScaled class
+
+
+/**
+ * @brief class representing couple value-number and bracket
+ */
+template<class T>
+class MscIntervalCouple
+{
+private:
+ bool m_closed;
+ T m_value;
+
+public:
+ MscIntervalCouple():
+ m_closed(true),m_value(0)
+ {
+ }
+
+ MscIntervalCouple(const bool& b,const T& d): m_closed(b),m_value(d)
+ {
+ }
+
+ const bool& get_closed() const
+ {
+ return m_closed;
+ }
+
+ const T& get_value() const
+ {
+ return m_value;
+ }
+
+ void set_closed(const bool& closed)
+ {
+ m_closed = closed;
+ }
+
+ void set_value(const T& value)
+ {
+ m_value=value;
+ }
+
+ const MscIntervalCouple operator+(const MscIntervalCouple& right)
+ {
+ return MscIntervalCouple(m_closed&&right.m_closed,m_value+right.m_value);
+ }
+
+ const MscIntervalCouple operator-(const MscIntervalCouple& right)
+ {
+ return MscIntervalCouple(m_closed&&right.m_closed,m_value-right.m_value);
+ }
+
+ const MscIntervalCouple operator+(const T& value)
+ {
+ return MscIntervalCouple(m_closed,m_value+value);
+ }
+
+ const MscIntervalCouple operator-(const T& value)
+ {
+ return MscIntervalCouple(m_closed,m_value-value);
+ }
+
+ const MscIntervalCouple operator*(const T& value)
+ {
+ return MscIntervalCouple(m_closed,m_value*value);
+ }
+
+ MscIntervalCouple& operator=(const MscIntervalCouple& right)
+ {
+ if(this==&right)
+ return *this;
+ m_value = right.m_value;
+ m_closed = right.m_closed;
+ return *this;
+ }
+
+ MscIntervalCouple& operator=(const T& value)
+ {
+ m_value = value;
+ return *this;
+ }
+
+ MscIntervalCouple& operator=(const bool& b)
+ {
+ m_closed = b;
+ return *this;
+ }
+
+
+ MscIntervalCouple& operator+=(const MscIntervalCouple& right)
+ {
+ m_value+=right.m_value;
+ m_closed=right.m_closed && m_closed;
+ return *this;
+ }
+
+ MscIntervalCouple& operator-=(const MscIntervalCouple& right)
+ {
+ m_value-=right.m_value;
+ m_closed=right.m_closed && m_closed;
+ return *this;
+ }
+
+ MscIntervalCouple& operator+=(const T& value)
+ {
+ m_value+=value;
+ return *this;
+ }
+
+ MscIntervalCouple& operator-=(const T& value)
+ {
+ m_value-=value;
+ return *this;
+ }
+
+ /**
+ * Warning: does not bother with left and right couple
+ */
+ bool operator==(const MscIntervalCouple& right) const throw()
+ {
+ return m_value==right.m_value && m_closed==right.m_closed;
+ }
+
+ /**
+ * @warning: does not bother with left and right couple
+ */
+ bool operator!=(const MscIntervalCouple& right) const throw()
+ {
+ return !(m_value==right.m_value && m_closed==right.m_closed);
+ }
+
+ /**
+ * @warning bother about left and right
+ * @throw MscIntervalCoupleException in case it cant be decided
+ */
+ bool operator<(const MscIntervalCouple& right) const throw(MscIntervalCoupleException)
+ {
+ if(m_value!=right.m_value)
+ return m_value<right.m_value;
+
+ if(*this==right && m_closed)
+ return false;
+ else
+ throw MscIntervalCoupleException();
+
+ }
+
+ /**
+ * @warning bother about left and right
+ * @throw MscIntervalCoupleException in case it cant be decided
+ */
+ bool operator>(const MscIntervalCouple& right) const throw(MscIntervalCoupleException)
+ {
+ if(m_value!=right.m_value)
+ return m_value>right.m_value;
+
+ if(*this==right && m_closed)
+ return false;
+ else
+ throw MscIntervalCoupleException();
+ }
+
+/**
+ * @return smaller of two MscIntervalCouple
+ * @throw MscIntervalCoupleException
+ */
+static MscIntervalCouple&
+minimum(MscIntervalCouple& right,MscIntervalCouple& left) throw(MscIntervalCoupleException)
+{
+ return (right<left)?right:left;
+}
+
+/**
+ * @return bigger of two MscIntervalCouple
+ * @throw MscIntervalCoupleException
+ */
+static MscIntervalCouple&
+maximum(MscIntervalCouple& right,MscIntervalCouple& left) throw(MscIntervalCoupleException)
+{
+ return (right>left)?right:left;
+}
+
+
+};
+// end of MscIntervalCouple class
+
+
+/**
+ * @brief class representing Interval
+ */
+template<class T>
+class MscTimeInterval
+{
+private:
+ MscIntervalCouple<T> m_begin;
+ MscIntervalCouple<T> m_end;
+
+public:
+ MscTimeInterval()
+ {}
+
+ MscTimeInterval(T value):m_begin(true,value),m_end(true,value)
+ {
+ }
+
+ MscTimeInterval(T left_value, T right_value)
+ :m_begin(true,left_value),m_end(true,right_value)
+ {
+
+ }
+
+ MscTimeInterval(const bool& left_closed,const T& left_value,
+ const T& right_value,const bool& right_closed)
+ :m_begin(left_closed,left_value),m_end(right_closed,right_value)
+ {
+ }
+ MscTimeInterval(const MscIntervalCouple<T>& begin,
+ const MscIntervalCouple<T>& end)
+ :m_begin(begin),m_end(end)
+ {
+ }
+
+ MscIntervalCouple<T> get_begin() const
+ {
+ return m_begin;
+ }
+
+ T get_begin_value() const
+ {
+ return m_begin.get_value();
+ }
+
+ const bool& get_begin_closed() const
+ {
+ return m_begin.get_closed();
+ }
+
+
+ const MscIntervalCouple<T>& get_end() const
+ {
+ return m_end;
+ }
+
+ T get_end_value() const
+ {
+ return m_end.get_value();
+ }
+
+ const bool& get_end_closed() const
+ {
+ return m_end.get_closed();
+ }
+
+ void set(T left_value,T right_value)
+ {
+ m_begin=left_value;
+ m_end=right_value;
+ }
+
+ void set(bool& left,T& b,T& e,bool& right)
+ {
+ m_begin=b;
+ m_begin=left;
+ m_end=e;
+ m_end=right;
+ }
+
+ void set_begin(const MscIntervalCouple<T> begin)
+ {
+ m_begin=begin;
+ }
+
+ void set_begin_closed(const bool& b)
+ {
+ m_begin.set_closed(b);
+ }
+
+ void set_end(const MscIntervalCouple<T> end)
+ {
+ m_end=end;
+ }
+
+ void set_end_closed(const bool& b)
+ {
+ m_end.set_closed(b);
+ }
+
+ MscTimeInterval& operator=(const T& value)
+ {
+ m_begin=m_end=true;
+ m_begin=m_end=value;
+ return *this;
+ }
+
+ MscTimeInterval& operator=(const MscTimeInterval& right)
+ {
+ if(this==&right)
+ return *this;
+
+ m_begin=right.m_begin;
+ m_end=right.m_end;
+
+ return *this;
+ }
+
+ const MscTimeInterval operator+(const MscTimeInterval& right)
+ {
+ return MscTimeInterval(m_begin+right.m_begin,m_end+right.m_end);
+ }
+
+ const MscTimeInterval operator+(const T& value)
+ {
+ return MscTimeInterval(m_begin+value,m_end+value);
+ }
+
+ const MscTimeInterval operator-(const MscTimeInterval& right)
+ {
+ return MscTimeInterval(m_begin-right.m_begin,m_end-right.m_end);
+ }
+
+ const MscTimeInterval operator-(const T& value)
+ {
+ return MscTimeInterval(m_begin-value,m_end-value);
+ }
+
+ const MscTimeInterval operator*(const T& value)
+ {
+ return MscTimeInterval(m_begin*value,m_end*value);
+ }
+
+ bool operator==(const MscTimeInterval& right) const
+ {
+ if(this==&right)
+ return true;
+ return (m_begin==right.m_begin)&&(m_end==right.m_end);
+ }
+
+ bool operator!=(const MscTimeInterval& right) const
+ {
+ return !((m_begin==right.m_begin)&&(m_end==right.m_end));
+ }
+
+ bool is_valid()
+ {
+ try
+ {
+ if(m_begin>m_end)
+ return false;
+ }
+ catch(MscIntervalCoupleException)
+ {
+ return false;
+ }
+ if(m_begin==m_end)
+ return m_begin.get_closed();
+ else
+ return true;
+ }
+
+ void set_empty()
+ {
+ set(1,0);
+ }
+
+
+/**
+ * \brief intersection of two interval
+ * @returns intersection of two intervals
+ * @warning returned interval does have to be valid, is_valid() may return false, CHECK FOR VALIDITY
+ */
+
+static MscTimeInterval interval_intersection(MscTimeInterval& left,MscTimeInterval& right) {
+ MscIntervalCouple<T> begin;
+ try
+ {
+ begin = MscIntervalCouple<T>::maximum(left.m_begin,right.m_begin);
+ }
+ catch(MscIntervalCoupleException){
+ begin = left.m_begin.get_value();
+ begin = false;
+ }
+ MscIntervalCouple<T> end;
+ try
+ {
+ end = MscIntervalCouple<T>::minimum(left.m_end,right.m_end);
+ }
+ catch(MscIntervalCoupleException){
+ end = left.m_end.get_value();
+ end = false;
+ }
+
+ return MscTimeInterval(begin,end);
+}
+
+/**
+ * \brief union of two interval
+ * @returns intersection of two intervals if they have intersection, else return empty interval;
+ * @warning CHECK if the returned interval is not empty!!!
+ */
+
+static MscTimeInterval interval_union(MscTimeInterval& left,MscTimeInterval& right) {
+ // check if they have intersection if not return empty interval
+ if(!interval_intersection(left,right).is_valid())
+ {
+ MscTimeInterval a;
+ a.set_empty();
+ return a;
+ }
+ MscIntervalCouple<T> begin;
+ try
+ {
+ begin = MscIntervalCouple<T>::minimum(left.m_begin,right.m_begin);
+ }
+ catch(MscIntervalCoupleException){
+ begin = left.m_begin.get_value();
+ begin = true;
+ }
+ MscIntervalCouple<T> end;
+ try
+ {
+ end = MscIntervalCouple<T>::maximum(left.m_end,right.m_end);
+ }
+ catch(MscIntervalCoupleException)
+ {
+ end = left.m_end.get_value();
+ end = true;
+ }
+
+ return MscTimeInterval(begin,end);
+}
+
+ friend std::ostream&
+ operator<<(std::ostream& os, const MscTimeInterval<T> interval)
+ {
+ if(interval.get_begin_closed())
+ os << "[";
+ else
+ os << "(";
+ os << interval.get_begin_value();
+ os << ",";
+ os << interval.get_end_value();
+ if(interval.get_end_closed())
+ os << "]";
+ else
+ os << ")";
+ return os;
+ }
+
+}; //end of MscTimeInterval class
+
+template class MscTimeInterval<double>;
+template class MscTimeInterval<DecScaled>;
+
+/**
+ * \brief List of intervals
+ * Keeping sorted list of intervals, dont have intersection
+ */
+template<class T>
+class MscTimeIntervalSet
+{
+private:
+ std::list< MscTimeInterval<T> > m_set;
+
+public:
+ MscTimeInterval<T> insert(const MscTimeInterval<T>& interval)
+ {
+ MscTimeInterval<T> tmp(interval);
+
+ //in case of empty list
+ if(m_set.empty())
+ {
+ m_set.push_back(interval);
+ return m_set.front();
+ }
+
+ typename std::list <MscTimeInterval<T> >::iterator it;
+ for(it=m_set.begin();it!=m_set.end();it++)
+ {
+ try
+ {
+ if(interval.get_begin()<it->get_begin()
+ || interval.get_begin()==it->get_begin())
+ {
+ break;
+ }
+ }
+ catch(MscIntervalCoupleException)
+ {
+ // it closed false
+ // tmp closed true
+ if(tmp.get_begin_closed())
+ break;
+ // it closed true
+ // tmp closed false
+ if(it->get_begin_closed())
+ {
+ tmp.set_begin_closed(true);
+ break;
+ }
+ // it closed false
+ // tmp closed false
+ break;
+ }
+
+ try
+ {
+ if(tmp.get_begin()<it->get_end()
+ || tmp.get_begin()==it->get_end())
+ {
+ tmp.set_begin(it->get_begin());
+ break;
+ }
+ }
+ catch(MscIntervalCoupleException)
+ {
+ if(!tmp.get_begin_closed()&&!it->get_end_closed())
+ {
+ it++;
+ break;
+ }
+ tmp.set_begin(it->get_begin());
+ break;
+ }
+ }
+
+ typename std::list <MscTimeInterval<T> >::iterator it2;
+ it2=it;
+ for(;it2!=m_set.end();m_set.erase(it2++))
+ {
+ try
+ {
+ if(tmp.get_end()<it2->get_begin())
+ {
+ m_set.insert(it2,tmp);
+ return tmp;
+ }
+ if(interval.get_end()==it2->get_begin())
+ {
+ tmp.set_end(it2->get_end());
+ m_set.insert(it2,tmp);
+ m_set.erase(it2);
+ return tmp;
+ }
+ }
+ catch(MscIntervalCoupleException)
+ {
+ if(!tmp.get_end_closed()&&!it2->get_begin_closed())
+ {
+ m_set.insert(it2,tmp);
+ return tmp;
+ }
+
+ tmp.set_end(it2->get_end());
+ m_set.insert(it2,tmp);
+ m_set.erase(it2);
+ return tmp;
+ }
+
+ try
+ {
+ if(interval.get_end()<it2->get_end())
+ {
+ tmp.set_end(it2->get_end());
+ m_set.insert(it2,tmp);
+ m_set.erase(it2);
+ return tmp;
+ }
+ if(interval.get_end()==it2->get_end())
+ {
+ m_set.insert(it2,tmp);
+ m_set.erase(it2);
+ return tmp;
+ }
+ }
+ catch(MscIntervalCoupleException)
+ {
+ if(!tmp.get_end_closed()&&!it2->get_end_closed())
+ {
+ m_set.insert(it2,tmp);
+ m_set.erase(it2);
+ return tmp;
+ }
+
+ tmp.set_end_closed(true);
+ m_set.insert(it2,tmp);
+ m_set.erase(it2);
+ return tmp;
+ }
+ }
+
+ if(it2==m_set.end())
+ {
+ m_set.push_back(tmp);
+ return tmp;
+ }
+ }
+
+ friend std::ostream&
+ operator<<(std::ostream& os, const MscTimeIntervalSet<T> interval)
+ {
+ if(interval.m_set.empty())
+ return os << "";
+ std::list <MscTimeInterval<T> > set;
+ set=interval.m_set;
+ typename std::list <MscTimeInterval<T> >::iterator it;
+ for(it=set.begin();it!=set.end();it++)
+ {
+ os << *it << " ";
+ }
+ return os;
+ }
+
+
+};
+
+template class MscTimeIntervalSet<double>;
+//template class MscTimeIntervalSet<DecScaled>;
+
+
+#endif // _TIME_H_
Modified: trunk/tests/CMakeLists.txt
===================================================================
--- trunk/tests/CMakeLists.txt 2009-04-14 08:18:04 UTC (rev 216)
+++ trunk/tests/CMakeLists.txt 2009-04-14 13:22:47 UTC (rev 217)
@@ -80,4 +80,11 @@
ADD_TEST(z120-02 z120_test z120_test02.mpr)
ENDIF(ANTLR_FOUND)
+ADD_EXECUTABLE(decimal_test
+ decimal_test.cpp
+)
+ADD_EXECUTABLE(interval_test
+ interval_test.cpp
+)
+ADD_TEST(decimal_test interval_test)
# $Id$
Added: trunk/tests/decimal_test.cpp
===================================================================
--- trunk/tests/decimal_test.cpp (rev 0)
+++ trunk/tests/decimal_test.cpp 2009-04-14 13:22:47 UTC (rev 217)
@@ -0,0 +1,42 @@
+#include<cassert>
+
+#include"data/time.h"
+
+int main()
+{
+ // Constructor
+ DecScaled dec1(50,1);
+ DecScaled dec2(5,2);
+ assert(dec1==dec2);
+
+
+ DecScaled dec3(1,0);
+ DecScaled dec4(1,0);
+ DecScaled dec5(1,3);
+ DecScaled dec6(123,5);
+ DecScaled dec7(23000000432,-4);
+ DecScaled dec8(146000000432,-4);
+ DecScaled dec9(1,0);
+
+ // addition
+ dec3 = dec2+dec1;
+ dec4 = dec1+dec2;
+ dec9=dec6+dec7;
+
+ assert(dec9==dec8);
+ assert(dec3==dec4);
+ assert(dec3==dec5);
+
+ // subtraction
+ dec5=dec3-dec1;
+ assert((dec3-dec1)==dec2);
+ assert((dec1-dec3)==-dec2);
+
+ // multiplication
+ DecScaled dec_m1(25,-3);
+ DecScaled dec_m2(25,-3);
+
+
+ return 0;
+}
+
Added: trunk/tests/interval_test.cpp
===================================================================
--- trunk/tests/interval_test.cpp (rev 0)
+++ trunk/tests/interval_test.cpp 2009-04-14 13:22:47 UTC (rev 217)
@@ -0,0 +1,106 @@
+#include<cassert>
+
+
+#include "data/time.h"
+
+int main()
+{
+ /* MscIntervalCouple */
+ MscIntervalCouple<double> couple1(true,9);
+ MscIntervalCouple<double> couple2(true,10);
+ MscIntervalCouple<double> couple3(true,9);
+
+ assert(couple1<couple2);
+ assert(!(couple1<couple3));
+
+ couple3.set_closed(false);
+ try {
+ couple1<couple3;
+ assert(false);
+ }
+ catch(MscIntervalCoupleException ex)
+ {
+ }
+
+ assert(couple1==MscIntervalCouple<double>::minimum(couple1,couple2));
+ assert(couple2==MscIntervalCouple<double>::maximum(couple1,couple2));
+
+ MscIntervalCouple<double> couple4(false,0);
+ couple4=couple1+couple2;
+ assert(couple4.get_closed());
+ assert(couple4.get_value()==19);
+
+ couple3.set_value(98);
+ couple4=couple1+couple3;
+ assert(!couple4.get_closed());
+ assert(couple4.get_value()==107);
+
+ /* MscTimeInterval */
+ MscTimeInterval<double> interval2(10);
+ MscTimeInterval<double> interval3(14,15);
+ MscTimeInterval<double> interval4(9,15);
+ MscTimeInterval<double> interval6(false,14,15,false);
+ MscTimeInterval<double> interval9(14);
+ MscTimeInterval<double> interval11(couple1,couple2);
+
+ assert(10==interval2.get_begin_value());
+ assert(10==interval2.get_end_value());
+ assert(14==interval3.get_begin_value());
+ assert(15==interval3.get_end_value());
+
+ MscTimeInterval<double> interval;
+ interval = interval2+interval3;
+ assert(24==interval.get_begin_value());
+ assert(25==interval.get_end_value());
+
+ MscTimeInterval<double> interval5;
+ MscTimeInterval<double> interval7;
+ MscTimeInterval<double> interval8;
+ MscTimeInterval<double> interval10;
+
+ interval5 = MscTimeInterval<double>::interval_intersection(interval3,interval4);
+ interval7 = MscTimeInterval<double>::interval_intersection(interval4,interval3);
+ interval8 = MscTimeInterval<double>::interval_intersection(interval4,interval6);
+ assert(interval5.is_valid());
+ assert(interval5==interval7);
+ assert(interval7==interval5);
+ assert(14==interval5.get_begin_value());
+ assert(15==interval5.get_end_value());
+
+ assert(interval5.get_begin_closed());
+ assert(interval5.get_end_closed());
+
+
+ assert(interval7!=interval8);
+ assert(interval7.get_begin_value()==interval8.get_begin_value());
+ assert(interval7.get_end_value()==interval8.get_end_value());
+ assert(!interval8.get_begin_closed());
+ assert(!interval8.get_end_closed());
+
+ interval10 = MscTimeInterval<double>::interval_intersection(interval9,interval6);
+ assert(!interval10.is_valid());
+ interval10 = MscTimeInterval<double>::interval_intersection(interval9,interval3);
+ assert(interval10.is_valid());
+ assert(interval10==interval9);
+
+ interval10 = interval10*3;
+ assert(42==interval10.get_begin_value());
+ assert(42==interval10.get_end_value());
+ assert(interval10.get_begin_closed());
+ assert(interval10.get_end_closed());
+
+
+ MscTimeInterval<double> inter1(10,18);
+ MscTimeInterval<double> inter2(4,11);
+ MscTimeInterval<double> inter3(4,9);
+
+ interval10 = MscTimeInterval<double>::interval_union(inter1,inter2);
+ assert(interval10.is_valid());
+ assert(4==interval10.get_begin_value());
+ assert(18==interval10.get_end_value());
+
+ interval10 = MscTimeInterval<double>::interval_union(inter1,inter3);
+ assert(!interval10.is_valid());
+
+ return 0;
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
