public static void Drop(IStackList <object> stack)
{
if (stack.Count > 0)
{
stack.Pop();
}
}
public static void PushRange <T>(this IStackList <object> stack, IEnumerable <T> collection)
{
foreach (var obj in collection)
{
stack.Push(obj);
}
}
public static void Swap(IStackList <object> stack)
{
if (stack.Count > 1)
{
var obj = stack.Pop();
stack.Insert(1, obj);
}
}
public static void Sample(IStackList<object> stack)
{
if (stack.HasA<int, IEnumerable<double>>())
{
var limit = stack.Pop<int>();
var seq = stack.Pop<IEnumerable<double>>();
stack.Push(seq.Take(limit));
}
}
public static void Load(IStackList <object> stack)
{
if (stack.HasA <string>())
{
var name = stack.Pop <string>();
var seq = SequenceFactory.Load(name);
stack.Push(seq);
}
}
public static void Cycle(IStackList<object> stack)
{
if (stack.HasA<IEnumerable<double>>())
{
var seq = stack.Pop<IEnumerable<double>>();
seq = seq.AsCycle();
stack.Push(seq);
}
}
public static void Saw(IStackList<object> stack)
{
if (stack.HasA<int>())
{
var x = 0;
var width = stack.Pop<int>();
var seq = SequenceFactory.From(() => Math.Pow(x++ % width, 2));
stack.Push(seq);
}
}
public static void Concat(IStackList<object> stack)
{
if (stack.HasA<IEnumerable<double>, IEnumerable<double>>())
{
var seq1 = stack.Pop<IEnumerable<double>>();
var seq2 = stack.Pop<IEnumerable<double>>();
var result = seq2.Concat(seq1);
stack.Push(result);
}
}
public static void Merge(IStackList<object> stack)
{
if (stack.HasA<IEnumerable<double>, IEnumerable<double>>())
{
var seq1 = stack.Pop<IEnumerable<double>>();
var seq2 = stack.Pop<IEnumerable<double>>();
var result = seq1.Zip(seq2, (a, b) => a + b);
stack.Push(result);
}
}
public static T Pop <T>(this IStackList <object> stack)
{
var item = stack.Pop();
if (typeof(T).IsAssignableFrom(item.GetType()))
{
return((T)item);
}
else
{
return((T)Convert.ChangeType(item, typeof(T)));
}
}
public static void Pick(IStackList <object> stack)
{
if (stack.HasA <int>())
{
var i = stack.Pop <int>();
if (i > stack.Count)
{
var obj = stack[i];
stack.Remove(obj);
stack.Push(obj);
}
else
{
stack.Push(i);
}
}
}
public static void Roll(IStackList <object> stack)
{
if (stack.HasA <int>())
{
var i = stack.Pop <int>();
if (i <= stack.Count)
{
for (var j = 0; j < i; j++)
{
var obj = stack.Pop();
stack.Add(obj);
}
}
else
{
stack.Push(i);
}
}
}
public static void Map(IStackList<object> stack)
{
if (stack.HasA<string, IEnumerable<double>>())
{
var expr = stack.Pop<string>();
var seq = stack.Pop<IEnumerable<double>>();
var ctx = new ExpressionContext();
ctx.Imports.AddType(typeof(Math));
ctx.Imports.AddType(typeof(Probability));
ctx.Variables["x"] = 0.0;
var gexpr = ctx.CompileGeneric<double>(expr);
var result = seq.Select(x =>
{
ctx.Variables["x"] = x;
return gexpr.Evaluate();
});
stack.Push(result);
}
}
static public IStackList<T> Append<T>(this IStackList<T> _this, T element)
{
return new MutableStackList<T>(_this.FromBottomToTop().Add(element));
}
public static bool HasA <T1, T2>(this IStackList <object> stack)
{
return(stack.HasA <T1>(0) && stack.HasA <T2>(1));
}
public static bool HasA <T>(this IStackList <object> stack, int idx)
{
return(typeof(T).IsAssignableFrom(stack[idx].GetType()));
}
public static string[] ToDisplay(this IStackList <object> stack)
{
var text = stack.Select(item => item.ToString());
return(text.ToArray());
}
public static void Para(IStackList<object> stack)
{
var x = 0;
var seq = SequenceFactory.From(() => Math.Pow(x++, 2));
stack.Push(seq);
}
public static void Base(IStackList<object> stack)
{
var x = 0;
var seq = SequenceFactory.From(() => x++);
stack.Push(seq);
}
public static void Noise(IStackList<object> stack)
{
var seq = SequenceFactory.From(Probability.Normal);
stack.Push(seq);
}
public static void Clear(IStackList <object> stack)
{
stack.Clear();
}
