Physics | C# Online Compiler

Physics by Gavin Underdown

using System;
using System.Deployment.Application;
using System.Windows.Forms;
using System.Xml.Linq;
using System.Reflection;

namespace fyziks
{
    /// <summary>
    /// Exception that is thrown when not enough input is entered. 
    /// </summary>
    public class notEnoughInputException : Exception
    {
        /// <summary>
        /// No Overload
        /// </summary>
        public notEnoughInputException()
        {
        }

        /// <summary>
        /// Overload with a message.
        /// </summary>
        /// <param name="message">Message.</param>
        public notEnoughInputException(string message)
            : base(message)
        {
        }

        /// <summary>
        /// Overload with message and inner exception
        /// </summary>
        /// <param name="message">Message.</param>
        /// <param name="inner">?</param>
        public notEnoughInputException(string message, Exception inner)
            : base(message, inner)
        {
        }
    }

    /// <summary>
    /// Triangle type.
    /// </summary>
    public class Triangle
    {
        /// <summary>
        /// X leg.
        /// </summary>
        public double X 
        {
            get { return _x; }
            set
            {   _x = value; }
        }
        /// <summary>
        /// Y leg.
        /// </summary>
        public double Y
        { 
            get { return _y; }
            set { _x = value; }
        }
        /// <summary>
        /// Hypotenuse. 
        /// </summary>
        public double Hypot { get; set;}
        /// <summary>
        /// Angle measure.
        /// </summary>
        public Angle Angle { get; set;}   
        /// <summary>
        /// is y leg > x leg. Determines if theta is at the large or small angle. Large  = true. Null = equal. 
        /// <remarks>Read only.</remarks>
        /// </summary>
        public bool? yIsMoreX { get; set; }

        /// <summary>
        /// Internal copy.
        /// </summary>
        private double _x { get; set;}
        /// <summary>
        /// Internal copy.
        /// </summary>
        private double _y { get; set;}
        
        /// <summary>
        /// Class Constructor. Allows for setting variables quicker.  
        /// </summary>
        /// <param name="xl">X leg.</param>
        /// <param name="yl">Y leg.</param>
        /// <param name="hypotenuse">Hpyotenuse.</param>
        /// <param name="angl">angle measure.</param>
        public Triangle(double xl, double yl, double hypotenuse, double angl)
        {
            _x= xl;
            _y = yl;
            Hypot = hypotenuse;
            Angle = new Angle(angl);
        }

        /// <summary>
        /// Class Constructor, no instance. 
        /// </summary>
        public Triangle()
        {
            _x = -1; _y = -1; Hypot = -1;
            Angle = new Angle(0);
        }


        /// <summary>
        /// Solves the triangle. 
        /// </summary>
        public void Solve()
        {
            if (this.Angle.Degrees == 0) { this.Angle.Degrees = findAngle(); }
            if (this.Hypot == 0) { this.Hypot = findHypot(); }
            if (this._y == 0) { _y = findYLeg(); }
            if (this._x == 0) { _x = findXLeg(); }
        }


        /// <summary>
        /// Solves for the hypotenuse of a triangle. 
        /// </summary>
        private double findHypot()
        {
            if (X != 0 && Y != 0) return (Math.Sqrt((Math.Pow(X, 2) + Math.Pow(Y, 2))));
            else if (((X == 0) || (Y == 0)) && Angle.Degrees != 0)
            {
                if (X == 0 && Y != 0)
                {
                    return (Y / Math.Sin(Angle.Radians));
                }
                else if (Y == 0 && X != 0)
                {
                    return (X / Math.Cos(Angle.Radians));
                }
            }
            return -1;  // on error. 
        }

        /// <summary>
        /// Finds the triangle's X leg. 
        /// </summary>
        private double findXLeg()
        {
            if (this.Y == 0 || this.Hypot == 0)
            {   // Solve via trig.
                if (this.Angle.Degrees == 0) { throw new Exception("Cannot calculate thisngle angle, missing legs and angle."); }
                else
                {   // If the angle is 45*, return the leg, because the legs are identical.
                    var x = this.Angle.Quadrant;
                    if (x == 2 || x == 14)
                    {   // Positive in those quadrants
                        return (this.Y);
                    }
                    else if (x == 10 || x == 6)
                    {   // Negative in these. 
                        return (-1 * this.Y);
                    }
                    else if (x == 1 || x == 15)     // +- 45
                    {   // x = c(sin(theta))    
                        return (this.Hypot * Math.Cos(this.Angle.Radians));
                    }
                    else if (x == 3 || x == 5)      // 45 -> 135
                    {   
                        return (this.Hypot * Math.Sin(this.Angle.Radians));
                    }
                    else if (x == 7 || x == 9)      // 135 -> 225
                    {   // multiplying by -1 ensures that it's a negative value, which it will be. 
                        return (-1 * (Math.Abs(this.Hypot * Math.Cos(this.Angle.Radians))));
                    }
                    else if (x == 11 || x == 14)    // 225 -> 315
                    {
                        return (-1 * Math.Abs(this.Hypot * Math.Sin(this.Angle.Radians)));
                    }
                }
            }
            else { return (Math.Pow(this.Hypot, 2) - Math.Pow(this.Y, 2)); } // Pythagorean. 
            return -1;  // on error.
        }

