public void UpdateImage()
{
StockHistory data = m_Data.AllStockHistories[m_ShareNum];
var metrics = new List <IMetric>();
//SemaMetric semaMetric = new SemaMetric(data);
//metrics.Add(semaMetric);
//FemaMetric femaMetric = new FemaMetric(data);
//metrics.Add(femaMetric);
BollingerBandsMetric bollingerBandsMetric = new BollingerBandsMetric(data);
metrics.Add(bollingerBandsMetric);
foreach (Label label in m_FunctorLabels)
{
IFunctor pred = (IFunctor)label.Tag;
pred.Analyse(data);
label.Content = pred.Val.ToString("0.000");
}
Graph g = new Graph(data, metrics);
AbstractPredictor Predictor = new ThingsDontChangePredictor();
double val = Predictor.PredictValue(data, 150, 50);
g.DrawPredictionPoint(val, 150 + 50);
img.Source = ToBitmapSource(g.Bitmap);
LabelShareName.Content = data.Name;
LabelProfit.Content = data.Profit(240, 150).ToString("0.00%");
}
static public Predicate CreateLikePatternPredicate(object o, object pattern)
{
IFunctor functor = o as IFunctor;
IGenerator generator = pattern as IGenerator;
return(new FunctorLikePatternPredicate(functor, generator));
}
public Matrix(int rows, int columns, IFunctor <TOne, TTwo> functor)
{
this.functor = functor;
values = new TTwo[rows, columns];
for (int i = 0; i < rows; ++i)
{
for (int j = 0; j < columns; ++j)
{
values[i, j] = Zero();
}
}
}
public Game(Matrix <T, TS> ts, string name, int x, int y, bool spoiler)
{
this.Init_X = x;
this.Init_Y = y;
this.functor = ts.functor;
this.ts = ts; // one ref in datamodel!
this.name = name;
this.states = ts.columns();
this.Spoiler = spoiler;
this.X = x;
this.Y = y;
// Bisimulation has to be computed!
winningMovesSpoiler = new Dictionary <Tuple, List <List <int> > >();
BisimilarPairs = computeBisimulation(ref winningMovesSpoiler);
this.random = new Random(DateTime.Now.Millisecond); // initialized once for the game
}
static public Predicate CreateEqualsPredicate(object o, object v)
{
bool lhsIsGen = o is IGenerator;
bool rhsIsGen = v is IGenerator;
if (lhsIsGen || rhsIsGen)
{
if (lhsIsGen && rhsIsGen)
{
object lhs = ((IGenerator)o).Evaluate();
object rhs = ((IGenerator)v).Evaluate();
return(lhs.Equals(rhs) ? TRUE_PREDICATE : FALSE_PREDICATE);
}
IFunctor func = lhsIsGen ? (IFunctor)v : (IFunctor)o;
IGenerator gen = lhsIsGen ? (IGenerator)o : (IGenerator)v;
return(new FunctorEqualsGeneratorPredicate(func, gen));
}
return(new FunctorEqualsFunctorPredicate((IFunctor)o, (IFunctor)v));
}
static public Predicate CreateLesserPredicate(object o, object v)
{
bool lhsIsGen = o is IGenerator;
bool rhsIsGen = v is IGenerator;
if (lhsIsGen || rhsIsGen)
{
if (lhsIsGen && rhsIsGen)
{
object lhs = ((IGenerator)o).Evaluate();
object rhs = ((IGenerator)v).Evaluate();
return(Comparer.Default.Compare(lhs, rhs) < 0
? TRUE_PREDICATE : FALSE_PREDICATE);
}
IFunctor func = lhsIsGen ? (IFunctor)v : (IFunctor)o;
IGenerator gen = lhsIsGen ? (IGenerator)o : (IGenerator)v;
return(new FunctorLesserGeneratorPredicate(func, gen));
}
return(new FunctorLesserFunctorPredicate((IFunctor)o, (IFunctor)v));
}
/// <summary>
/// Cria um predicado para comparação de menor.
/// </summary>
/// <param name="o">Objeto em questão.</param>
/// <param name="v">Valor que será comparado.</param>
/// <returns></returns>
public static Predicate CreateLesserPredicate(object o, object v)
{
bool flag = o is IGenerator;
bool flag2 = v is IGenerator;
if (!flag && !flag2)
{
return(new FunctorLesserFunctorPredicate((IFunctor)o, (IFunctor)v));
}
if (flag && flag2)
{
object a = ((IGenerator)o).Evaluate();
object b = ((IGenerator)v).Evaluate();
if (System.Collections.Comparer.Default.Compare(a, b) >= 0)
{
return(FALSE_PREDICATE);
}
return(TRUE_PREDICATE);
}
IFunctor lhs = flag ? ((IFunctor)v) : ((IFunctor)o);
return(new FunctorLesserGeneratorPredicate(lhs, flag ? ((IGenerator)o) : ((IGenerator)v)));
}
/// <summary>
/// Cria um predicado para comparação igual.
/// </summary>
/// <param name="o">Objeto em questão.</param>
/// <param name="v">Valor que será comparado.</param>
/// <returns></returns>
public static Predicate CreateEqualsPredicate(object o, object v)
{
bool flag = o is IGenerator;
bool flag2 = v is IGenerator;
if (!flag && !flag2)
{
return(new FunctorEqualsFunctorPredicate((IFunctor)o, (IFunctor)v));
}
if (flag && flag2)
{
object obj2 = ((IGenerator)o).Evaluate();
object obj3 = ((IGenerator)v).Evaluate();
if (!obj2.Equals(obj3))
{
return(FALSE_PREDICATE);
}
return(TRUE_PREDICATE);
}
IFunctor functor = flag ? ((IFunctor)v) : ((IFunctor)o);
return(new FunctorEqualsGeneratorPredicate(functor, flag ? ((IGenerator)o) : ((IGenerator)v)));
}
public FunctorEqualsFunctorPredicate(IFunctor lhs, IFunctor rhs)
{
functor = lhs;
generator = rhs;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="functor"></param>
/// <param name="functor2"></param>
public FunctorLesserFunctorPredicate(IFunctor functor, IFunctor functor2)
{
_functor = functor;
_functor2 = functor2;
}
public FunctorLikePatternPredicate(IFunctor lhs, IGenerator rhs)
{
functor = lhs;
generator = rhs;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="first">First functor</param>
/// <param name="next">Next functor</param>
public FunctorComposition(IFunctor first, IFunctor next)
{
this.first = first;
this.next = next;
}
public CompositeFunction(IFunctor func, IFunctor func2)
{
this.func = func;
this.func2 = func2;
}
public CompositeFunction(IFunctor func, IFunctor func2)
{
this.func = func;
this.func2 = func2;
}
public override IFunctor <TLeft, TResult> FMap <TA, TResult>(Func <TA, TResult> f, IFunctor <TLeft, TA> fa)
{
var ma = (Either <TLeft, TA>)fa;
return(ma.Match(Either <TLeft> .Left <TResult>, a => Either <TLeft> .Right(f(a))));
}
public IsNullPredicate(IFunctor f)
{
functor = f;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="func">Primeira função da composição.</param>
/// <param name="func2">Segunda função da composição.</param>
public CompositeFunction(IFunctor func, IFunctor func2)
{
_func = func;
_func2 = func2;
}
/// <summary>
/// コンポーネントを初期化するための引数をバインド済みの関数オブジェクトを追加する
/// </summary>
/// <param name="functor">追加する関数オブジェクト</param>
public void AddInitializationFactor(IFunctor functor)
{
initializationFactors.Add(functor);
}
public abstract IFunctor <T1, TB> FMap <TA, TB>(Func <TA, TB> f, IFunctor <T1, TA> fa);
public static IFunctor <B> fmap <A, B>(this Func <A, B> f, IFunctor <A> a) => a.fmap(f);
public FunctorLawsTests(IFunctor <TF> functor, IEqK <TF> eqK) : base(functor, eqK)
{
var functorLaws = new FunctorLaws <TF>(functor);
Add("Covariant Identity", args =>
functorLaws.CovariantIdentity(args.LiftedA).Holds(eqK));
Add("CovariantComposition", args =>
functorLaws.CovariantComposition(args.LiftedA, args.FuncAtoB, args.FuncBtoC).Holds(eqK));
Add("Lift Identity", args =>
functorLaws.LiftIdentity(args.LiftedA).Holds(eqK));
Add("Lift Composition", args =>
functorLaws.LiftComposition(args.LiftedA, args.FuncAtoB, args.FuncBtoC).Holds(eqK));
Add("Void Identity", args =>
functorLaws.VoidIdentity(args.LiftedA).Holds(eqK));
Add("Void Composition", args =>
functorLaws.VoidComposition(args.LiftedA).Holds(eqK));
Add("FProduct Identity", args =>
functorLaws.FProductIdentity(args.LiftedA, args.B).Holds(eqK));
Add("FProduct Composition", args =>
functorLaws
.FProductComposition(args.LiftedA, args.FuncAtoB, ((TA a, TB b)ab) => args.FuncBtoC(ab.b))
.Holds(eqK));
Add("FProductLeft Identity", args =>
functorLaws.FProductLeftIdentity(args.LiftedA, args.B).Holds(eqK));
Add("FProductLeft Composition", args =>
functorLaws
.FProductLeftComposition(args.LiftedA, args.FuncAtoB, ((TB b, TA a)ba) => args.FuncBtoC(ba.b))
.Holds(eqK));
Add("As Identity", args =>
functorLaws.AsIdentity(args.LiftedA, args.B).Holds(eqK));
Add("As Composition", args =>
functorLaws.AsComposition(args.LiftedA, args.B, args.C).Holds(eqK));
Add("TupleLeft Identity", args =>
functorLaws.TupleLeftIdentity(args.LiftedA, args.B).Holds(eqK));
Add("TupleLeft Composition", args =>
functorLaws.TupleLeftComposition(args.LiftedA, args.B, args.C).Holds(eqK));
Add("TupleRight Identity", args =>
functorLaws.TupleRightIdentity(args.LiftedA, args.B).Holds(eqK));
Add("TupleRight Composition", args =>
functorLaws.TupleRightComposition(args.LiftedA, args.B, args.C).Holds(eqK));
Add("Unzip Identity", args =>
functorLaws.UnzipIdentity(args.LiftedA, args.FuncAtoB) switch
{
var(a, b) => a.Holds(eqK) && b.Holds(eqK)
}
public Apply(IFunctor <X, CX, Y, CY> functor, Applier <X, CX, CFX, Y, CY> apply)
{
this._functor = functor;
this._apply = apply;
}
/// <summary>
/// Equivalent to <see cref="IFunctor{TSource}.Map{TResult}(Func{TSource, TResult})"/>. The functor-type is preserved, but checking for a concrete type is the responsibility of the caller.
/// Offers LINQ query support with one <c>from</c>-clause.
/// </summary>
/// <typeparam name="TSource">The type of the source's value.</typeparam>
/// <typeparam name="TResult">The type of the result's value.</typeparam>
/// <param name="source">The source.</param>
/// <param name="f">The function to apply.</param>
public static IFunctor <TResult> Select <TSource, TResult>(this IFunctor <TSource> source, Func <TSource, TResult> f)
=> source.Map(f);
public FunctorLesserGeneratorPredicate(IFunctor lhs, IGenerator rhs)
{
functor = lhs;
generator = rhs;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="functor"></param>
/// <param name="generator"></param>
public FunctorEqualsGeneratorPredicate(IFunctor functor, IGenerator generator)
{
_functor = functor;
_generator = generator;
}
/// <summary>
/// Selects the specified select statement.
/// </summary>
/// <param name="selectStatement">The select statement.</param>
/// <returns></returns>
public Query <T> Select(IFunctor <T> selectStatement)
{
_selectStatement = selectStatement;
return(this);
}
public FunctorLikePatternPredicate(IFunctor lhs, IGenerator rhs)
{
functor = lhs;
generator = rhs;
}
public FunctorGreaterFunctorPredicate(IFunctor lhs, IFunctor rhs)
{
functor = lhs;
generator = rhs;
}
/// <summary>
/// Composes this arrow "f" with next arrow "g"
/// </summary>
/// <param name="category"> The category of arrow</param>
/// <param name="next"> The next arrow "g" </param>
/// <returns>Composition "fg" </returns>
public IAdvancedCategoryArrow Compose(ICategory category, IAdvancedCategoryArrow next)
{
IFunctor f = next as IFunctor;
return(new FunctorComposition(this, f));
}
public IsNullPredicate(IFunctor f)
{
functor = f;
}
public FunctorLesserFunctorPredicate(IFunctor lhs, IFunctor rhs)
{
functor = lhs;
generator = rhs;
}
public FunctorEqualsFunctorPredicate(IFunctor lhs, IFunctor rhs)
{
functor = lhs;
generator = rhs;
}
/// <summary>
/// Tries to cast a <see cref="IFunctor{TSource}"/> to a <see cref="IAsyncApplicative{TSource}"/> via an explicit cast.
/// Convenience method.
/// </summary>
/// <typeparam name="T">The type of the value contained in the functor.</typeparam>
/// <param name="f">The functor to cast to an <see cref="IAsyncApplicative{TSource}"/>.</param>
public static IAsyncApplicative <T> ToAsyncApplicative <T>(this IFunctor <T> f) => (IAsyncApplicative <T>)f;
/// <summary>
/// Constructs a <see cref="IAlt"/> value predicated on supplied data
/// </summary>
/// <typeparam name="X"></typeparam>
/// <typeparam name="CX"></typeparam>
/// <param name="functor"></param>
/// <param name="alt"></param>
/// <returns></returns>
public static IAlt <X, CX> make <X, CX>(IFunctor <X, CX, X, CX> functor, AltMap <CX> alt)
where CX : IContainer <X>
=> new Alt <X, CX>(functor, alt);
public Schedulable(IScheduler scheduler, IFunctor <T> func)
{
Schedulder = scheduler;
Func = func;
}
public FunctorGreaterGeneratorPredicate(IFunctor lhs, IGenerator rhs)
{
functor = lhs;
generator = rhs;
}
