AbstractTimeSeries (Time2 Library 2.0.0 API)

java.lang.Object
- ch.agent.t2.timeseries.AbstractTimeSeries<T>

Type Parameters:

T - the value type

All Implemented Interfaces:

TimeAddressable<T>, Iterable<Observation<T>>

Direct Known Subclasses:

RegularTimeSeries, SparseTimeSeries
```
public abstract class AbstractTimeSeries<T>
extends Object
implements TimeAddressable<T>
```
AbstractTimeseries is the basis for RegularTimeSeries and SparseTimeSeries.

Author:

Jean-Paul Vetterli

Constructor Summary

Constructors
Constructor and Description
`AbstractTimeSeries()` The parameterless constructor always throws an UnsupportedOperationException.
`AbstractTimeSeries(Class<T> type, TimeDomain domain, T missingValue)` Construct a time series with the given time domain, data type, and missing value.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected int`	`accept(TimeAddressable<T> updates, UpdateReviewer<T> reviewer)` Return the number of updates rejected by the reviewer.
`TimeAddressable<T>`	`copy()` Return a copy of the time series.
`T`	`get(long t)` Return the value at the given numerical time index.
`abstract TimeAddressable<T>`	`get(long first, long last)` Return a new time series corresponding to the range between two numerical time indexes.
`T`	`get(TimeIndex t)` Return the value identified by the given time index.
`Observation<T>`	`getFirst(TimeIndex t)` Return the observation at or after the given time.
`long`	`getFirstIndex()` Return the numerical time index of the first element, or -1 when there is no data.
`Observation<T>`	`getLast(TimeIndex t)` Return the observation at or before the given time.
`long`	`getLastIndex()` Return the numerical time index of the last element, or -1 when there is no data.
`T`	`getMissingValue()` Return the object representing missing values.
`Range`	`getRange()` Return the range of the time series.
`int`	`getSize()` Return the number of values.
`TimeDomain`	`getTimeDomain()` Return the time domain of the time series.
`Class<T>`	`getType()` Return the type of he observations.
`protected abstract void`	`internalClear()` Remove all values from the time series.
`protected abstract T`	`internalGet(long time)` Get the value identified by the given numerical time index.
`protected abstract Collection<T>`	`internalGetData()` Return all values as a `Collection`.
`protected abstract Observation<T>`	`internalGetFirst(long index)` Return the observation at or after the given numerical time index.
`protected abstract long`	`internalGetFirstIndex()` Return the numerical time index of the first element.
`protected abstract Observation<T>`	`internalGetLast(long time)` Return the observation at or before the given numerical time index.
`protected abstract long`	`internalGetLastIndex()` Return the numerical time index of the last element.
`protected abstract int`	`internalGetSize()` Return the used size of the data structure where values are stored.
`protected abstract void`	`internalPut(long time, T value)` Put the value into the series at the given numerical time index.
`protected abstract void`	`internalRemove(long time)` Remove the value at the given numerical time index.
`protected abstract void`	`internalSetBounds(long first, long last)` Shrink the range to the one given by the two numerical time indexes.
`boolean`	`isMissing(T value)` Return true if the given value is missing.
`static <X> TimeAddressable<X>`	`make(Class<X> type, TimeDomain domain, boolean forceSparse)` Construct a time series of the type and domain specified.
`protected T`	`normalizeMissingValue(T value)` Replace all objects equal to the missing value with the "official" missing value object.
`void`	`put(long index, T value)` Put a value identified by a numerical time index into the time series.
`void`	`put(long index, T[] values)` Put an array of values identified with the numerical time index of its first element into the time series.
`void`	`put(TimeAddressable<T> values, UpdateReviewer<T> reviewer)` Conditionally put all values from another time series into this time series.
`void`	`put(TimeIndex t, T value)` Put a value identified by a time index into the time series.
`void`	`put(TimeIndex t, T[] values)` Put an array of values identified with time index of its first element into the time series.
`void`	`remove(TimeIndex t)` Remove the value identified by the time index.
`boolean`	`setRange(Range range)` Set the range to the intersection of the current range with the given range.
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface ch.agent.t2.timeseries.TimeAddressable
asIndexable, get, getValueCount, isIndexable, iterator, makeEmptyCopy

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - AbstractTimeSeries
```
public AbstractTimeSeries()
```
    The parameterless constructor always throws an UnsupportedOperationException.
  - AbstractTimeSeries
```
public AbstractTimeSeries(Class<T> type,
                          TimeDomain domain,
                          T missingValue)
