escript/py_src/timeseries.py

# $Id$

import numarray

class TimeSeriesBase:
   """The TimeSeriesBase class is the base class for all class of the TimeSeries module.
      It takes care of the updating depending TimeSeriesBase objects and the debuging mechnism"""

   def __init__(self):
       self.__debug=False

   def __str__(self):
       return "TimeSeriesBase"

   def setDebugOn(self):
      """switch on degugging mode"""
      self.__debug=True

   def setDebugOff(self):
      """switch off degugging mode"""
      self.__debug=False

   def setDebug(self,flag=False):
      """sets debug mode to flag"""
      if flag:
         self.setDebugOn()
      else:
         self.setDebugOff()
         
   def debug(self):
      """returns true if debug mode is on"""
      return self.__debug
      
class TimeSeriesFilter(TimeSeriesBase):
   """TimeSeriesFilter objects are applied to TimeSeries objects to filer out information or to convert it.
      A TimeSeriesFilter objects is called by the TimeSeries object it is depending on to consider the values currently in the buffer for
      updating. Some TimeSeriesFilter may require values outside the buffer. The TimeSeries object maintains the last buffer_overlap values
      in the buffer so they can be used to process (not neccesarily all) value in the buffer."""

   def __init__(self,buffer_overlap=0):
       self.__left_required_extension=buffer_overlap

   def __str__(self):
       return "TimeSeriesFilter"

   def getBufferOverlapNeededForUpdate(self):
       return self.__left_required_extension

   def update(self,times,values):
       pass

_DEFAULT_CACHE_SIZE=9
_DEFAULT_BUFFER_SIZE=5
_FLOATING_TYPE=numarray.Float64