        /// <summary>
        /// Finds the Y leg of the triangle. 
        /// </summary>
        private double findYLeg()
        {
            if (this.X == 0 || this.Hypot == 0)
            {   // Solve via trig.
                if (this.Angle.Degrees == 0) { throw new Exception("Cannot calculate the X leg, missing input."); }
                else
                {   
                    var x = Angle.Degrees;
                    // If the angle is 45*, return the leg, because the legs are identical.
                    if (x == 2 || x == 6)
                    {   // Positive in those quadrants
                        return (this.Y);
                    }
                    else if (x == 10 || x == 14)
                    {   // Negative in these. 
                        return (-1 * this.Y);
                    }
                    else if (x == 1 || x == 7)  // 0 -> 45 + 135 -> 180
                    {   
                        return (this.Hypot * Math.Sin(this.Angle.Radians));
                    }
                    else if (x == 3 || x == 5)  // 45 -> 135
                    {
                        return (this.Hypot * Math.Cos(this.Angle.Radians));
                    }
                    else if (x == 9 || x == 15) // 180 -> 225 + 315 -> 0
                    {   
                        return (-1 * (this.Hypot * Math.Sin(this.Angle.Radians)));
                    }
                    else if (x == 11 || x == 14)// 225 -> 315
                    {   // multiplying by -1 ensures that it's a negative value, which it will be. 
                        return (-1 * (Math.Abs(this.Hypot * Math.Sin(this.Angle.Radians))));
                    }
                }
            }
            else { return (Math.Pow(this.Hypot, 2) - Math.Pow(this.Y, 2)); } // Pythagorean. 
            return -1; // on error. 

        }

        /// <summary>
        /// Finds the angle measure. 
        /// </summary>
        private double findAngle()
        {
            if (this.Hypot == 0)            // Tangent
            { return (Angle.RadianToDegree(Math.Acos(this.Y / this.Hypot))); }
            else if (this.Y == 0)       // Sine
            { return (Angle.RadianToDegree(Math.Asin(this.X / this.Hypot))); }
            else if (this.Hypot == 0)   // Tangent
            { return (Angle.RadianToDegree(Math.Atan(this.Y / this.X))); }

            else { return -1; }
        }
    }

    /// <summary>
    /// Holds angle measurement in degrees and radians.
    /// </summary>
    public class Angle
    {
        /// <summary>
        /// Class Constructor, instance with a double for degrees.  
        /// </summary>
        /// <param name="degrees">Setting the intital degree value. </param>
        public Angle(double degrees)
        {
            this.Degrees = degrees; // goes through the set loop.
        }

        private double _radians;
        private double _degrees;
        private byte _quadrant;

        /// <summary>
        /// Measure in radians. Read only, because it will be converted from degrees. 
        /// </summary>
        public double Radians
        {
            get { return _radians; }
        }
        /// <summary>
        /// Measure in Degrees. 
        /// </summary>
        public double Degrees
        {
            get { return _degrees; }
            set
            {
                if (value > 360)
                {
                    double x = value / 360; // Gets a percentage of the thing. 
                    while (x >= 1)
                    {   // Subtract 1 as long as it's above 1.
                        x--;    
                    }   // Gets a percentage more or less.
                    _degrees = x * 360; // Convert back to a whole and set the value. 

                } 
                    // Throw it so that it would ask for a ref = horizontal angle, no negative values.
                else
                {
                    _degrees = value;
                    _radians = DegreeToRadian(_degrees);
                    findSubQuarter();
                }
            }
        }

        /// <summary>
        /// Quadrant of what the angle is in. 
        /// </summary>
        /// <remarks>0-15, 0 is 0*, 1 is 0  x  45, 1 = 45</remarks>
        public byte Quadrant
        {
            get { return _quadrant; }
        }

