/*
* Copyright (c) Daisuke OKAJIMA All rights reserved.
*
* $Id$
*/
// Copyright (c) 2014 panacoran <panacoran@users.sourceforge.jp>
// This program is part of OmegaChart.
// OmegaChart is licensed under the Apache License, Version 2.0.
using System;
using System.IO;
using System.Collections;
using System.Diagnostics;
using System.Text;
using Zanetti.Arithmetic;
using Zanetti.Arithmetic.Series;
using Zanetti.Indicators;
namespace Zanetti.Data
{
//primitive indicatorをサポートするためのもの
internal class DataFarmPrimitiveAccess
{
//delegateの引数になるためにこの形でないとだめ
internal static double GetDate(TradeData tr)
{
return (double)tr.Farm.GetInt(tr.Offset);
}
internal static double GetOpen(TradeData tr)
{
return AdjustPrice((double)tr.Farm.GetInt(tr.Offset + DataFarm.OPEN_OFFSET), tr);
}
internal static double GetHigh(TradeData tr)
{
return AdjustPrice((double)tr.Farm.GetInt(tr.Offset + DataFarm.HIGH_OFFSET), tr);
}
internal static double GetLow(TradeData tr)
{
return AdjustPrice((double)tr.Farm.GetInt(tr.Offset + DataFarm.LOW_OFFSET), tr);
}
internal static double GetClose(TradeData tr)
{
return AdjustPrice((double)tr.Farm.GetInt(tr.Offset + DataFarm.CLOSE_OFFSET), tr);
}
internal static double GetVolume(TradeData tr)
{
//オーバーフロー対策の一時しのぎ
return AdjustVolume((double)(uint)tr.Farm.GetInt(tr.Offset + DataFarm.VOLUME_OFFSET), tr);
}
internal static double GetCreditLong(TradeData tr)
{
return AdjustVolume((double)tr.Farm.GetInt(tr.Offset + DataFarm.CREDITLONG_OFFSET), tr);
}
internal static double GetCreditShort(TradeData tr)
{
return AdjustVolume((double)tr.Farm.GetInt(tr.Offset + DataFarm.CREDITSHORT_OFFSET), tr);
}
private static double AdjustPrice(double value, TradeData tr)
{
double split = Env.Preference.AdjustSplit ? tr.Farm.CalcSplitRatio(tr.Date) : 1;
if (value == 0 && GetVolume(tr) == 0)
{ //出来高がない日は価格が０と記入されているので前日の終値で代用
TradeData pr = tr.Prev;
return pr == null ? 0 : GetClose(tr.Prev);
}
else
return tr.Farm.Brand.PriceScale * value / split;
}
private static double AdjustVolume(double value, TradeData tr)
{
double split = Env.Preference.AdjustSplit ? tr.Farm.CalcSplitRatio(tr.Date) : 1;
return value * split;
}
}
internal class NewDailyData
{
public int open;
public int high;
public int low;
public int close;
public int volume;
}
internal abstract class DataFarm : IDisposable
{
public const int RECORD_LENGTH = 32;
public const int OPEN_OFFSET = 4;
public const int HIGH_OFFSET = 8;
public const int LOW_OFFSET = 12;
public const int CLOSE_OFFSET = 16;
public const int VOLUME_OFFSET = 20;
public const int CREDITSHORT_OFFSET = 24;
public const int CREDITLONG_OFFSET = 28;
protected bool _isEmpty; //エラーなどで利用不能なことを示すフラグ
protected AbstractBrand _brand;
protected byte[] _farm; //一次データ。同一のDataFarmオブジェクトを他の銘柄に使いまわすときもあるので、必要以上の長さが確保されることもある
protected int _byteLength; //_farmの論理的な長さ
protected TradeData[] _data; //必要に応じて生成されるTradeDataの列。一目など未来の日付のデータがあると配列の長さは_farmに対応する分より大きいこともある
protected int _filledLength; //最新日付までの長さ
public DataFarm()
{
}
public abstract void LoadFor(AbstractBrand br);
public AbstractBrand Brand
{
get
{
return _brand;
}
}
public int TotalLength
{
get
{
return _data.Length;
}
}
public int FilledLength
{
get
{
return _filledLength;
}
}
public bool IsEmpty
{
get
{
return _isEmpty;
}
}
public byte[] RawDataImage
{
get
{
return _farm;
}
}
internal int GetInt(int offset)
{
if (offset >= _byteLength)
throw new IndexOutOfRangeException();
unsafe
{
fixed (byte* p = &_farm[0])
{
return *(int*)(p + offset);
}
}
}
public TradeData GetByIndex(int index)
{
Debug.Assert(_data != null);
if (index < 0 || index >= _data.Length)
throw new TradeDataOverflowException(index.ToString() + " is out of range");
TradeData td = _data[index];
if (td != null) return td; //cache hit
td = new TradeData(this, index, index * RECORD_LENGTH);
_data[index] = td;
return td;
}
public abstract int LastDate { get; }
public abstract int FirstDate { get; }
public int DateToIndex(int date)
{
return DateToIndex(0, _filledLength, date);
}
private int DateToIndex(int begin, int end, int date)
{
//binary search
if (end - begin <= 1)
return begin;
else
{
int h = (begin + end) / 2;
int t = GetByIndex(h).Date;
if (date < t)
return DateToIndex(begin, h, date);
else
return DateToIndex(h, end, date);
}
}
//分割比率の取得
public double CalcSplitRatio(int date)
{
return _brand.CalcSplitRatio(date, this.LastDate);
}
public void Dispose()
{
_farm = null;
_data = null;
}
internal static int GetInt(byte[] rawdata, int offset)
{
Debug.Assert(rawdata.Length > 0);
unsafe
{
fixed (byte* p = &rawdata[0])
{
return *(int*)(p + offset);
}
}
}
internal static void SetInt(byte[] rawdata, int offset, int value)
{
unsafe
{
fixed (byte* p = &rawdata[0])
{
*(int*)(p + offset) = value;
}
}
}
internal static void SetUInt(byte[] rawdata, int offset, uint value)
{
unsafe
{
fixed (byte* p = &rawdata[0])
{
*(uint*)(p + offset) = value;
}
}
}
protected static int AdjustPrice(int raw, double ratio)
{
return (int)((double)raw / ratio);
}
protected static int AdjustVolume(int raw, double ratio)
{
return (int)((double)raw * ratio);
}
}
internal class DailyDataFarm : DataFarm
{
protected int _extraDataOffset; //１日単位でデータの追加をしたときのために
public DailyDataFarm()
: base()
{
}
public override void LoadFor(AbstractBrand br)
{
_brand = br;
Construct(Util.GetDailyDataFileName(br.Code), 0);
}
public void LoadFor(AbstractBrand br, int extra_dates)
{
_brand = br;
Construct(Util.GetDailyDataFileName(br.Code), extra_dates);
}
private void Construct(string filename, int extra_dates)
{
_isEmpty = true;
#if DOJIMA
Dojima.DojimaUtil.HalfDailyDataFarmCache.Clear(_brand);
#endif
if (File.Exists(filename))
{
int length = (int)new FileInfo(filename).Length;
if (length == 0) return;
if (_farm == null || _farm.Length < length + extra_dates * RECORD_LENGTH)
_farm = new byte[length + extra_dates * RECORD_LENGTH];
int future_length = Env.CurrentIndicators.GetAddedFutureLength(ChartFormat.Daily);
_filledLength = length / RECORD_LENGTH;
_data = new TradeData[_filledLength + future_length];
_byteLength = length;
_extraDataOffset = 0;
_isEmpty = false;
FileStream s = null;
try
{
s = new FileStream(filename, FileMode.Open);
s.Read(_farm, 0, length);
}
finally
{
if (s != null) s.Close();
}
// 個別銘柄の株価データの先頭にある出来高0のデータを取り除く
var basic = _brand as BasicBrand;
if (basic == null || basic.Market == MarketType.B || basic.Market == MarketType.Custom)
return;
var idx = 0;
for (var i = 0; i < _filledLength; i++)
{
unsafe
{
var head = i * RECORD_LENGTH;
fixed (byte* p = &_farm[0])
{
if (*(int*)(p + head + VOLUME_OFFSET) == 0)
idx += RECORD_LENGTH;
else
break;
}
}
}
if (idx == 0)
return;
_byteLength -= idx;
_filledLength = _byteLength / RECORD_LENGTH;
for (var i = 0; i < _byteLength; i++)
_farm[i] = _farm[i + idx];
}
}
public void Save(string filename)
{
if (_farm != null)
{ //エラーハンドリングできていない
FileStream s = new FileStream(filename, FileMode.Create);
s.Write(_farm, 0, _byteLength + _extraDataOffset);
s.Close();
}
}
internal void WriteExtraData(int record_offset, int value)
{
unsafe
{
fixed (byte* p = &_farm[0])
{
*(int*)(p + _byteLength + _extraDataOffset + record_offset) = value;
}
}
}
internal void ProgressExtraDataAddress()
{
_extraDataOffset += RECORD_LENGTH;
Debug.Assert(_extraDataOffset <= _farm.Length);
}
//連続的に複数の日付を更新することもできるが、増加方向であることが必須
internal void UpdateDataFarm(int date, NewDailyData td)
{
int ld;
if (this.IsEmpty)
{
//とりあえず１日書き込める分だけ初期化
if (_farm == null)
{
_farm = new byte[RECORD_LENGTH * 200]; //この上限はどこかで取得すべきだが
_filledLength = 0;
_data = null;
_byteLength = 0;
_extraDataOffset = 0;
}
ld = 0;
}
else
ld = this.LastDate;
int offset;
if (ld < date)
{
offset = _byteLength + _extraDataOffset; //emptyのときは常にこれ
_extraDataOffset += RECORD_LENGTH;
}
else
{
offset = _byteLength - RECORD_LENGTH;
do
{
int t = GetInt(offset);
if (t == date)
break;
else if (t < date)
{
offset += RECORD_LENGTH;
break;
}
else
offset -= RECORD_LENGTH;
} while (true);
}
unsafe
{
fixed (byte* p = &_farm[0])
{
byte* a = p + offset;
*(int*)(a + 0) = date;
*(int*)(a + 4) = td.open;
*(int*)(a + 8) = td.high;
*(int*)(a + 12) = td.low;
*(int*)(a + 16) = td.close;
*(int*)(a + 20) = td.volume;
}
}
}
//次の２つはTradeDataを作らないようにしている、注意
public override int LastDate
{
get
{
return GetInt(_byteLength - RECORD_LENGTH);
}
}
public override int FirstDate
{
get
{
return GetInt(0);
}
}
}
internal class WeeklyDataFarm : DataFarm
{
private int _firstDate;
private int _lastDate;
public WeeklyDataFarm()
: base()
{
}
public override void LoadFor(AbstractBrand br)
{
_brand = br;
Construct(Util.GetDailyDataFileName(br.Code));
}
private void Construct(string filename)
{
_isEmpty = true;
if (File.Exists(filename))
{
int length = (int)new FileInfo(filename).Length;
if (length > 0)
{
//まずは日足を読む
byte[] daily = new byte[length];
FileStream s = null;
try
{
s = new FileStream(filename, FileMode.Open);
s.Read(daily, 0, length);
}
finally
{
if (s != null) s.Close();
}
_isEmpty = false;
_firstDate = GetInt(daily, 0);
_lastDate = GetInt(daily, daily.Length - RECORD_LENGTH);
var daily_begin = Util.IntToDate(GetInt(daily, 0));
var weekly_begin = daily_begin.AddDays(-(int)daily_begin.DayOfWeek);
var daily_end = Util.IntToDate(GetInt(daily, daily.Length - RECORD_LENGTH));
var weekly_end = daily_end.AddDays(-(int)daily_end.DayOfWeek);
_filledLength = (int)(weekly_end - weekly_begin).TotalDays / 7 + 1;
_data = new TradeData[_filledLength + Env.CurrentIndicators.GetAddedFutureLength(ChartFormat.Weekly)];
//byte[]部分のデータ読み
_farm = new byte[_data.Length * RECORD_LENGTH];
_byteLength = _farm.Length;
int offset = 0;
var weekly = weekly_begin;
for (int i = 0; i < _filledLength; i++, weekly = weekly.AddDays(7))
{
offset = FillWeeklyData(i * RECORD_LENGTH, daily, offset, Util.DateToInt(weekly));
if (offset >= daily.Length) break;
}
}
}
}
private int FillWeeklyData(int farmoffset, byte[] daily, int offset, int firstdate)
{
int enddate = Util.DateToInt(Util.IntToDate(firstdate).AddDays(7));
int vol = 0, high = Int32.MinValue, low = Int32.MaxValue;
int open = 0, close = 0, cre_long = 0, cre_short = 0;
int today = GetInt(daily, offset);
bool is_index = _brand.IsBuiltIn;
// base_splitを得るのに最初の取引日である 'today' を使うのは誤り。
// 下の、SetInt(_farm, farmoffset, wi.FirstDate);
// で、後に式を評価する際に用いられる基準日として日曜基準で 'wi.FirstDate' を使っているのだから、
// ここでもこの値を使うべき。 2005/3/15 T. SARUKI
//
double base_split = this.CalcSplitRatio(firstdate); //分割を考慮する場合は期間内の調整が要る
while (offset <= daily.Length - RECORD_LENGTH && today < enddate)
{
//if(!is_index && today>20031201) Debugger.Break();
double split = Env.Preference.AdjustSplit ? this.CalcSplitRatio(today) / base_split : 1;
int v = AdjustVolume(GetInt(daily, offset + VOLUME_OFFSET), split);
if (is_index || v != 0)
{ //非indexで出来高０の日は集計しない
if (open == 0) open = AdjustPrice(GetInt(daily, offset + OPEN_OFFSET), split);
close = AdjustPrice(GetInt(daily, offset + CLOSE_OFFSET), split);
high = Math.Max(high, AdjustPrice(GetInt(daily, offset + HIGH_OFFSET), split));
low = Math.Min(low, AdjustPrice(GetInt(daily, offset + LOW_OFFSET), split));
cre_long = AdjustVolume(GetInt(daily, offset + CREDITLONG_OFFSET), split);
cre_short = AdjustVolume(GetInt(daily, offset + CREDITSHORT_OFFSET), split);
vol += v;
}
offset += RECORD_LENGTH;
if (offset < daily.Length) today = GetInt(daily, offset);
}
SetInt(_farm, farmoffset, firstdate);
SetInt(_farm, farmoffset + OPEN_OFFSET, open);
SetInt(_farm, farmoffset + HIGH_OFFSET, high);
SetInt(_farm, farmoffset + LOW_OFFSET, low);
SetInt(_farm, farmoffset + CLOSE_OFFSET, close);
SetInt(_farm, farmoffset + VOLUME_OFFSET, vol);
SetInt(_farm, farmoffset + CREDITLONG_OFFSET, cre_long);
SetInt(_farm, farmoffset + CREDITSHORT_OFFSET, cre_short);
return offset;
}
public override int LastDate
{
get
{
return _lastDate;
}
}
public override int FirstDate
{
get
{
return _firstDate;
}
}
}
internal class MonthlyDataFarm : DataFarm
{
private int _firstDate;
private int _lastDate;
public MonthlyDataFarm()
: base()
{
}
public override void LoadFor(AbstractBrand br)
{
_brand = br;
Construct(Util.GetDailyDataFileName(br.Code));
}
private void Construct(string filename)
{
_isEmpty = true;
if (File.Exists(filename))
{
int length = (int)new FileInfo(filename).Length;
if (length > 0)
{
//まずは日足を読む
byte[] daily = new byte[length];
_isEmpty = false;
FileStream s = null;
try
{
s = new FileStream(filename, FileMode.Open);
s.Read(daily, 0, length);
}
finally
{
if (s != null) s.Close();
}
_firstDate = GetInt(daily, 0);
_lastDate = GetInt(daily, daily.Length - RECORD_LENGTH);
DateTime monthly_begin = new DateTime(_firstDate / 10000, (_firstDate % 10000) / 100, (_firstDate % 100));
DateTime monthly_end = new DateTime(_lastDate / 10000, (_lastDate % 10000) / 100, (_lastDate % 100));
_filledLength = (monthly_end.Year - monthly_begin.Year) * 12 + monthly_end.Month + 1 - monthly_begin.Month;
_data = new TradeData[_filledLength + Env.CurrentIndicators.GetAddedFutureLength(ChartFormat.Monthly)];
// 以下WeeklyIndexとかぶって冗長
//byte[]部分のデータ読み
_farm = new byte[_data.Length * RECORD_LENGTH];
_byteLength = _farm.Length;
DateTime yearmonth = monthly_begin;
int offset = 0;
for (int i = 0; i < _filledLength; i++)
{
offset = FillMonthlyData(i * RECORD_LENGTH, daily, offset, yearmonth);
if (offset >= daily.Length) break;
yearmonth = yearmonth.AddMonths(1);
}
}
}
}
// このメソッドもWeeklyIndexのFillWeeklyDataとかぶってかなり冗長
private int FillMonthlyData(int farmoffset, byte[] daily, int offset, DateTime yearmonth)
{
DateTime endmonth = yearmonth.AddMonths(1);
int enddate = endmonth.Year * 10000 + endmonth.Month * 100 + 1;
int vol = 0, high = Int32.MinValue, low = Int32.MaxValue;
int open = 0, close = 0, cre_long = 0, cre_short = 0;
int today = GetInt(daily, offset);
bool is_index = _brand.IsBuiltIn;
// base_splitを得るのに最初の取引日である 'today' を使うのは誤り。
// 下の、SetInt(_farm, farmoffset, yearmonth.Year * 10000 + yearmonth.Month * 100 + 1);
// で、後に式を評価する際に用いられる基準日として月の初日である 'yearmonth.Year * 10000 + yearmonth.Month * 100 + 1' を使っているのだから、
// ここでもこの値を使うべき。 2005/3/15 T. SARUKI
//
double base_split = this.CalcSplitRatio(Util.DateToInt(yearmonth.Year, yearmonth.Month, 1));
while (offset <= daily.Length - RECORD_LENGTH && today < enddate)
{
double split = Env.Preference.AdjustSplit ? this.CalcSplitRatio(today) / base_split : 1;
int v = AdjustVolume(GetInt(daily, offset + VOLUME_OFFSET), split);
if (is_index || v != 0)
{ //非indexで出来高０の日は集計しない
if (open == 0) open = AdjustPrice(GetInt(daily, offset + OPEN_OFFSET), split);
close = AdjustPrice(GetInt(daily, offset + CLOSE_OFFSET), split);
high = Math.Max(high, AdjustPrice(GetInt(daily, offset + HIGH_OFFSET), split));
low = Math.Min(low, AdjustPrice(GetInt(daily, offset + LOW_OFFSET), split));
cre_long = AdjustVolume(GetInt(daily, offset + CREDITLONG_OFFSET), split);
cre_short = AdjustVolume(GetInt(daily, offset + CREDITSHORT_OFFSET), split);
vol += v;
}
offset += RECORD_LENGTH;
if (offset < daily.Length) today = GetInt(daily, offset);
}
SetInt(_farm, farmoffset, yearmonth.Year * 10000 + yearmonth.Month * 100 + 1);
SetInt(_farm, farmoffset + OPEN_OFFSET, open);
SetInt(_farm, farmoffset + HIGH_OFFSET, high);
SetInt(_farm, farmoffset + LOW_OFFSET, low);
SetInt(_farm, farmoffset + CLOSE_OFFSET, close);
SetInt(_farm, farmoffset + VOLUME_OFFSET, vol);
SetInt(_farm, farmoffset + CREDITLONG_OFFSET, cre_long);
SetInt(_farm, farmoffset + CREDITSHORT_OFFSET, cre_short);
return offset;
}
public override int LastDate
{
get
{
return _lastDate;
}
}
public override int FirstDate
{
get
{
return _firstDate;
}
}
}
internal class YearlyDataFarm : DataFarm
{
private int _firstDate;
private int _lastDate;
public YearlyDataFarm()
: base()
{
}
public override void LoadFor(AbstractBrand br)
{
_brand = br;
Construct(Util.GetDailyDataFileName(br.Code));
}
private void Construct(string filename)
{
_isEmpty = true;
if (File.Exists(filename))
{
int length = (int)new FileInfo(filename).Length;
if (length > 0)
{
//まずは日足を読む
byte[] daily = new byte[length];
_isEmpty = false;
FileStream s = null;
try
{
s = new FileStream(filename, FileMode.Open);
s.Read(daily, 0, length);
}
finally
{
if (s != null) s.Close();
}
_firstDate = GetInt(daily, 0);
_lastDate = GetInt(daily, daily.Length - RECORD_LENGTH);
DateTime yearly_begin = new DateTime(_firstDate / 10000, (_firstDate % 10000) / 100, (_firstDate % 100));
DateTime yearly_end = new DateTime(_lastDate / 10000, (_lastDate % 10000) / 100, (_lastDate % 100));
_filledLength = yearly_end.Year - yearly_begin.Year + 1;
_data = new TradeData[_filledLength + Env.CurrentIndicators.GetAddedFutureLength(ChartFormat.Yearly)];
// 以下WeeklyIndexとかぶって冗長
//byte[]部分のデータ読み
_farm = new byte[_data.Length * RECORD_LENGTH];
_byteLength = _farm.Length;
DateTime yearmonth = yearly_begin;
int offset = 0;
for (int i = 0; i < _filledLength; i++)
{
offset = FillYearlyData(i * RECORD_LENGTH, daily, offset, yearmonth);
if (offset >= daily.Length) break;
yearmonth = yearmonth.AddYears(1);
}
}
}
}
// このメソッドもWeeklyIndexのFillWeeklyDataとかぶってかなり冗長
private int FillYearlyData(int farmoffset, byte[] daily, int offset, DateTime yearmonth)
{
DateTime endyear = yearmonth.AddYears(1);
int enddate = endyear.Year * 10000 + 101;
int high = Int32.MinValue, low = Int32.MaxValue;
int open = 0, close = 0, cre_long = 0, cre_short = 0;
uint vol = 0;
int today = GetInt(daily, offset);
bool is_index = _brand.IsBuiltIn;
// base_splitを得るのに最初の取引日である 'today' を使うのは誤り。
// 下の、SetInt(_farm, farmoffset, yearmonth.Year * 10000 + yearmonth.Month * 100 + 1);
// で、後に式を評価する際に用いられる基準日として月の初日である 'yearmonth.Year * 10000 + yearmonth.Month * 100 + 1' を使っているのだから、
// ここでもこの値を使うべき。 2005/3/15 T. SARUKI
//
double base_split = this.CalcSplitRatio(Util.DateToInt(yearmonth.Year, 1, 1));
while (offset <= daily.Length - RECORD_LENGTH && today < enddate)
{
double split = Env.Preference.AdjustSplit ? this.CalcSplitRatio(today) / base_split : 1;
int v = AdjustVolume(GetInt(daily, offset + VOLUME_OFFSET), split);
if (is_index || v != 0)
{ //非indexで出来高０の日は集計しない
if (open == 0) open = AdjustPrice(GetInt(daily, offset + OPEN_OFFSET), split);
close = AdjustPrice(GetInt(daily, offset + CLOSE_OFFSET), split);
high = Math.Max(high, AdjustPrice(GetInt(daily, offset + HIGH_OFFSET), split));
low = Math.Min(low, AdjustPrice(GetInt(daily, offset + LOW_OFFSET), split));
cre_long = AdjustVolume(GetInt(daily, offset + CREDITLONG_OFFSET), split);
cre_short = AdjustVolume(GetInt(daily, offset + CREDITSHORT_OFFSET), split);
vol += (uint)(v / 10);
}
offset += RECORD_LENGTH;
if (offset < daily.Length) today = GetInt(daily, offset);
}
SetInt(_farm, farmoffset, yearmonth.Year * 10000 + 101);
SetInt(_farm, farmoffset + OPEN_OFFSET, open);
SetInt(_farm, farmoffset + HIGH_OFFSET, high);
SetInt(_farm, farmoffset + LOW_OFFSET, low);
SetInt(_farm, farmoffset + CLOSE_OFFSET, close);
SetUInt(_farm, farmoffset + VOLUME_OFFSET, vol);
SetInt(_farm, farmoffset + CREDITLONG_OFFSET, cre_long);
SetInt(_farm, farmoffset + CREDITSHORT_OFFSET, cre_short);
return offset;
}
public override int LastDate
{
get
{
return _lastDate;
}
}
public override int FirstDate
{
get
{
return _firstDate;
}
}
}
//他の銘柄から導出される銘柄
internal class DerivedDataFarm : DataFarm
{
private int _firstDate;
private int _lastDate;
private DerivedBrand _derivedBrand;
private ChartFormat _chartFormat;
public DerivedDataFarm(DerivedBrand br, ChartFormat fmt)
: base()
{
_derivedBrand = br;
_chartFormat = fmt;
}
public override void LoadFor(AbstractBrand br)
{
Debug.Assert(br is DerivedBrand);
_brand = br;
_derivedBrand = (DerivedBrand)br;
Construct(_derivedBrand);
}
private void Construct(DerivedBrand br)
{
DataFarm[] fs = new DataFarm[br.Dependencies.Length];
int len = Int32.MaxValue;
int shortest_farm_index = 0;
for (int i = 0; i < fs.Length; i++)
{
DataFarm f = Env.BrandCollection.ReserveFarm(br.Dependencies[i], _chartFormat);
if (f.IsEmpty)
{
_isEmpty = true;
return; //一つでも利用不可があればダメ
}
fs[i] = f;
if (f.FilledLength < len)
{
shortest_farm_index = i;
len = f.FilledLength;
}
}
DataFarm shortest_farm = fs[shortest_farm_index];
if (_farm == null || _farm.Length < len * RECORD_LENGTH) _farm = new byte[len * RECORD_LENGTH];
_byteLength = len * RECORD_LENGTH;
_data = new TradeData[len + Env.CurrentIndicators.GetAddedFutureLength(_chartFormat)];
_filledLength = len;
_isEmpty = false;
_firstDate = shortest_farm.GetByIndex(0).Date;
_lastDate = shortest_farm.GetByIndex(shortest_farm.FilledLength - 1).Date;
//データの構築 本当はここも遅延評価すると効率的だが
FillData(len, shortest_farm_index, br, fs);
}
private void FillData(int len, int shortest_farm_index, DerivedBrand br, DataFarm[] deps)
{
int[] indexmap = new int[deps.Length];
EvalResult[][] args = new EvalResult[4][];
for (int i = 0; i < 4; i++)
{
args[i] = new EvalResult[deps.Length];
for (int j = 0; j < deps.Length; j++) args[i][j] = new EvalResult(0);
}
Indicator[] inds = new Indicator[] {
Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.Open),
Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.High),
Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.Low),
Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.Close)};
TradeData[] tds = new TradeData[deps.Length];
Evaluator ev = new Evaluator(br.Name);
for (int i = 0; i < len; i++)
{
ev.BaseIndex = i;
//日付の決定
int date = deps[shortest_farm_index].GetByIndex(i).Date;
int farmoffset = i * RECORD_LENGTH;
for (int j = 0; j < deps.Length; j++)
{
int candidate = indexmap[j] + 1; //多くの場合日付とindexは一致しているので、DateToIndexの実行回数を減らすためindexmapを用意
TradeData td = candidate < deps[j].TotalLength ? deps[j].GetByIndex(candidate) : null;
if (td == null || td.Date != date)
{
candidate = deps[j].DateToIndex(date);
td = deps[j].GetByIndex(candidate);
}
indexmap[j] = candidate;
for (int k = 0; k < inds.Length; k++)
args[k][j].DoubleVal = td.GetValue(inds[k]);
}
//日付
SetInt(_farm, farmoffset, date);
//４本値の計算
Expression expr = br.Expression;
ev.Args = args[0];
int open = (int)((EvalResult)expr.Apply(ev)).DoubleVal;
SetInt(_farm, farmoffset + OPEN_OFFSET, open);
ev.Args = args[3];
int close = (int)((EvalResult)expr.Apply(ev)).DoubleVal;
SetInt(_farm, farmoffset + CLOSE_OFFSET, close);
ev.Args = args[1];
int v1 = (int)((EvalResult)expr.Apply(ev)).DoubleVal;
ev.Args = args[2];
int v2 = (int)((EvalResult)expr.Apply(ev)).DoubleVal;
//計算式により、それぞれの高値・安値で計算したものが結果としてどうなるかは変わってしまう
SetInt(_farm, farmoffset + HIGH_OFFSET, Math.Max(Math.Max(open, close), Math.Max(v1, v2)));
SetInt(_farm, farmoffset + LOW_OFFSET, Math.Min(Math.Min(open, close), Math.Min(v1, v2)));
}
}
public override int LastDate
{
get
{
return _lastDate;
}
}
public override int FirstDate
{
get
{
return _firstDate;
}
}
}
//internal delegate double Calculate(Indicator indicator, TradeData data);
//節の種類
internal enum Fushi
{
Unknown,
None,
High,
Low
}
/// 日足・週足・月足などの１件のレコード
internal class TradeData
{
private DataFarm _farm;
private int _index;
private int _offset;
private double[] _data;
private Fushi _fushi;
public TradeData(DataFarm farm, int index, int offset)
{
_farm = farm;
_index = index;
_offset = offset;
_data = new double[Env.CurrentIndicators.IndicatorCount];
_fushi = Fushi.Unknown;
for (int i = 0; i < _data.Length; i++)
_data[i] = Double.NaN;
}
public DataFarm Farm
{
get
{
return _farm;
}
}
public int Index
{
get
{
return _index;
}
}
public int Offset
{
get
{
return _offset;
}
}
public TradeData Prev
{
get
{
return _index > 0 ? _farm.GetByIndex(_index - 1) : null;
}
}
public TradeData Next
{
get
{
return _index < _farm.TotalLength - 1 ? _farm.GetByIndex(_index + 1) : null;
}
}
public bool IsFuture
{
get
{
return _index >= _farm.FilledLength;
}
}
public bool CoversDate(int date)
{
if (date == this.Date)
return true;
else
{
int c = this.Date;
if (c > date)
return false;
else
{
TradeData next = this.Next;
return next != null && date < next.Date;
}
}
}
public double GetValue(Indicator indicator)
{
double t = _data[indicator.LaneID];
//overflowによる演算不可はPositiveInfinityであらわす
if (Double.IsPositiveInfinity(t)) return Double.NaN;
if (!Double.IsNaN(t)) return t; //キャッシュにヒット
try
{
if (indicator.CheckRange(this))
{
t = indicator.Calculate(this);
_data[indicator.LaneID] = t;
}
else
t = Double.NaN;
return t;
}
catch (TradeDataOverflowException)
{
//Debug.WriteLine("Out of range!");
_data[indicator.LaneID] = Double.PositiveInfinity;
return Double.NaN;
}
}
public int Date
{
get
{
return (int)GetValue(Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.Date));
}
}
public double Open
{
get
{
return GetValue(Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.Open));
}
}
public double High
{
get
{
return GetValue(Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.High));
}
}
public double Low
{
get
{
return GetValue(Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.Low));
}
}
public double Close
{
get
{
return GetValue(Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.Close));
}
}
public double Volume
{
get
{
return GetValue(Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.Volume));
}
}
public double CreditLong
{
get
{
return GetValue(Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.CreditLong));
}
}
public double CreditShort
{
get
{
return GetValue(Env.CurrentIndicators.GetPrimitive(PrimitiveIndicator.CreditShort));
}
}
//節の計算
public Fushi Fushi
{
get
{
if (_fushi != Fushi.Unknown) return _fushi;
double h1 = Double.MinValue;
double l1 = Double.MaxValue;
double h2 = Double.MinValue;
double l2 = Double.MaxValue;
int fushi = Env.Preference.FushiRange;
//あまり端に表示しても仕方ない
if (_index < fushi || _index > _farm.FilledLength - fushi)
{
_fushi = Fushi.None;
return _fushi;
}
for (int i = _index - fushi; i < _index; i++)
{
h1 = Math.Max(h1, _farm.GetByIndex(i).High);
l1 = Math.Min(l1, _farm.GetByIndex(i).Low);
}
for (int i = _index + 1; i < _index + fushi; i++)
{
h2 = Math.Max(h2, _farm.GetByIndex(i).High);
l2 = Math.Min(l2, _farm.GetByIndex(i).Low);
}
//過去に同値があるときは無視、未来にあるときは節
if (h1 < this.High && h2 <= this.High)
_fushi = Fushi.High;
else if (l1 > this.Low && l2 >= this.Low)
_fushi = Fushi.Low;
else
_fushi = Fushi.None;
return _fushi;
}
}
}
internal class TradeDataOverflowException : ApplicationException
{
public TradeDataOverflowException(string msg)
: base(msg)
{
}
}
internal class IndicatorTimeSeries : TimeSeries
{
protected DataFarm _farm;
protected int _begin;
protected int _end;
protected Indicator _indicator;
public IndicatorTimeSeries(DataFarm farm, Indicator ind, int begin, int end)
{
_farm = farm;
_begin = begin;
_end = end;
_indicator = ind;
}
public override int Count
{
get
{
return _end - _begin;
}
}
public int BeginIndex
{
get
{
return _begin;
}
}
public int EndIndex
{
get
{
return _end;
}
}
public override double LastValue
{
get
{
return _farm.GetByIndex(_end - 1).GetValue(_indicator);
}
}
protected class IndicatorCursor : TimeSeries.Cursor
{
private int _index;
private IndicatorTimeSeries _parent;
public IndicatorCursor(IndicatorTimeSeries parent)
{
_parent = parent;
_index = _parent._begin;
}
public override bool HasNext
{
get
{
return _index < _parent._end;
}
}
public override double Next
{
get
{
return _parent._farm.GetByIndex(_index++).GetValue(_parent._indicator);
}
}
}
public override Cursor CreateCursor()
{
return new IndicatorCursor(this);
}
}
}