private static void Finish(Uri address, ComputationRequest request, int[] iframe)
{
using (Proxy proxy = new Proxy(address))
{
proxy.Finish(request.Id, iframe);
}
}
/// <summary>
/// Instatiates the Query Vector Set and Data Vector sets
/// </summary>
/// <param name="querySetFilePath">optional parameter, if set to null will read default query set file or randomize input</param>
/// <param name="dataSetFilePath">optional parameter, if set to null will read default data set file or randomize input</param>
/// <returns></returns>
public ComputationRequest <float> GetQueryAndDistanceMatrix(string querySetFilePath = null, string dataSetFilePath = null)
{
var computationRequest = new ComputationRequest <float>();
var fillMatrix = new Func <string, bool, string, Matrix <float> >((providedPath, isDefaultEnabled, defaultPath) =>
{
if (!String.IsNullOrEmpty(providedPath))
{
var parsedFile = this.ParseCSVFile(providedPath);
return((parsedFile != null) ? parsedFile : new RandomFloatMatrix());
}
else if (String.IsNullOrEmpty(providedPath) && isDefaultEnabled)
{
var parsedFile = this.ParseCSVFile(defaultPath);
return((parsedFile != null) ? parsedFile : new RandomFloatMatrix());
}
else
{
return(new RandomFloatMatrix());
}
});
computationRequest.QueryVectors = fillMatrix(querySetFilePath, ConfigurationHelper.Instance.DefaultFilesEnabled,
ConfigurationHelper.Instance.QuerySetFilePath);
computationRequest.DatasetVectors = fillMatrix(dataSetFilePath, ConfigurationHelper.Instance.DefaultFilesEnabled,
ConfigurationHelper.Instance.DataSetFilePath);
return(computationRequest);
}
private static void RunTest()
{
const uint limit = 1000000;
const int row = 0;
const int col = 0;
const int height = 16;
int width = Console.WindowWidth > 32
? 32
: Console.WindowWidth;
int partialWidth = width;
int partialHeight = height;
DoubleComplex min = new DoubleComplex(-2, -1.5);
DoubleComplex max = new DoubleComplex(1, 1.5);
ComputationRequest request = new ComputationRequest(min, max, width, height, partialWidth, partialHeight, limit, row, col, ComputationType.Render);
DateTime begin = DateTime.Now;
int[] iframe = InvokeCompute(request);
DateTime end = DateTime.Now;
WriteFrame(iframe, width, height, limit);
Console.WriteLine($"(frame size: {width}:{height}) {(end - begin).TotalSeconds}s");
}
private static void FinishCrop(Uri address, ComputationRequest request, string[] bounds)
{
using (Proxy proxy = new Proxy(address))
{
proxy.FinishCrop(request.Id, bounds);
}
}
private static string[] InvokeCrop(ComputationRequest request)
{
dim size = new dim
{
x = (uint)request.Width,
y = (uint)request.Height
};
dim zoom_size = new dim
{
x = (uint)request.PartialWidth,
y = (uint)request.PartialHeight
};
dim offset = new dim
{
x = (uint)request.Col,
y = (uint)request.Row
};
StringBuilder sb = new StringBuilder(4 * (int)request.Limit);
crop(sb, request.Limit, request.RMin, request.IMin, request.RMax, request.IMax, size, zoom_size, offset);
string str = sb.ToString();
return(new[]
{
str.Substring(0 * (int)request.Limit, (int)request.Limit),
str.Substring(1 * (int)request.Limit, (int)request.Limit),
str.Substring(2 * (int)request.Limit, (int)request.Limit),
str.Substring(3 * (int)request.Limit, (int)request.Limit)
});
}
private static void RunMode(int id, Uri address, TimeSpan sleep)
{
while (true)
{
ComputationRequest request = Request(address, sleep);
Console.Write($"{id}({request.Type}): [{request.Id}({request.Type})]");
if (request.Type == ComputationType.Render)
{
DateTime begin = DateTime.Now;
int[] iframe = InvokeCompute(request);
DateTime end = DateTime.Now;
Finish(address, request, iframe);
Console.WriteLine($" {(end - begin).TotalSeconds}s");
}
else
{
DateTime begin = DateTime.Now;
string[] bounds = InvokeCrop(request);
DateTime end = DateTime.Now;
FinishCrop(address, request, bounds);
Console.WriteLine($" {(end - begin).TotalSeconds}s");
}
}
}
public ActionResult <ComputationResponse> Compute([FromBody] ComputationRequest request)
{
try {
var doc = new XmlDocument();
doc.LoadXml(request.XmlExpression);
var symbol = ReplaceBuiltInStringSymbols(doc.AsExpressionInfo().Symbol);
var(context, inputs) = symbol.Visit(new FormInputReader());
var(steps, result) = new SymbolicContext(context).Run(symbol);
var points = ListOfListToTuples((result as Expression)?.Arguments?.Last() as Expression)
.ToImmutableArray();
return(new ComputationResponse {
RawInput = symbol.Visit(MathematicaPrinter.Default),
Steps = steps.WithoutDuplicates().Select(x => x.Visit(MathematicaPrinter.Default)),
Result = result.Visit(MathematicaPrinter.Default),
//
Points = points,
FormInputs = inputs.Select(x => new ComputationResponse.FormInput {
Variable = x.Item1,
Default = x.Item2
}).ToImmutableArray()
});
}
catch (Exception e) {
logger.LogError("{error}:\n{stack}", e.Message, e.StackTrace);
return(BadRequest(e.Message));
}
}
public async Task <ActionResult> Post(ComputationRequest request)
{
var id = Guid.NewGuid().ToString();
await _requests.SaveAsync(id, request, HttpContext.RequestAborted);
await _queue.EnqueueAsync(id, HttpContext.RequestAborted);
return(AcceptedAtRoute(nameof(GetResultAsync), new { Id = id }));
}
/// <summary>
/// Evaluates the distance between the according vectors and the overall running time
/// </summary>
/// <param name="ComputationRequest">Query set of vectors, Data set of vectors and the metric</param>
/// <returns></returns>
public ComputationResult<float> GetComputationResult(ComputationRequest<float> request)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var distanceMatrix = this.GetDistanceMatrix(request);
stopwatch.Stop();
return new ComputationResult<float>(distanceMatrix, stopwatch.Elapsed.ToString());
}
/// <summary>
/// Evaluates the distance between the according vectors
/// </summary>
/// <param name="ComputationRequest">Query set of vectors, Data set of vectors and the metric</param>
/// <returns></returns>
public Matrix <float> GetDistanceMatrix(ComputationRequest <float> request)
{
var distanceMatrix = new Matrix <float>(request.QueryVectors.Height, request.DatasetVectors.Height);
for (int i = 0; i < request.QueryVectors.Height; i++)
{
for (int j = 0; j < request.DatasetVectors.Height; j++)
{
distanceMatrix.AddElement(request.CalculateDistance(request.QueryVectors[i],
request.DatasetVectors[j]), i, j);
}
}
return(distanceMatrix);
}
/// <summary>
/// Evaluates the distance between the according vectors
/// uses PLINQ to do this async
/// </summary>
/// <param name="ComputationRequest">Query set of vectors, Data set of vectors and the metric</param>
/// <returns></returns>
public Matrix<float> GetDistanceMatrix(ComputationRequest<float> request)
{
var distanceMatrix = new Matrix<float>(request.QueryVectors.Height, request.DatasetVectors.Height);
Matrix<float> datasetMatrix = (Matrix<float>)request.DatasetVectors.Clone();
Matrix<float> querySetMatrix = (Matrix<float>)request.QueryVectors.Clone();
for(int i=0; i<querySetMatrix.Height; i++)
{
var list = datasetMatrix.AsParallel().Select(row => request.CalculateDistance(querySetMatrix[i], row)).ToList();
distanceMatrix[i] = list;
}
return distanceMatrix;
}
public void Post([FromBody] ComputationRequest request)
{
CloudStorageAccount account = CloudStorageAccount.Parse(
CloudConfigurationManager.GetSetting("TaskStorage")
);
var blobClient = account.CreateCloudBlobClient();
var container = blobClient.GetContainerReference("Requests");
container.CreateIfNotExists();
Random rand = new Random(Environment.TickCount);
var blob =
container.GetBlockBlobReference(string.Format("{0}_{1}", DateTime.Now.ToString("yyyyMMdd"), rand.Next()));
blob.UploadText(JsonConvert.SerializeObject(request));
}
private void PushRequest(ComputationRequest request)
{
request.Portfolio = this.PortfolioViewModel.Instruments.ToArray();
request.MarketData = this.MarketDataListViewModel.Instruments.ToArray();
request.DomesticCurrency = this.TaskSettingsViewModel.DomesticCurrency;
request.NotificationEmail = this.TaskSettingsViewModel.EmailAddress;
foreach (var inst in request.Portfolio)
{
ProcessSymbols(inst, this.TaskSettingsViewModel.DomesticCurrency);
}
foreach (var inst in request.MarketData)
{
ProcessSymbols(inst, this.TaskSettingsViewModel.DomesticCurrency);
}
}
private static void SendEmail(ComputationRequest request, string title, string text)
{
// Create network credentials to access your SendGrid account
var username = "******";
var pswd = "6Ujk6BWvIUfT213";
var credentials = new NetworkCredential(username, pswd);
// Create the email object first, then add the properties.
SendGridMessage myMessage = new SendGridMessage();
myMessage.AddTo(request.NotificationEmail);
myMessage.From = new MailAddress("*****@*****.**", "Risk Analysis Tool");
myMessage.Subject = title;
myMessage.Text = text;
// Create an Web transport for sending email.
var transportWeb = new Web(credentials);
// Send the email.
// You can also use the **DeliverAsync** method, which returns an awaitable task.
transportWeb.DeliverAsync(myMessage).Wait();
}
private static int[] InvokeCompute(ComputationRequest request)
{
int[] iframe = new int[request.PartialWidth * request.PartialHeight];
dim size = new dim
{
x = (uint)request.Width,
y = (uint)request.Height
};
dim partial = new dim
{
x = (uint)request.PartialWidth,
y = (uint)request.PartialHeight
};
dim offset = new dim
{
x = (uint)request.Col * partial.x,
y = (uint)request.Row * partial.y
};
IntPtr ptr = Marshal.AllocHGlobal(sizeof(int) * request.PartialWidth * request.PartialHeight);
try
{
compute(ptr, request.RMin, request.IMin, request.RMax, request.IMax, size, partial, offset, request.Limit);
Marshal.Copy(ptr, iframe, 0, request.PartialWidth * request.PartialHeight);
}
finally
{
Marshal.FreeHGlobal(ptr);
}
return(iframe);
}
private static ComputationRequest Request(Uri address, TimeSpan sleep)
{
while (true)
{
try
{
using (Proxy proxy = new Proxy(address))
{
ComputationRequest request = proxy.Request();
if (request != null)
{
return(request);
}
Thread.Sleep((int)sleep.TotalMilliseconds);
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"Service failure: {ex.Message}");
Thread.Sleep((int)sleep.TotalMilliseconds);
}
}
}
/// <summary>
/// Evaluates the distance between the according vectors
/// </summary>
/// <param name="QueryVectors">first set of vectors</param>
/// <param name="DatasetVectors">second set of vectors</param>
/// <returns></returns>
public Matrix <float> GetDistanceMatrix(ComputationRequest <float> request)
{
throw new NotImplementedException();
}
/// <summary>
/// Evaluates the distance between the according vectors and the overall running time
/// </summary>
/// <param name="QueryVectors">first set of vectors</param>
/// <param name="DatasetVectors">second set of vectors </param>
/// <returns></returns>
public ComputationResult <float> GetComputationResult(ComputationRequest <float> request)
{
throw new NotImplementedException();
}