        /// <summary>
        /// Finds the quadrant of the angle. 
        /// </summary>
        private void findSubQuarter()
        {
            if (this.Degrees == 0 || this.Degrees == 360) _quadrant = 0;
            else if (this.Degrees < 45 && this.Degrees > 0) _quadrant = 1;
            else if (this.Degrees == 45) _quadrant = 2;
            else if (this.Degrees > 45 && this.Degrees < 90) _quadrant = 3;
            else if (this.Degrees == 90) _quadrant = 4;
            else if (this.Degrees > 90 && this.Degrees < 135) _quadrant = 5;
            else if (this.Degrees == 135) _quadrant = 6;
            else if (this.Degrees > 135 && this.Degrees < 180) _quadrant = 7;
            else if (this.Degrees == 180) _quadrant = 8;
            else if (this.Degrees > 180 && this.Degrees < 225) _quadrant = 9;
            else if (this.Degrees == 225) _quadrant = 10;
            else if (this.Degrees > 225 && this.Degrees < 270) _quadrant = 11;
            else if (this.Degrees == 270) _quadrant = 12;
            else if (this.Degrees > 270 && this.Degrees < 315) _quadrant = 13;
            else if (this.Degrees == 315) _quadrant = 14;
            else if (this.Degrees > 315 && this.Degrees < 360) _quadrant = 15;

        }

        /// <summary>
        /// Converts a degree measure to a radian.
        /// </summary>
        /// <param name="angle">Measure, in degrees.</param>
        /// <returns>Radian measure.</returns>
        public static double DegreeToRadian(double angle)
        {
            return ((/*Math.PI */ angle) / 180.0);
        }

        /// <summary>
        /// Converts a radian measure to a degree.
        /// </summary>
        /// <remarks>Sets the internal value, be warned!</remarks>
        /// <param name="angle">Measure, in radians.</param>
        /// <returns>Radian measure.</returns>
        public static double RadianToDegree(double angle)
        {
            return ((180 / Math.PI) * angle);
        }


    }

    /// <summary>
    /// Data storage type, for the kinematics. 
    /// </summary>
    public class Data
    {
        public double? Xi { get; set; }

        public double? Xf { get; set; }

        public double? Vi_x { get; set; }

        public double? Vf_x { get; set; }

        public double? Ax { get; set; }

        public double? Tx { get; set; }

        public double Yi { get; set; }

        public double Yf { get; set; }

        public double Vi_y { get; set; }

        public double Vf_y { get; set; }

        public double Ay { get; set; }

        public double Ty { get; set; }


        public double Zi { get; set; }

        public double Zf { get; set; }

        public double? Vi_z { get; set; }

        public double? Vf_z { get; set; }

        public double Az { get; set; }

        public double? Tz { get; set; }

        /// <summary>
        /// Angle along the Y/Z or Y/X axis.
        /// </summary>
        public Angle Elevation { get; set; }

        /// <summary>
        /// Angle along the X/Z axis. 
        /// </summary>
        public Angle Azimuth { get; set; }

        /// <summary>
        /// Number of dimensions dealt with. 
        /// </summary>
        /// <remarks>Read Only.</remarks>
        public byte No_Dimens
        { get { return _dims; } }
        /// <summary>
        /// Internal copy of the number of dimensions.
        /// </summary>
        private byte _dims;


    }





    public partial class frmMain : Form
    {

        /// <summary>
        /// Gets the current version of the program. 
        /// </summary>
        public string CurrentVersion
        {
            get
            {
                return ApplicationDeployment.IsNetworkDeployed
                       ? ApplicationDeployment.CurrentDeployment.CurrentVersion.ToString()
                       : Assembly.GetExecutingAssembly().GetName().Version.ToString();
            }
        }

        /// <summary>
        /// Single instance of the maths class to do maths in, clearly.
        /// </summary>
        public maths _maths = new maths();
         
        /// <summary>
        /// Class Constructor.
        /// </summary>
        public frmMain()
        {
            InitializeComponent();
            //WriteVersion();
            //Process.Start(System.IO.Directory.GetCurrentDirectory() + @"\updater.exe"); // Starts the updater program. 
        }

        private void btnKinematics_Click(object sender, EventArgs e)
        {
            kinematics _kinematics = new kinematics(this);
            _kinematics.Show();
        }

        /*
        public void WriteVersion()
        {
            string directory = System.IO.Directory.GetCurrentDirectory();
            XDocument xml = new XDocument(new XDeclaration("1.0", "utf-8", null),
                                            new XComment("Contains the current version of this executable"));
            XElement version = new XElement("version", CurrentVersion);
            xml.Save(directory + @"\version.xml");
        } */

        

        private void btnTrig_Click(object sender, EventArgs e)
        {
            var trig = new trig(this);
            trig.Show();
        }

        private void btnProjectile_Click(object sender, EventArgs e)
        {

        }
    }