```
    Construct a time series with the given time domain, data type, and missing value.
    
    Parameters:
    
    type - data type of observations
    
    domain - a non-null time domain
    
    missingValue - the object to use for representing missing values
- Method Detail
  - make
```
public static <X> TimeAddressable<X> make(Class<X> type,
                                          TimeDomain domain,
                                          boolean forceSparse)
```
    Construct a time series of the type and domain specified. When forceParse is true, or when the domain resolution is less than a day, the time series returned is addressable (sparse), else it is indexable (regular).
    
    Type Parameters:
    
    X - corresponds to the value type
    
    Parameters:
    
    type - non-null value type
    
    domain - a non-null time domain
    
    forceSparse - if true, always return a sparse time series
    
    Returns:
    
    a time series
  - isMissing
```
public boolean isMissing(T value)
```
    Description copied from interface: TimeAddressable
    
    Return true if the given value is missing.
    
    Specified by:
    
    isMissing in interface TimeAddressable<T>
    
    Returns:
    
    true if the argument is the missing value
  - copy
```
public TimeAddressable<T> copy()
                        throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Return a copy of the time series.
    
    Specified by:
    
    copy in interface TimeAddressable<T>
    
    Returns:
    
    a copy of the time series
    
    Throws:
    
    T2Exception
  - get
```
public T get(long t)
      throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Return the value at the given numerical time index. Return the missing value object when there is no value. There is no value either when the given index is out of range or when there is a hole in the range at the requested position.
    
    Specified by:
    
    get in interface TimeAddressable<T>
    
    Parameters:
    
    t - a number
    
    Returns:
    
    a value
    
    Throws:
    
    T2Exception
  - get
```
public abstract TimeAddressable<T> get(long first,
                                       long last)
                                throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Return a new time series corresponding to the range between two numerical time indexes. The result is never null. When there is no data corresponding to the arguments, an empty time series is returned.
    
    Specified by:
    
    get in interface TimeAddressable<T>
    
    Parameters:
    
    first - a numerical time index giving the lower bound of the wanted range
    
    last - a numerical time index giving the upper bound of the wanted range
    
    Returns:
    
    a time series
    
    Throws:
    
    T2Exception
  - get
```
public T get(TimeIndex t)
      throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Return the value identified by the given time index. Return the missing value object when there is no value. There is no value either when the given index is out of range or when there is a hole in the range at the requested position.
    
    Specified by:
    
    get in interface TimeAddressable<T>
    
    Parameters:
    
    t - a non-null time index
    
    Returns:
    
    a value
    
    Throws:
    
    T2Exception
  - getType
```
public Class<T> getType()
```
    Description copied from interface: TimeAddressable
    
    Return the type of he observations.
    
    Specified by:
    
    getType in interface TimeAddressable<T>
    
    Returns:
    
    a time domain
  - getTimeDomain
```
public TimeDomain getTimeDomain()
```
    Description copied from interface: TimeAddressable
    
    Return the time domain of the time series.
    
    Specified by:
    
    getTimeDomain in interface TimeAddressable<T>
    
    Returns:
    
    a time domain
  - getRange
```
public Range getRange()
```
    Description copied from interface: TimeAddressable
    
    Return the range of the time series. The range is the empty range when there is no data. Modifying the range returned by this method does not have any effect on the range of the time series.
    
    Specified by:
    
    getRange in interface TimeAddressable<T>
    
    Returns:
    
    a copy of the range of the time series
  - getFirstIndex
```
public long getFirstIndex()
```
    Description copied from interface: TimeAddressable
    
    Return the numerical time index of the first element, or -1 when there is no data. To get the time of the first element as a TimeIndex, use TimeAddressable.getRange().
    
    Specified by:
    
    getFirstIndex in interface TimeAddressable<T>
    
    Returns:
    
    the index of the first element
  - getLastIndex
```
public long getLastIndex()
```
    Description copied from interface: TimeAddressable
    
    Return the numerical time index of the last element, or -1 when there is no data. To get the time of the last element as a TimeIndex, use TimeAddressable.getRange().
    
    Specified by:
    
    getLastIndex in interface TimeAddressable<T>
    
    Returns:
    
    the index of the last element
  - getLast
```
public Observation<T> getLast(TimeIndex t)
                       throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Return the observation at or before the given time. When the argument is null, return the last observation. Return null when the wanted observation cannot be found. When not null, the result will not contain a missing value (this is a special rule of this method, not a general rule for Observation objects).
    
    Specified by:
    
    getLast in interface TimeAddressable<T>
    
    Parameters:
    
    t - a time index
    
    Returns:
    
    an observation or null
    
    Throws:
    
    T2Exception
  - getFirst
