예제 #1
0
        private void SetupDotNetToRConverters()
        {
            SetupDotNetToRConverter(typeof(void), p => null);

            SetupDotNetToRConverter(typeof(string), p => engine.CreateCharacter((string)p));
            SetupDotNetToRConverter(typeof(string[]), p => engine.CreateCharacterVector((string[])p));
            SetupDotNetToRConverter(typeof(List <string>), p => engine.CreateCharacterVector((IEnumerable <string>)p));
            SetupDotNetToRConverter(typeof(IList <string>), p => engine.CreateCharacterVector((IEnumerable <string>)p));
            SetupDotNetToRConverter(typeof(ICollection <string>), p => engine.CreateCharacterVector((IEnumerable <string>)p));
            SetupDotNetToRConverter(typeof(IEnumerable <string>), p => engine.CreateCharacterVector((IEnumerable <string>)p));
            SetupDotNetToRConverter(typeof(string[, ]), p => engine.CreateCharacterMatrix((string[, ])p));

            SetupDotNetToRConverter(typeof(int), p => engine.CreateInteger((int)p));
            SetupDotNetToRConverter(typeof(int[]), p => engine.CreateIntegerVector((int[])p));
            SetupDotNetToRConverter(typeof(List <int>), p => engine.CreateIntegerVector((IEnumerable <int>)p));
            SetupDotNetToRConverter(typeof(IList <int>), p => engine.CreateIntegerVector((IEnumerable <int>)p));
            SetupDotNetToRConverter(typeof(ICollection <int>), p => engine.CreateIntegerVector((IEnumerable <int>)p));
            SetupDotNetToRConverter(typeof(IEnumerable <int>), p => engine.CreateIntegerVector((IEnumerable <int>)p));
            SetupDotNetToRConverter(typeof(int[, ]), p => engine.CreateIntegerMatrix((int[, ])p));

            SetupDotNetToRConverter(typeof(bool), p => engine.CreateLogical((bool)p));
            SetupDotNetToRConverter(typeof(bool[]), p => engine.CreateLogicalVector((bool[])p));
            SetupDotNetToRConverter(typeof(List <bool>), p => engine.CreateLogicalVector((IEnumerable <bool>)p));
            SetupDotNetToRConverter(typeof(IList <bool>), p => engine.CreateLogicalVector((IEnumerable <bool>)p));
            SetupDotNetToRConverter(typeof(ICollection <bool>), p => engine.CreateLogicalVector((IEnumerable <bool>)p));
            SetupDotNetToRConverter(typeof(IEnumerable <bool>), p => engine.CreateLogicalVector((IEnumerable <bool>)p));
            SetupDotNetToRConverter(typeof(bool[, ]), p => engine.CreateLogicalMatrix((bool[, ])p));

            SetupDotNetToRConverter(typeof(double), p => engine.CreateNumeric((double)p));
            SetupDotNetToRConverter(typeof(double[]), p => engine.CreateNumericVector((double[])p));
            SetupDotNetToRConverter(typeof(List <double>), p => engine.CreateNumericVector((IEnumerable <double>)p));
            SetupDotNetToRConverter(typeof(IList <double>), p => engine.CreateNumericVector((IEnumerable <double>)p));
            SetupDotNetToRConverter(typeof(ICollection <double>), p => engine.CreateNumericVector((IEnumerable <double>)p));
            SetupDotNetToRConverter(typeof(IEnumerable <double>), p => engine.CreateNumericVector((IEnumerable <double>)p));
            SetupDotNetToRConverter(typeof(double[, ]), p => engine.CreateNumericMatrix((double[, ])p));

            SetupDotNetToRConverter(typeof(DateTime), p => engine.CreatePosixct((DateTime)p));
            SetupDotNetToRConverter(typeof(DateTime[]), p => engine.CreatePosixctVector((DateTime[])p));
            SetupDotNetToRConverter(typeof(List <DateTime>), p => engine.CreatePosixctVector((IEnumerable <DateTime>)p));
            SetupDotNetToRConverter(typeof(IList <DateTime>), p => engine.CreatePosixctVector((IEnumerable <DateTime>)p));
            SetupDotNetToRConverter(typeof(ICollection <DateTime>), p => engine.CreatePosixctVector((IEnumerable <DateTime>)p));
            SetupDotNetToRConverter(typeof(IEnumerable <DateTime>), p => engine.CreatePosixctVector((IEnumerable <DateTime>)p));
            SetupDotNetToRConverter(typeof(DateTime[, ]), p => engine.CreatePosixctMatrix((DateTime[, ])p));

            SetupDotNetToRConverter(typeof(TimeSpan), p => engine.CreateDiffTime((TimeSpan)p));
            SetupDotNetToRConverter(typeof(TimeSpan[]), p => engine.CreateDiffTimeVector((TimeSpan[])p));
            SetupDotNetToRConverter(typeof(List <TimeSpan>), p => engine.CreateDiffTimeVector((IEnumerable <TimeSpan>)p));
            SetupDotNetToRConverter(typeof(IList <TimeSpan>), p => engine.CreateDiffTimeVector((IEnumerable <TimeSpan>)p));
            SetupDotNetToRConverter(typeof(ICollection <TimeSpan>), p => engine.CreateDiffTimeVector((IEnumerable <TimeSpan>)p));
            SetupDotNetToRConverter(typeof(IEnumerable <TimeSpan>), p => engine.CreateDiffTimeVector((IEnumerable <TimeSpan>)p));
            SetupDotNetToRConverter(typeof(TimeSpan[, ]), p => engine.CreateDiffTimeMatrix((TimeSpan[, ])p));
        }