class TimeSeries(TimeSeriesBase):
   def __init__(self,buffer_overlap=0,buffer_size=_DEFAULT_BUFFER_SIZE,cache_size=_DEFAULT_CACHE_SIZE,numComponents=1):
       if buffer_size>cache_size: raise ValueError,"buffer size has to be less or equal cache size"
       TimeSeriesBase.__init__(self)
       self.__updates=list()
       self.__max_buffer_overlap=0
       self.__buffer_overlap=0
       self.__numNodes=0
       self.__numNodesInBuffer=0
       self.__numNodesInCache=0
       self.__firstNodeInBuffer=0
       self.__firstNodeInCache=0
       self.__buffer_size=buffer_size
       self.__node_cache=numarray.zeros((cache_size,),_FLOATING_TYPE)
       self.__attachment_cache=[]
       if numComponents<2:
          self.__value_cache=numarray.zeros((cache_size,),_FLOATING_TYPE)
       else:
          self.__value_cache=numarray.zeros((cache_size,numComponents),_FLOATING_TYPE)
       self.resizeMaxBufferOverlap(buffer_overlap)

   def __del__(self):
       self.flush()

   def __str__(self):
       return "TimeSeries"

   def getNumComponents(self):
       if self.__value_cache.rank==1:
          return 1
       else: 
          self.__value_cache.shape[1]

   def getNumNodes(self):
       """returns the number of time nodes in the time series"""
       return self.__numNodes

   def getCacheSize(self):
       """returns the cache size"""
       return self.__node_cache.shape[0]

   def getBufferSize(self):
       """returns the cache size"""
       return self.__buffer_size

   def getNumNodesInCache(self):
       """returns the number of nodes in cache"""
       return self.__numNodesInCache

   def getNumNodesInBuffer(self):
       """returns the number of nodes in cache"""
       return self.__numNodesInBuffer
    
   def getFirstNodeInCache(self):
       """returns the id number of the first node in the cache"""
       return self.__firstNodeInCache

   def getFirstNodeInBuffer(self):
       """returns the id number of the first node in the buffer"""
       return self.__firstNodeInBuffer

   def getFirstNodeOfBufferInCache(self):
       """returns the first location of the first node in the buffer relative to the cache"""
       return self.getFirstNodeInBuffer()-self.getFirstNodeInCache()

   def getBufferOverlap(self):
       """returns the current size of the left extension"""
       return self.__buffer_overlap

   def getMaxBufferOverlap(self):
       """returns the maximum size of the left extension"""
       return self.__max_buffer_overlap

   def resizeMaxBufferOverlap(self,new_buffer_overlap=0):
       if new_buffer_overlap>self.__max_buffer_overlap:
          if self.getNumNodes()>0: raise ValueError,"left extension can only be resized for empty time series"
          if self.getCacheSize()<self.getBufferSize()+new_buffer_overlap:
               raise ValueError,"Cache size is too small! required cache size is %s"%self.getBufferSize()+new_buffer_overlap
          self.__max_buffer_overlap=new_buffer_overlap
          if self.debug(): print "Debug: %s: left extension is increased to %d"%(self,new_buffer_overlap)

   def getLastNode(self):
       if self.getNumNodesInCache()>0:
          return self.__node_cache[self.getNumNodesInCache()-1]
       else: 
          return -1.e300

   def getLastValue(self):
       if self.getNumNodesInCache()>0:
          return self.__node_cache[self.getNumNodesInCache()-1]
       else: 
          raise ValueError,"No value available"

   def checkInUpdate(self,time_series_filter):
       """checks in a time_series_filter object to be updated when buffer is full"""
       if self.getNumNodes()>0:
          raise TypeError,"Check in of TimeSeries requires empty buffer."
       self.__updates.append(time_series_filter)
       self.resizeMaxBufferOverlap(time_series_filter.getBufferOverlapNeededForUpdate())
       if self.debug(): print "Debug: %s: %s checked in successfully."%(self,time_series_filter)

   def append(self,time_nodes,values,attachments=None):
       """appends the time_nodes and values into the buffer"""
       num_additional_nodes=time_nodes.shape[0]
       if num_additional_nodes<1: return
       if self.debug(): 
            if num_additional_nodes>1:
               print "Debug: %s: values %d to %d are added to time series."%(self,self.getNumNodes(),self.getNumNodes()+num_additional_nodes-1)
            else:
               print "Debug: %s: value %d is added to time series."%(self,self.getNumNodes())
       if not num_additional_nodes==values.shape[0]:
          raise ValueError,"Number time nodes and number of values don't match."
       if self.getLastNode()>=time_nodes[0]:
          raise ValueError,"first time node to be checked in is less than last previously checked in node"

       if num_additional_nodes>1:
            if min(time_nodes[1:num_additional_nodes]-time_nodes[0:num_additional_nodes-1])<=0:
              raise ValueError,"time nodes have to be strictly increasing"
      
       # full cache requires a shift:
       if self.getNumNodesInCache()+num_additional_nodes>self.getCacheSize():
           new_num_nodes_in_cache=self.getNumNodesInBuffer()+self.getBufferOverlap()
           if new_num_nodes_in_cache+num_additional_nodes>self.getCacheSize():
              raise ValueError,"Cache overflow: Expected size is bigger than %d"%(new_num_nodes_in_cache+num_additional_nodes)
           start=self.getNumNodesInCache()-new_num_nodes_in_cache
           end=start+new_num_nodes_in_cache
           self.__node_cache[0:new_num_nodes_in_cache]=self.__node_cache[start:end]
           self.__value_cache[0:new_num_nodes_in_cache]=self.__value_cache[start:end]
           self.__attachment_cache[0:new_num_nodes_in_cache]=self.__attachment_cache[start:end]
 
           self.__firstNodeInCache+=start
           self.__numNodesInCache=new_num_nodes_in_cache
           if self.debug(): print "Debug: %s: %d values from %d onwards are moved to the beginning of the cache (first node in cache is now %d)."% \
                                                                                    (self,new_num_nodes_in_cache,start,self.__firstNodeInCache)
           
       # copy values into cache:
       if self.getNumNodesInCache()+num_additional_nodes>self.getCacheSize():
           raise ValueError,"Cache overflow: Expected size is bigger than %d"%(self.getNumNodesInCache()+num_additional_nodes)
       if self.debug(): 
           if num_additional_nodes>1:
              print "Debug: %s: values %d to %d of cache are updated"%(self,self.getNumNodesInCache(),self.getNumNodesInCache()+num_additional_nodes-1)
           else:
              print "Debug: %s: value %d of cache is updated."%(self,self.getNumNodesInCache())
       self.__node_cache[self.getNumNodesInCache():self.getNumNodesInCache()+num_additional_nodes]=time_nodes
       self.__value_cache[self.getNumNodesInCache():self.getNumNodesInCache()+num_additional_nodes]=values
       self.__numNodes+=num_additional_nodes
       self.__numNodesInBuffer+=num_additional_nodes
       self.__numNodesInCache+=num_additional_nodes
       print self.__node_cache
       print self.__value_cache
       # copy values into cache:
       if self.getNumNodesInBuffer()>=self.getBufferSize():
              if self.debug() and len(self.__updates)>0: print "Debug: %s: buffer is full. Updating process is started"%self
              self.processBuffer()

   def flush(self):
      self.processBuffer()

   def processBuffer(self):
        if self.getNumNodesInBuffer()>0:
           for i in self.__updates: 
             if self.debug(): print "Debug: %s: update for %s started"%(self,i)
             if i.getBufferOverlapNeededForUpdate()>self.getBufferOverlap():
                s=self.getFirstNodeOfBufferInCache()
                l=self.getNumNodesInBuffer()
             else:
                s=self.getFirstNodeOfBufferInCache()-i.getBufferOverlapNeededForUpdate()
                l=self.getNumNodesInBuffer()+i.getBufferOverlapNeededForUpdate()
             i.update(self.__node_cache[s:s+l],self.__value_cache[s:s+l])
           self.__firstNodeInBuffer+=self.__numNodesInBuffer
           self.__numNodesInBuffer=0
        self.__buffer_overlap=self.getMaxBufferOverlap()
        if self.debug(): print "Debug: %s: first node in buffer is now %d"%(self,self.__firstNodeInBuffer)

   