```
public Observation<T> getFirst(TimeIndex t)
                        throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Return the observation at or after the given time. When the argument is null, return the first observation. Return null when the wanted observation cannot be found. When not null, the result will not contain a missing value (this is a special rule of this method, not a general rule for Observation objects).
    
    Specified by:
    
    getFirst in interface TimeAddressable<T>
    
    Parameters:
    
    t - a time index
    
    Returns:
    
    an observation or null
    
    Throws:
    
    T2Exception
  - getSize
```
public int getSize()
```
    Description copied from interface: TimeAddressable
    
    Return the number of values. Missing values are included. Note that in a sparse time series the result is not always the same as the range size.
    
    Specified by:
    
    getSize in interface TimeAddressable<T>
    
    Returns:
    
    the number of values
  - put
```
public void put(long index,
                T value)
         throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Put a value identified by a numerical time index into the time series. The value can only be null when null was defined to represent missing values.
    
    Specified by:
    
    put in interface TimeAddressable<T>
    
    Parameters:
    
    index - a numerical time index
    
    value - a value
    
    Throws:
    
    T2Exception
  - put
```
public void put(long index,
                T[] values)
         throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Put an array of values identified with the numerical time index of its first element into the time series. Values elements can only be null when null was defined to represent missing values. .
    
    Specified by:
    
    put in interface TimeAddressable<T>
    
    Parameters:
    
    index - a numerical time index
    
    values - a non-null array of values
    
    Throws:
    
    T2Exception
  - put
```
public void put(TimeAddressable<T> values,
                UpdateReviewer<T> reviewer)
         throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Conditionally put all values from another time series into this time series. The condition is that, if not null, the reviewer accepts all new values. With a null reviewer, all values are always accepted.
    Important note. When the implementation of the values time series does not explicitly represent missing values (see SparseTimeSeries for example), this method cannot be relied upon for "deleting" values of the target.
    
    Specified by:
    
    put in interface TimeAddressable<T>
    
    Parameters:
    
    values - a non-null time series
    
    reviewer - a reviewer
    
    Throws:
    
    T2Exception
  - put
```
public void put(TimeIndex t,
                T value)
         throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Put a value identified by a time index into the time series. The value can only be null when null was defined to represent missing values.
    
    Specified by:
    
    put in interface TimeAddressable<T>
    
    Parameters:
    
    t - a non-null time index
    
    value - a value
    
    Throws:
    
    T2Exception
  - put
```
public void put(TimeIndex t,
                T[] values)
         throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Put an array of values identified with time index of its first element into the time series. Values elements can only be null when null was defined to represent missing values.
    
    Specified by:
    
    put in interface TimeAddressable<T>
    
    Parameters:
    
    t - a non-null time index
    
    values - a non-null array of values
    
    Throws:
    
    T2Exception
  - remove
```
public void remove(TimeIndex t)
            throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Remove the value identified by the time index.
    
    Specified by:
    
    remove in interface TimeAddressable<T>
    
    Parameters:
    
    t - a non-null time index
    
    Throws:
    
    T2Exception
  - setRange
```
public boolean setRange(Range range)
                 throws T2Exception
```
    Description copied from interface: TimeAddressable
    
    Set the range to the intersection of the current range with the given range. If the intersection is empty, all values are removed. A null range parameter is interpreted as a request to clear all values. Returns true if the range was modified.
    
    Specified by:
    
    setRange in interface TimeAddressable<T>
    
    Parameters:
    
    range - the new range will be the intersection of the current range with this one
    
    Returns:
    
    true if the range was modified
    
    Throws:
    
    T2Exception
  - getMissingValue
```
public T getMissingValue()
```
    Description copied from interface: TimeAddressable
    
    Return the object representing missing values.
    
    Specified by:
    
    getMissingValue in interface TimeAddressable<T>
    
    Returns:
    
    an object of the value type
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - normalizeMissingValue
```
protected T normalizeMissingValue(T value)
                           throws T2Exception
