public ReferencingVectorParameterExpression(T scalarValue, ParameterType parameterType, int index)
: base(GetType <T>(), parameterType, index)
{
Array = null;
ScalarValue = scalarValue;
IsScalar = true;
}
private static Tuple <int, string[]> FormatColumn <T>(NArray <T> nArray, int column, int height, int upper, int lower, bool withEllipsis, string ellipsis, Func <T, string> formatValue)
{
var storage = nArray.Storage as ManagedStorage <T>;
var c = new string[height];
int index = 0;
for (var row = 0; row < upper; row++)
{
c[index++] = formatValue(storage[row, column]);
}
if (withEllipsis)
{
c[index++] = "";
}
for (var row = nArray.RowCount - lower; row < nArray.RowCount; row++)
{
c[index++] = formatValue(storage[row, column]);
}
int w = c.Max(x => x.Length);
if (withEllipsis)
{
c[upper] = ellipsis;
}
return(new Tuple <int, string[]>(w, c));
}
public void CheckExponentialPerformance()
{
IntelMathKernelLibrary.SetSequential();
var location = StorageLocation.Host;
using (var randomStream = new RandomNumberStream(location, RandomNumberGeneratorType.MRG32K3A, 111))
{
var normalDistribution = new Normal(randomStream, 0, 1);
var a = new NArray(location, 5000);
var b = new NArray(location, 5000);
a.FillRandom(normalDistribution);
var aArray = GetArray(a);
var bArray = GetArray(b);
var watch = new Stopwatch(); watch.Start();
for (int i = 0; i < 1000; ++i)
{
IntelMathKernelLibrary.Exp(aArray, 0, bArray, 0, 5000);
}
var baseline = watch.ElapsedMilliseconds;
Console.WriteLine("5 millions in place Exps");
Console.WriteLine(baseline);
}
}
public static void CalculateTasks(SimulationGraph graph, List <IPricer> pricers, List <NArray> derivatives = null)
{
var simulationCount = graph.Context.Settings.SimulationCount;
var timePointCount = graph.Context.Settings.SimulationTimePoints.Length;
if (derivatives == null)
{
derivatives = new List <NArray>();
}
var tasks = new List <Task>();
foreach (var partition in Partitioner(pricers.Count))
{
var resultsStorage = new CalculationResult(simulationCount, timePointCount, derivatives.Count);
tasks.Add(Task.Run(() =>
{
for (int i = 0; i < timePointCount; ++i)
{
foreach (var index in partition)
{
NArray.Evaluate(() =>
{
NArray pv;
pricers[index].Price(i, out pv);
return(pv);
},
derivatives, Aggregator.ElementwiseAdd, resultsStorage.GetStorageForTimePoint(i));
}
}
}));
}
Task.WaitAll(tasks.ToArray());
}
public override NArray Step(TimeInterval timeStep, NArray previous)
{
var t = timeStep.IntervalInYears;
return(previous * NMath.Exp(-Lambda * t)
+ NMath.Sqrt(E(2.0 * Lambda, t)) * _normalVariates.Value);
}
public void VectorBinarySearch()
{
var factory = new NArrayFactory(StorageLocation.Host);
int length = 30000;
int knotPointsLength = 100;
var valuesArray = Enumerable.Range(0, length).Select(i => (double)i / length + 0.5).ToArray();
var values = factory.CreateFromEnumerable(valuesArray);
var xArray = Enumerable.Range(0, knotPointsLength).Select(i => (double)i / knotPointsLength).ToArray();
var yArray = Enumerable.Range(0, knotPointsLength).Select(i => 5 + (double)i / knotPointsLength).ToArray();
NArray x = factory.CreateFromEnumerable(xArray);
NArray y = factory.CreateFromEnumerable(yArray);
var watch = new Stopwatch(); watch.Start();
for (int i = 0; i < 50000; ++i)
{
BinarySearch(xArray, yArray, valuesArray);
}
Console.WriteLine("Baseline sequential");
Console.WriteLine(watch.ElapsedMilliseconds); watch.Restart();
for (int i = 0; i < 100; ++i)
{
var left = NArrayFactory.CreateConstantLike(values, 0);
var right = NArrayFactory.CreateConstantLike(values, x.Length - 1);
var mid = (left + right) >> 1;
//// we are going to stop when right - left = 1
//// for the vector version, we cannot allow the break condition to be different for different
//// vector elements
int elements = (x.Length - 1) << 1;
while (elements > 1)
{
var active = (right - left) > 1;
var midValue = x[mid];
right[midValue >= values && active] = mid;
// or alternate form:
//right.Assign(
// () => midValue >= values && active,
// () => mid);
// A conditional in a CUDA kernel would cause the evaluation of both branches
// But we can be more efficient on CPU (e.g. mask vector indexing)
left[midValue < values && active] = mid;
mid = left + right >> 1;
elements = elements >> 1;
}
}
Console.WriteLine("Vector sequential");
Console.WriteLine(watch.ElapsedMilliseconds); watch.Restart();
//check!
//(right - left).DebugDataView.ToArray()
}
public void SimpleSpeedTest()
{
using (var randomStream = new RandomNumberStream(StorageLocation.Host, RandomNumberGeneratorType.MRG32K3A, 111))
{
var normalDistribution = new Normal(randomStream, 0, 1);
var variates = NArray.CreateRandom(5000, normalDistribution);
var variatesArray = GetArray(variates);
var variates2 = NArray.CreateRandom(5000, normalDistribution);
var variatesArray2 = GetArray(variates);
var target = NArray.CreateRandom(5000, normalDistribution);
var targetArray = GetArray(target);
TestHelpers.Timeit(() =>
{
for (int i = 0; i < 1000; ++i)
{
//IntelMathKernelLibrary.Multiply(variatesArray, 0, variatesArray2, 0, targetArray, 0, 5000);
//IntelMathKernelLibrary.Exp(variatesArray, 0, targetArray, 0, variatesArray.Length);
IntelMathKernelLibrary.ConstantAddMultiply(variatesArray, 0, 5, 0, targetArray, 0, 5000);
}
});
}
}
private NArray Value(Normal normalDistribution)
{
double deltaT = 1;
double r = 0.1;
double vol = 0.3;
int vectorLength = 5000;
var optionPrices = new NArray(StorageLocation.Host, vectorLength);
var variates = NArray.CreateRandom(optionPrices.Length, normalDistribution);
var logStockPrice = Math.Log(100)
+ variates * Math.Sqrt(deltaT) * vol + (r - 0.5 * vol * vol) * deltaT;
var forwardStockPrices = NMath.Exp(logStockPrice + r * deltaT);
// now create deals
var strikes = Enumerable.Range(0, 1000).Select(i => 80 + 5.0 / 1000).ToArray();
var deals = strikes.Select(s =>
new Deal()
{
Strike = s, ForwardStockPrices = (i) => { return(forwardStockPrices); }
})
.ToList();
return(AggregateValuations(deals, vectorLength));
}
public void CheckExponentialPerformance()
{
IntelMathKernelLibrary.SetSequential();
var location = StorageLocation.Host;
using (var randomStream = new RandomNumberStream(location, RandomNumberGeneratorType.MRG32K3A, 111))
{
var normalDistribution = new Normal(randomStream, 0, 1);
var a = new NArray(location, 5000);
var b = new NArray(location, 5000);
a.FillRandom(normalDistribution);
var aArray = GetArray(a);
var bArray = GetArray(b);
var watch = new Stopwatch(); watch.Start();
for (int i = 0; i < 1000; ++i)
{
IntelMathKernelLibrary.Exp(aArray, 0, bArray, 0, 5000);
}
var baseline = watch.ElapsedMilliseconds;
Console.WriteLine("5 millions in place Exps");
Console.WriteLine(baseline);
}
}
public override void Assign <T>(NArray <T> a, NArrayBool condition, NArray <T> result)
{
T[] aArray, resultArray;
bool[] cArray;
int aStart, cStart, resultStart;
GetArray(a, out aArray, out aStart);
GetArray(condition, out cArray, out cStart);
GetArray(result, out resultArray, out resultStart);
if (a.IsScalar)
{
for (int i = 0; i < result.Length; ++i)
{
if (cArray[cStart + i])
{
resultArray[resultStart + i] = aArray[aStart];
}
}
}
else
{
for (int i = 0; i < result.Length; ++i)
{
if (cArray[cStart + i])
{
resultArray[resultStart + i] = aArray[aStart + i];
}
}
}
}
public VectorParameterExpression GetParameter <T>(NArray <T> array)
{
var local = array as ILocalNArray;
if (local != null)
{
return(_localParameters[local.Index] as VectorParameterExpression);
}
else
{
// if the array is a scalar and not an independent variable of any derivative calculation, we do not care where it came from; do not
// add to argument list
if (array.IsScalar && !IsIndependentVariable(array))
{
return(new ConstantExpression <T>(array.First()));
}
VectorParameterExpression argument;
// is this fast enough?
if (!_argumentLookup.TryGetValue(array, out argument))
{
argument = array.IsScalar ? new ReferencingVectorParameterExpression <T>(array.First(), ParameterType.Argument, _argumentLookup.Count)
: new ReferencingVectorParameterExpression <T>(array, ParameterType.Argument, _argumentLookup.Count);
_argumentLookup.Add(array, argument);
}
return(argument);
}
}
public void BlackScholes()
{
NArray s;
using (var stream = new RandomNumberStream(StorageLocation.Host, RandomNumberGeneratorType.MRG32K3A))
{
var normal = new Normal(stream, 0, 1);
s = 100 * NMath.Exp(NArray.CreateRandom(5, normal) * 0.2);
}
double k = 90;
var volatility = 0.2;
var t = 5;
var df = Math.Exp(-0.005 * t);
var result = NArray.Evaluate(() =>
{
var f = s / df;
return(df * Finance.BlackScholes(CallPut.Call, f, k, volatility, t));
}, s);
var sds = s + 1e-6;
var check = (df * Finance.BlackScholes(CallPut.Call, sds / df, k, volatility, t)
- df * Finance.BlackScholes(CallPut.Call, s / df, k, volatility, t)) * 1e6;
Assert.IsTrue(TestHelpers.AgreesAbsolute(result[1], check));
}
public void TestRandomNumberGeneration()
{
var location = StorageLocation.Host;
// We create the stream.
// This identifies the stream and stores the state or pointer to the state (in the case
// of IntelMKL, CUDA, etc).
using (var randomStream = new RandomNumberStream(location, RandomNumberGeneratorType.MRG32K3A, 111))
{
// We then create a distribution based on the stream.
// This stores only specific parameters of the distribution (i.e. mean and standard deviation).
// The purpose of the design is to push scaling and offsetting of random numbers to the Provider,
// which can do this efficiently whilst generating.
var normal = new Normal(randomStream, 0, 1);
var a = new NArray(location, 1000);
var b = new NArray(location, 1000);
// When we call FillRandom, we need to use a Provider that is appropriate to the stream.
a.FillRandom(normal);
b.FillRandom(normal);
var v = a * b;
}
}
public void FillRandom(NArray values)
{
NMath.MatrixMultiply(_weights, _uncorrelatedVariates, _correlatedGaussianVariates);
// extract a vector and interpolate
//var vector = _correlatedGaussianVariates.
}
public void WorkedExample()
{
NArray x0, x1;
using (var stream = new RandomNumberStream(StorageLocation.Host, RandomNumberGeneratorType.MRG32K3A))
{
var normal = new Normal(stream, 0, 1);
x0 = NArray.CreateRandom(5000, normal);
x1 = NArray.CreateRandom(5000, normal);
}
var result = NArray.Evaluate(() =>
{
return(x0 * x1 + x0 * NMath.Exp(2 * x1));
}, x0, x1);
var derivativeWRTx0 = result[1];
var derivativeWRTx1 = result[2];
Assert.IsTrue(TestHelpers.AgreesAbsolute(derivativeWRTx0, x1 + NMath.Exp(2 * x1)));
Assert.IsTrue(TestHelpers.AgreesAbsolute(derivativeWRTx1, x0 + 2 * x0 * NMath.Exp(2 * x1)));
// can also call in such a way that the expression list is appended to a StringBuilder:
var logger = new StringBuilder();
var loggedResult = NArray.Evaluate(() =>
{
return(x0 * x1 + x0 * NMath.Exp(2 * x1));
}, logger, x0, x1);
Console.WriteLine(logger.ToString());
}
public static IList<NArray> Evaluate(Func<NArray> function, IList<NArray> independentVariables, StringBuilder expressionsOut = null,
Aggregator aggregator = Aggregator.ElementwiseAdd, IList<NArray> existingStorage = null, VectorExecutionOptions vectorOptions = null)
{
if (existingStorage != null && existingStorage.Count != independentVariables.Count + 1)
throw new ArgumentException(string.Format("storage provided does not match requirement for 1 result and {0} derivatives",
independentVariables.Count));
var timer = new ExecutionTimer();
timer.Start();
NArray[] outputs = new NArray[independentVariables.Count + 1];
var context = new DeferredExecutionContext(new VectorExecutionOptions(), independentVariables);
NArray dependentVariable;
try
{
// execute function as deferred operations and obtain reference to the dependentVariable
dependentVariable = function();
}
finally
{
context.Finish();
}
timer.MarkFunctionComplete();
for (int i = 0; i < outputs.Length; ++i)
{
// if new storage is required, we create scalars in the first instance
outputs[i] = (existingStorage == null) ? NArray.CreateScalar(0) : existingStorage[i];
}
context._executor.Evaluate(context._options, outputs, dependentVariable, independentVariables,
timer, expressionsOut, aggregator);
//Console.WriteLine(timer.Report());
return outputs;
}
private void DoWorkDeferred(NArray a, Normal normalDistribution, bool threaded = false)
{
// A version where assignment happens, but we defer execution.
var result = NArray.CreateLike(a);
result.Assign(a);
var result2 = NArray.CreateLike(a);
//var options = new DeferredExecution.VectorExecutionOptions() { MultipleThreads = threaded };
for (int j = 0; j < 100; ++j)
{
NArray.Evaluate(() =>
{
return(NMath.Log(NMath.Exp(result)));
}, new List <NArray>(), Aggregator.ElementwiseAdd, new List <NArray> {
result2
});
//using (NArray.DeferredExecution(options))
//{
// var temp = NMath.Exp(result);
// result.Assign(NMath.Log(temp));
//}
}
}
public void AddScaleOffsetOperation <T>(NArray <T> a, T scale, T offset, NArray <T> result)
{
_operations.Add(
Expression.Assign(GetParameter <T>(result),
ExpressionExtended.ScaleOffset <T>(GetParameter <T>(a), scale, offset))
);
}
public void AddScaleInverseOperation <T>(NArray <T> a, T scale, NArray <T> result)
{
_operations.Add(
Expression.Assign(GetParameter <T>(result),
ExpressionExtended.ScaleInverse <T>(GetParameter <T>(a), scale))
);
}
public void TestRandomNumberGeneration()
{
var location = StorageLocation.Host;
// We create the stream.
// This identifies the stream and stores the state or pointer to the state (in the case
// of IntelMKL, CUDA, etc).
using (var randomStream = new RandomNumberStream(location, RandomNumberGeneratorType.MRG32K3A, 111))
{
// We then create a distribution based on the stream.
// This stores only specific parameters of the distribution (i.e. mean and standard deviation).
// The purpose of the design is to push scaling and offsetting of random numbers to the Provider,
// which can do this efficiently whilst generating.
var normal = new Normal(randomStream, 0, 1);
var a = new NArray(location, 1000);
var b = new NArray(location, 1000);
// When we call FillRandom, we need to use a Provider that is appropriate to the stream.
a.FillRandom(normal);
b.FillRandom(normal);
var v = a * b;
}
}
public override void UnaryElementWiseOperation(NArray <double> a,
NArray <double> result, UnaryElementWiseOperation operation)
{
if (operation == VectorAccelerator.UnaryElementWiseOperation.Negate)
{
ScaleOffset(a, -1, 0, result);
return;
}
VectorOperation vectorVectorOperation = null;
switch (operation)
{
case VectorAccelerator.UnaryElementWiseOperation.CumulativeNormal: vectorVectorOperation = IntelMathKernelLibrary.CumulativeNormal; break;
case VectorAccelerator.UnaryElementWiseOperation.Exp: vectorVectorOperation = IntelMathKernelLibrary.Exp; break;
case VectorAccelerator.UnaryElementWiseOperation.InverseCumulativeNormal: vectorVectorOperation = IntelMathKernelLibrary.InverseCumulativeNormal; break;
case VectorAccelerator.UnaryElementWiseOperation.InverseSquareRoot: vectorVectorOperation = IntelMathKernelLibrary.InverseSquareRoot; break;
case VectorAccelerator.UnaryElementWiseOperation.Inverse: vectorVectorOperation = IntelMathKernelLibrary.Inverse; break;
case VectorAccelerator.UnaryElementWiseOperation.Log: vectorVectorOperation = IntelMathKernelLibrary.Log; break;
case VectorAccelerator.UnaryElementWiseOperation.SquareRoot: vectorVectorOperation = IntelMathKernelLibrary.SquareRoot; break;
}
VectorOperation(a, result, vectorVectorOperation);
}
public override void BinaryElementWiseOperation(NArray <int> a, NArray <int> b,
NArray <int> result, ExpressionType operation)
{
int[] aArray, bArray, resultArray;
int aStart, bStart, resultStart;
GetArray(a, out aArray, out aStart);
GetArray(b, out bArray, out bStart);
GetArray(result, out resultArray, out resultStart);
if (operation == ExpressionType.Add)
{
for (int i = 0; i < result.Length; ++i)
{
resultArray[resultStart + i] = aArray[aStart + i] + bArray[bStart + i];
}
}
else if (operation == ExpressionType.Subtract)
{
for (int i = 0; i < result.Length; ++i)
{
resultArray[resultStart + i] = aArray[aStart + i] - bArray[bStart + i];
}
}
}
public void TestPerformance()
{
LinearGaussianModel model;
IEnumerable <NArray> allDiscountFactorT0;
TimePoint[] timePoints;
SimulationGraph graph;
List <IPricer> pricers;
SimulateModel(out model, out allDiscountFactorT0, out timePoints, out graph, out pricers);
var resultStorage = Enumerable.Range(0, 1 + allDiscountFactorT0.Count()).
Select(i => new NArray(StorageLocation.Host, 5000, 1)).ToArray();
Console.WriteLine(); Console.WriteLine("Deferred execution all derivatives, storage provided");
VectorAccelerator.Tests.TestHelpers.Timeit(() =>
{
NArray.Evaluate(() =>
{
var df = model[10, timePoints[10].DateTime.AddMonths(3)];
return(df);
},
allDiscountFactorT0.ToArray(), Aggregator.ElementwiseAdd, resultStorage);
}, 10, 10);
}
public void FillRandom(NArray values)
{
NMath.MatrixMultiply(_weights, _uncorrelatedVariates, _correlatedGaussianVariates);
// extract a vector and interpolate
//var vector = _correlatedGaussianVariates.
}
public void AddUnaryElementWiseOperation <T>(NArray <T> a,
NArray <T> result, UnaryElementWiseOperation operation)
{
_operations.Add(
Expression.Assign(GetParameter <T>(result),
ExpressionExtended.MakeUnary(operation, GetParameter <T>(a)))
);
}
public static NArray CorrelationMatrixToWeights(NArray correlationMatrix)
{
var nearestCorrelationMatrix = NearestCorrelationMatrix(correlationMatrix);
var cholesky = NMath.CholeskyDecomposition(nearestCorrelationMatrix);
// the weights are simply the Cholesky decomposition
return(cholesky);
}
/// <summary>
/// Returns a string that summarizes the content of this matrix.
/// </summary>
public static string ToMatrixString <T>(NArray <T> array, string format = null, IFormatProvider provider = null) where T : IFormattable
{
if (format == null)
{
format = "G6";
}
return(ToMatrixString(array, 8, 4, 5, 2, 76, "..", "..", "..", " ", Environment.NewLine, x => x.ToString(format, provider)));
}
public static string ToMatrixString <T>(NArray <T> array, int upperRows, int lowerRows, int minLeftColumns, int rightColumns, int maxWidth,
string horizontalEllipsis, string verticalEllipsis, string diagonalEllipsis,
string columnSeparator, string rowSeparator, Func <T, string> formatValue)
{
return(FormatStringArrayToString(
ToMatrixStringArray(array, upperRows, lowerRows, minLeftColumns, rightColumns, maxWidth, columnSeparator.Length, horizontalEllipsis, verticalEllipsis, diagonalEllipsis, formatValue),
columnSeparator, rowSeparator));
}
private void VectorOperation(NArray <double> a, NArray <double> result, VectorOperation operation)
{
double[] aArray, resultArray;
int aStart, resultStart;
GetArray(a, out aArray, out aStart);
GetArray(result, out resultArray, out resultStart);
operation(aArray, aStart, resultArray, resultStart, result.Length);
}
public override void ScaleOffset(NArray <double> a, double scale, double offset, NArray <double> result)
{
double[] aArray, resultArray;
int aStart, resultStart;
GetArray(a, out aArray, out aStart);
GetArray(result, out resultArray, out resultStart);
IntelMathKernelLibrary.ConstantAddMultiply(aArray, aStart, scale, offset, resultArray, resultStart, result.Length);
}
public override void Initialise(SimulationGraph graph)
{
base.Initialise(graph);
_state = new NArray[graph.Context.Settings.SimulationTimePoints.Length];
_weinerPaths = GetFactorIdentifiers().Select(id =>
graph.RegisterModel <WienerPathModel>(id))
.ToArray();
}
public static void BlackScholesD1D2Parameters(NArray forward, double strike, NArray volatility,
double deltaTime, out NArray d1, out NArray d2)
{
var volMultSqrtDTime = volatility * Math.Sqrt(deltaTime);
d1 = (NMath.Log(forward / strike) + (0.5 * volatility * volatility * deltaTime))
/ volMultSqrtDTime;
d2 = d1 - volMultSqrtDTime;
}
public void Price(int timeIndex, out NArray pv)
{
if (_timePoints[timeIndex] > _deal.EndDate)
{
pv = 0; return;
}
var coverage = (_deal.EndDate - _deal.StartDate).TotalDays / 365.25;
pv = _deal.Notional * _deal.Rate * coverage * _df[timeIndex, _deal.EndDate];
}
public override void ScaleInverse(NArray <double> a, double scale, NArray <double> result)
{
double[] aArray, resultArray;
int aStart, resultStart;
GetArray(a, out aArray, out aStart);
GetArray(result, out resultArray, out resultStart);
VectorOperation(a, result, IntelMathKernelLibrary.Inverse);
IntelMathKernelLibrary.ConstantAddMultiply(resultArray, resultStart, scale, 0, resultArray, resultStart, result.Length);
}
public override void RelativeOperation(NArray <int> a, NArray <int> b, NArrayBool result, RelativeOperator op)
{
int[] aArray, bArray;
bool[] resultArray;
int aStart, bStart, resultStart;
GetArray(a, out aArray, out aStart);
GetArray(b, out bArray, out bStart);
GetArray(result, out resultArray, out resultStart);
switch (op)
{
case RelativeOperator.LessThan:
for (int i = 0; i < resultArray.Length; ++i)
{
resultArray[resultStart + i] = aArray[aStart + i] < bArray[bStart + i];
}
break;
case RelativeOperator.LessThanEquals:
for (int i = 0; i < resultArray.Length; ++i)
{
resultArray[resultStart + i] = aArray[aStart + i] <= bArray[bStart + i];
}
break;
case RelativeOperator.Equals:
for (int i = 0; i < resultArray.Length; ++i)
{
resultArray[resultStart + i] = aArray[aStart + i] == bArray[bStart + i];
}
break;
case RelativeOperator.NotEquals:
for (int i = 0; i < resultArray.Length; ++i)
{
resultArray[resultStart + i] = aArray[aStart + i] != bArray[bStart + i];
}
break;
case RelativeOperator.GreaterThanEquals:
for (int i = 0; i < resultArray.Length; ++i)
{
resultArray[resultStart + i] = aArray[aStart + i] >= bArray[bStart + i];
}
break;
case RelativeOperator.GreaterThan:
for (int i = 0; i < resultArray.Length; ++i)
{
resultArray[resultStart + i] = aArray[aStart + i] > bArray[bStart + i];
}
break;
}
}
public static NArray BlackScholes(double callPutFactor, NArray forward, double strike,
NArray volatility, double deltaTime)
{
NArray d1, d2;
if (deltaTime == 0) return callPutFactor * (forward - strike);
BlackScholesD1D2Parameters(forward, strike, volatility, deltaTime, out d1, out d2);
var nd1 = NMath.CumulativeNormal(callPutFactor * d1);
var nd2 = NMath.CumulativeNormal(callPutFactor * d2);
return callPutFactor * (forward * nd1 - strike * nd2);
}
public NArray BinaryExpression(NArray operand1, NArray operand2,
Func<Expression, Expression, BinaryExpression> operation)
{
CheckNArrays(operand1, operand2);
NArray result;
ParameterExpression parameterExpression;
NewLocal(out result, out parameterExpression);
Expression arg1, arg2;
arg1 = (operand1.IsScalar) ? (Expression)GetConstant(operand1.First()) : (Expression)GetNArray(operand1);
arg2 = (operand2.IsScalar) ? (Expression)GetConstant(operand2.First()) : (Expression)GetNArray(operand2);
_expressions.Add(
Expression.Assign(parameterExpression,
operation(arg1, arg2)
));
return result;
}
public void CreateInputs()
{
var location = StorageLocation.Host;
using (var randomStream = new RandomNumberStream(location, RandomNumberGeneratorType.MRG32K3A, 111))
{
var normalDistribution = new Normal(randomStream, 0, 1);
_a = new NArray(location, 5000);
_a.FillRandom(normalDistribution);
_a_array = GetArray(_a);
_b = new NArray(location, 5000);
_b.FillRandom(normalDistribution);
_b_array = GetArray(_b);
_c = new NArray(location, 5000);
_c.FillRandom(normalDistribution);
_c_array = GetArray(_c);
}
}
public override IObject Construct(IEnvironment environment, IArgs args)
{
var array = new NArray(Environment);
array.Initialize();
if (args.Count != 1)
{
// 15.4.2.1 new Array ( [ item0 [ , item1 [ , … ] ] ] )
array.DefineOwnProperty("length", Environment.CreateDataDescriptor(Environment.CreateNumber(args.Count), true, false, false), false);
for (int i = 0; i < args.Count; i++)
{
array.DefineOwnProperty(i.ToString(), Environment.CreateDataDescriptor(args[i], true, true, true), false);
}
}
else
{
// 15.4.2.2 new Array (len)
var arg0 = args[0];
if (arg0.TypeCode != LanguageTypeCode.Number)
{
array.DefineOwnProperty("length", Environment.CreateDataDescriptor(Environment.CreateNumber(1.0), true, false, false), false);
array.DefineOwnProperty("0", Environment.CreateDataDescriptor(arg0, true, true, true), false);
}
else
{
var len = ((INumber)arg0).BaseValue;
var uint32 = arg0.ConvertToUInt32().BaseValue;
if (len != uint32)
{
throw Environment.CreateRangeError("The supplied length " + len + " does not fall into the unsigned 32-bit integer range.");
}
array.DefineOwnProperty("length", Environment.CreateDataDescriptor(arg0, true, false, false), false);
}
}
return array;
}
public void OptionPricingTest()
{
var location = StorageLocation.Host;
var a = new NArray(location, Enumerable.Range(0, 10).Select(i => (double)i).ToArray());
var b = new NArray(location, Enumerable.Range(0, 10).Select(i => (double)i * 2).ToArray());
var c = 5 - b;
var check = c.First();
IntelMathKernelLibrary.SetAccuracyMode(VMLAccuracy.LowAccuracy);
IntelMathKernelLibrary.SetSequential();
using (var randomStream = new RandomNumberStream(location, RandomNumberGeneratorType.MRG32K3A, 111))
{
var normalDistribution = new Normal(randomStream, 0, 1);
var vectorOptions = new VectorExecutionOptions() { MultipleThreads = true };
var watch = new Stopwatch();
watch.Start();
var optionPrices = Value(normalDistribution);
Console.WriteLine(String.Format("Start-up: {0}ms", watch.ElapsedMilliseconds));
randomStream.Reset();
watch.Restart();
optionPrices = Value(normalDistribution);
Console.WriteLine(String.Format("Threaded, deferred 1: {0}ms", watch.ElapsedMilliseconds));
randomStream.Reset();
watch.Restart();
var optionPricesDeferred = Value(normalDistribution);
Console.WriteLine(String.Format("Threaded, deferred 2: {0}ms", watch.ElapsedMilliseconds)); watch.Restart();
Console.WriteLine(TestHelpers.AgreesAbsoluteString(optionPrices, optionPricesDeferred));
}
}
public static NArray Multiply(NArray a, NArray b)
{
return a * b;
}
public NArray UnaryExpression(NArray operand, Func<Expression, UnaryExpression> operation)
{
CheckNArrays(operand);
NArray result;
ParameterExpression parameterExpression;
NewLocal(out result, out parameterExpression);
_expressions.Add(
Expression.Assign(parameterExpression,
operation(GetNArray(operand))
));
return result;
}
private NArray CalculateSyntheticReturns(NArray correlationMatrix, int returnsCount)
{
var location = StorageLocation.Host;
var cholesky = NMath.CholeskyDecomposition(correlationMatrix);
var variates = new NArray(location, returnsCount, correlationMatrix.RowCount);
using (var stream = new RandomNumberStream(location))
{
var normal = new Normal(stream, 0, 1);
variates.FillRandom(normal);
}
return variates * cholesky.Transpose();
}
private void NewLocal(out NArray newLocal, out ParameterExpression newLocalExpression)
{
newLocal = new LocalNArray(_localVariables.Count, _vectorsLength);
newLocalExpression = Expression.Parameter(typeof(double), "local" + _localVariables.Count);
_localVariables.Add(newLocalExpression);
}
private ParameterExpression GetNArray(NArray NArray)
{
if (NArray is LocalNArray) // this is a local variable
{
return _localVariables[(NArray as LocalNArray).Index];
}
else
{
ParameterExpression expression;
if (!_parameters.TryGetValue(NArray, out expression))
{
var newParameterExpression = Expression.Parameter(typeof(double), "parameter" + _parameters.Count);
_parameters.Add(NArray, newParameterExpression);
}
return _parameters[NArray];
}
}
public void Assign(NArray operand1, NArray operand2)
{
_expressions.Add(
Expression.Assign(GetNArray(operand1), GetNArray(operand2))
);
}
public static NArray BlackScholes(CallPut callPutFactor, NArray forward, double strike,
NArray volatility, double deltaTime)
{
return BlackScholes(callPutFactor == CallPut.Call ? 1 : -1, forward, strike, volatility, deltaTime);
}
public static bool AgreesAbsolute(NArray first, NArray second)
{
return AgreesAbsolute(first.DebugDataView, second.DebugDataView);
}
public static string AgreesAbsoluteString(NArray first, NArray second)
{
return AgreesAbsoluteString((first.Storage as ManagedStorage<double>).Array,
(second.Storage as ManagedStorage<double>).Array);
}
public NArray MethodCallExpression(NArray operand, MethodInfo method)
{
CheckNArrays(operand);
NArray result;
ParameterExpression parameterExpression;
NewLocal(out result, out parameterExpression);
_expressions.Add(
Expression.Assign(parameterExpression,
Expression.Call(method, GetNArray(operand))
));
return result;
}
public DataPoint(DateTime time, NArray value)
{
Time = time; Value = value;
}
public Curve(DateTime[] times, NArray[] values)
{
if (times.Length != values.Length) throw new ArgumentException("length mismatch");
Data = times.Zip(values, (t, v) => new DataPoint(t, v)).ToArray();
}
private double[] VectorResultViaScalarFunction(NArray a, NArray b, Func<double, double, double> function)
{
var result = new double[Math.Max(a.Length, b.Length)];
var aArray = a.DebugDataView.ToArray();
var bArray = b.DebugDataView.ToArray();
for (int i = 0; i < result.Length; ++i)
{
result[i] = function(aArray.Length == 1 ? aArray[0] : aArray[i],
bArray.Length == 1 ? bArray[0] : bArray[i]);
}
return result;
}
private NArray Value(Normal normalDistribution)
{
double deltaT = 1;
double r = 0.1;
double vol = 0.3;
int vectorLength = 5000;
var optionPrices = new NArray(StorageLocation.Host, vectorLength);
var variates = NArray.CreateRandom(optionPrices.Length, normalDistribution);
var logStockPrice = Math.Log(100)
+ variates * Math.Sqrt(deltaT) * vol + (r - 0.5 * vol * vol) * deltaT;
var forwardStockPrices = NMath.Exp(logStockPrice + r * deltaT);
// now create deals
var strikes = Enumerable.Range(0, 1000).Select(i => 80 + 5.0 / 1000).ToArray();
var deals = strikes.Select(s =>
new Deal() { Strike = s, ForwardStockPrices = (i) => { return forwardStockPrices; } })
.ToList();
return AggregateValuations(deals, vectorLength);
}
public static NArray Add(NArray a, NArray b)
{
return a + b;
}
/// <summary>
/// A very customisable aggregation routine
/// </summary>
/// <param name="deals"></param>
/// <param name="vectorLength"></param>
/// <returns></returns>
private NArray AggregateValuations(IList<Deal> deals, int vectorLength)
{
object lockObject = new object();
var rangePartitioner = Partitioner.Create(0, deals.Count);
var sum = new NArray(StorageLocation.Host, vectorLength);
var options = new ParallelOptions();// { MaxDegreeOfParallelism = 2 };
Parallel.ForEach(
// input intervals
rangePartitioner,
options,
// local initial partial result
() => new NArray(StorageLocation.Host, vectorLength),
// loop body for each interval
(range, loopState, initialValue) =>
{
var partialSum = initialValue;
for (int i = range.Item1; i < range.Item2; i++)
{
partialSum.Add(
NArray.Evaluate(() =>
{
return deals[i].Price(0);
}));
}
return partialSum;
},
// final step of each local context
(localPartialSum) =>
{
// using a lock to enforce serial access to shared result
lock (lockObject)
{
sum.Add(localPartialSum);
}
});
return sum;
}
public static NArray Divide(NArray a, NArray b)
{
return a / b;
}
private double[] GetArray(NArray a)
{
return (a.Storage as ManagedStorage<double>).Array;
}
public static NArray Subtract(NArray a, NArray b)
{
return a - b;
}
public NArray LeftSegmentIndex(NArray t)
{
return null;
}
