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 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 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 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; }