Variable Transformations in IronPython QuickStart Sample

Illustrates how to perform a range of transformations on statistical data in IronPython.
```Python
import numerics

from System import DateTime

from Extreme.Mathematics import *
from Extreme.Statistics import *
from Extreme.Statistics.TimeSeriesAnalysis import *

# Illustrates various kinds of transformations of numerical variables
# by showing how to compute several financial indicators.

# We use a TimeSeriesCollection to load the data.
import clr
clr.AddReference("System.Data")
from System.Data import *
from System.Data.OleDb import *

def LoadTimeSeriesData():
    filename = r'..\Data\MicrosoftStock.xls'
    connectionString = r'Provider=Microsoft.Jet.OLEDB.4.0;Data Source='+filename+';Extended Properties="Excel 8.0;HDR=Yes;IMEX=1"'
    cnn = None
    ds = DataSet()
    try:
        cnn = OleDbConnection(connectionString)
        cnn.Open()
        adapter = OleDbDataAdapter("Select * from [MicrosoftStock$]", cnn)
        adapter.Fill(ds)
    except OleDbException as ex:
        print ex.InnerException
    finally:
        if cnn != None:
            cnn.Close()
    return ds.Tables[0]

seriesTable = LoadTimeSeriesData()
timeSeries = TimeSeriesCollection(seriesTable)

open = timeSeries["Open"]
close = timeSeries["Close"]
high = timeSeries["High"]
low = timeSeries["Low"]
volume = timeSeries["Volume"]

#
# Arithmetic operations
#

# The NumericalVariable class defines the standard
# arithmetic operators. Operands can be either
# numerical variables or constants.

# The Typical Price (TP) is the average of the day's high, low and close:
TP = (high + low + close) / 3

# Exponentiation is available through the Power method:
inverseVolume = NumericalVariable.Power(volume, -1)
            

#
# Simple transformations
#

# The Transforms property of a numerical variable gives access
# to a large number of transformations.

# The GetLag method returns a variable whose observations 
# are moved ahead by the specified amount:
close1 = close.Transforms.GetLag(1)
# You can get cumulative sums and products:
cumVolume = volume.Transforms.GetCumulativeSum()

#
# Indicators of change
#

# You can get the absolute change, percent change, # or (exponential) growth rate of a variable. The optional
# parameter is the number of periods to go back.
# The default is 1.
closeChange = close.Transforms.GetChange(10)
            
# You can extrapolate the change to a longer number of periods.
# The additional argument is the number of large periods.
monthyChange = close.Transforms.GetExtrapolatedChange(10, 20)

#
# Moving averages
#

# You can get simple, exponential, and weighted moving averages.
MA20 = close.Transforms.GetMovingAverage(20)

# Weighted moving averages can use either a fixed array or vector
# to specify the weight. The weights are automatically normalized.
weights = Vector([ 1.0, 2.0, 3.0 ])
WMA3 = close.Transforms.GetWeightedMovingAverage(weights)
# You can also specify another variable for the weights.
# In this case, the corresponding observations are used.
# For example, to obtain the volume weighted average
# of the close price over a 14 day period, you can write:
VWA14 = close.Transforms.GetWeightedMovingAverage(14, volume)

# Other statistics, such as maximum, minimum and standard 
# deviation are also available.

#
# Misc. transforms
#

# The Box-Cox transform is often used to reduce the effects
# of non-normality of a variable. It takes one parameter, # which must be between 0 and 1.
bcVolume = volume.Transforms.GetBoxCoxTransform(0.4)

#
# Creating more complicated indicators
#

# All these transformations can be combined to create
# more compicated transformations. We give some examples
# of common Technical Analysis indicators.

# The Accumulation Distribution is a leading indicator of price movements.
# It is used in many other indicators.
# The formula uses only arithmetic operations:
AD = (close - open) / (high - low) * volume

# The Chaikin oscillator is used to monitor the flow of money into
# and out of a market.  It is the difference between a 3 day and a 10 day
# moving average of the Accumulation Distribution.
# We use the GetExponentialMovingAverage method for this purpose.
CO = AD.Transforms.GetExponentialMovingAverage(3) \
    - AD.Transforms.GetExponentialMovingAverage(10)

# Bollinger bands provide an envelope around the price that indicates
# whether the current price level is relatively high or low.
# It uses a 20 day simple average as a central line:
TPMA20 = TP.Transforms.GetMovingAverage(20)
# The actual bands are at 2 standard deviations (over the same period)
# from the central line. We have to pass the moving average
# over the same period as the second parameter.
SD20 = TP.Transforms.GetMovingStandardDeviation(20, TPMA20)
BOLU = MA20 + 2*SD20
BOLD = MA20 - 2*SD20

# The Relative Strength Index is an index that compares 
# the average price gain to the average loss.
# The GetPositiveToNegativeIndex method performs this
# calculation in one operation. The first argument is the period.
# The second argument is the variable that determines
# if an observation counts towards the plus or the minus side.
change = close.Transforms.GetChange(1)
RSI = change.Transforms.GetPositiveToNegativeIndex(14, change)

# Finally, let's print some of our results:
index = timeSeries.GetRowIndex(DateTime(2002, 9, 17))
print "Data for September 17, 2002:"
print "Accumulation Distribution (in millions): {0:.2f}".format(AD[index] / 1000000)
print "Chaikin Oscillator (in millions): {0:.2f}".format(CO[index] / 1000000)
print "Bollinger Band (Upper): {0:.2f}".format(BOLU[index])
print "Bollinger Band (Central): {0:.2f}".format(TPMA20[index])
print "Bollinger Band (Lower): {0:.2f}".format(BOLD[index])
print "Relative Strength Index: {0:.2f}".format(RSI[index])

```