/// <summary>
/// Returns Forex time series for a given currencies pair
/// </summary>
/// <param name="forexClient"></param>
/// <param name="fromCurrency"></param>
/// <param name="toCurrency"></param>
/// <param name="interval"></param>
/// <param name="outputSize"></param>
/// <returns></returns>
public static async Task <ForexTimeSeries> GetTimeSeriesAsync(this ForexClient forexClient,
PhysicalCurrency fromCurrency,
PhysicalCurrency toCurrency,
Interval interval,
OutputSize outputSize = OutputSize.Compact)
{
var parser = new ForexTimeSeriesParser(interval, fromCurrency, toCurrency);
var query = new Dictionary <string, string>()
{
{ ApiQueryConstants.FromSymbolQueryVar, fromCurrency.ToString() },
{ ApiQueryConstants.ToSymbolQueryVar, toCurrency.ToString() },
};
var function = interval.ConvertToApiFunction();
if (function == ApiFunction.FX_INTRADAY)
{
query.Add(ApiQueryConstants.IntervalQueryVar, interval.ConvertToQueryString());
}
if (function == ApiFunction.FX_INTRADAY || function == ApiFunction.FX_DAILY)
{
query.Add(ApiQueryConstants.OutputSizeQueryVar, outputSize.ConvertToQueryString());
}
return(await forexClient.RequestApiAsync(parser, function, query));
}
private Task GenerateAndCompareBill(Bill bill, OutputSize outputSize, GraphicsFormat graphicsFormat)
{
bill.Format.OutputSize = outputSize;
bill.Format.GraphicsFormat = graphicsFormat;
byte[] imageData = QRBill.Generate(bill);
return(VerifyImages.Verify(imageData, graphicsFormat));
}
public async Task ReturnValidNotIntradayTimeSeries(Interval interval, OutputSize size, bool isAdjusted)
{
using var client = new AlphaVantageClient(_apiKey);
using var stocksClient = client.Stocks();
var timeSeries = await stocksClient.GetTimeSeriesAsync("AAPL", interval, size, isAdjusted);
timeSeries.Should().NotBeNull()
.And.Match <StockTimeSeries>(ts =>
ts.IsAdjusted == isAdjusted &&
ts.Interval == interval);
timeSeries.MetaData.Should().NotBeNull()
.And.HaveCountGreaterThan(1);
timeSeries.DataPoints.Should().NotBeNull()
.And.HaveCountGreaterThan(1)
.And.NotContainNulls()
.And.OnlyContain(dp => IsDataPointValid(dp));
if (isAdjusted == false)
{
return;
}
timeSeries.DataPoints.Should()
.OnlyContain(dp =>
IsAdjustedDataPointValid(dp, interval == Interval.Daily && isAdjusted));
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
// set to QR bill only, i.e. 210 by 105 mm
OutputSize savedOutputSize = Bill.Format.OutputSize;
Bill.Format.OutputSize = OutputSize.QrBillOnly;
// find smaller dimension
float scale = MathF.Min(Size.Width / 210f, Size.Height / 105f);
float xPadding = (Size.Width - scale * 210f) / 2f;
float yPadding = (Size.Height - scale * 105f) / 2f;
// draw white background
RectangleF billBounds = new RectangleF(xPadding, yPadding, scale * 210f, scale * 105f);
e.Graphics.FillRectangle(Brushes.White, billBounds);
// draw QR bill
using SystemDrawingCanvas canvas = new SystemDrawingCanvas(e.Graphics, xPadding, Size.Height - yPadding, scale, "Arial");
try
{
QRBill.Draw(Bill, canvas);
}
catch (QRBillValidationException)
{
// ignore invalid bill data
}
Bill.Format.OutputSize = savedOutputSize;
}
/// <summary>
/// Writes this layer as XML
/// </summary>
/// <param name="writer">The XML writer</param>
public void WriteTo(XmlWriter writer)
{
writer.WriteStartElement("layer");
writer.WriteAttributeString("input-size", InputSize.ToString());
writer.WriteAttributeString("output-size", OutputSize.ToString());
writer.WriteAttributeString("activation", Activation.ToString());
writer.WriteAttributeString("weight-init", WeightInitialisation.ToString());
writer.WriteAttributeString("regularisation", Regularisation.ToString());
writer.WriteAttributeString("weight-update", WeightUpdate.ToString());
writer.WriteAttributeString("trainer", LayerTrainer.ToString());
writer.WriteAttributeString("lambda", Lambda.ToString());
writer.WriteAttributeString("momentum", Momentum.ToString());
writer.WriteAttributeString("decay-rate", DecayRate.ToString());
writer.WriteAttributeString("decay-rate2", DecayRate2.ToString());
writer.WriteAttributeString("dropout", Dropout.ToString());
if (Bias != null)
{
Bias.WriteTo("bias", writer);
}
if (Weight != null)
{
writer.WriteStartElement("weight");
foreach (var item in Weight)
{
item.WriteTo("row", writer);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
public static string BuildFilename(OutputSize outputSize, ApiFunction apiFunction, string symbol)
{
return(BaseFileName.Replace("@function", func(apiFunction))
.Replace("@runDate", DateTime.Today.AddDays(-1).ToShortDateString().Replace("/", "-"))
.Replace("@outputsize", output(outputSize))
.Replace("@symbol", symbol));
}
protected override Tensor FeedForwardsInternal(Tensor input)
{
var inputWithBias = Vector <float> .Build.Dense(input.Value.Count + 1, 1);
inputWithBias.SetSubVector(1, input.Value.Count, input);
return(new Tensor(OutputSize.Clone(), _weights * inputWithBias));
}
private void GenerateAndCompareBill(Bill bill, OutputSize outputSize, GraphicsFormat graphicsFormat,
string expectedFileName)
{
bill.Format.OutputSize = outputSize;
bill.Format.GraphicsFormat = graphicsFormat;
byte[] imageData = QRBill.Generate(bill);
FileComparison.AssertFileContentsEqual(imageData, expectedFileName);
}
private Task GenerateAndCompareBill(Bill bill, OutputSize outputSize, GraphicsFormat graphicsFormat)
{
bill.Format.OutputSize = outputSize;
bill.Format.GraphicsFormat = graphicsFormat;
bill.Format.FontFamily = "Arial,\"Liberation Sans\"";
byte[] imageData = QRBill.Generate(bill);
return(VerifyImages.VerifyPng(imageData));
}
/// <summary>
/// Stock data for same day data.
/// </summary>
/// <param name="symbol"></param>
/// <param name="interval"></param>
/// <param name="outputSize"></param>
public StockData(string symbol, TimeInterval interval = TimeInterval.min15, OutputSize outputSize = OutputSize.compact)
{
TimeFunction = TimeFunction.INTRADAY;
string link = $"{urlStart}query?function=TIME_SERIES_{TimeFunction}&symbol={symbol}" +
$"&outputsize={outputSize}&interval={(int)interval}min&{finish}";
ReadData(TimeFunction, link);
}
public TimeSeriesDailyRequest(string symbol,
OutputSize outputSize = OutputSize.Compact, DataType dataType = DataType.Json)
: base(Function.TIME_SERIES_DAILY)
{
Symbol = symbol;
OutputSize = outputSize;
DataType = dataType;
}
public TimeSeriesIntradayExtendedRequest(string symbol, Interval interval,
bool adjusted = true, OutputSize outputSize = OutputSize.Compact)
: base(Function.TIME_SERIES_INTRADAY_EXTENDED)
{
Symbol = symbol;
Interval = interval;
Adjusted = adjusted;
OutputSize = outputSize;
}
public async Task ThrowException_ForInvalidSymbol(Interval interval, OutputSize size, bool isAdjusted)
{
using var client = new AlphaVantageClient(_apiKey);
using var stocksClient = client.Stocks();
await Assert.ThrowsAsync <AlphaVantageException>(async() =>
{
await stocksClient.GetTimeSeriesAsync("wrong_symbol", interval, size, isAdjusted);
});
}
public TimeSeriesIntradayRequest(string symbol, Interval interval,
bool adjusted = true, OutputSize outputSize = OutputSize.Compact, DataType dataType = DataType.Json)
: base(Function.TIME_SERIES_INTRADAY)
{
Symbol = symbol;
Interval = interval;
Adjusted = adjusted;
OutputSize = outputSize;
DataType = dataType;
}
public async Task <IActionResult> GetDailyTimeSeriesAsync(string symbol, OutputSize outputSize = OutputSize.Compact)
{
var result = await _alphaVantageService.GetDailyTimeSeriesAsync(symbol, outputSize);
return(Ok(new
{
symbol,
outputSize = outputSize.ToString(),
Data = result,
}));
}
/// <summary>Gets the hash code for this instance.</summary>
/// <returns>A hash code for the current object.</returns>
public override int GetHashCode()
{
int hashCode = 43802783;
hashCode = hashCode * -1521134295 + OutputSize.GetHashCode();
hashCode = hashCode * -1521134295 + Language.GetHashCode();
hashCode = hashCode * -1521134295 + SeparatorType.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(FontFamily);
hashCode = hashCode * -1521134295 + GraphicsFormat.GetHashCode();
return(hashCode);
}
/// <summary>
/// Retrieves quotes from Alpha Vantage API based on ticker and outputSize.
/// </summary>
/// <param name="ticker">Security ticker. A string.</param>
/// <param name="outputSize">Alpha Vantage API response output size. An OutputSize enum.</param>
/// <returns>List of serialized Quote objects.</returns>
internal async Task <List <Quote> > GetQuotesAsync(string ticker, OutputSize outputSize, CancellationToken cancellationToken)
{
var outputSizeLowercase = outputSize.ToString().ToLower();
var apiKey = Configuration.GetValue <string>("AlphaVantage:ApiKey");
HttpClient httpClient = HttpClientFactory.CreateClient();
HttpResponseMessage response = await httpClient.GetAsync($"{TimeSeriesDailyAdjustedURL}&symbol={ticker}&outputsize={outputSizeLowercase}&apikey={apiKey}", cancellationToken);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
return(ParseResponseBody(responseBody));
}
private void initControls()
{
TbxIpAddr.Text = IpAddr;
TbxUsername.Text = Username;
TbxPassword.Text = Password;
BtnConnect.Content = "连接";
TbxTest.Text = "";
tbxPlatName.Text = "";
tbxPlatVen.Text = "";
tbxPlatVer.Text = "";
tbxDevName.Text = "";
tbxDevVen.Text = "";
tbxDevVer.Text = "";
tbxDevCU.Text = "";
tbxDevFreq.Text = "";
tbxDevPerf.Text = "";
lbxDevList.Items.Clear();
tbxN.Text = N.ToString();
tbxC.Text = C.ToString();
tbxH.Text = H.ToString();
tbxW.Text = W.ToString();
tbxK.Text = K.ToString();
tbxOutW.Text = OutW.ToString();
tbxOutH.Text = OutH.ToString();
tbxGroupSz.Text = String.Format("{0:D}, {1:D}, 1", group_size_x, group_size_y);
tbxGlobalSz.Text = String.Format("{0:D}, {1:D}, 1", global_size_x, global_size_y);
tbxPck.Text = pck_order.ToString();
tbxLdsAtomic.Text = c_lds_atomic.ToString();
tbxLdsSplit.Text = c_lds_split.ToString();
tbxL2Atomic.Text = c_l2_atomic.ToString();
tbxL2Split.Text = c_l2_split.ToString();
tbxKoutMaps.Text = k_out_maps.ToString();
tbxInSize.Text = InputSize.ToString();
tbxWeiSize.Text = WeightSize.ToString();
tbxOutSize.Text = OutputSize.ToString();
tbxSigSize.Text = sig_slot_size.ToString();
tbxL2Size.Text = l2_tmp_size.ToString();
tbxElapsed.Text = BestElapsedTime.ToString();
tbxPerf.Text = BestPerformence.ToString();
tbxEffic.Text = BestEfficiency.ToString();
tbxCalcu.Text = Calculation.ToString();
tbxtheore.Text = TheoryElapsedTime.ToString();
tbxProcess.Text = String.Format("Tunning Problem: {0:D}/{1:D}... Searching Kernel: {2:D}/{3:D}...",
TunnedProblem, TotalProblem, SearchedKernel, TotalProblem);
tbxPercent.Text = String.Format("{0:F2}%", SearchingPercent * 100);
btnTensile.IsEnabled = false;
}
private static string output(OutputSize outputSize)
{
switch (outputSize)
{
case OutputSize.Full:
return("full");
case OutputSize.Compact:
return("compact");
}
return("");
}
protected override Tensor FeedForwardsInternal(Tensor input)
{
var weightsArray = _weights.SplitByColumn(_kernelCount)
.Select(w => _isTranspose ? w.Rotate180() : w)
.ToArray();
var rows = CartesianConvolve(
weightsArray,
input.ToMatrices()
)
.ToColumnMajorArray();
return(new Tensor(OutputSize.Clone(), rows));
}
private void DrawBorder()
{
SeparatorType separatorType = _bill.Format.SeparatorType;
OutputSize outputSize = _bill.Format.OutputSize;
if (separatorType == SeparatorType.None)
{
return;
}
_graphics.SetTransformation(0, 0, 0, 1, 1);
// Draw vertical separator line between receipt and payment part
_graphics.StartPath();
_graphics.MoveTo(ReceiptWidth, 0);
if (separatorType == SeparatorType.SolidLineWithScissors)
{
_graphics.LineTo(ReceiptWidth, SlipHeight - 8);
_graphics.MoveTo(ReceiptWidth, SlipHeight - 5);
}
_graphics.LineTo(ReceiptWidth, SlipHeight);
// Draw horizontal separator line between bill and rest of A4 sheet
if (outputSize != OutputSize.QrBillOnly)
{
_graphics.MoveTo(0, SlipHeight);
if (separatorType == SeparatorType.SolidLineWithScissors)
{
_graphics.LineTo(5, SlipHeight);
_graphics.MoveTo(8, SlipHeight);
}
_graphics.LineTo(SlipWidth, SlipHeight);
}
_graphics.StrokePath(0.5, 0);
// Draw scissors
if (separatorType == SeparatorType.SolidLineWithScissors)
{
DrawScissors(ReceiptWidth, SlipHeight - 5, 3, 0);
if (outputSize != OutputSize.QrBillOnly)
{
DrawScissors(5, SlipHeight, 3, Math.PI / 2.0);
}
}
}
public static string BuildUrl(OutputSize outputSize, ApiFunction apiFunction, string symbol, string key)
{
string url = BaseUrl;
if (apiFunction == ApiFunction.Daily)
{
url = url.Replace("<interval>", "");
}
else if (apiFunction == ApiFunction.ThirtyMin)
{
url = url.Replace("<interval>", "&interval=30min");
}
return(url.Replace("@function", func(apiFunction))
.Replace("@key", key)
.Replace("@outputsize", output(outputSize))
.Replace("@symbol", symbol));
}
public async Task DownloadAsync(
string symbol,
Interval interval,
OutputSize outputSize,
DirectoryInfo directoryInfo,
DateOrder dateOrder,
bool timestampFiles = false,
string apiKey = "demo")
{
Console.WriteLine($"Downloading: {symbol}");
var func = ToFunctionIntervalQueryValues(interval);
var output = outputSize.ToString().ToLower();
var uri = $"https://www.alphavantage.co/query?{func}&symbol={symbol}&outputsize={output}&datatype=csv&apikey={apiKey}";
var response = await _client.GetAsync(uri);
if (!response.IsSuccessStatusCode)
{
Console.WriteLine($"Failed download for: {symbol}. StatusCode: {response.StatusCode}, Content: {response.Content}");
return;
}
Console.WriteLine($"Saving: {symbol}");
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
var data = await response.Content.ReadAsStringAsync();
if (dateOrder == DateOrder.Ascending)
{
var dataRows = data.Split(Environment.NewLine);
data = $"{dataRows[0]}{string.Join(Environment.NewLine, dataRows.Skip(1).Reverse())}";
}
var timestampString = timestampFiles ? "_" + DateTime.UtcNow.ToFileTimeUtc() : string.Empty;
var fileName = $"{symbol}{timestampString}";
var path = Path.Combine(directoryInfo.FullName, $"{fileName}.csv");
await File.WriteAllTextAsync(path, data);
Console.WriteLine($"Stored: {symbol}");
}
public async Task ReturnValidIntradayTimeSeries(Interval interval, OutputSize size, bool isAdjusted)
{
using var client = new AlphaVantageClient(_apiKey);
using var stocksClient = client.Stocks();
var timeSeries = await stocksClient.GetTimeSeriesAsync("AAPL", interval, size, isAdjusted);
timeSeries.Should().NotBeNull()
.And.Match <StockTimeSeries>(ts =>
ts.IsAdjusted == false && // intraday ts are always not adjusted
ts.Interval == interval);
timeSeries.MetaData.Should().NotBeNull()
.And.HaveCountGreaterThan(1);
timeSeries.DataPoints.Should().NotBeNull()
.And.HaveCountGreaterThan(1)
.And.NotContainNulls()
.And.OnlyContain(dp =>
IsDataPointValid(dp) && dp.GetType() != typeof(StockAdjustedDataPoint));
}
/// <summary>
/// Returns stocks time series for requested symbol
/// </summary>
/// <param name="stocksClient"></param>
/// <param name="symbol"></param>
/// <param name="interval"></param>
/// <param name="size"></param>
/// <param name="isAdjusted"></param>
/// <returns></returns>
public static async Task <StockTimeSeries> GetTimeSeriesAsync(this StocksClient stocksClient,
string symbol,
Interval interval,
OutputSize size = OutputSize.Compact,
bool isAdjusted = false)
{
var parser = new StocksTimeSeriesParser(interval, isAdjusted);
var query = new Dictionary <string, string>()
{
{ ApiQueryConstants.SymbolQueryVar, symbol },
{ ApiQueryConstants.OutputSizeQueryVar, size.ConvertToQueryString() }
};
var function = interval.ConvertToApiFunction(isAdjusted);
if (function == ApiFunction.TIME_SERIES_INTRADAY)
{
query.Add(ApiQueryConstants.IntervalQueryVar, interval.ConvertToQueryString());
}
return(await stocksClient.RequestApiAsync(parser, function, query));
}
/// <inheritdoc cref="IAlphaVantageService.GetDailyTimeSeriesAsync"/>
public async Task <List <SampleDto> > GetDailyTimeSeriesAsync(string symbol, OutputSize outputSize = OutputSize.Compact)
{
if (string.IsNullOrEmpty(symbol))
{
throw new ArgumentNullException(nameof(symbol));
}
if (outputSize == OutputSize.None)
{
throw new ArgumentException(nameof(outputSize));
}
var function = ApiFunctions.TIME_SERIES_DAILY;
var parameters = new Dictionary <ApiParameters, string>
{
{ ApiParameters.Symbol, symbol },
{ ApiParameters.OutputSize, outputSize.ToLower() },
};
var response = await _connector.RequestApiAsync <Dictionary <DateTime, SampleAlphaDto> >(function, parameters);
return(response.Data.Select(q => (SampleDto)q).ToList());
}
public async Task ReturnValidTimeSeries(Interval interval, OutputSize outputSize)
{
using var client = new AlphaVantageClient(_apiKey);
using var forexClient = client.Forex();
var fromCurrency = PhysicalCurrency.USD;
var toCurrency = PhysicalCurrency.ILS;
var timeSeries = await forexClient.GetTimeSeriesAsync(fromCurrency, toCurrency, interval, outputSize);
timeSeries.Should().NotBeNull()
.And.Match <ForexTimeSeries>(ts =>
ts.Interval == interval &&
ts.FromCurrency == fromCurrency &&
ts.ToCurrency == toCurrency);
timeSeries.MetaData.Should().NotBeNull()
.And.HaveCountGreaterThan(1);
timeSeries.DataPoints.Should().NotBeNull()
.And.HaveCountGreaterThan(1)
.And.NotContainNulls()
.And.OnlyContain(dp => IsDataPointValid(dp));
}
/// <summary>
/// Imports the async. endTime stock history inclusive
/// </summary>
/// <returns>The async.</returns>
/// <param name="symbol">Symbol.</param>
/// <param name="startTime">Start time.</param>
/// <param name="endTime">End time.</param>
/// <param name="period">Period.</param>
/// <param name="token">Token.</param>
public async Task <IReadOnlyList <IOhlcv> > ImportAsync(string symbol, DateTime?startTime = default(DateTime?), DateTime?endTime = default(DateTime?), PeriodOption period = PeriodOption.Daily, CancellationToken token = default(CancellationToken))
{
if (period == PeriodOption.PerSecond || period == PeriodOption.Per10Minute || period == PeriodOption.BiHourly)
{
throw new ArgumentException($"This importer does not support {period.ToString()}");
}
Client.BaseAddress = new Uri("https://www.alphavantage.co");
string query = string.Empty;
string function = "TIME_SERIES_DAILY";
string format = "yyyy-MM-dd";
switch (period)
{
case PeriodOption.PerMinute:
format = "yyyy-MM-dd HH:mm:ss";
function = "function=TIME_SERIES_INTRADAY&interval=1min";
break;
case PeriodOption.Per5Minute:
format = "yyyy-MM-dd HH:mm:ss";
function = "function=TIME_SERIES_INTRADAY&interval=5min";
break;
case PeriodOption.Per15Minute:
format = "yyyy-MM-dd HH:mm:ss";
function = "function=TIME_SERIES_INTRADAY&interval=15min";
break;
case PeriodOption.Per30Minute:
format = "yyyy-MM-dd HH:mm:ss";
function = "function=TIME_SERIES_INTRADAY&interval=30min";
break;
case PeriodOption.Hourly:
format = "yyyy-MM-dd HH:mm:ss";
function = "function=TIME_SERIES_INTRADAY&interval=60min";
break;
case PeriodOption.Daily:
function = "function=TIME_SERIES_DAILY";
break;
case PeriodOption.Weekly:
function = "function=TIME_SERIES_WEEKLY";
break;
case PeriodOption.Monthly:
function = "function=TIME_SERIES_MONTHLY";
break;
default:
break;
}
query = $"/query?{function}&symbol={symbol}&apikey={ApiKey}&outputsize={OutputSize.ToString()}&datatype=csv";
var csvStream = await client.GetStreamAsync(query);
TextReader textReader = new StreamReader(csvStream);
var culture = "en-US";
var cultureInfo = new CultureInfo(culture);
var candles = new List <IOhlcv>();
using (var csvReader = new CsvReader(textReader, new Configuration()
{
CultureInfo = cultureInfo, Delimiter = ",", HasHeaderRecord = true
}))
{
bool isHeaderBypassed = false;
while (csvReader.Read())
{
// HasHeaderRecord is not working for CsvReader 6.0.2
if (!isHeaderBypassed)
{
isHeaderBypassed = true;
continue;
}
var date = string.IsNullOrWhiteSpace(format) ? csvReader.GetField <DateTime>(0) : DateTime.ParseExact(csvReader.GetField <string>(0), format, cultureInfo);
if ((!startTime.HasValue || date >= startTime) && (!endTime.HasValue || date <= endTime))
{
candles.Add(GetRecord(csvReader, format, cultureInfo));
}
}
}
return(candles.OrderBy(c => c.DateTime).ToList());
}
public AlphaVantageImporter(string apiKey, OutputSize outputSize = OutputSize.compact)
{
ApiKey = apiKey;
OutputSize = outputSize;
}
private void procTensileLog(String logStr)
{
Action act;
String tmpLog;
tmpLog = delLogHead(logStr);
if (initInfoFlag == true)
{
if (tmpLog.StartsWith("output WHKN"))
{
tmpLog = tmpLog.Split('=')[1];
tmpLog = tmpLog.Trim();
OutW = int.Parse(tmpLog.Split(',')[0].Trim());
OutH = int.Parse(tmpLog.Split(',')[1].Trim());
OutK = int.Parse(tmpLog.Split(',')[2].Trim());
OutN = int.Parse(tmpLog.Split(',')[3].Trim());
}
if (tmpLog.StartsWith("init tensor input"))
{
InputSize = tmpLog.Split('=')[2].Trim();
}
if (tmpLog.StartsWith("init tensor weight"))
{
WeightSize = tmpLog.Split('=')[2].Trim();
}
if (tmpLog.StartsWith("init tensor output"))
{
OutputSize = tmpLog.Split('=')[2].Trim();
}
if (tmpLog.StartsWith("Calculation"))
{
Calculation = tmpLog.Split(',')[0].Trim().Split('=')[1].Trim();
TheoryElapsedTime = tmpLog.Split(',')[1].Trim().Split('=')[1].Trim();
}
if (tmpLog.StartsWith("run host calculate"))
{
initInfoFlag = false;
kernelParamFlag = false;
act = new Action(() =>
{
tbxOutW.Text = OutW.ToString();
tbxOutH.Text = OutH.ToString();
tbxInSize.Text = InputSize.ToString();
tbxWeiSize.Text = WeightSize.ToString();
tbxOutSize.Text = OutputSize.ToString();
tbxCalcu.Text = Calculation.ToString();
tbxtheore.Text = TheoryElapsedTime.ToString();
});
this.Dispatcher.Invoke(act);
}
}
if (kernelParamFlag == true)
{
if (tmpLog.Contains("PCK_order"))
{
pck_order = int.Parse(getNumStr(tmpLog.Split('=')[1].Trim()));
}
if (tmpLog.Contains("c_lds_atomic") && tmpLog.Contains("c_lds_split"))
{
c_lds_atomic = int.Parse(tmpLog.Split(',')[0].Split('=')[1].Trim());
c_lds_split = int.Parse(tmpLog.Split(',')[1].Split('=')[1].Trim());
}
if (tmpLog.Contains("c_l2_atomic") && tmpLog.Contains("c_l2_split"))
{
c_l2_atomic = int.Parse(tmpLog.Split(',')[0].Split('=')[1].Trim());
c_l2_split = int.Parse(tmpLog.Split(',')[1].Split('=')[1].Trim());
}
if (tmpLog.Contains("k_out_maps") && tmpLog.Contains("k_out_group"))
{
k_out_maps = int.Parse(tmpLog.Split(',')[0].Split('=')[1].Trim());
}
if (tmpLog.Contains("group_size"))
{
group_size_x = int.Parse(tmpLog.Split('=')[1].Split(',')[0].Trim());
group_size_y = int.Parse(tmpLog.Split('=')[1].Split(',')[1].Trim());
}
if (tmpLog.Contains("sigal_size") && tmpLog.Contains("l2_size"))
{
sig_slot_size = tmpLog.Split(',')[0].Split('=')[1].Trim();
l2_tmp_size = tmpLog.Split(',')[1].Split('=')[1].Trim();
}
if (tmpLog.Contains("-------------------------------------------------------------------------"))
{
kernelParamFlag = false;
act = new Action(() =>
{
tbxPck.Text = pck_order.ToString();
tbxLdsAtomic.Text = c_lds_atomic.ToString();
tbxLdsSplit.Text = c_lds_split.ToString();
tbxL2Atomic.Text = c_l2_atomic.ToString();
tbxL2Split.Text = c_l2_split.ToString();
tbxKoutMaps.Text = k_out_maps.ToString();
tbxSigSize.Text = sig_slot_size.ToString();
tbxL2Size.Text = l2_tmp_size.ToString();
tbxGroupSz.Text = String.Format("{0:D}, {1:D}, 1", group_size_x, group_size_y);
});
this.Dispatcher.Invoke(act);
}
}
else
{
if (tmpLog.StartsWith("launch kernel"))
{
KernelIterations = int.Parse(getNumStr(tmpLog));
}
if (tmpLog.Contains("elapsed") && tmpLog.Contains("performence") && (!tmpLog.StartsWith("Best for now")))
{
ElapsedTime = tmpLog.Split(',')[0].Split('=')[1].Trim();
Performence = tmpLog.Split(',')[1].Split('=')[1].Trim();
Efficiency = tmpLog.Split(',')[1].Split('=')[2].Trim();
}
if (tmpLog.StartsWith("Best for now:"))
{
BestElapsedTime = tmpLog.Split(',')[0].Split('=')[1].Trim();
BestEfficiency = tmpLog.Split(',')[1].Split('=')[1].Trim();
}
if (tmpLog.StartsWith("Searching"))
{
SearchedKernel = int.Parse(getNumStr(tmpLog.Split(':')[1]).Split('/')[0].Trim());
TotalKernel = int.Parse(getNumStr(tmpLog.Split(':')[1]).Split('/')[1].Trim());
SearchingPercent = 1.0 * SearchedKernel / TotalKernel;
}
if (tmpLog.Contains("Kernel Param:"))
{
kernelParamFlag = true;
act = new Action(() =>
{
tbxElapsed.Text = BestElapsedTime.ToString();
tbxPerf.Text = BestPerformence.ToString();
tbxEffic.Text = BestEfficiency.ToString();
tbxProcess.Text = String.Format("Tunning Problem: {0:D}/{1:D}... Searching Kernel: {2:D}/{3:D}...",
TunnedProblem, TotalProblem, SearchedKernel, TotalKernel);
tbxPercent.Text = String.Format("{0:F2}%", SearchingPercent * 100);
pbProcPercent.Value = SearchingPercent * 100;
});
this.Dispatcher.Invoke(act);
}
if (tmpLog.Contains("search kernel parameters finished"))
{
finishFlag = true;
}
}
if (finishFlag == true)
{
if (tmpLog.Contains("Best score"))
{
BestElapsedTime = tmpLog.Split(':')[1].Split(',')[0].Trim();
BestPerformence = tmpLog.Split(':')[1].Split(',')[1].Trim();
BestEfficiency = tmpLog.Split(':')[1].Split(',')[2].Trim();
}
if (tmpLog.Contains("+ group_size ="))
{
group_size_x = int.Parse(tmpLog.Split('=')[1].Split(',')[0].Trim());
group_size_y = int.Parse(tmpLog.Split('=')[1].Split(',')[1].Trim());
}
if (tmpLog.Contains("global_size"))
{
global_size_x = int.Parse(tmpLog.Split('=')[1].Split(',')[0].Trim());
global_size_y = int.Parse(tmpLog.Split('=')[1].Split(',')[1].Trim());
}
if (tmpLog.Contains("PCK_order"))
{
pck_order = int.Parse(tmpLog.Split('=')[1].Trim());
}
if (tmpLog.Contains("c_in_lds_atomic_group"))
{
c_lds_atomic = int.Parse(tmpLog.Split('=')[1].Trim());
}
if (tmpLog.Contains("c_in_lds_split_group"))
{
c_lds_split = int.Parse(tmpLog.Split('=')[1].Trim());
}
if (tmpLog.Contains("c_in_l2_atomic_group"))
{
c_l2_atomic = int.Parse(tmpLog.Split('=')[1].Trim());
}
if (tmpLog.Contains("c_in_l2_split_group"))
{
c_l2_split = int.Parse(tmpLog.Split('=')[1].Trim());
}
if (tmpLog.Contains("k_out_maps") && (!tmpLog.Contains("k_out_group")))
{
k_out_maps = int.Parse(tmpLog.Split('=')[1].Trim());
}
if (tmpLog.Contains("mean err"))
{
if (tmpLog.Contains('@'))
{
mean_err = double.Parse(getNumStr(tmpLog.Split('=')[1].Split('@')[1]));
}
else
{
mean_err = double.Parse(tmpLog.Split('=')[1].Trim());
}
}
if (tmpLog.Contains("release host"))
{
act = new Action(() =>
{
tbxElapsed.Text = BestElapsedTime.ToString();
tbxPerf.Text = BestPerformence.ToString();
tbxEffic.Text = BestEfficiency.ToString();
tbxPck.Text = pck_order.ToString();
tbxLdsAtomic.Text = c_lds_atomic.ToString();
tbxLdsSplit.Text = c_lds_split.ToString();
tbxL2Atomic.Text = c_l2_atomic.ToString();
tbxL2Split.Text = c_l2_split.ToString();
tbxKoutMaps.Text = k_out_maps.ToString();
tbxSigSize.Text = sig_slot_size.ToString();
tbxL2Size.Text = l2_tmp_size.ToString();
SearchedKernel = TotalKernel;
tbxGroupSz.Text = String.Format("{0:D}, {1:D}, 1", group_size_x, group_size_y);
tbxGlobalSz.Text = String.Format("{0:D}, {1:D}, 1", global_size_x, global_size_y);
tbxProcess.Text = String.Format("Tunning Problem: {0:D}/{1:D}... Searching Kernel: {2:D}/{3:D}...",
TunnedProblem, TotalProblem, SearchedKernel, TotalKernel);
tbxPercent.Text = String.Format("{0:F2}%", SearchingPercent * 100);
pbProcPercent.Value = 100;
});
this.Dispatcher.Invoke(act);
}
}
}