    // Vf^2 = Vi^2 + 2(AX)
    // Xf = Xi + (Vi * t) + 1/2(a * t^2)
    // Vf = Vi + (A * t)
    /// <summary>
    /// Kinematic equasion form.
    /// </summary>
    public partial class kinematics : Form
    {
        /// <summary>
        /// Nullable Decimal array for the input. Null = unknown.
        /// </summary>
        /// <remarks>
        /// Index 0 = Xi
        /// Index 1 = Xf
        /// Index 2 = Vi
        /// Index 3 = Vf
        /// Index 4 = a
        /// Index 5 = t
        /// </remarks>
        decimal?[,] input = new decimal?[2,6];

        TextBox[,] txtArray = new TextBox[2, 6];
        CheckBox[,] chkArray = new CheckBox[2, 6];       // Two parellel arrays designed to to match the check box to the text boxes.

        /// <summary>
        /// Copy of the main form to talk back and forth with.
        /// </summary>
        public frmMain _frmMain;

        /// <summary>
        /// Class Constructor.
        /// </summary>
        /// <param name="_form">Calling instance of the main form.</param>
        public kinematics(frmMain _form)
        {
            InitializeComponent();
            _frmMain = _form;
        }
        

        /// <summary>
        /// Parses the data into the arrays. 
        /// </summary>
        public void getData()
        {
            if (chkY.Checked == true)  // if y dimension, populate for both.
            {
                for (int ia = 0; ia <= 1; ia++)
                {   // For every index in the x or y coordinate system

                    for (int ib = 0; ib <= 5; ib++)
                    {   // For every matching pair in the arrays
                        if (chkArray[ia, ib].Checked == true)
                        {   // If the value is unknown.
                            txtArray[ia, ib].BackColor = Color.DarkGray;
                            input[ia, ib] = null;       // Mark the value as null.
                        }
                        else
                        {
                            txtArray[ia, ib].BackColor = Color.White;
                            input[ia, ib] = Convert.ToDecimal(txtArray[ia, ib].Text.Trim());
                        }
                    }
                }
            }
            else    // populate for just x, y gets nulled.  
            {
                    for (int ib = 0; ib <= 5; ib++)
                    {   // For every matching pair in the arrays
                        if (chkArray[0, ib].Checked == true)
                        {   // If the value is unknown.
                            txtArray[0, ib].BackColor = Color.DarkGray;
                            input[0, ib] = null;       // Mark the value as null.
                        }
                        else
                        {
                            txtArray[0, ib].BackColor = Color.White;
                            input[0, ib] = Convert.ToDecimal(txtArray[0, ib].Text.Trim());
                        }
                        input[1, ib] = null;
                }
            }
        }

        private void showOutput(decimal[,] output)
        {
            for (int ia = 0; ia <= 1; ia++)
            {   // For every index in the x or y coordinate system
                for (int ib = 0; ib <= 5; ib++)
                {   // For every matching pair in the arrays
                    txtArray[ia, ib].Text = output[ia, ib].ToString();
                }
            }
        }


        private void btnCalc_Click(object sender, EventArgs e)
        {
            getData();
            decimal[,] _result = _frmMain._maths.findKinematics(input);
            showOutput(_result);
        }

