private void PublishOrdersAfterReplay()
{
string currencyPair = "XBTUSD";
Order order1 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1));
Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2));
Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 405, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3));
Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 100, 407, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4));
Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 409, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5));
Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "sell", 104, 413, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6));
ManualResetEvent resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne(10000);
}
public async Task OppositeSymbolTest()
{
// Arrange
InputPayload InputPayload = new InputPayload()
{
Move = 1,
AzurePlayerSymbol = "X",
HumanPlayerSymbol = "O",
GameBoard = new List <string> {
"X", "O", "?", "?", "?", "?", "?", "?", "?"
},
};
// Act
HttpOperationResponse <object> resultObject = await _client.ProcessComplexInputWithHttpMessagesAsync(InputPayload);
// Assert
Assert.AreEqual(StatusCodes.Status200OK, (int)resultObject.Response.StatusCode);
OutputPayload response = resultObject.Body as OutputPayload;
if (response != null)
{
Assert.IsTrue(
(response.AzurePlayerSymbol == "X" && response.HumanPlayerSymbol == "O") ||
(response.AzurePlayerSymbol == "O" && response.HumanPlayerSymbol == "X"));
}
else
{
Assert.Fail("Expected an ExecuteMove response but didn't receive one");
}
}
public CalculateResponse Compute(InputPayload payload)
{
if (Validate(payload))
{
result.Value = payload.Value1 * payload.Value2;
}
return(result);
}
private void Scenario1()
{
string currencyPair = "XBTUSD";
Order order1 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 100, 400, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order1));
Order order2 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 101, 401, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order2));
Order order3 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 102, 402, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order3));
Order order4 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 103, 403, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order4));
Order order5 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 104, 404, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order5));
Order order6 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 105, 405, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order6));
Order order7 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 106, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order7));
Order order8 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 100, 410, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order8));
Order order9 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 101, 409, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order9));
Order order10 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 102, 407, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order10));
Order order11 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 103, 406, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order11));
Order order12 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 104, 405, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order12));
Order order13 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 105, 411, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order13));
Order order14 = OrderFactory.CreateOrder("4444", currencyPair, "limit", "sell", 106, 412, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order14));
Order order15 = OrderFactory.CreateOrder("5555", currencyPair, "limit", "buy", 107, 400, new StubbedOrderIdGenerator());
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order15));
ManualResetEvent resetEvent = new ManualResetEvent(false);
resetEvent.WaitOne(20000);
}
public bool Validate(InputPayload payload)
{
if ((payload.Value1 == float.MinValue) || (payload.Value2 == float.MinValue))
{
result.Success = false;
result.Message = "Invalid parameter value";
return(false);
}
else
{
return(true);
}
}
public void CreateOrder_PublishToInputDisruptor_JournalerShouldSaveTheEvent()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
InputPayload payload = InputPayload.CreatePayload(order);
InputDisruptorPublisher.Publish(payload);
_manualResetEvent.WaitOne(5000);
//retrieve order
Order savedOrder = _eventStore.GetEvent(order.OrderId.Id.ToString()) as Order;
Assert.NotNull(savedOrder);
Assert.AreEqual(savedOrder, order);
}
public void CreateAndLogOrder_GetAllTheOrdersBackFromTheEventStore_CheckIfOrderIsRetreivedProperly()
{
Order order = OrderFactory.CreateOrder("1234", "XBTUSD", "limit", "buy", 5, 10,
new StubbedOrderIdGenerator());
InputPayload payload = InputPayload.CreatePayload(order);
InputDisruptorPublisher.Publish(payload);
_manualResetEvent.WaitOne(5000);
//retrieve order
Order savedOrder = _eventStore.GetEvent(order.OrderId.Id.ToString()) as Order;
Assert.NotNull(savedOrder);
Assert.AreEqual(savedOrder, order);
}
private void OnInput(InputPayload input)
{
switch (input.Type)
{
case InputPayload.Action.Up: spaceship.SpeedUp(); break;
case InputPayload.Action.Down: spaceship.SpeedDown(); break;
case InputPayload.Action.Left: spaceship.RotateLeft(); break;
case InputPayload.Action.Right: spaceship.RotateRight(); break;
case InputPayload.Action.Button: weapons.Shoot(); break;
}
}
public CalculateResponse Post(InputPayload payload)
{
CalculateResponse response = null;
//Log all requests
log.Info(string.Format("HttpPost requested {0}", new JavaScriptSerializer().Serialize(payload)));
Operators.Calculator Calculator = null;
try
{
switch (payload.Operation)
{
case "add":
log.Info("Add operation executed");
Calculator = new Operators.Calculator(new Operators.Add());
break;
case "subtract":
log.Info("Subtract operation executed");
Calculator = new Operators.Calculator(new Operators.Subtract());
break;
case "multiply":
log.Info("Multiply operation executed");
Calculator = new Operators.Calculator(new Operators.Multiply());
break;
case "divide":
log.Info("Divide operation executed");
Calculator = new Operators.Calculator(new Operators.Divide());
break;
default:
log.Error(string.Format("Invalid operation {0}", payload.Operation));
Calculator = new Operators.Calculator(new Operators.InvalidOperation());
break;
}
}
catch (Exception ex)
{
//log invalid paramter passing
log.Error(string.Format("Exception error occur {0}", ex.Message));
Calculator = new Operators.Calculator(new Operators.InvalidParameter());
}
response = Calculator.Compute(payload);
log.Info(string.Format("HttpPost response {0}", new JavaScriptSerializer().Serialize(response)));
return(response);
}
public async Task <ActionResult> SampleInnerMethod([FromBody] InputPayload input)
{
try
{
_logger.Information("[SampleInnerMethod] - Param1:[" + input.Param1 + "] - Param2:[" + input.Param2 + "]");
string get_data = await _repository.Get(input.Param1);
string save_data = await _repository.Save(input.Param2);
return(Ok("Calling sample method finished."));
}
catch (Exception ex)
{
_logger.Error(ex.Message);
return(BadRequest());
}
}
/// <summary>
/// payload is either Order or CancelOrder
/// </summary>
/// <param name="payload"></param>
/// <returns></returns>
public static InputPayload CreatePayload(object payload)
{
InputPayload inputPayload = null;
if (payload is Order)
{
inputPayload = new InputPayload();
inputPayload.Order = payload as Order;
inputPayload.IsOrder = true;
}
else if (payload is OrderCancellation)
{
inputPayload = new InputPayload();
inputPayload.OrderCancellation = payload as OrderCancellation;
inputPayload.IsOrder = false;
}
return(inputPayload);
}
public NewOrderRepresentation CreateOrder(CreateOrderCommand orderCommand)
{
IOrderIdGenerator orderIdGenerator = ContextRegistry.GetContext()["OrderIdGenerator"] as IOrderIdGenerator;
Tuple <string, string> splittedCurrencyPairs = CurrencySplitterService.SplitCurrencyPair(orderCommand.Pair);
Order order = OrderFactory.CreateOrder(orderCommand.TraderId, orderCommand.Pair,
orderCommand.Type, orderCommand.Side, orderCommand.Volume, orderCommand.Price, orderIdGenerator);
if (_balanceValidationService.FundsConfirmation(order.TraderId.Id, splittedCurrencyPairs.Item1,
splittedCurrencyPairs.Item2, order.Volume.Value, order.Price.Value, order.OrderSide.ToString(),
order.OrderId.Id))
{
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(order));
return(new NewOrderRepresentation(order));
}
throw new InvalidOperationException("Not Enough Balance for Trader with ID: " + orderCommand.TraderId);
}
[ProducesResponseType(typeof(int), StatusCodes.Status400BadRequest)] // Tells swagger that the response format will be an int for a BadRequest (400)
public ActionResult <OutputPayload> ProcessComplexInput([FromBody] InputPayload inputPayload)
{
// Ensure valid player markers, valid board
if (!(inputPayload.ValidPlayerMarkers()) ||
(!(TicTacToe.BoardIsValid(inputPayload.gameBoard))))
{
return(BadRequest(400));
}
// Compute response
TicTacToe ttt = new TicTacToe(inputPayload.gameBoard,
inputPayload.azurePlayerSymbol, inputPayload.humanPlayerSymbol);
WinStatus ws = ttt.winStatus;
// If game isn't over, get the AI's next move
int?nextMove;
if (ws.winner.Equals(TicTacToe.GAME_NOT_DONE_STR))
{
int choice = ttt.MinimaxWithPruningMove();
ttt[TicTacToe.IndexToTuple(choice)] = inputPayload.azurePlayerSymbol;
nextMove = choice;
// Recalculate win status
ws = TicTacToe.GetWinStatus(ttt.board);
}
else
{
nextMove = null;
}
// Assemble response payload
OutputPayload complexOutput = new OutputPayload()
{
move = nextMove,
azurePlayerSymbol = inputPayload.azurePlayerSymbol,
humanPlayerSymbol = inputPayload.humanPlayerSymbol,
winner = ws.winner,
winPositions = (ws.winPositions == null) ? null : ws.winPositions.ConvertAll(i => i.ToString()),
gameBoard = TicTacToe.BoardToList(ttt.board),
};
return(complexOutput);
}
public async Task ValidNumberOfMarkersTest()
{
// Arrange
InputPayload InputPayload = new InputPayload()
{
Move = 1,
AzurePlayerSymbol = "X",
HumanPlayerSymbol = "O",
GameBoard = new List <string> {
"X", "O", "O", "?", "?", "?", "?", "?", "?"
},
};
// Act
HttpOperationResponse <object> resultObject = await _client.ProcessComplexInputWithHttpMessagesAsync(InputPayload);
// Assert
Assert.AreEqual(StatusCodes.Status400BadRequest, (int)resultObject.Response.StatusCode);
}
public CancelOrderResponse CancelOrder(CancelOrderCommand cancelOrderCommand)
{
try
{
// Verify cancel order command
if (_commandValidationService.ValidateCancelOrderCommand(cancelOrderCommand))
{
string currencyPair = _commandValidationService.GetCurrencyPair(cancelOrderCommand.OrderId);
OrderCancellation cancellation = new OrderCancellation(cancelOrderCommand.OrderId,
cancelOrderCommand.TraderId, currencyPair);
InputDisruptorPublisher.Publish(InputPayload.CreatePayload(cancellation));
return(new CancelOrderResponse(true, "Cancel Request Accepted"));
}
return(new CancelOrderResponse(false, new InvalidDataException("Invalid orderid").ToString()));
}
catch (Exception exception)
{
return(new CancelOrderResponse(false, exception.Message));
}
}
public async Task TieTest()
{
// Arrange
InputPayload InputPayload = new InputPayload()
{
Move = 7,
AzurePlayerSymbol = "X",
HumanPlayerSymbol = "O",
GameBoard = new List <string> {
"X", "O", "X", "X", "O", "X", "O", "X", "O"
},
};
// Act
HttpOperationResponse <object> resultObject = await _client.ProcessComplexInputWithHttpMessagesAsync(InputPayload);
OutputPayload response = resultObject.Body as OutputPayload;
// Assert
Assert.IsTrue(response.Winner.Equals("tie"));
}
public bool Validate(InputPayload payload)
{
return(false);
}
public CalculateResponse Compute(InputPayload payload)
{
return(operation.Compute(payload));
}
/// <summary>
/// Provides an AI-generated optimal countermove to a tic-tac-toe game state
/// by using minimax.
/// </summary>
/// <param name='body'>
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <object> > ProcessComplexInputWithHttpMessagesAsync(InputPayload body = default(InputPayload), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("body", body);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "ProcessComplexInput", tracingParameters);
}
// Construct URL
var _baseUrl = this.BaseUri.AbsoluteUri;
var _url = new Uri(new Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "api/v1/ttt/executemove").ToString();
// Create HTTP transport objects
HttpRequestMessage _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (body != null)
{
_requestContent = SafeJsonConvert.SerializeObject(body, this.SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8");
}
// Set Credentials
if (this.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await this.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await this.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200 && (int)_statusCode != 400)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <object>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <OutputPayload>(_responseContent, this.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
// Deserialize Response
if ((int)_statusCode == 400)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <int?>(_responseContent, this.DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
/// <summary>
/// Provides an AI-generated optimal countermove to a tic-tac-toe game state
/// by using minimax.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// </param>
public static object ProcessComplexInput(this IRestClientSDKLibraryClient operations, InputPayload body = default(InputPayload))
{
return(Task.Factory.StartNew(s => ((IRestClientSDKLibraryClient)s).ProcessComplexInputAsync(body), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
public ActionResult testAPI([FromBody] InputPayload model)
{
return(Ok());
}
/// <summary>
/// Provides an AI-generated optimal countermove to a tic-tac-toe game state
/// by using minimax.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='body'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> ProcessComplexInputAsync(this IRestClientSDKLibraryClient operations, InputPayload body = default(InputPayload), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.ProcessComplexInputWithHttpMessagesAsync(body, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
private static List<OutputPayload> BuildOutputs(InputPayload line, DateTime[] dates)
{
List<OutputPayload> outputs = new List<OutputPayload>();
for (int i = 0; i < line.Weights.Length; i++)
{
var o = new OutputPayload()
{
Pen = line.Pen,
TRT = line.TRT,
Rep = line.Rep,
Ration = line.Ration,
ID = line.ID,
Date = dates[i],
Weight = line.Weights[i]
};
outputs.Add(o);
}
return outputs;
}
private static InputPayload GetPayloadFromLine(string line)
{
var fields = GetFields(line);
var payload = new InputPayload()
{
Pen = fields[0],
TRT = fields[1],
Rep = fields[2],
Ration = fields[3],
ID = fields[4],
Weights = fields.Skip(5).Select(s => !String.IsNullOrWhiteSpace(s) ? Decimal.Parse(s) : 0).ToArray()
};
return payload;
}
private static string[][] BuildOutput(InputPayload line, DateTime[] dates)
{
// only process files with 1 or more dates
if (dates.Length == 0)
return null;
List<OutputPayload> outputs = BuildOutputs(line, dates);
if (dates.Length > 1)
{
// check if the first two dates are contiguous
if (AreDatesContiguous(dates[0], dates[1]))
{
// remove the first output row
outputs.RemoveAt(0);
// set the weight value of the first output to the first two weights in the input
outputs[0].Weight = line.Weights.Take(2).Average();
}
// check if the last two dates are contiguous
if (AreDatesContiguous(dates[dates.Length - 2], dates[dates.Length - 1]))
{
// remove the 2nd to last output row
outputs.RemoveAt(outputs.Count - 2);
// set the weight value of the last output to the last two weights in the input
outputs[outputs.Count - 1].Weight = line.Weights.Skip(line.Weights.Length - 2).Average();
}
}
string[][] results = new string[outputs.Count][];
for (int i = 0; i < outputs.Count; i++)
{
if (results[i] == null)
results[i] = new string[11];
// get previous values
DateTime? prevDate = i != 0 ? outputs[i - 1].Date : (DateTime?)null;
int? prevRunningDays = i != 0 ? outputs[i - 1].RunningDays : (int?)null;
decimal? prevWeight = i != 0 ? outputs[i - 1].Weight : (decimal?)null;
// set Period, Running Days, and ADG
outputs[i].Period = i.ToString();
outputs[i].DaysInPeriod = prevDate.HasValue ? (outputs[i].Date - prevDate).Value.Days : 1;
outputs[i].RunningDays = prevRunningDays.HasValue ? prevRunningDays.Value + outputs[i].DaysInPeriod : 1;
outputs[i].ADG = prevWeight.HasValue ? (outputs[i].Weight - prevWeight.Value) / outputs[i].DaysInPeriod : 0;
// 0) Pen
// 1) Treatment
// 2) Replication
// 3) Ration
// 4) Tag
// 5) Date
// 6) WT
// 7) Period
// 8) DaysInPeriod
// 9) RunningDays
// 10) ADG
results[i][0] = line.Pen;
results[i][1] = line.TRT;
results[i][2] = line.Rep;
results[i][3] = line.Ration;
results[i][4] = line.ID;
results[i][5] = outputs[i].Date.ToShortDateString();
results[i][6] = outputs[i].Weight.ToString();
results[i][7] = outputs[i].Period;
results[i][8] = outputs[i].DaysInPeriod.ToString();
results[i][9] = outputs[i].RunningDays.ToString();
results[i][10] = outputs[i].ADG.ToString();
}
return results;
}
public CalculateResponse Compute(InputPayload payload)
{
return(result);
}
