Esempio n. 1
0
 public void notifyStatus(String msg, String url, double perc)
 {
     if (TradeSystemActionsTextbox.InvokeRequired)
     {
         try
         {
             DelegateNotifyStatus method = notifyStatus;
             this.Invoke(method, new object[] { msg, url, perc });
         }
         catch (ObjectDisposedException) { }
     }
     else
     {
         if (msg.Equals("TradeSystemAction"))
         {
             TradeSystemActionsTextbox.AppendText(url + "\n");
         }
         else if (msg.Equals("TradeSystemDBPurge"))
         {
             HeartBeat();
         }
     }
 }
Esempio n. 2
0
        private void ManageResults()
        {
            double[] ops_good      = new double[MaxLambda];
            double[] ops_good_gain = new double[MaxLambda];

            double[] ops_bad      = new double[MaxLambda];
            double[] ops_bad_gain = new double[MaxLambda];

            double[] ops_very_good = new double[MaxLambda];
            double[] ops_very_bad  = new double[MaxLambda];

            double[] ops_tot          = new double[MaxLambda];
            double[] delta_t          = new double[MaxLambda];
            double[] total_gain       = new double[MaxLambda];
            double[] total_investment = new double[MaxLambda];

            double[] title_good_tot = new double[MaxLambda];
            double[] title_good_bad = new double[MaxLambda];

            double[] time_day_good_tot   = new double[MaxLambda];
            double[] time_day_good_bad   = new double[MaxLambda];
            double[] time_week_good_tot  = new double[MaxLambda];
            double[] time_week_good_bad  = new double[MaxLambda];
            double[] time_month_good_tot = new double[MaxLambda];
            double[] time_month_good_bad = new double[MaxLambda];

            double[] INDEX = new double[MaxLambda];

            for (int i = 0; i < MaxLambda; i++)
            {
                ops_good[i]      = 0;
                ops_good_gain[i] = 0;

                ops_bad[i]      = 0;
                ops_bad_gain[i] = 0;

                ops_very_good[i] = 0;
                ops_very_bad[i]  = 0;

                ops_tot[i]          = 0;
                delta_t[i]          = 0;
                total_gain[i]       = 0;
                total_investment[i] = 0;

                title_good_tot[i] = 0;
                title_good_bad[i] = 0;

                time_day_good_tot[i]   = 0;
                time_day_good_bad[i]   = 0;
                time_week_good_tot[i]  = 0;
                time_week_good_bad[i]  = 0;
                time_month_good_tot[i] = 0;
                time_month_good_bad[i] = 0;

                INDEX[i] = 0;
            }

            for (int i = 0; i < TotSim; i++)
            {
                int index = sim_results[i].lambda;

                ops_good[index]      += sim_results[i].ops_good;
                ops_good_gain[index] += sim_results[i].ops_good_gain;

                ops_bad[index]      += sim_results[i].ops_bad;
                ops_bad_gain[index] += sim_results[i].ops_bad_gain;

                ops_very_good[index] += sim_results[i].ops_very_good;
                ops_very_bad[index]  += sim_results[i].ops_very_bad;

                ops_tot[index]          += sim_results[i].ops_tot;
                delta_t[index]          += sim_results[i].delta_t;
                total_gain[index]       += sim_results[i].total_gain;
                total_investment[index] += sim_results[i].total_investment;

                title_good_tot[index] += sim_results[i].title_good_tot;
                title_good_bad[index] += sim_results[i].title_good_bad;

                time_day_good_tot[index]   += sim_results[i].time_day_good_tot;
                time_day_good_bad[index]   += sim_results[i].time_day_good_bad;
                time_week_good_tot[index]  += sim_results[i].time_week_good_tot;
                time_week_good_bad[index]  += sim_results[i].time_week_good_bad;
                time_month_good_tot[index] += sim_results[i].time_month_good_tot;
                time_month_good_bad[index] += sim_results[i].time_month_good_bad;

                INDEX[index] += sim_results[i].INDEX;
            }

            for (int i = InitLambda; i < MaxLambda; i++)
            {
                ops_good[i]      /= RunN;
                ops_good_gain[i] /= RunN;

                ops_bad[i]      /= RunN;
                ops_bad_gain[i] /= RunN;

                ops_very_good[i] /= RunN;
                ops_very_bad[i]  /= RunN;

                ops_tot[i]          /= RunN;
                delta_t[i]          /= RunN;
                total_gain[i]       /= RunN;
                total_investment[i] /= RunN;

                title_good_tot[i] /= RunN;
                title_good_bad[i] /= RunN;

                time_day_good_tot[i]   /= RunN;
                time_day_good_bad[i]   /= RunN;
                time_week_good_tot[i]  /= RunN;
                time_week_good_bad[i]  /= RunN;
                time_month_good_tot[i] /= RunN;
                time_month_good_bad[i] /= RunN;

                INDEX[i] /= RunN;
            }

            StreamWriter SW = null;

            try { SW = new StreamWriter(simulationfilenameTextbox.Text); }
            catch (Exception) { SW = null; }


            for (int i = InitLambda; i < MaxLambda; i++)
            {
                TradeSystemActionsTextbox.AppendText("[" + i + "] PROFIT: " + ((int)(total_gain[i])) + "\n");

                SW.Write(i + " ");                                                     // 1
                SW.Write(total_gain[i] + " " + total_investment[i] + " ");             // 2 3
                SW.Write(ops_good[i] + " " + ops_bad[i] + " " + ops_tot[i] + " ");     // 4 5 6
                SW.Write(ops_good_gain[i] + " " + ops_bad_gain[i] + " ");              // 7 8
                SW.Write(ops_very_good[i] + " " + ops_very_bad[i] + " ");              // 9 10
                SW.Write(title_good_tot[i] + " " + time_day_good_bad[i] + " ");        // 11 12
                SW.Write(time_day_good_tot[i] + " " + time_day_good_bad[i] + " ");     // 13 14
                SW.Write(time_week_good_tot[i] + " " + time_week_good_bad[i] + " ");   // 15 16
                SW.Write(time_month_good_tot[i] + " " + time_month_good_bad[i] + " "); // 17 18
                SW.Write(delta_t[i] + " ");                                            // 19
                SW.Write(INDEX[i] + " ");                                              // 20
                SW.WriteLine();
            }

            SW.Close();
        }