        private void kinematics_Load(object sender, EventArgs e)
        {
            // Match the text boxes and the check boxes. 
            txtArray[0, 0] = this.txtXi; txtArray[0, 1] = this.txtXf;
            txtArray[0, 2] = this.txtXVi; txtArray[0, 3] = this.txtXVf;
            txtArray[0, 4] = this.txtXacc; txtArray[0, 5] = this.txtT;

            txtArray[1, 0] = this.txtYi; txtArray[1, 1] = this.txtYf;
            txtArray[1, 2] = this.txtYVi; txtArray[1, 3] = this.txtYVf;
            txtArray[1, 4] = this.txtYacc; txtArray[1, 5] = this.txtT;

            chkArray[0, 0] = this.chkXi; chkArray[0, 1] = this.chkXf;
            chkArray[0, 2] = this.chkXVi; chkArray[0, 3] = this.chkXVf;
            chkArray[0, 4] = this.chkXacc; chkArray[0, 5] = this.chkT;

            chkArray[1, 0] = this.chkYi; chkArray[1, 1] = this.chkYf;
            chkArray[1, 2] = this.chkYVi; chkArray[1, 3] = this.chkYVf;
            chkArray[1, 4] = this.chkYacc; chkArray[1, 5] = this.chkT;
        }


    }

​x
 
using System;
using System.Deployment.Application;
using System.Windows.Forms;
using System.Xml.Linq;
using System.Reflection;
​
namespace fyziks
{
    /// <summary>
    /// Exception that is thrown when not enough input is entered. 
    /// </summary>
    public class notEnoughInputException : Exception
    {
        /// <summary>
        /// No Overload
        /// </summary>
        public notEnoughInputException()
        {
        }
​
        /// <summary>
        /// Overload with a message.
        /// </summary>
        /// <param name="message">Message.</param>
        public notEnoughInputException(string message)
            : base(message)
        {
        }
​
        /// <summary>
        /// Overload with message and inner exception
        /// </summary>
        /// <param name="message">Message.</param>
        /// <param name="inner">?</param>
        public notEnoughInputException(string message, Exception inner)
            : base(message, inner)
        {
        }
    }
​
    /// <summary>
    /// Triangle type.
    /// </summary>
    public class Triangle
    {
        /// <summary>
        /// X leg.
        /// </summary>
        public double X 
        {
            get { return _x; }
            set
            {   _x = value; }
        }
        /// <summary>
        /// Y leg.
        /// </summary>
        public double Y
        { 
            get { return _y; }
            set { _x = value; }
        }
        /// <summary>
        /// Hypotenuse. 
        /// </summary>
        public double Hypot { get; set;}
        /// <summary>
        /// Angle measure.
        /// </summary>
        public Angle Angle { get; set;}   
        /// <summary>
        /// is y leg > x leg. Determines if theta is at the large or small angle. Large  = true. Null = equal. 
        /// <remarks>Read only.</remarks>
        /// </summary>
        public bool? yIsMoreX { get; set; }
​
        /// <summary>
        /// Internal copy.
        /// </summary>
        private double _x { get; set;}
        /// <summary>
        /// Internal copy.
        /// </summary>
        private double _y { get; set;}
        