예제 #2
0
        private void MakePtfReport(string[] input_files, string path_out, string report_name)
        {
            // make sure we start in the correct directory with a clean environment
            engine.Evaluate("rm(list=ls())");
            engine.Evaluate("gc()");
            engine.Evaluate("setwd('C:/Users/Keiran/Documents/Backtest_Source/R')");

            // pass pnl files into R
            CharacterVector r_input_files = engine.CreateCharacterVector(input_files);

            engine.SetSymbol("filenames", r_input_files);

            // output directory
            CharacterVector r_path_out = engine.CreateCharacterVector(new string[] { path_out });

            engine.SetSymbol("path.out", r_path_out);

            // report name
            CharacterVector r_filestem = engine.CreateCharacterVector(new string[] { report_name });

            engine.SetSymbol("filestem", r_filestem);

            // pass in dates and flags
            LogicalVector r_relrtns = engine.CreateLogicalVector(new bool[] { relative_returns });

            engine.SetSymbol("rel.rtns", r_relrtns);
            CharacterVector r_startEndDate = engine.CreateCharacterVector(new string[] { date_start.ToShortDateString(), date_end.ToShortDateString() });

            engine.SetSymbol("start.end.dates", r_startEndDate);


            // 2. sanity checks
            engine.Evaluate("print(rel.rtns)");
            engine.Evaluate("print(start.end.dates)");
            engine.Evaluate("print(filenames)");
            engine.Evaluate("print(path.out)");
            engine.Evaluate("print(filestem)");

            // 3. run R script to make daily pnl
            engine.Evaluate("source('PortfolioMakeReport.R')");

            // 4. copy pdf report to output directory
            string pdffile      = report_name + ".pdf";
            string pdffile_orig = System.IO.Path.Combine(@"C:\Temp\TeX_Tmp\", pdffile);

            pdffile_dest = System.IO.Path.Combine(path_out, pdffile);
            File.Copy(pdffile_orig, pdffile_dest, true);

            // 5. copy daily and monthly pnl files to output directory
            string daily_file      = report_name + "_pnl_daily.csv";
            string daily_file_orig = System.IO.Path.Combine(@"C:\Temp\TeX_Tmp\", daily_file);
            string daily_file_dest = System.IO.Path.Combine(path_out, daily_file);

            File.Copy(daily_file_orig, daily_file_dest, true);
            string monthly_file      = report_name + "_pnl_monthly.csv";
            string monthly_file_orig = System.IO.Path.Combine(@"C:\Temp\TeX_Tmp\", monthly_file);
            string monthly_file_dest = System.IO.Path.Combine(path_out, monthly_file);

            File.Copy(monthly_file_orig, monthly_file_dest, true);
        }
예제 #3
0
        public static void Start(REngine engine)
        {
            Console.WriteLine("\n\nExporting Objects\n\n");
            string RCodeString = string.Empty;

            //R character vector -- R.NET RDotNet.RDotNet.CharacterVector
            Console.WriteLine("\nR character vector\n");
            string[]        myStringArray     = new string[] { "PIDataLink", "PIProcessBook", "PIWebParts" };
            CharacterVector myCharacterVector = engine.CreateCharacterVector(myStringArray.AsEnumerable());

            engine.SetSymbol("mycharvector", myCharacterVector);
            engine.Evaluate("print(mycharvector)");


            //R integer vector -- R.NET RDotNet.NumericVector
            Console.WriteLine("\nR int vector\n");
            int[]         myIntegerArray  = new int[] { 4, 6, 10, 140, 54, 25 };
            IntegerVector myIntegerVector = engine.CreateIntegerVector(myIntegerArray);

            engine.SetSymbol("myintvector", myIntegerVector);
            engine.Evaluate("print(myintvector)");

            //R real vector -- R.NET RDotNet.NumericVector
            Console.WriteLine("\nR real vector\n");
            NumericVector myNumericVector = engine.CreateNumericVector(new double[] { 30.02, 29.99, 30.11, 29.97, 30.01, 29.99 });

            engine.SetSymbol("mynumvector", myNumericVector);
            engine.Evaluate("print(mynumvector)");

            //R complex vector -- R.NET RDotNet.ComplexVector
            Console.WriteLine("\nR complex vector\n");
            Complex[]     myComplexArray  = new Complex[] { Complex.FromPolarCoordinates(10, 0.524), new Complex(12, 6), new Complex(14, 3), (Complex)12.3m, Complex.One + Complex.One };
            ComplexVector myComplexVector = engine.CreateComplexVector(myComplexArray);

            engine.SetSymbol("mycomplexvector", myComplexVector);
            engine.Evaluate("print(mycomplexvector)");


            //R raw vector -- R.NET RDotNet.RawVector
            Console.WriteLine("\nR raw vector\n");
            byte[]    myByteArray = System.Text.Encoding.ASCII.GetBytes("u03a0");
            RawVector myRawVector = engine.CreateRawVector(myByteArray);

            engine.SetSymbol("myrawvector", myRawVector);
            engine.Evaluate("print(myrawvector)");

            //R logical vector -- R.NET RDotNet.LogicalVector
            Console.WriteLine("\nR logical vector\n");
            LogicalVector myLogicalVector = engine.CreateLogicalVector(new Boolean[] { true, false, false, false, true });

            engine.SetSymbol("mylogicalvector", myLogicalVector);
            engine.Evaluate("print(mylogicalvector)");
        }