public float[] RandN(float mean, float std_dev, int count)
{
if ((std_dev < 0) || (count <= 0)) //check std_dev and count
{
return(null);
}
//prepare request
SMemIPCData msg_data = new SMemIPCData();
msg_data.messageType = 2;
msg_data.messageValue = "RANDN";
msg_data.N = 1;
msg_data.parameters = new List <List <ResultStruct> >(3);
for (int i = 0; i < 3; i++)
{
msg_data.parameters.Add(new List <ResultStruct>());
}
ResultStruct rs_temp = new ResultStruct();
//mean
rs_temp.Cols = 1;
rs_temp.Rows = 1;
rs_temp.Type = ResultEnum.Unit | ResultEnum.Float;
rs_temp.Value = mean;
msg_data.parameters[0].Add(rs_temp);
//std dev
rs_temp.Cols = 1;
rs_temp.Rows = 1;
rs_temp.Type = ResultEnum.Unit | ResultEnum.Float;
rs_temp.Value = std_dev;
msg_data.parameters[1].Add(rs_temp);
//count
rs_temp.Cols = 1;
rs_temp.Rows = 1;
rs_temp.Type = ResultEnum.Unit | ResultEnum.Float;
rs_temp.Value = (float)count;
msg_data.parameters[2].Add(rs_temp);
SMemIPCData response = Globals.ThisAddIn.smem_ipc.SendMessage(msg_data);
if (response.messageType == 3)
{
return(response.Results[0].Value as float[]);
}
else
{
return(null);
}
}
public float[] PowerTransform(float[] data, float lambda)
{
//check that all the data is > 0
for (int i = 0; i < data.Length; i++)
{
if (data[i] <= 0)
{
//send error
return(null);
}
}
//send request
SMemIPCData msg_data = new SMemIPCData();
msg_data.messageType = 2;
msg_data.messageValue = "POWER-TRANSFORM";
msg_data.N = 1;
msg_data.parameters = new List <List <ResultStruct> >(2);
msg_data.parameters[0] = new List <ResultStruct>();
msg_data.parameters[1] = new List <ResultStruct>();
ResultStruct rs_temp = new ResultStruct();
//data
rs_temp.Cols = 1;
rs_temp.Rows = data.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = data;
msg_data.parameters[0].Add(rs_temp);
//lambda
rs_temp.Rows = 1;
rs_temp.Type = ResultEnum.Unit | ResultEnum.Float;
rs_temp.Value = lambda;
msg_data.parameters[1].Add(rs_temp);
SMemIPCData response = Globals.ThisAddIn.smem_ipc.SendMessage(msg_data);
if (response.messageType == 3)
{
return(response.Results[0].Value as float[]);
}
else
{
return(null);
}
}
private bool EventWaitHandleThread()
{
message_wait.WaitOne();
//read what's in the shared memory
SMemIPCData data = IPCCodec.Deserialize(phile_stream);
//pass to program for processing
switch (data.messageType)
{
case 2: //compute function
SMemIPCData results = new SMemIPCData();
results.messageType = 3;
//call VBA handler
List <ResultStruct> res_temp = vba_core.ComputeOperator(data.messageValue, data.parameters, data.N, data.num_parameters);
//place results in shared memory
results.Results = res_temp;
IPCCodec.Serialize(phile_stream, results);
//store the result prefix length
phile_prefix_stream.Write(0, phile_stream.Position);
break;
case 4: //store in GPU
break;
case 5: //retrieve from GPU
break;
case 6:
string[] parameters = data.messageValue.Split('|');
Program.HandleFile(parameters[0], parameters[1]);
break;
default:
break;
}
message_handled.Set();
return(false);
}
public SMemIPCData SendMessage(SMemIPCData data_in)
{
try
{
sharedmem_mutex.WaitOne(); //take the mutex
//save message in shared memory
IPCCodec.Serialize(phile_stream, data_in);
//prepare the message prefix
phile_prefix.Write(0, phile_stream.Position);
message_wait.Set(); //signal message ready
message_handled.WaitOne(); //wait for reply ready signal
//copy results from shared memory
long result_size = phile_prefix.ReadInt64(0);
if (result_size > phile_stream.Capacity)
{
//enlarge the view stream if the result is too big
try
{
phile_stream.Close();
phile_stream = phile.CreateViewStream(sizeof(long), result_size);
}
catch
{
throw new SystemException("ijiCore: Result set too large.");
}
}
return(IPCCodec.Deserialize(phile_stream));
}
catch (Exception e)
{
return(null);
}
finally
{
sharedmem_mutex.ReleaseMutex();
}
}
public float[] ArrayRandom(int n)
{
SMemIPCData msg_data = new SMemIPCData();
msg_data.messageType = 2;
msg_data.messageValue = "RANDOM";
msg_data.N = n;
SMemIPCData response = Globals.ThisAddIn.smem_ipc.SendMessage(msg_data);
if (response.messageType == 3)
{
float[] res = new float[response.Results.Count];
Parallel.For(0, response.Results.Count, i =>
{
res[i] = (float)response.Results[i].Value;
});
return(res);
//TODO: mutex needs to handle case where if current client crashes, it must free itself after a certain timeout.
}
else
{
return(null);
}
}
public static SMemIPCData Deserialize(Stream stream_in, long offset = 0)
{
/* Packing format:
* 1 => messageType
* 2 => messageValue
* 3 => N
* 4 => num_parameters
* 5 => parameters
* 6 => results
* */
/* ResultStruct packing format:
* 1 => Cols
* 2 => Rows
* 3 => Type
* 4 => Value
* */
SMemIPCData result = new SMemIPCData();
int subarray_count;
long value_count;
BinaryReader br = new BinaryReader(stream_in);
ResultStruct rs_temp = new ResultStruct();
stream_in.Position = offset;
result.messageType = br.ReadByte();
string temp = br.ReadString();
result.messageValue = temp == string.Empty ? null : temp;
result.N = br.ReadInt32();
result.num_parameters = br.ReadInt32();
//parameters
int par_count = br.ReadInt32();
if (par_count == 0)
{
result.parameters = null;
}
else
{
result.parameters = new List <List <ResultStruct> >(par_count);
for (int i = 0; i < par_count; i++)
{
subarray_count = br.ReadInt32();
result.parameters.Add(new List <ResultStruct>(subarray_count));
for (int j = 0; j < subarray_count; j++)
{
rs_temp.Cols = br.ReadInt32();
rs_temp.Rows = br.ReadInt32();
rs_temp.Type = (ResultEnum)br.ReadByte();
if ((rs_temp.Type & ResultEnum.Unit) == ResultEnum.Unit)
{
if ((rs_temp.Type & ResultEnum.Float) == ResultEnum.Float)
{
rs_temp.Value = br.ReadSingle();
}
else
{
rs_temp.Value = br.ReadString();
}
}
else if ((rs_temp.Type & ResultEnum.Array) == ResultEnum.Array)
{
value_count = br.ReadInt64();
if ((rs_temp.Type & ResultEnum.Float) == ResultEnum.Float)
{
rs_temp.Value = new float[value_count];
for (int k = 0; k < value_count; k++)
{
(rs_temp.Value as float[])[k] = br.ReadSingle();
}
}
else
{
rs_temp.Value = new string[value_count];
for (int k = 0; k < value_count; k++)
{
(rs_temp.Value as string[])[k] = br.ReadString();
}
}
}
result.parameters[i].Add(rs_temp);
}
}
}
//results
par_count = br.ReadInt32();
if (par_count == 0)
{
result.Results = null;
}
else
{
result.Results = new List <ResultStruct>(par_count);
for (int i = 0; i < par_count; i++)
{
rs_temp.Cols = br.ReadInt32();
rs_temp.Rows = br.ReadInt32();
rs_temp.Type = (ResultEnum)br.ReadByte();
if ((rs_temp.Type & ResultEnum.Unit) == ResultEnum.Unit)
{
if ((rs_temp.Type & ResultEnum.Float) == ResultEnum.Float)
{
rs_temp.Value = br.ReadSingle();
}
else
{
rs_temp.Value = br.ReadString();
}
}
else if ((rs_temp.Type & ResultEnum.Array) == ResultEnum.Array)
{
value_count = br.ReadInt64();
if ((rs_temp.Type & ResultEnum.Float) == ResultEnum.Float)
{
rs_temp.Value = new float[value_count];
for (int k = 0; k < value_count; k++)
{
(rs_temp.Value as float[])[k] = br.ReadSingle();
}
}
else
{
rs_temp.Value = new string[value_count];
for (int k = 0; k < value_count; k++)
{
(rs_temp.Value as string[])[k] = br.ReadString();
}
}
}
result.Results.Add(rs_temp);
}
}
return(result);
}
public static void Serialize(Stream stream_in, SMemIPCData data_in, long offset = 0)
{
/* Packing format:
* 1 => messageType
* 2 => messageValue
* 3 => N
* 4 => num_parameters
* 5 => parameters
* 6 => results
* */
/* ResultStruct packing format:
* 1 => Cols
* 2 => Rows
* 3 => Type
* 4 => Value
* */
BinaryWriter bw = new BinaryWriter(stream_in);
stream_in.Position = offset;
//static data
bw.Write(data_in.messageType);
bw.Write(data_in.messageValue ?? String.Empty);
bw.Write(data_in.N);
bw.Write(data_in.num_parameters);
//parameters
if (data_in.parameters == null)
{
bw.Write((int)0);
}
else
{
bw.Write(data_in.parameters.Count); //write 1-d length L
//for each element i in (L)
for (int i = 0; i < data_in.parameters.Count; i++)
{
//write 2-d length (M) at i
bw.Write(data_in.parameters[i].Count);
//for each element j in M
for (int j = 0; j < data_in.parameters[i].Count; j++)
{
//write result struct static values
bw.Write(((ResultStruct)data_in.parameters[i][j]).Cols);
bw.Write(((ResultStruct)data_in.parameters[i][j]).Rows);
bw.Write((byte)((ResultStruct)data_in.parameters[i][j]).Type);
if ((((ResultStruct)data_in.parameters[i][j]).Type & ResultEnum.Unit) == ResultEnum.Unit)
{
if ((((ResultStruct)data_in.parameters[i][j]).Type & ResultEnum.Float) == ResultEnum.Float)
{
bw.Write((float)((ResultStruct)data_in.parameters[i][j]).Value);
}
else
{
bw.Write((string)((ResultStruct)data_in.parameters[i][j]).Value);
}
}
else if ((((ResultStruct)data_in.parameters[i][j]).Type & ResultEnum.Array) == ResultEnum.Array)
{
//write the value array length
bw.Write((long)(((ResultStruct)data_in.parameters[i][j]).Cols * ((ResultStruct)data_in.parameters[i][j]).Rows));
if ((((ResultStruct)data_in.parameters[i][j]).Type & ResultEnum.Float) == ResultEnum.Float)
{
for (long k = 0; k < ((ResultStruct)data_in.parameters[i][j]).Cols * ((ResultStruct)data_in.parameters[i][j]).Rows; k++)
{
bw.Write((((ResultStruct)data_in.parameters[i][j]).Value as float[])[k]);
}
}
else
{
for (long k = 0; k < ((ResultStruct)data_in.parameters[i][j]).Cols * ((ResultStruct)data_in.parameters[i][j]).Rows; k++)
{
bw.Write((((ResultStruct)data_in.parameters[i][j]).Value as string[])[k]);
}
}
}
}
}
}
//results
if (data_in.Results == null)
{
bw.Write((int)0);
}
else
{
bw.Write(data_in.Results.Count);
for (int i = 0; i < data_in.Results.Count; i++)
{
bw.Write(((ResultStruct)data_in.Results[i]).Cols);
bw.Write(((ResultStruct)data_in.Results[i]).Rows);
bw.Write((byte)((ResultStruct)data_in.Results[i]).Type);
if ((((ResultStruct)data_in.Results[i]).Type & ResultEnum.Unit) == ResultEnum.Unit)
{
if ((((ResultStruct)data_in.Results[i]).Type & ResultEnum.Float) == ResultEnum.Float)
{
bw.Write((float)((ResultStruct)data_in.Results[i]).Value);
}
else
{
bw.Write((string)((ResultStruct)data_in.Results[i]).Value);
}
}
else if ((((ResultStruct)data_in.Results[i]).Type & ResultEnum.Array) == ResultEnum.Array)
{
bw.Write((long)((ResultStruct)data_in.Results[i]).Cols * ((ResultStruct)data_in.Results[i]).Rows);
if ((((ResultStruct)data_in.Results[i]).Type & ResultEnum.Float) == ResultEnum.Float)
{
for (long j = 0; j < ((ResultStruct)data_in.Results[i]).Cols * ((ResultStruct)data_in.Results[i]).Rows; j++)
{
bw.Write((((ResultStruct)data_in.Results[i]).Value as float[])[j]);
}
}
else
{
for (long j = 0; j < ((ResultStruct)data_in.Results[i]).Cols * ((ResultStruct)data_in.Results[i]).Rows; j++)
{
bw.Write((((ResultStruct)data_in.Results[i]).Value as string[])[j]);
}
}
}
}
}
}
public float[] MCWienerCallPrice(float[] spot_price, float[] maturity_time, float[] risk_free_rate, float[] volatility, int time_steps, float[] strike_price, byte style)
{
/* style types:
* 0 => European
* 1 => American
* 2 => Asian
* 3 => Lookback
* 4 => Barrier
* */
//check that all inputs are of the same length
if (maturity_time.Length != spot_price.Length ||
risk_free_rate.Length != spot_price.Length ||
strike_price.Length != spot_price.Length ||
volatility.Length != spot_price.Length)
{
//error here for mismatching lengths
return(null);
}
//prepare request
SMemIPCData msg_data = new SMemIPCData();
msg_data.messageType = 2;
msg_data.messageValue = "MC-WIENER-CALL-PRICE";
msg_data.N = 1;
msg_data.parameters = new List <List <ResultStruct> >(7);
for (int i = 0; i < 7; i++)
{
msg_data.parameters.Add(new List <ResultStruct>());
}
ResultStruct rs_temp = new ResultStruct();
//spot price
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = spot_price;
msg_data.parameters[0].Add(rs_temp);
//time to maturity
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = maturity_time;
msg_data.parameters[1].Add(rs_temp);
//risk free rate
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = risk_free_rate;
msg_data.parameters[2].Add(rs_temp);
//volatility
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = volatility;
msg_data.parameters[3].Add(rs_temp);
//number of steps
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Unit | ResultEnum.Float;
rs_temp.Value = (float)time_steps;
msg_data.parameters[4].Add(rs_temp);
//strike price
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = strike_price;
msg_data.parameters[5].Add(rs_temp);
//style
rs_temp.Cols = 1;
rs_temp.Rows = 1;
rs_temp.Type = ResultEnum.Unit | ResultEnum.Float;
rs_temp.Value = (float)style;
msg_data.parameters[6].Add(rs_temp);
SMemIPCData response = Globals.ThisAddIn.smem_ipc.SendMessage(msg_data);
if (response.messageType == 3)
{
return(response.Results[0].Value as float[]);
}
else
{
return(null);
}
}
public float[] BlackScholesCallPrice(float[] spot_price, float[] maturity_time, float[] strike_price, float[] risk_free_rate, float[] volatility)
{
//check that all inputs are of the same length
if (maturity_time.Length != spot_price.Length ||
strike_price.Length != spot_price.Length ||
risk_free_rate.Length != spot_price.Length ||
volatility.Length != spot_price.Length)
{
//error here for mismatching lengths
return(null);
}
//prepare request
SMemIPCData msg_data = new SMemIPCData();
msg_data.messageType = 2;
msg_data.messageValue = "BLACK-SCHOLES-CALL";
msg_data.N = 1;
msg_data.parameters = new List <List <ResultStruct> >(5);
for (int i = 0; i < 5; i++)
{
msg_data.parameters.Add(new List <ResultStruct>());
}
ResultStruct rs_temp = new ResultStruct();
//spot price
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = spot_price;
msg_data.parameters[0].Add(rs_temp);
//time to maturity
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = maturity_time;
msg_data.parameters[1].Add(rs_temp);
//strike price
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = strike_price;
msg_data.parameters[2].Add(rs_temp);
//risk free rate
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = risk_free_rate;
msg_data.parameters[3].Add(rs_temp);
//volatility
rs_temp.Cols = 1;
rs_temp.Rows = spot_price.Length;
rs_temp.Type = ResultEnum.Array | ResultEnum.Float;
rs_temp.Value = volatility;
msg_data.parameters[4].Add(rs_temp);
SMemIPCData response = Globals.ThisAddIn.smem_ipc.SendMessage(msg_data);
if (response.messageType == 3)
{
return(response.Results[0].Value as float[]);
}
else
{
return(null);
}
}