        /// <summary>
        /// Class Constructor. Allows for setting variables quicker.  
        /// </summary>
        /// <param name="xl">X leg.</param>
        /// <param name="yl">Y leg.</param>
        /// <param name="hypotenuse">Hpyotenuse.</param>
        /// <param name="angl">angle measure.</param>
        public Triangle(double xl, double yl, double hypotenuse, double angl)
        {
            _x= xl;
            _y = yl;
            Hypot = hypotenuse;
            Angle = new Angle(angl);
        }
​
        /// <summary>
        /// Class Constructor, no instance. 
        /// </summary>
        public Triangle()
        {
            _x = -1; _y = -1; Hypot = -1;
            Angle = new Angle(0);
        }
​
​
        /// <summary>
        /// Solves the triangle. 
        /// </summary>
        public void Solve()
        {
            if (this.Angle.Degrees == 0) { this.Angle.Degrees = findAngle(); }
            if (this.Hypot == 0) { this.Hypot = findHypot(); }
            if (this._y == 0) { _y = findYLeg(); }
            if (this._x == 0) { _x = findXLeg(); }
        }
​
​
        /// <summary>
        /// Solves for the hypotenuse of a triangle. 
        /// </summary>
        private double findHypot()
        {
            if (X != 0 && Y != 0) return (Math.Sqrt((Math.Pow(X, 2) + Math.Pow(Y, 2))));
            else if (((X == 0) || (Y == 0)) && Angle.Degrees != 0)
            {
                if (X == 0 && Y != 0)
                {
                    return (Y / Math.Sin(Angle.Radians));
                }
                else if (Y == 0 && X != 0)
                {
                    return (X / Math.Cos(Angle.Radians));
                }
            }
            return -1;  // on error. 
        }
​
        /// <summary>
        /// Finds the triangle's X leg. 
        /// </summary>
        private double findXLeg()
        {
            if (this.Y == 0 || this.Hypot == 0)
            {   // Solve via trig.
                if (this.Angle.Degrees == 0) { throw new Exception("Cannot calculate thisngle angle, missing legs and angle."); }
                else
                {   // If the angle is 45*, return the leg, because the legs are identical.
                    var x = this.Angle.Quadrant;
                    if (x == 2 || x == 14)
                    {   // Positive in those quadrants
                        return (this.Y);
                    }
                    else if (x == 10 || x == 6)
                    {   // Negative in these. 
                        return (-1 * this.Y);
                    }
                    else if (x == 1 || x == 15)     // +- 45
                    {   // x = c(sin(theta))    
                        return (this.Hypot * Math.Cos(this.Angle.Radians));
                    }
                    else if (x == 3 || x == 5)      // 45 -> 135
                    {   
                        return (this.Hypot * Math.Sin(this.Angle.Radians));
                    }
                    else if (x == 7 || x == 9)      // 135 -> 225
                    {   // multiplying by -1 ensures that it's a negative value, which it will be. 
                        return (-1 * (Math.Abs(this.Hypot * Math.Cos(this.Angle.Radians))));
                    }
                    else if (x == 11 || x == 14)    // 225 -> 315
                    {
                        return (-1 * Math.Abs(this.Hypot * Math.Sin(this.Angle.Radians)));
                    }
                }
            }
            else { return (Math.Pow(this.Hypot, 2) - Math.Pow(this.Y, 2)); } // Pythagorean. 
            return -1;  // on error.
        }
​
        /// <summary>
        /// Finds the Y leg of the triangle. 
        /// </summary>
        private double findYLeg()
        {
            if (this.X == 0 || this.Hypot == 0)
            {   // Solve via trig.
                if (this.Angle.Degrees == 0) { throw new Exception("Cannot calculate the X leg, missing input."); }
                else
                {   
                    var x = Angle.Degrees;
                    // If the angle is 45*, return the leg, because the legs are identical.
                    if (x == 2 || x == 6)
                    {   // Positive in those quadrants
                        return (this.Y);
                    }
                    else if (x == 10 || x == 14)
                    {   // Negative in these. 
                        return (-1 * this.Y);
                    }
                    else if (x == 1 || x == 7)  // 0 -> 45 + 135 -> 180
                    {   
                        return (this.Hypot * Math.Sin(this.Angle.Radians));
                    }
                    else if (x == 3 || x == 5)  // 45 -> 135
                    {
                        return (this.Hypot * Math.Cos(this.Angle.Radians));
                    }
                    else if (x == 9 || x == 15) // 180 -> 225 + 315 -> 0
                    {   
                        return (-1 * (this.Hypot * Math.Sin(this.Angle.Radians)));
                    }
                    else if (x == 11 || x == 14)// 225 -> 315
                    {   // multiplying by -1 ensures that it's a negative value, which it will be. 
                        return (-1 * (Math.Abs(this.Hypot * Math.Sin(this.Angle.Radians))));
                    }
                }
            }
            else { return (Math.Pow(this.Hypot, 2) - Math.Pow(this.Y, 2)); } // Pythagorean. 
            return -1; // on error. 
​
        }
​
        /// <summary>
        /// Finds the angle measure. 
        /// </summary>
        private double findAngle()
        {
            if (this.Hypot == 0)            // Tangent
            { return (Angle.RadianToDegree(Math.Acos(this.Y / this.Hypot))); }
            else if (this.Y == 0)       // Sine
            { return (Angle.RadianToDegree(Math.Asin(this.X / this.Hypot))); }
            else if (this.Hypot == 0)   // Tangent
            { return (Angle.RadianToDegree(Math.Atan(this.Y / this.X))); }
​
            else { return -1; }
        }
    }
​
    /// <summary>
    /// Holds angle measurement in degrees and radians.
    /// </summary>
    public class Angle
    {
        /// <summary>
        /// Class Constructor, instance with a double for degrees.  
        /// </summary>
        /// <param name="degrees">Setting the intital degree value. </param>
        public Angle(double degrees)
        {
            this.Degrees = degrees; // goes through the set loop.
        }
​
        private double _radians;
        private double _degrees;
        private byte _quadrant;
​
        /// <summary>
        /// Measure in radians. Read only, because it will be converted from degrees. 
        /// </summary>
        public double Radians
        {
            get { return _radians; }
        }
        /// <summary>
        /// Measure in Degrees. 
        /// </summary>
        public double Degrees
        {
            get { return _degrees; }
            set
            {
                if (value > 360)
                {
                    double x = value / 360; // Gets a percentage of the thing. 
                    while (x >= 1)
                    {   // Subtract 1 as long as it's above 1.
                        x--;    
                    }   // Gets a percentage more or less.
                    _degrees = x * 360; // Convert back to a whole and set the value. 
​
                } 
                    // Throw it so that it would ask for a ref = horizontal angle, no negative values.
                else
                {
                    _degrees = value;
                    _radians = DegreeToRadian(_degrees);
                    findSubQuarter();
                }
            }
        }
​
        /// <summary>
        /// Quadrant of what the angle is in. 
        /// </summary>
        /// <remarks>0-15, 0 is 0*, 1 is 0  x  45, 1 = 45</remarks>
        public byte Quadrant
        {
            get { return _quadrant; }
        }
​
        /// <summary>
        /// Finds the quadrant of the angle. 
        /// </summary>
        private void findSubQuarter()
        {
            if (this.Degrees == 0 || this.Degrees == 360) _quadrant = 0;
            else if (this.Degrees < 45 && this.Degrees > 0) _quadrant = 1;
            else if (this.Degrees == 45) _quadrant = 2;
            else if (this.Degrees > 45 && this.Degrees < 90) _quadrant = 3;
            else if (this.Degrees == 90) _quadrant = 4;
            else if (this.Degrees > 90 && this.Degrees < 135) _quadrant = 5;
            else if (this.Degrees == 135) _quadrant = 6;
            else if (this.Degrees > 135 && this.Degrees < 180) _quadrant = 7;
            else if (this.Degrees == 180) _quadrant = 8;
            else if (this.Degrees > 180 && this.Degrees < 225) _quadrant = 9;
            else if (this.Degrees == 225) _quadrant = 10;
            else if (this.Degrees > 225 && this.Degrees < 270) _quadrant = 11;
            else if (this.Degrees == 270) _quadrant = 12;
            else if (this.Degrees > 270 && this.Degrees < 315) _quadrant = 13;
            else if (this.Degrees == 315) _quadrant = 14;
            else if (this.Degrees > 315 && this.Degrees < 360) _quadrant = 15;
​
        }
​
        /// <summary>
        /// Converts a degree measure to a radian.
        /// </summary>
        /// <param name="angle">Measure, in degrees.</param>
        /// <returns>Radian measure.</returns>
        public static double DegreeToRadian(double angle)
        {
            return ((/*Math.PI */ angle) / 180.0);
        }
​
        /// <summary>
        /// Converts a radian measure to a degree.
        /// </summary>
        /// <remarks>Sets the internal value, be warned!</remarks>
        /// <param name="angle">Measure, in radians.</param>
        /// <returns>Radian measure.</returns>
        public static double RadianToDegree(double angle)
        {
            return ((180 / Math.PI) * angle);
        }
​
​
    }
​
    /// <summary>
    /// Data storage type, for the kinematics. 
    /// </summary>
    public class Data
    {
        public double? Xi { get; set; }
​
        public double? Xf { get; set; }
​
        public double? Vi_x { get; set; }
​
        public double? Vf_x { get; set; }
​
        public double? Ax { get; set; }
​
        public double? Tx { get; set; }
​
        public double Yi { get; set; }
​
        public double Yf { get; set; }
​
        public double Vi_y { get; set; }
​
        public double Vf_y { get; set; }
​
        public double Ay { get; set; }
​
        public double Ty { get; set; }
​
​
        public double Zi { get; set; }
​
        public double Zf { get; set; }
​
        public double? Vi_z { get; set; }
​
        public double? Vf_z { get; set; }
​
        public double Az { get; set; }
​
        public double? Tz { get; set; }
​
        /// <summary>
        /// Angle along the Y/Z or Y/X axis.
        /// </summary>
        public Angle Elevation { get; set; }
​
        /// <summary>
        /// Angle along the X/Z axis. 
        /// </summary>
        public Angle Azimuth { get; set; }
​
        /// <summary>
        /// Number of dimensions dealt with. 
        /// </summary>
        /// <remarks>Read Only.</remarks>
        public byte No_Dimens
        { get { return _dims; } }
        /// <summary>
        /// Internal copy of the number of dimensions.
        /// </summary>
        private byte _dims;
​
​
    }
​
​
​
​
​
    public partial class frmMain : Form
    {
​
        /// <summary>
        /// Gets the current version of the program. 
        /// </summary>
        public string CurrentVersion
        {
            get
            {
                return ApplicationDeployment.IsNetworkDeployed
                       ? ApplicationDeployment.CurrentDeployment.CurrentVersion.ToString()
                       : Assembly.GetExecutingAssembly().GetName().Version.ToString();
            }
        }
​
        /// <summary>
        /// Single instance of the maths class to do maths in, clearly.
        /// </summary>
        public maths _maths = new maths();
         