```
    Replace all objects equal to the missing value with the "official" missing value object.
    Null values are illegal and produce an exception, unless they represent missing values.
    
    Parameters:
    
    value - the value to normalize
    
    Returns:
    
    the value, normalized
    
    Throws:
    
    T2Exception
  - accept
```
protected int accept(TimeAddressable<T> updates,
                     UpdateReviewer<T> reviewer)
              throws T2Exception
```
    Return the number of updates rejected by the reviewer. A result of 0 means all updates have been accepted
    
    Parameters:
    
    updates - a non-null time series of updates
    
    reviewer - a non-null reviewer
    
    Returns:
    
    the number of updates rejected
    
    Throws:
    
    T2Exception
  - internalGetFirstIndex
```
protected abstract long internalGetFirstIndex()
```
    Return the numerical time index of the first element.
    
    Returns:
    
    a numerical time index
  - internalGetLastIndex
```
protected abstract long internalGetLastIndex()
```
    Return the numerical time index of the last element.
    
    Returns:
    
    a numerical time index
  - internalGetFirst
```
protected abstract Observation<T> internalGetFirst(long index)
                                            throws T2Exception
```
    Return the observation at or after the given numerical time index. Return null when there is no such observation. When the result is not null, its value will not be a missing value (this is not a general rule for Observation, only a special rule for this method).
    
    Parameters:
    
    index - a number
    
    Returns:
    
    an observation or null
    
    Throws:
    
    T2Exception
  - internalGetLast
```
protected abstract Observation<T> internalGetLast(long time)
                                           throws T2Exception
```
    Return the observation at or before the given numerical time index. Return null when there is no such observation. When the result is not null, its value will not be a missing value (this is not a general rule for Observation, only a special rule for this method).
    
    Parameters:
    
    time - a numerical time index
    
    Returns:
    
    an observation or null
    
    Throws:
    
    T2Exception
  - internalClear
```
protected abstract void internalClear()
```
    Remove all values from the time series.
  - internalGet
```
protected abstract T internalGet(long time)
                          throws T2Exception
```
    Get the value identified by the given numerical time index.
    
    Parameters:
    
    time - a numerical time index
    
    Returns:
    
    a value
    
    Throws:
    
    T2Exception
  - internalGetSize
```
protected abstract int internalGetSize()
```
    Return the used size of the data structure where values are stored.
    
    Returns:
    
    the used size of the data structure with the values
  - internalPut
```
protected abstract void internalPut(long time,
                                    T value)
                             throws T2Exception
```
    Put the value into the series at the given numerical time index.
    The method silently ignores missing values added out of range. Adding missing values at the boundary shrinks the range.
    
    Parameters:
    
    time - a numerical time index
    
    value - a value
    
    Throws:
    
    T2Exception
  - internalRemove
```
protected abstract void internalRemove(long time)
                                throws T2Exception
```
    Remove the value at the given numerical time index.
    
    Parameters:
    
    time - a numerical time index
    
    Throws:
    
    T2Exception
  - internalSetBounds
```
protected abstract void internalSetBounds(long first,
                                          long last)
                                   throws T2Exception
```
    Shrink the range to the one given by the two numerical time indexes. The method assumes that the new range lies within the current range. Not playing by the rules is likely to result in a RuntimeException being thrown.
    
    Parameters:
    
    first - a numerical time index giving the lower bound of the new range
    
    last - a numerical time index giving the upper bound of the new range
    
    Throws:
    
    T2Exception
  - internalGetData
```
protected abstract Collection<T> internalGetData()
```
    Return all values as a Collection.
    
    Returns:
    
    all values as a collection

Class AbstractTimeSeries<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface ch.agent.t2.timeseries.TimeAddressable

Methods inherited from interface java.lang.Iterable

Constructor Detail

AbstractTimeSeries

AbstractTimeSeries

Method Detail

make

isMissing

copy

get

get

get

getType

getTimeDomain

getRange

getFirstIndex

getLastIndex

getLast

getFirst

getSize

put

put

put

put

put

remove

setRange

getMissingValue

toString

normalizeMissingValue

accept

internalGetFirstIndex

internalGetLastIndex

internalGetFirst

internalGetLast

internalClear

internalGet

internalGetSize

internalPut

internalRemove

internalSetBounds

internalGetData