API tools faq
paste
Advertisement
NUCLEARESOL

Middle school Thesis

NUCLEARESOL
Jun 8th, 2024
486
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 22.16 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Diagnostics;
  3. using System.Threading;
  4. using System.Globalization;
  5.  
  6. class Program
  7. {
  8.  
  9.     static void Main()
  10.     {
  11.         int version = 1;
  12.         string type = "parabola";
  13.         double gravitationalA = 9.81d;
  14.         double[] startPoint = {5,10};
  15.         double[] endpoint = { 0, 0 };
  16.         double[] rangex = { 5, 10 };
  17.         double[] rangey = { 5, 10 };
  18.         const Boolean calculateDistance = false;
  19.         Boolean researchMode = false;
  20.  
  21.         Console.WriteLine("Following Variables are used:");
  22.         Console.WriteLine("Gravitational Accel: " + gravitationalA + " m/s");
  23.         Console.WriteLine("Goal: " + endpoint[0] + "," + endpoint[1]);
  24.         Console.WriteLine("Start: " + startPoint[0] + "," + startPoint[1]);
  25.         Console.WriteLine("Calculate Distance" + calculateDistance);
  26.         Console.WriteLine("Research Mode" + researchMode);
  27.         Console.WriteLine("y/n");
  28.         string confirmation = Console.ReadLine();
  29.  
  30.         if (confirmation != "y")
  31.         {
  32.             Console.WriteLine("");
  33.             Console.WriteLine("Abort, Please change the variable");
  34.             Console.WriteLine("graph type");
  35.             type = Console.ReadLine();
  36.             Console.WriteLine("Gravitational Acceleration");
  37.             gravitationalA = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture.NumberFormat);
  38.             Console.WriteLine("Research Mode");
  39.             researchMode = bool.Parse(Console.ReadLine());
  40.             if (researchMode != true)
  41.             {
  42.                 Console.WriteLine("Start Point X");
  43.                 startPoint[0] = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture.NumberFormat);
  44.                 Console.WriteLine("Start Point Y");
  45.                 startPoint[1] = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture.NumberFormat);
  46.             }
  47.             else
  48.             {
  49.                 Console.WriteLine("X min");
  50.                 rangex[0] = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture.NumberFormat);
  51.                 Console.WriteLine("X max");
  52.                 rangex[1] = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture.NumberFormat);
  53.  
  54.                 Console.WriteLine("Y min");
  55.                 rangey[0] = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture.NumberFormat);
  56.                 Console.WriteLine("Y max");
  57.                 rangey[1] = double.Parse(Console.ReadLine(), CultureInfo.InvariantCulture.NumberFormat);
  58.             }
  59.             Console.WriteLine("");
  60.             Console.WriteLine("Following Variables are used:");
  61.             Console.WriteLine("Gravitational Accel: " + gravitationalA + " m/s");
  62.             Console.WriteLine("Goal: " + endpoint[0] + "," + endpoint[1]);
  63.             Console.WriteLine("Start: " + startPoint[0] + "," + startPoint[1]);
  64.             //Thread.Sleep(3000);
  65.         }
  66.  
  67.         // Console.WriteLine("");
  68.         // Console.WriteLine("Starting calculation");
  69.         double x = startPoint[0];
  70.         double velX = 0f;
  71.         const double timestep = 0.001f;
  72.         double time = 0f;
  73.         double initialCollvar = 1;
  74.         double initialCollvarStep = 0.1f;
  75.         double zeroInAccuracy = 0.000001f;
  76.         double maxTime = double.PositiveInfinity;
  77.         double limit = 400;
  78.         string strg = "";
  79.         Console.WriteLine(limit);
  80.         var start = Process.GetCurrentProcess().TotalProcessorTime;
  81.         int i = 0;
  82.         static double NewtonsMethod(double target, double initialGuess, double tolerance, int maxIterations)
  83.         {
  84.             double x = initialGuess;
  85.  
  86.             for (int i = 0; i < maxIterations; i++)
  87.             {
  88.                 double fx = (2 * x - Math.Sin(2 * x)) / (1 - Math.Cos(2 * x));
  89.                 double derivative = -2 * ((x / Math.Tan(x)) - 1) * Math.Pow(1 / Math.Sin(x), 2);
  90.                 Console.WriteLine(x + " " + fx + " " + derivative);
  91.                 //Thread.Sleep(1000);
  92.                 if (Math.Abs(fx - target) < tolerance)
  93.                 {
  94.                     Console.WriteLine($"Converged after {i} iterations.");
  95.                     return x;
  96.                 }
  97.  
  98.                 x = x - (fx - target) / derivative;
  99.             }
  100.  
  101.             Console.WriteLine("Did not converge within the specified number of iterations.");
  102.             return x;
  103.         }
  104.         static void Print2DArray<T>(T[,] matrix)
  105.         {
  106.             for (int i = 0; i < matrix.GetLength(0); i++)
  107.             {
  108.                 for (int j = 0; j < matrix.GetLength(1); j++)
  109.                 {
  110.                     Console.Write(matrix[i, j] + "\t");
  111.                 }
  112.                 Console.WriteLine();
  113.             }
  114.         }
  115.         Tuple<double, double> calculateAcceleration(double X, double collVar, double depvar1, double depvar2)
  116.         {
  117.             double localSlope = 2.0f * collVar * (X - depvar1);
  118.  
  119.             //Console.WriteLine(-(float)(Math.Cos(Math.Atan(1f / localSlope)) * Math.Sin(Math.Atan(1f / localSlope)) * gravitationalA));
  120.             return Tuple.Create(-(double)(Math.Cos(Math.Atan(1f / localSlope)) * Math.Sin(Math.Atan(1f / localSlope)) * gravitationalA), localSlope);
  121.         }
  122.         Tuple<double, double> calculateAccelerationCircle(double X, double Y, double collVar, double h, double k)
  123.         {
  124.             double localSlope = (h - X) / (Y - k);
  125.  
  126.             //return -(float)(Math.Cos(Math.Atan(1f / localSlope)) * Math.Sin(Math.Atan(1f / localSlope)) * gravitationalA);
  127.             return Tuple.Create(-(double)(Math.Cos(Math.Atan(1f / localSlope)) * Math.Sin(Math.Atan(1f / localSlope)) * gravitationalA), localSlope);
  128.         }
  129.         Tuple<double, double> calculateAccelerationCubic(double X, double collVar, double h, double k)
  130.         {
  131.             double localSlope = collVar*3.0d*Math.Pow(X-h,2.0);
  132.  
  133.             //return -(float)(Math.Cos(Math.Atan(1f / localSlope)) * Math.Sin(Math.Atan(1f / localSlope)) * gravitationalA);
  134.             return Tuple.Create(-(double)(Math.Cos(Math.Atan(1f / localSlope)) * Math.Sin(Math.Atan(1f / localSlope)) * gravitationalA), localSlope);
  135.         }
  136.  
  137.         Console.WriteLine(strg);
  138.         Console.WriteLine("");
  139.         strg = "";
  140.         Tuple<double, double, double, double> CalculateTimeParabola(double initialCollvar)
  141.         {
  142.             double h = 0;
  143.             double k = 0;
  144.             double distance = 0;
  145.             double deltaX = 0;
  146.             i = i + 1;
  147.             x = startPoint[0];
  148.             velX = 0f;
  149.             time = 0f;
  150.             distance = 0f;
  151.             h = 0.5f * (startPoint[0] - (startPoint[1] / (startPoint[0] * initialCollvar)));
  152.             k = -initialCollvar * (double)Math.Pow(h, 2);
  153.             //Console.WriteLine(h + "," + k);
  154.             if (h < startPoint[0] && k > startPoint[1])
  155.             {
  156.                 return Tuple.Create(limit, initialCollvar, h, k);
  157.             }
  158.             while (x>= 0 && time < limit)
  159.             {
  160.                 Tuple<double, double> calculatedValues = calculateAcceleration(x, initialCollvar, h, k);
  161.                 x = x - timestep;
  162.                 double y = initialCollvar * Math.Pow((x - h),2) + k;
  163.                 velX = Math.Sqrt(2 * gravitationalA * (startPoint[1]-y)) / (Math.Sqrt(Math.Pow(calculatedValues.Item2,2)+1));
  164.                 if (Double.IsNaN(velX) )
  165.                 {
  166.                     return Tuple.Create(limit, initialCollvar, h, k);
  167.                 }
  168.                 time = time + Math.Abs(timestep / velX);
  169.              
  170.                 //Console.Write("(" + x + "," + velX + "),");
  171.             }
  172.  
  173.             //Console.WriteLine(Math.Abs(Math.Abs(initialCollvarStep) * 100 - 100) + " % complete");
  174.             //Console.WriteLine();
  175.             //Console.WriteLine(time);
  176.             if (Double.IsNaN(time))
  177.             {
  178.                 time = limit;
  179.                 Console.WriteLine(time);
  180.             }
  181.             //Thread.Sleep(200000);
  182.             return Tuple.Create(time, initialCollvar, h, k);
  183.         }
  184.  
  185.         Tuple<double, double, double, double> CalculateTimeCircle(double initialCollvar)
  186.         {
  187.             if (initialCollvar < (double)Math.Sqrt(Math.Pow(startPoint[1], 2) + Math.Pow((Math.Pow(startPoint[1], 2) - Math.Pow(startPoint[0], 2)) / (-2 * startPoint[0]), 2)))
  188.             {
  189.                 return Tuple.Create(limit, initialCollvar, 0.0d, 0.0d);
  190.             }
  191.             double q = Math.Sqrt(Math.Pow(startPoint[1], 2) + Math.Pow(startPoint[0], 2));
  192.             double x3 = startPoint[0] / 2;
  193.             double y3 = startPoint[1] / 2;
  194.  
  195.  
  196.             double h = x3 + (Math.Sqrt(Math.Pow(initialCollvar, 2) - Math.Pow(q / 2, 2)) * (-startPoint[1])) / q;
  197.             double k = y3 + (Math.Sqrt(Math.Pow(initialCollvar, 2) - Math.Pow(q / 2, 2)) * (startPoint[0])) / q;
  198.  
  199.             double distance = 0;
  200.             double deltaX = 0;
  201.             i = i + 1;
  202.             x = startPoint[0];
  203.             velX = 0f;
  204.             time = 0f;
  205.             distance = 0f;
  206.             double y = k - Math.Sqrt(Math.Pow(initialCollvar, 2) - Math.Pow(x - h, 2));
  207.             while (x >= 0 && time < limit)
  208.             {
  209.                 Tuple<double, double> calculatedValues = calculateAccelerationCircle(x, y, initialCollvar, h, k);
  210.                 x = x - timestep;
  211.                 y = k - Math.Sqrt(Math.Pow(initialCollvar, 2) - Math.Pow(x - h, 2));
  212.                 velX = Math.Sqrt(2 * gravitationalA * (startPoint[1] - y)) / (Math.Sqrt(Math.Pow(calculatedValues.Item2, 2) + 1));
  213.                 if (Double.IsNaN(velX))
  214.                 {
  215.                     return Tuple.Create(limit, initialCollvar, h, k);
  216.                 }
  217.                 time = time + Math.Abs(timestep / velX);
  218.  
  219.  
  220.             }
  221.             // while (x >= 0 && time < limit)
  222.             // {
  223.             // y = k - Math.Sqrt(Math.Pow(initialCollvar, 2) - Math.Pow(x - h, 2));
  224.             //Tuple<double, double> calculatedVales = calculateAccelerationCircle(x, y, initialCollvar, h, k);
  225.             // deltaX = (double)(velX * timestep + 0.5f * calculatedVales.Item1 * Math.Pow(timestep, 2));
  226.             // x = (double)(x + deltaX);
  227.             // velX = velX + (0 + calculateAccelerationCircle(x, y, initialCollvar, h, k).Item1) * timestep / 1f;
  228.             //  if (calculateDistance)
  229.             // {
  230.             //     distance = distance + (double)Math.Sqrt(deltaX * deltaX * (calculatedVales.Item2 * calculatedVales.Item2 + 1.0f));
  231.             //  }
  232.             //  time = time + timestep;
  233.             //  }
  234.             if (Double.IsNaN(time))
  235.             {
  236.                 time = limit;
  237.                 Console.WriteLine(time);
  238.             }
  239.             return Tuple.Create(time, initialCollvar, h, k);
  240.         }
  241.         Tuple<double, double, double, double> CalculateTimeCubic(double initialCollvar)
  242.         {
  243.             double h = 0;
  244.             double k = 0;
  245.             double distance = 0;
  246.             double deltaX = 0;
  247.             i = i + 1;
  248.             x = startPoint[0];
  249.             velX = 0f;
  250.             time = 0f;
  251.             distance = 0f;
  252.             if (initialCollvar <= 0 |initialCollvar >= 12.0 * startPoint[1] / (3.0 * Math.Pow(startPoint[0], 3)))
  253.             {
  254.                 return Tuple.Create(limit+100, initialCollvar, h, k);
  255.             }
  256.  
  257.             h = (3.0d * Math.Pow(startPoint[0], 2) - Math.Sqrt(9.0d * Math.Pow(startPoint[0], 4) - 4.0 * 3.0 * startPoint[0] * (Math.Pow(startPoint[0], 3) - startPoint[1] / initialCollvar))) / (2 * 3 * startPoint[0]);
  258.             k = initialCollvar * (double)Math.Pow(h, 3);
  259.             while (x >= 0 && time < limit)
  260.             {
  261.                 Tuple<double, double> calculatedValues = calculateAccelerationCubic(x, initialCollvar, h, k);
  262.                 x = x - timestep;
  263.                 double y = initialCollvar * Math.Pow((x - h), 3) + k;
  264.                 velX = Math.Sqrt(2 * gravitationalA * (startPoint[1] - y)) / (Math.Sqrt(Math.Pow(calculatedValues.Item2, 2) + 1));
  265.                 if (Double.IsNaN(velX))
  266.                 {
  267.                     return Tuple.Create(limit, initialCollvar, h, k);
  268.                 }
  269.                 time = time + Math.Abs(timestep / velX);
  270.  
  271.                 //Console.Write("(" + x + "," + velX + "),");
  272.             }
  273.             //while (x >= 0 && time < limit)
  274.            // {
  275.               //  Tuple<double, double> calculatedVales = calculateAccelerationCubic(x, initialCollvar, h, k);
  276.             //    deltaX = (double)(velX * timestep + 0.5f * calculatedVales.Item1 * Math.Pow(timestep, 2));
  277.             //    x = (double)(x + deltaX);
  278.              //   velX = velX + (0 + calculateAccelerationCubic(x, initialCollvar, h, k).Item1) * timestep / 1f;
  279.              //   if (calculateDistance)
  280.                // {
  281.                //     distance = distance + (double)Math.Sqrt(deltaX * deltaX * (calculatedVales.Item2 * calculatedVales.Item2 + 1.0f));
  282.             //    }
  283.             //    time = time + timestep;
  284.            // }
  285.            //Console.WriteLine(initialCollvarStep);
  286.            // Thread.Sleep(100);
  287.             if (Double.IsNaN(time))
  288.             {
  289.                 time = limit;
  290.                // Console.WriteLine(time);
  291.             }
  292.  
  293.             return Tuple.Create(time, initialCollvar, h, k);
  294.         }
  295.  
  296.         Tuple<double, double, double, double, double, double> jumpingDecend()
  297.         {
  298.            Console.WriteLine(Math.Abs(initialCollvarStep)+","+zeroInAccuracy);
  299.             Thread.Sleep(1000);
  300.             double var1 = 0;
  301.             double var2 = 0;
  302.             double var3 = 0;
  303.             double var4 = 0;
  304.             if (type == "parabola")
  305.             {
  306.                 var1 = 0;
  307.                 var2 = 0;
  308.             }
  309.             if (type == "circle")
  310.             {
  311.                 initialCollvar = (double)Math.Sqrt(Math.Pow(startPoint[1], 2) + Math.Pow((Math.Pow(startPoint[1], 2) - Math.Pow(startPoint[0], 2)) / (-2 * startPoint[0]), 2));
  312.                 //  Console.WriteLine(initialCollvar+"RADIUS");
  313.             }
  314.             if (type == "cubic")
  315.             {
  316.                 initialCollvar = (12.0 * startPoint[1] / (3.0 * Math.Pow(startPoint[0], 3)))/2;
  317.                 initialCollvarStep = (12.0 * startPoint[1] / (3.0 * Math.Pow(startPoint[0], 3))) / 20;
  318.                 zeroInAccuracy = initialCollvar / 100000;
  319.                // zeroInAccuracy = 0.0;
  320.                // Console.WriteLine(initialCollvar+"RADIUS");
  321.             }
  322.  
  323.             while (Math.Abs(initialCollvarStep) >= zeroInAccuracy)
  324.             {
  325.                 // --  Console.Write("BOB");
  326.                 initialCollvar = initialCollvar + initialCollvarStep;
  327.                 if (type == "parabola")
  328.                 {
  329.                     time = CalculateTimeParabola(initialCollvar).Item1;
  330.                 }
  331.                 else if (type == "circle")
  332.                 {
  333.                     time = CalculateTimeCircle(initialCollvar).Item1;
  334.                 }
  335.                 else if (type == "cubic")
  336.                 {
  337.                     time = CalculateTimeCubic(initialCollvar).Item1;
  338.                     //Console.WriteLine(time + "," + (time - maxTime));
  339.                 }
  340.                 // Console.WriteLine(distance);
  341.                 //  Console.WriteLine(initialCollvar + "(x-" + h + ")^2+" + k);
  342.                 strg = strg + "(" + initialCollvar + "," + time + ")" + ",";
  343.                 if (maxTime > time)
  344.                 {
  345.                     maxTime = time;
  346.                     initialCollvarStep = initialCollvarStep * 2;
  347.                 }
  348.  
  349.                 else if (time > maxTime)
  350.                 {
  351.                     if (time >= limit)
  352.                     {
  353.                         initialCollvar = initialCollvar - initialCollvarStep;
  354.                         initialCollvarStep = -initialCollvarStep / 4;
  355.                     }
  356.                     else if (Math.Abs(time - maxTime) > 0.0000000001)
  357.                     {
  358.                         //Console.WriteLine(Math.Abs(time - maxTime));
  359.                         initialCollvarStep = -initialCollvarStep;
  360.                     }
  361.                     else if (Math.Abs(time - maxTime) < 0.0000000001)
  362.                     {
  363.                         initialCollvarStep = initialCollvarStep / 2;
  364.                        // Console.WriteLine("EQUAL");
  365.                     }
  366.                 }
  367.                 else
  368.                 {
  369.                     initialCollvarStep = initialCollvarStep / 2;
  370.  
  371.                 }
  372.             }
  373.            
  374.             if (type == "circle")
  375.             {
  376.                 Tuple<double, double, double, double> resultcal = CalculateTimeCircle(initialCollvar);
  377.                 time = CalculateTimeCircle(initialCollvar).Item1;
  378.                 var1 = resultcal.Item1;
  379.                 var2 = resultcal.Item3;
  380.                 var3 = resultcal.Item4;
  381.             }
  382.             else if (type == "parabola")
  383.             {
  384.                 Tuple<double, double, double, double> resultcal = CalculateTimeParabola(initialCollvar);
  385.                 time = CalculateTimeParabola(initialCollvar).Item1;
  386.                 var1 = resultcal.Item2;
  387.                 var2 = resultcal.Item3;
  388.                 var3 = resultcal.Item4;
  389.             }
  390.             else if (type == "cubic")
  391.             {
  392.                 Tuple<double, double, double, double> resultcal = CalculateTimeCubic(initialCollvar);
  393.                 time = CalculateTimeCubic(initialCollvar).Item1;
  394.                 var1 = resultcal.Item2;
  395.                 var2 = resultcal.Item3;
  396.                 var3 = resultcal.Item4;
  397.             }
  398.             if (time > limit)
  399.             {
  400.  
  401.                 if (type == "circle")
  402.                 {
  403.                     initialCollvar = initialCollvar - initialCollvarStep / 2;
  404.                     Tuple<double, double, double, double> resultcal = CalculateTimeCircle(initialCollvar);
  405.                     time = resultcal.Item1;
  406.                     var1 = resultcal.Item2;
  407.                     var2 = resultcal.Item3;
  408.                     var3 = resultcal.Item4;
  409.                 }
  410.                 else if (type == "parabola")
  411.                 {
  412.                     initialCollvar = initialCollvar - initialCollvarStep / 2;
  413.                     Tuple<double, double, double, double> resultcal = CalculateTimeParabola(initialCollvar);
  414.                     time = resultcal.Item1;
  415.                     var1 = resultcal.Item2;
  416.                     var2 = resultcal.Item3;
  417.                     var3 = resultcal.Item4;
  418.                 }
  419.                 else if (type == "cubic")
  420.                 {
  421.                     initialCollvar = initialCollvar - initialCollvarStep / 2;
  422.                     Tuple<double, double, double, double> resultcal = CalculateTimeCubic(initialCollvar);
  423.                     time = resultcal.Item1;
  424.                     var1 = resultcal.Item2;
  425.                     var2 = resultcal.Item3;
  426.                     var3 = resultcal.Item4;
  427.                 }
  428.             }
  429.             Console.WriteLine("Finished");
  430.             return Tuple.Create(initialCollvar, time, var1, var2, var3, var4);
  431.         }
  432.        if (researchMode != true)
  433.         {
  434.             Tuple<double, double, double, double, double, double> resultTuple = jumpingDecend();
  435.             var stop = Process.GetCurrentProcess().TotalProcessorTime;
  436.  
  437.             Console.WriteLine("");
  438.             Console.WriteLine("time taken " + resultTuple.Item2 + " seconds");
  439.             Console.WriteLine("At variable = " + resultTuple.Item1);
  440.             Console.WriteLine("h = " + resultTuple.Item4);
  441.             Console.WriteLine("k = " + resultTuple.Item5);
  442.             Console.WriteLine();
  443.             // stopwatch.Stop();
  444.             Console.WriteLine("");
  445.             Console.WriteLine("Calculation Time is " + (stop - start).TotalMilliseconds);
  446.             Console.WriteLine("Cal amt" + i);
  447.             //  Console.WriteLine("Starting control group in 5 seconds");
  448.             Console.WriteLine(strg);
  449.             Thread.Sleep(60000);
  450.             start = Process.GetCurrentProcess().TotalProcessorTime;
  451.             double theta = NewtonsMethod(startPoint[0] / startPoint[1], 1, 1e-20, 2000);
  452.             double D = 2 * startPoint[1] / (1 - Math.Cos(theta * 2));
  453.             Console.WriteLine(D);
  454.             double t = Math.Sqrt(2 * D / gravitationalA) * theta;
  455.             Console.WriteLine(t);
  456.             stop = Process.GetCurrentProcess().TotalProcessorTime;
  457.             Console.WriteLine("Calculation Time is " + (stop - start).TotalMilliseconds);
  458.             strg = "";
  459.         }
  460.        else
  461.         {
  462.             double[,] timetable = new double[(int)(rangex[1] - rangex[0] + 1), (int)(rangey[1] - rangey[0] + 1)];
  463.             double[,] vartable = new double[(int)(rangex[1] - rangex[0] + 1), (int)(rangey[1] - rangey[0] + 1)];
  464.             for (int iterx = (int)rangex[0]; iterx <= (int)rangex[1]; iterx++)
  465.             {
  466.                 for (int itery = (int)rangey[0]; itery <= (int)rangey[1]; itery++)
  467.                 {
  468.                     startPoint[0]= (double)iterx;
  469.                     startPoint[1]= (double)itery;
  470.                     initialCollvarStep = 1;
  471.                     initialCollvarStep = 0.1f;
  472.                     maxTime = double.PositiveInfinity;
  473.                     time = 0f;
  474.                     Tuple<double, double, double, double, double, double> resultTuple = jumpingDecend();
  475.                     Console.WriteLine((int)(100 * ((rangey[1] - rangey[0] + 1) * (iterx - rangex[0]) + 1 + itery - rangey[0]) / ((rangex[1] - rangex[0] + 1) * (rangey[1] - rangey[0]+1)))+"% done");
  476.                     timetable[iterx-1, itery-1] = resultTuple.Item2;
  477.                     vartable[iterx-1, itery-1] = resultTuple.Item1;
  478.                     //  Console.WriteLine(startPoint[0]+":" +startPoint[1]);
  479.                     // Console.WriteLine("time taken " + resultTuple.Item2 + " seconds");
  480.                     // Console.WriteLine("At variable = " + resultTuple.Item1);
  481.                     //Print2DArray(timetable);
  482.                    // Console.WriteLine("h = " + resultTuple.Item4);
  483.                    // Console.WriteLine("k = " + resultTuple.Item5);
  484.  
  485.                 }
  486.             }
  487.             Console.WriteLine("TIME TABLE");
  488.             Print2DArray(timetable);
  489.             Console.WriteLine("VALUE TABLE");
  490.             Print2DArray(vartable);
  491.         }
  492.     }
  493. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!