        /// <summary>
        /// Class Constructor.
        /// </summary>
        public frmMain()
        {
            InitializeComponent();
            //WriteVersion();
            //Process.Start(System.IO.Directory.GetCurrentDirectory() + @"\updater.exe"); // Starts the updater program. 
        }
​
        private void btnKinematics_Click(object sender, EventArgs e)
        {
            kinematics _kinematics = new kinematics(this);
            _kinematics.Show();
        }
​
        /*
        public void WriteVersion()
        {
            string directory = System.IO.Directory.GetCurrentDirectory();
            XDocument xml = new XDocument(new XDeclaration("1.0", "utf-8", null),
                                            new XComment("Contains the current version of this executable"));
            XElement version = new XElement("version", CurrentVersion);
            xml.Save(directory + @"\version.xml");
        } */
​
        
​
        private void btnTrig_Click(object sender, EventArgs e)
        {
            var trig = new trig(this);
            trig.Show();
        }
​
        private void btnProjectile_Click(object sender, EventArgs e)
        {
​
        }
    }
​
​
    // Vf^2 = Vi^2 + 2(AX)
    // Xf = Xi + (Vi * t) + 1/2(a * t^2)
    // Vf = Vi + (A * t)
    /// <summary>
    /// Kinematic equasion form.
    /// </summary>
    public partial class kinematics : Form
    {
        /// <summary>
        /// Nullable Decimal array for the input. Null = unknown.
        /// </summary>
        /// <remarks>
        /// Index 0 = Xi
        /// Index 1 = Xf
        /// Index 2 = Vi
        /// Index 3 = Vf
        /// Index 4 = a
        /// Index 5 = t
        /// </remarks>
        decimal?[,] input = new decimal?[2,6];
​
        TextBox[,] txtArray = new TextBox[2, 6];
        CheckBox[,] chkArray = new CheckBox[2, 6];       // Two parellel arrays designed to to match the check box to the text boxes.
​
        /// <summary>
        /// Copy of the main form to talk back and forth with.
        /// </summary>
        public frmMain _frmMain;
​
        /// <summary>
        /// Class Constructor.
        /// </summary>
        /// <param name="_form">Calling instance of the main form.</param>
        public kinematics(frmMain _form)
        {
            InitializeComponent();
            _frmMain = _form;
        }
        
​
        /// <summary>
        /// Parses the data into the arrays. 
        /// </summary>
        public void getData()
        {
            if (chkY.Checked == true)  // if y dimension, populate for both.
            {
                for (int ia = 0; ia <= 1; ia++)
                {   // For every index in the x or y coordinate system
​
                    for (int ib = 0; ib <= 5; ib++)
                    {   // For every matching pair in the arrays
                        if (chkArray[ia, ib].Checked == true)
                        {   // If the value is unknown.
                            txtArray[ia, ib].BackColor = Color.DarkGray;
                            input[ia, ib] = null;       // Mark the value as null.
                        }
                        else
                        {
                            txtArray[ia, ib].BackColor = Color.White;
                            input[ia, ib] = Convert.ToDecimal(txtArray[ia, ib].Text.Trim());
                        }
                    }
                }
            }
            else    // populate for just x, y gets nulled.  
            {
                    for (int ib = 0; ib <= 5; ib++)
                    {   // For every matching pair in the arrays
                        if (chkArray[0, ib].Checked == true)
                        {   // If the value is unknown.
                            txtArray[0, ib].BackColor = Color.DarkGray;
                            input[0, ib] = null;       // Mark the value as null.
                        }
                        else
                        {
                            txtArray[0, ib].BackColor = Color.White;
                            input[0, ib] = Convert.ToDecimal(txtArray[0, ib].Text.Trim());
                        }
                        input[1, ib] = null;
                }
            }
        }
​
        private void showOutput(decimal[,] output)
        {
            for (int ia = 0; ia <= 1; ia++)
            {   // For every index in the x or y coordinate system
                for (int ib = 0; ib <= 5; ib++)
                {   // For every matching pair in the arrays
                    txtArray[ia, ib].Text = output[ia, ib].ToString();
                }
            }
        }
​
​
        private void btnCalc_Click(object sender, EventArgs e)
        {
            getData();
            decimal[,] _result = _frmMain._maths.findKinematics(input);
            showOutput(_result);
        }
​
        private void kinematics_Load(object sender, EventArgs e)
        {
            // Match the text boxes and the check boxes. 
            txtArray[0, 0] = this.txtXi; txtArray[0, 1] = this.txtXf;
            txtArray[0, 2] = this.txtXVi; txtArray[0, 3] = this.txtXVf;
            txtArray[0, 4] = this.txtXacc; txtArray[0, 5] = this.txtT;
​
            txtArray[1, 0] = this.txtYi; txtArray[1, 1] = this.txtYf;
            txtArray[1, 2] = this.txtYVi; txtArray[1, 3] = this.txtYVf;
            txtArray[1, 4] = this.txtYacc; txtArray[1, 5] = this.txtT;
​
            chkArray[0, 0] = this.chkXi; chkArray[0, 1] = this.chkXf;
            chkArray[0, 2] = this.chkXVi; chkArray[0, 3] = this.chkXVf;
            chkArray[0, 4] = this.chkXacc; chkArray[0, 5] = this.chkT;
​
            chkArray[1, 0] = this.chkYi; chkArray[1, 1] = this.chkYf;
            chkArray[1, 2] = this.chkYVi; chkArray[1, 3] = this.chkYVf;
            chkArray[1, 4] = this.chkYacc; chkArray[1, 5] = this.chkT;
        }
​
​
    }
​

Compilation error (line 609, col 6): } expected

Last Run:	11:27:47 pm
Compile:	0s
Execute:	0.016s
Memory:	0b
CPU:	0s

View IL Code