Esempio n. 3
0
        public void notifySimulationStatus(String msg, TradeSystem t)
        {
            if (TradeSystemActionsTextbox.InvokeRequired)
            {
                try
                {
                    DelegateSimulationStatus method = notifySimulationStatus;
                    this.Invoke(method, new object[] { msg, t });
                }
                catch (ObjectDisposedException) { }
            }
            else
            {
                if (msg.Equals("DONE"))
                {
                    sim_results[sim_done++] = t.Results;

                    RunN   = Int32.Parse(textBox1.Text);
                    TotSim = (int)((MaxLambda - InitLambda) * RunN);

                    int val0 = (int)(100 * sim_done / TotSim);
                    int val  = val0 - progressBar1.Value;
                    progressBar1.Increment(val);

                    TradeSystemActionsTextbox.Clear();
                    double timeremaining = (TotSim - sim_done) * ((DateTime.Now - time_start).TotalSeconds) / (sim_done);
                    int    min           = (int)(timeremaining / 60);
                    int    sec           = (int)(timeremaining % 60);
                    if (min == 0)
                    {
                        TradeSystemActionsTextbox.AppendText("Time Remaining: " + sec + "''\n");
                    }
                    else
                    {
                        TradeSystemActionsTextbox.AppendText("Time Remaining: " + min + "' " + sec + "''\n");
                    }

                    if (sim_done == 1)
                    {
                        TradeSystemActionsTextbox.Clear();
                        TradeSystemActionsTextbox.AppendText("Time Remaining: -----\n");
                    }


                    if (sim_done == TotSim)
                    {
                        TradeSystemActionsTextbox.Clear();
                        sec = (int)((DateTime.Now - time_start).TotalSeconds);
                        min = (int)(sec / 60);
                        sec = (int)(sec % 60);
                        if (min == 0)
                        {
                            TradeSystemActionsTextbox.AppendText("Simulation Time: " + sec + "''\n");
                        }
                        else
                        {
                            TradeSystemActionsTextbox.AppendText("Simulation Time: " + min + "' " + sec + "''\n");
                        }


                        tradesystem_tasklist = null;

                        ManageResults();

                        FindSimulationFilename();
                        maxlambdaTextbox.ReadOnly  = false;
                        initlambdaTextbox.ReadOnly = false;
                        textBox1.ReadOnly          = false;
//						SomeStuff();
                    }
                    else
                    {
                        int index = sim_done + max_threads - 1;

                        if (index < tradesystem_tasklist.Count)
                        {
                            tradesystem_tasklist.ElementAt(index).run();
                        }
                    }
                }
            }
        }