class TimeSeriesCollector(TimeSeries):
      """TimeSeriesCollector collects values at time nodes"""
      def __init__(self):
         TimeSeries.__init__(self)

      def __str__(self):
         return "TimeSeriesCollector"

      def add(self,time_mark,value):
           """adds the value at time time_mark to the time series"""
           self.append(numarray.array([time_mark]),numarray.array([value]))

      def read(self,istream,seperator=","):
        """reads pairs from iostream istream"""
        for l in istream:
           d=l.strip().split(seperator)
           self.add(float(d[0]),float(d[1]))

class TimeSeriesIntegrator(TimeSeries,TimeSeriesFilter):
      def __init__(self,time_series):
         TimeSeriesFilter.__init__(self,1)
         TimeSeries.__init__(self,buffer_size=time_series.getBufferSize(),cache_size=time_series.getCacheSize(), \
                                                                         numComponents=time_series.getNumComponents())
         self.setDebug(time_series.debug())
         time_series.checkInUpdate(self)
         self.__integral=0

      def __str__(self):
         return "TimeSeriesIntegrator"

      def update(self,times,values):
          l=times.shape[0]
          self.append(times[1:l],(values[0:l-1]+values[1:l])/2.*(times[1:l]-times[0:l-1]))
         

class TimeSeriesDifferential(TimeSeries,TimeSeriesFilter):
      def __init__(self,time_series):
         TimeSeriesFilter.__init__(self,1)
         TimeSeries.__init__(self,buffer_size=time_series.getBufferSize(),cache_size=time_series.getCacheSize(), \
                                                                         numComponents=time_series.getNumComponents())
         self.setDebug(time_series.debug())
         time_series.checkInUpdate(self)

      def __str__(self):
         return "TimeSeriesDifferential"

      def update(self,times,values):
          l=times.shape[0]
          self.append((times[0:l-1]+times[1:l])/2,(values[0:l-1]-values[1:l])/(times[0:l-1]-times[1:l]))

