KernelDispatch.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Wolfram.NETLink;

namespace PolyLink
{
    public class KernelDispatch : IKernelDispatch
    {
        public static int KernelWait = 1;

        private readonly IKernelLink _kernel;

        public KernelDispatch()
        {
            //Set up kernel link
            _kernel = MSingle.Kernel;
            //_kernel.WaitAndDiscardAnswer();
        }

        public IKernelLink Kernel
        {
            get { return _kernel; }
        }
        
        public IKernelOperation this[string s]
        {
            get
            {
                return new KernelOperation(_kernel, s);
            }
        }
    }

    public interface IKernelOperation
    {
        string Command { get; }

        IKernelLink Kernel { get; }

        KernelOperation Format(params object[] args);

        KernelOperation Bracket(params object[] args);

        KernelOperation Bracket<T>(IEnumerable<T> args);

        object EvalObject();

        Expr Eval();

        Func<Expr, Expr> EvalFunc();

        KernelOperation FullSimplify();
    }

    public struct KernelOperation : IKernelOperation
    {
        private readonly string _command;
        private readonly IKernelLink _kernel;

        public KernelOperation(IKernelLink kernel, string command)
        {
            _kernel = kernel;
            _command = command;
        }

        public string Command
        {
            get { return _command; }
        }

        public IKernelLink Kernel
        {
            get { return _kernel; }
        }

        public void CheckArgs<T>(IEnumerable<T> args)
        {
            if (args.Any(t => t is KernelOperation))
            {
                throw new ArgumentException("Never feed a KernelOperation into another KernelOperation. You probably forgot an Eval somewhere.");
            }
        }

        public KernelOperation Format(params object[] args)
        {
            CheckArgs(args.AsEnumerable());
            return new KernelOperation(Kernel, String.Format(Command, args.Select(o => "(" + o.ToString() + ")").ToArray()));
        }

        public KernelOperation Bracket(params object[] args)
        {
            CheckArgs(args.AsEnumerable());
            return Bracket(args.AsEnumerable());
        }

        public KernelOperation Bracket<T>(IEnumerable<T> args)
        {
            args = args.ToArray();
            CheckArgs(args);
            return new KernelOperation(Kernel,
                String.Format("{0}[{1}]",_command, String.Join(",", args))
                );
        }

        public object EvalObject()
        {
            MaybePrint();
            Kernel.Evaluate(_command);
            Kernel.WaitForAnswer();
            var e = Kernel.GetExpr();
            //Console.WriteLine("Result of EvalObject was {0} characters big", e.ToString().Length);
            Kernel.Evaluate(e);
            Kernel.WaitForAnswer();
            return Kernel.GetObject();

        }



        public Expr Eval()
        {
            MaybePrint();
            Kernel.Evaluate(_command);
            Kernel.WaitForAnswer();
            Expr e = Kernel.GetExpr();
            //Console.WriteLine("Result of Eval was {0} characters big", e.ToString().Length);
            return e;
        }

        public Func<Expr, Expr> EvalFunc()
        {
            var k = Kernel;
            var s = _command;
            return delegate(Expr expr)
                {
                    k.Evaluate(String.Format("{0}[{1}]", s, expr));
                    k.WaitForAnswer();
                    return k.GetExpr();
                };
        }

        public KernelOperation FullSimplify()
        {
            return new KernelOperation(Kernel, String.Format("RootReduce[{0}]",Command));
        }


        private static int x = 0;

        private void MaybePrint()
        {
            x++;
            if (x%1000 == 0)
                Console.WriteLine("Computation number: {0}", x);
        }
    }
}