class TimeSeriesViewer(TimeSeriesFilter):
      def __init__(self,time_series):
         TimeSeriesFilter.__init__(self,0)
         time_series.checkInUpdate(self)

      def __str__(self):
         return "TimeSeriesViewer"

      def update(self,times,values):
          for i in range(times.shape[0]): print "[%s: %s]"%(times[i],values[i])

class TimeSeriesWriter(TimeSeriesFilter):
      def __init__(self,time_series,ostream,seperator=","):
         TimeSeriesFilter.__init__(self,0)
         time_series.checkInUpdate(self)
         self.setDebug(time_series.debug())
         self.__ostream=ostream
         self.__seperator=seperator

      def __str__(self):
         return "TimeSeriesWriter"

      def update(self,times,values):
        for i in range(times.shape[0]): self.__ostream.writelines("%s,%s\n"%(times[i],values[i]))

# test

if __name__=="__main__":

   c=TimeSeriesCollector()
   c.setDebugOn()
   ii=TimeSeriesIntegrator(c)
   d=TimeSeriesDifferential(c)
   v=TimeSeriesViewer(ii)
   w=TimeSeriesWriter(d,file("test.csv","w"))

   for i in range(15):
      c.add(i*1.,i+1.)
1	# $Id$
2
3	import numarray
4
5	class TimeSeriesBase:
6	"""The TimeSeriesBase class is the base class for all class of the TimeSeries module.
7	It takes care of the updating depending TimeSeriesBase objects and the debuging mechnism"""
8
9	def __init__(self):
10	self.__debug=False
11
12	def __str__(self):
13	return "TimeSeriesBase"
14
15	def setDebugOn(self):
16	"""switch on degugging mode"""
17	self.__debug=True
18
19	def setDebugOff(self):
20	"""switch off degugging mode"""
21	self.__debug=False
22
23	def setDebug(self,flag=False):
24	"""sets debug mode to flag"""
25	if flag:
26	self.setDebugOn()
27	else:
28	self.setDebugOff()
29
30	def debug(self):
31	"""returns true if debug mode is on"""
32	return self.__debug
33
34	class TimeSeriesFilter(TimeSeriesBase):
35	"""TimeSeriesFilter objects are applied to TimeSeries objects to filer out information or to convert it.
36	A TimeSeriesFilter objects is called by the TimeSeries object it is depending on to consider the values currently in the buffer for
37	updating. Some TimeSeriesFilter may require values outside the buffer. The TimeSeries object maintains the last buffer_overlap values
38	in the buffer so they can be used to process (not neccesarily all) value in the buffer."""
39
40	def __init__(self,buffer_overlap=0):
41	self.__left_required_extension=buffer_overlap
42
43	def __str__(self):
44	return "TimeSeriesFilter"
45
46	def getBufferOverlapNeededForUpdate(self):
47	return self.__left_required_extension
48
49	def update(self,times,values):
50	pass
51
52	_DEFAULT_CACHE_SIZE=9
53	_DEFAULT_BUFFER_SIZE=5
54	_FLOATING_TYPE=numarray.Float64
55
56	class TimeSeries(TimeSeriesBase):
57	def __init__(self,buffer_overlap=0,buffer_size=_DEFAULT_BUFFER_SIZE,cache_size=_DEFAULT_CACHE_SIZE,numComponents=1):
58	if buffer_size>cache_size: raise ValueError,"buffer size has to be less or equal cache size"
59	TimeSeriesBase.__init__(self)
60	self.__updates=list()
61	self.__max_buffer_overlap=0
62	self.__buffer_overlap=0
63	self.__numNodes=0
64	self.__numNodesInBuffer=0
65	self.__numNodesInCache=0
66	self.__firstNodeInBuffer=0
67	self.__firstNodeInCache=0
68	self.__buffer_size=buffer_size
69	self.__node_cache=numarray.zeros((cache_size,),_FLOATING_TYPE)
70	self.__attachment_cache=[]
71	if numComponents<2:
72	self.__value_cache=numarray.zeros((cache_size,),_FLOATING_TYPE)
73	else:
74	self.__value_cache=numarray.zeros((cache_size,numComponents),_FLOATING_TYPE)
75	self.resizeMaxBufferOverlap(buffer_overlap)
76
77	def __del__(self):
78	self.flush()
79
80	def __str__(self):
81	return "TimeSeries"
82
83	def getNumComponents(self):
84	if self.__value_cache.rank==1:
85	return 1
86	else:
87	self.__value_cache.shape[1]
88
89	def getNumNodes(self):
90	"""returns the number of time nodes in the time series"""
91	return self.__numNodes
92
93	def getCacheSize(self):
94	"""returns the cache size"""
95	return self.__node_cache.shape[0]
96
97	def getBufferSize(self):
98	"""returns the cache size"""
99	return self.__buffer_size
100
101	def getNumNodesInCache(self):
102	"""returns the number of nodes in cache"""
103	return self.__numNodesInCache
104
105	def getNumNodesInBuffer(self):
106	"""returns the number of nodes in cache"""
107	return self.__numNodesInBuffer
108
109	def getFirstNodeInCache(self):
110	"""returns the id number of the first node in the cache"""
111	return self.__firstNodeInCache
112
113	def getFirstNodeInBuffer(self):
114	"""returns the id number of the first node in the buffer"""
115	return self.__firstNodeInBuffer
116
117	def getFirstNodeOfBufferInCache(self):
118	"""returns the first location of the first node in the buffer relative to the cache"""
119	return self.getFirstNodeInBuffer()-self.getFirstNodeInCache()
120
121	def getBufferOverlap(self):
122	"""returns the current size of the left extension"""
123	return self.__buffer_overlap
124
125	def getMaxBufferOverlap(self):
126	"""returns the maximum size of the left extension"""
127	return self.__max_buffer_overlap
128
129	def resizeMaxBufferOverlap(self,new_buffer_overlap=0):
130	if new_buffer_overlap>self.__max_buffer_overlap:
131	if self.getNumNodes()>0: raise ValueError,"left extension can only be resized for empty time series"
132	if self.getCacheSize()<self.getBufferSize()+new_buffer_overlap:
133	raise ValueError,"Cache size is too small! required cache size is %s"%self.getBufferSize()+new_buffer_overlap
134	self.__max_buffer_overlap=new_buffer_overlap
135	if self.debug(): print "Debug: %s: left extension is increased to %d"%(self,new_buffer_overlap)
136
137	def getLastNode(self):
138	if self.getNumNodesInCache()>0:
139	return self.__node_cache[self.getNumNodesInCache()-1]
140	else:
141	return -1.e300
142
143	def getLastValue(self):
144	if self.getNumNodesInCache()>0:
145	return self.__node_cache[self.getNumNodesInCache()-1]
146	else:
147	raise ValueError,"No value available"
148
149	def checkInUpdate(self,time_series_filter):
150	"""checks in a time_series_filter object to be updated when buffer is full"""
151	if self.getNumNodes()>0:
152	raise TypeError,"Check in of TimeSeries requires empty buffer."
153	self.__updates.append(time_series_filter)
154	self.resizeMaxBufferOverlap(time_series_filter.getBufferOverlapNeededForUpdate())
155	if self.debug(): print "Debug: %s: %s checked in successfully."%(self,time_series_filter)
156
157	def append(self,time_nodes,values,attachments=None):
158	"""appends the time_nodes and values into the buffer"""
159	num_additional_nodes=time_nodes.shape[0]
160	if num_additional_nodes<1: return
161	if self.debug():
162	if num_additional_nodes>1:
163	print "Debug: %s: values %d to %d are added to time series."%(self,self.getNumNodes(),self.getNumNodes()+num_additional_nodes-1)
164	else:
165	print "Debug: %s: value %d is added to time series."%(self,self.getNumNodes())
166	if not num_additional_nodes==values.shape[0]:
167	raise ValueError,"Number time nodes and number of values don't match."
168	if self.getLastNode()>=time_nodes[0]:
169	raise ValueError,"first time node to be checked in is less than last previously checked in node"
170
171	if num_additional_nodes>1:
172	if min(time_nodes[1:num_additional_nodes]-time_nodes[0:num_additional_nodes-1])<=0:
173	raise ValueError,"time nodes have to be strictly increasing"
174
175	# full cache requires a shift:
176	if self.getNumNodesInCache()+num_additional_nodes>self.getCacheSize():
177	new_num_nodes_in_cache=self.getNumNodesInBuffer()+self.getBufferOverlap()
178	if new_num_nodes_in_cache+num_additional_nodes>self.getCacheSize():
179	raise ValueError,"Cache overflow: Expected size is bigger than %d"%(new_num_nodes_in_cache+num_additional_nodes)
180	start=self.getNumNodesInCache()-new_num_nodes_in_cache
181	end=start+new_num_nodes_in_cache
182	self.__node_cache[0:new_num_nodes_in_cache]=self.__node_cache[start:end]
183	self.__value_cache[0:new_num_nodes_in_cache]=self.__value_cache[start:end]
184	self.__attachment_cache[0:new_num_nodes_in_cache]=self.__attachment_cache[start:end]
185
186	self.__firstNodeInCache+=start
187	self.__numNodesInCache=new_num_nodes_in_cache
188	if self.debug(): print "Debug: %s: %d values from %d onwards are moved to the beginning of the cache (first node in cache is now %d)."% \
189	(self,new_num_nodes_in_cache,start,self.__firstNodeInCache)
190
191	# copy values into cache:
192	if self.getNumNodesInCache()+num_additional_nodes>self.getCacheSize():
193	raise ValueError,"Cache overflow: Expected size is bigger than %d"%(self.getNumNodesInCache()+num_additional_nodes)
194	if self.debug():
195	if num_additional_nodes>1:
196	print "Debug: %s: values %d to %d of cache are updated"%(self,self.getNumNodesInCache(),self.getNumNodesInCache()+num_additional_nodes-1)
197	else:
198	print "Debug: %s: value %d of cache is updated."%(self,self.getNumNodesInCache())
199	self.__node_cache[self.getNumNodesInCache():self.getNumNodesInCache()+num_additional_nodes]=time_nodes
200	self.__value_cache[self.getNumNodesInCache():self.getNumNodesInCache()+num_additional_nodes]=values
201	self.__numNodes+=num_additional_nodes
202	self.__numNodesInBuffer+=num_additional_nodes
203	self.__numNodesInCache+=num_additional_nodes
204	print self.__node_cache
205	print self.__value_cache
206	# copy values into cache:
207	if self.getNumNodesInBuffer()>=self.getBufferSize():
208	if self.debug() and len(self.__updates)>0: print "Debug: %s: buffer is full. Updating process is started"%self
209	self.processBuffer()
210
211	def flush(self):
212	self.processBuffer()
213
214	def processBuffer(self):
215	if self.getNumNodesInBuffer()>0:
216	for i in self.__updates:
217	if self.debug(): print "Debug: %s: update for %s started"%(self,i)
218	if i.getBufferOverlapNeededForUpdate()>self.getBufferOverlap():
219	s=self.getFirstNodeOfBufferInCache()
220	l=self.getNumNodesInBuffer()
221	else:
222	s=self.getFirstNodeOfBufferInCache()-i.getBufferOverlapNeededForUpdate()
223	l=self.getNumNodesInBuffer()+i.getBufferOverlapNeededForUpdate()
224	i.update(self.__node_cache[s:s+l],self.__value_cache[s:s+l])
225	self.__firstNodeInBuffer+=self.__numNodesInBuffer
226	self.__numNodesInBuffer=0
227	self.__buffer_overlap=self.getMaxBufferOverlap()
228	if self.debug(): print "Debug: %s: first node in buffer is now %d"%(self,self.__firstNodeInBuffer)
229
230
231
232
233	class TimeSeriesCollector(TimeSeries):
234	"""TimeSeriesCollector collects values at time nodes"""
235	def __init__(self):
236	TimeSeries.__init__(self)
237
238	def __str__(self):
239	return "TimeSeriesCollector"
240
241	def add(self,time_mark,value):
242	"""adds the value at time time_mark to the time series"""
243	self.append(numarray.array([time_mark]),numarray.array([value]))
244
245	def read(self,istream,seperator=","):
246	"""reads pairs from iostream istream"""
247	for l in istream:
248	d=l.strip().split(seperator)
249	self.add(float(d[0]),float(d[1]))
250
251	class TimeSeriesIntegrator(TimeSeries,TimeSeriesFilter):
252	def __init__(self,time_series):
253	TimeSeriesFilter.__init__(self,1)
254	TimeSeries.__init__(self,buffer_size=time_series.getBufferSize(),cache_size=time_series.getCacheSize(), \
255	numComponents=time_series.getNumComponents())
256	self.setDebug(time_series.debug())
257	time_series.checkInUpdate(self)
258	self.__integral=0
259
260	def __str__(self):
261	return "TimeSeriesIntegrator"
262
263	def update(self,times,values):
264	l=times.shape[0]
265	self.append(times[1:l],(values[0:l-1]+values[1:l])/2.*(times[1:l]-times[0:l-1]))
266
267
268	class TimeSeriesDifferential(TimeSeries,TimeSeriesFilter):
269	def __init__(self,time_series):
270	TimeSeriesFilter.__init__(self,1)
271	TimeSeries.__init__(self,buffer_size=time_series.getBufferSize(),cache_size=time_series.getCacheSize(), \
272	numComponents=time_series.getNumComponents())
273	self.setDebug(time_series.debug())
274	time_series.checkInUpdate(self)
275
276	def __str__(self):
277	return "TimeSeriesDifferential"
278
279	def update(self,times,values):
280	l=times.shape[0]
281	self.append((times[0:l-1]+times[1:l])/2,(values[0:l-1]-values[1:l])/(times[0:l-1]-times[1:l]))
282
283	class TimeSeriesViewer(TimeSeriesFilter):
284	def __init__(self,time_series):
285	TimeSeriesFilter.__init__(self,0)
286	time_series.checkInUpdate(self)
287
288	def __str__(self):
289	return "TimeSeriesViewer"
290
291	def update(self,times,values):
292	for i in range(times.shape[0]): print "[%s: %s]"%(times[i],values[i])
293
294	class TimeSeriesWriter(TimeSeriesFilter):
295	def __init__(self,time_series,ostream,seperator=","):
296	TimeSeriesFilter.__init__(self,0)
297	time_series.checkInUpdate(self)
298	self.setDebug(time_series.debug())
299	self.__ostream=ostream
300	self.__seperator=seperator
301
302	def __str__(self):
303	return "TimeSeriesWriter"
304
305	def update(self,times,values):
306	for i in range(times.shape[0]): self.__ostream.writelines("%s,%s\n"%(times[i],values[i]))
307
308	# test
309
310	if __name__=="__main__":
311
312	c=TimeSeriesCollector()
313	c.setDebugOn()
314	ii=TimeSeriesIntegrator(c)
315	d=TimeSeriesDifferential(c)
316	v=TimeSeriesViewer(ii)
317	w=TimeSeriesWriter(d,file("test.csv","w"))
318
319	for i in range(15):
320	c.add(i*1.,i+1.)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision