Ejemplo n.º 1
0
        private static decimal ConvertAngleValue(decimal angle, AngleUnits fromUnits, AngleUnits toUnits)

        {
            decimal factor = _ConversionFactors[(int)toUnits, (int)fromUnits];

            return(Normalize((angle * factor), toUnits)); //Normalize converted angle
        }
Ejemplo n.º 2
0
        public override Double Compute(AngleUnits angleUnit)
        {
            if (String.IsNullOrWhiteSpace(Expression))
            {
                return(Double.NaN);
            }

            var _unitList = new List <IComputeUnit>();

            try
            {
                var parameters = GetParameterStrings(this.Expression);
                foreach (var parameter in parameters)
                {
                    var unit = NumericCalculator.Parse(parameter);
                    if (unit == null)
                    {
                        return(Double.NaN);
                    }
                    _unitList.Add(unit);
                }
                var values = _unitList.Select(p => p.Compute(angleUnit)).ToList();
                return(this.ApplyFunction(values, angleUnit));
            }
            catch
            {
                return(Double.NaN);
            }
            finally
            {
                _unitList.Clear();
            }
        }
        public Angle ConvertAngle(AngleUnits targetUnits)
        {
            Angle angle = new Angle();

            switch (targetUnits)
            {
            case AngleUnits.Degrees:
                angle = ToDegrees();
                break;

            case AngleUnits.Gradians:
                angle = ToGradians();
                break;

            case AngleUnits.Radians:
                angle = ToRadians();
                break;

            case AngleUnits.Turns:
                angle = ToTurns();
                break;

            default:
                break;
            }
            return(angle);
        }
        public static string ToSymbol(this AngleUnits units)
        {
            string str = String.Empty;

            switch (units)
            {
            case AngleUnits.Degrees:
                str = "°";
                break;

            case AngleUnits.Gradians:
                str = "g";
                break;

            case AngleUnits.Radians:
                str = "rad";
                break;

            case AngleUnits.Turns:
                str = "tr";
                break;

            default:
                break;
            }
            return(str);
        }
        private static decimal ConvertAngleValue(decimal angle, AngleUnits fromUnits, AngleUnits toUnits)
        {
            decimal factor = _ConversionFactors[(int)toUnits, (int)fromUnits];
            decimal result = factor * angle;

            return(Normalize(result, toUnits));
        }
Ejemplo n.º 6
0
 public Position(AngleUnits angles, AltitudeUnits alts)
 {
     latitude       = 0;
     longitude      = 0;
     altitude       = 0;
     altitude_units = alts;
     angle_units    = angles;
 }
Ejemplo n.º 7
0
 public Position()
 {
     latitude       = 0;
     longitude      = 0;
     altitude       = 0;
     altitude_units = AltitudeUnits.Feet;
     angle_units    = AngleUnits.Degrees;
 }
Ejemplo n.º 8
0
 public Position(AngleUnits angles, AltitudeUnits alts)
 {
     this.latitude       = 0;
     this.longitude      = 0;
     this.altitude       = 0;
     this.altitude_units = alts;
     this.angle_units    = angles;
 }
Ejemplo n.º 9
0
 public Position()
 {
     this.latitude       = 0;
     this.longitude      = 0;
     this.altitude       = 0;
     this.altitude_units = AltitudeUnits.Feet;
     this.angle_units    = AngleUnits.Degrees;
 }
Ejemplo n.º 10
0
 public Position()
 {
     this.latitude = 0;
     this.longitude = 0;
     this.altitude = 0;
     this.altitude_units = AltitudeUnits.Feet;
     this.angle_units = AngleUnits.Degrees;
 }
Ejemplo n.º 11
0
 public Position(AngleUnits angles, AltitudeUnits alts)
 {
     this.latitude = 0;
     this.longitude = 0;
     this.altitude = 0;
     this.altitude_units = alts;
     this.angle_units = angles;
 }
Ejemplo n.º 12
0
        public static decimal ConvertAngleValue(decimal angle, AngleUnits fromUnits, AngleUnits toUnits)
        {
            decimal result = 0M;
            decimal factor = _ConversionFactors[(int)toUnits, (int)fromUnits];

            angle  = angle * factor;
            result = Normalize(angle, toUnits);
            return(result);
        }
Ejemplo n.º 13
0
 public override Double Compute(AngleUnits angleUnit)
 {
     try
     {
         return(Helpers.IsNumericValue(this.Expression) ? Double.Parse(this.Expression) : Double.NaN);
     }
     catch
     {
         return(Double.NaN);
     }
 }
Ejemplo n.º 14
0
 public Angle(double value, AngleUnits units)
 {
     switch (units)
     {
         case AngleUnits.DEGREES:
             this._value = Globals.Deg2Rad(value);
             break;
         default:
             this._value = Globals.NormalizeRads(value);
             break;
     }
 }
Ejemplo n.º 15
0
        private Dictionary <char, INumber> Vars = new Dictionary <char, INumber>();//Liste von Variablen neu initialisieren;

        #region Trigonometrie

        /// <summary>
        /// Ruft die Größe des Vollkreises in der angegebenen Einheit ab.
        /// </summary>
        /// <param name="unit">Die Einheit in der der Vollkreis gemessen werden soll.</param>
        /// <returns>Die Größe des Vollkreises in der Einheit <paramref name="unit"/>.</returns>
        public static double Circle(AngleUnits unit)
        {
            switch (unit)
            {
            case AngleUnits.Degree:
                return(360);

            case AngleUnits.Radian:
                return(Math.PI);

            default:
                return(400);
            }
        }
Ejemplo n.º 16
0
 internal double GetAngle(AngleUnits units)
 {
     switch (units)
     {
         case AngleUnits.Radians:
             return AsRad;
         case AngleUnits.Grads:
             return AsGrad;
         case AngleUnits.Degrees:
             return AsDeg;
         default:
             throw new Exception("Unsupported AngleUnits: " + units.ToString());
     }
 }
Ejemplo n.º 17
0
        /// <summary>
        /// Gibt den Hyperbelsekans des angegebenen Winkels zurück.
        /// </summary>
        /// <param name="value">Ein im Bogenmaß, Gradmaß oder Gon angegebener Winkel/Wert.</param>
        /// <param name="angleUnit">Die Einheit, in der der Winkel angegeben wurde.</param>
        /// <returns>Der Hyperbelsekans von <paramref name="value"/>.</returns>
        public static double Sech(double value, AngleUnits angleUnit)
        {
            switch (angleUnit)
            {
            case AngleUnits.Degree:
                return(Sech(value / 180 * Math.PI));

            case AngleUnits.Gradian:
                return(Sech(value / 200 * Math.PI));

            case AngleUnits.Radian:
            default:
                return(Sech(value));
            }
        }
        public ThunderBolt(string portName, AngleUnits au, AltitudeUnits tu, OutputPort activityLed)
        {
            _activityLed = activityLed;
            PacketQueue = new FixedSizedQueue(10);

            PacketProcessing = new Thread(new ThreadStart(worker_thread));

            position = new Position(au, tu);
            last_position = new Position(au, tu);
            m_port = new SerialPort(portName, 9600, Parity.None, 8, StopBits.One);
            m_port.DataReceived += new SerialDataReceivedEventHandler(m_port_DataReceived);
            m_port.ErrorReceived += new SerialErrorReceivedEventHandler(m_port_ErrorReceived);
            for (int i = 0; i < 32; i++)
                Satellites[i] = new SatInfo();
        }
 private static decimal Normalize(decimal value, AngleUnits units)
 {
     if (units == AngleUnits.Degrees)
     {
         while (value < 0)
         {
             value += 360;
         }
         while (value >= 360)
         {
             value -= 360;
         }
     }
     else if (units == AngleUnits.Gradians)
     {
         while (value < 0)
         {
             value += 400;
         }
         while (value >= 400)
         {
             value -= 400;
         }
     }
     else if (units == AngleUnits.Radians)
     {
         while (value < 0)
         {
             value += twoPi;
         }
         while (value >= twoPi)
         {
             value -= twoPi;
         }
     }
     else if (units == AngleUnits.Turns)
     {
         while (value < 0)
         {
             value += 1;
         }
         while (value >= 1)
         {
             value -= 1;
         }
     }
     return(value);
 }
Ejemplo n.º 20
0
        public static string GetUnitsSymbol(AngleUnits angleUnits)
        {
            switch (angleUnits)
            {
            case AngleUnits.Degrees:
                return("°");

            case AngleUnits.Radians:
                return("rad");

            case AngleUnits.MilliRadians:
                return("mil");

            default:
                throw new ArgumentOutOfRangeException(nameof(angleUnits), angleUnits, null);
            }
        }
Ejemplo n.º 21
0
        public static Angle GetFromValue(double value, AngleUnits units)
        {
            switch (units)
            {
            case AngleUnits.Degrees:
                return(GetFromDegrees(value));

            case AngleUnits.Radians:
                return(GetFromRadians(value));

            case AngleUnits.MilliRadians:
                return(GetFromRadians(value / 1000));

            default:
                throw new ArgumentOutOfRangeException(nameof(units), units, null);
            }
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Gibt einen Winkel/Wert zurück, dessen Hyperbelkosekans die angegebene Zahl ist.
        /// </summary>
        /// <param name="value">Eine Zahl die einen Hyperbelkosekans darstellt.</param>
        /// <param name="angleUnit">Die Einheit, in der der Winkel angegeben wurde.</param>
        /// <returns>Ein Wert/Winkel dessen Hyperbelkosekans <paramref name="value"/> ist.</returns>
        public static double Acsch(double value, AngleUnits angleUnit)
        {
            double a = Acsch(value);

            switch (angleUnit)
            {
            case AngleUnits.Degree:
                return(a / Math.PI * 180);

            case AngleUnits.Gradian:
                return(a / Math.PI * 200);

            case AngleUnits.Radian:
            default:
                return(a);
            }
        }
Ejemplo n.º 23
0
        public double GetValueInUnits(AngleUnits angleUnits)
        {
            switch (angleUnits)
            {
            case AngleUnits.Degrees:
                return(InDegrees);

            case AngleUnits.Radians:
                return(InRadians);

            case AngleUnits.MilliRadians:
                return(InMilliRadians);

            default:
                throw new ArgumentOutOfRangeException(nameof(angleUnits), angleUnits, null);
            }
        }
Ejemplo n.º 24
0
        public Angle ConvertAngle(AngleUnits targetUnits)
        {
            switch (targetUnits)
            {
            case AngleUnits.Degrees:
                return(ToDegrees());

            case AngleUnits.Radians:
                return(ToRadians());

            case AngleUnits.Gradians:
                return(ToGradians());

            case AngleUnits.Turns:
                return(ToTurns());

            default:
                return(this);
            }
        }
Ejemplo n.º 25
0
        public static string ToSymbol(this AngleUnits units)
        {
            switch (units)
            {
            case AngleUnits.Degrees:
                return("°");

            case AngleUnits.Gradians:
                return("g");

            case AngleUnits.Radians:
                return("rad");

            case AngleUnits.Turns:
                return("tr");

            default:
                return(string.Empty);
            }
        }
Ejemplo n.º 26
0
        /// <summary>
        /// Convert the given object to a new angle unit of measure
        /// </summary>
        /// <param name="targetUnits"></param>
        /// <returns>(Angle) object of converted angle with measured units</returns>
        public Angle ConvertAngle(AngleUnits targetUnits)
        {
            switch (targetUnits)
            {
            case AngleUnits.Degrees:
                return(ToDegrees());

            case AngleUnits.Gradians:
                return(ToGradians());

            case AngleUnits.Radians:
                return(ToRadians());

            case AngleUnits.Turns:
                return(ToTurns());

            default:
                throw new ArgumentException("The target unit is not a valid enum of type AngleUnits");
            }
        }
Ejemplo n.º 27
0
        public string ToString(AngleUnits units)
        {
            double val = 0.0;
            string suffix = "";
            switch (units)
            {
                case AngleUnits.DEGREES:
                    val = this.Degrees;
                    suffix = " deg";
                    break;
                default:
                    val = this.Rads;
                    suffix = " rad";
                    break;
            }

            string s = val.ToString("#.00000000") + suffix;

            return s;
        }
        /// <summary>
        /// This method accepts a value of type AngleUnits and returns
        /// the appropriate string symbol that represents that unit type:
        /// </summary>
        /// <param name="units">(AngleUnits) units value</param>
        /// <returns>(string) of the unit symbol</returns>
        public static string ToSymbol(this AngleUnits units)
        {
            switch (units)
            {
            case AngleUnits.Degrees:
                return("°");

            case AngleUnits.Gradians:
                return("g");

            case AngleUnits.Radians:
                return("rad");

            case AngleUnits.Turns:
                return("tr");

            default:
                throw new ArgumentException("The units value enum is invalid");
            }
        }
Ejemplo n.º 29
0
        private Double ApplyFunction(List <Double> values, AngleUnits angleUnit)
        {
            if (values == null || !values.Any())
            {
                return(Double.NaN);
            }

            switch (_function)
            {
            case ComplexFunctions.Min:
                return(values.Min());

            case ComplexFunctions.Max:
                return(values.Max());

            case ComplexFunctions.Average:
            case ComplexFunctions.Ave:
                return(values.Average());

            case ComplexFunctions.Sum:
                return(values.Sum());

            case ComplexFunctions.Pow:
                return(values.Count >= 2 ? Math.Pow(values[0], values[1]) : Double.NaN);

            case ComplexFunctions.Atan2:
                return(GetReturnedAngleValue(values.Count >= 2 ? Math.Atan2(values[0], values[1]) : Double.NaN, angleUnit));

            case ComplexFunctions.LogX:
                return(values.Count >= 2 ? Math.Log(values[0], values[1]) : Double.NaN);

            case ComplexFunctions.BigMul:
                return(values.Count >= 2 ? Math.BigMul((int)values[0], (int)values[1]) : Double.NaN);

            case ComplexFunctions.IEEERemainder:
                return(values.Count >= 2 ? Math.IEEERemainder(values[0], values[1]) : Double.NaN);
            }
            return(Double.NaN);
        }
Ejemplo n.º 30
0
        /// <summary>
        /// Constructor for the angle accepting various unit types
        /// </summary>
        /// <param name="value">The angle value in specified units</param>
        /// <param name="units">The unit type being provided</param>
        public Angle(double value, AngleUnits units)
        {
            switch (units)
            {
            case AngleUnits.DEG:
                v = ToAngleValue(DegToRad(value));
                break;

            case AngleUnits.RAD:
                v = ToAngleValue(value);
                break;

            case AngleUnits.GRAD:
                v = ToAngleValue(GradToRad(value));
                break;

            default:
                // Should have thrown an error
                v = 0.0;
                break;
            }
        }
Ejemplo n.º 31
0
        /// <summary>
        /// The Normalize() method ensures that the provided value is within the legal range of angle values
        ///for the given unit of measure. Therefore, if the units parameter indicates AngleUnits.Degrees, the
        ///value parameter must be greater than or equal to 0 and less than 360. If the value is less than 0
        ///then 360 must be added to value repeatedly until it is non-negative.Likewise, if the value is
        ///greater than or equal to 360, then 360 must be repeatedly subtracted from value until it is within
        ///the specified range.The same technique is used for the other three angle types, just with a
        ///different maximum value:
        ///• Degrees: 360
        ///• Gradians: 400
        ///• Radians: 2π
        // • Turns: 1
        /// Finally, return the normalized value.
        /// </summary>
        /// <param name="value">(decimal) value of the angle</param>
        /// <param name="units">(AngleUnits) enum unit of measure</param>
        /// <returns>return the normalized value. (decimal)</returns>
        private static decimal Normalize(decimal value, AngleUnits units)
        {
            decimal minimum;
            decimal maximum;

            switch (units)
            {
            case AngleUnits.Degrees:

                minimum = 0M;
                maximum = 360M;

                return(NormalizeValue(value, minimum, maximum));

            case AngleUnits.Gradians:

                minimum = 0M;
                maximum = 400M;

                return(NormalizeValue(value, minimum, maximum));

            case AngleUnits.Radians:

                minimum = 0M;
                maximum = twoPi;

                return(NormalizeValue(value, minimum, maximum));

            case AngleUnits.Turns:

                minimum = 0M;
                maximum = 1M;

                return(NormalizeValue(value, minimum, maximum));

            default:
                throw new ArgumentException("The AngleUnits enum value is not valid");
            } // end of switch statement
        }     // end of method Normalize
Ejemplo n.º 32
0
        public Angle ConvertAngle(AngleUnits targetUnits)
        {
            Angle newuom = new Angle();

            switch (targetUnits)
            {
            case AngleUnits.Degrees:
                newuom = ToDegrees();
                break;

            case AngleUnits.Radians:
                newuom = ToRadians();
                break;

            case AngleUnits.Gradians:
                newuom = ToGradians();
                break;

            case AngleUnits.Turns:
                newuom = ToTurns();
                break;
            }
            return(newuom);
        }
Ejemplo n.º 33
0
        private static decimal Normalize(decimal value, AngleUnits units)
        {
            switch (units)
            {
            case AngleUnits.Degrees:
                if (value < 0 || value > 360)
                {
                    value -= Math.Floor(value / 360) * 360;
                }
                return(value);

            case AngleUnits.Gradians:
                if (value < 0 || value > 400)
                {
                    value -= Math.Floor(value / 400) * 400;
                }
                return(value);

            case AngleUnits.Radians:
                if (value < 0 || value > twoPi)
                {
                    value -= Math.Floor(value / twoPi) * twoPi;
                }
                return(value);

            case AngleUnits.Turns:
                if (value < 0 || value > 1)
                {
                    value -= Math.Floor(value);
                }
                return(value);

            default:
                return(0M);
            }
        }
Ejemplo n.º 34
0
 public static Angle FromString(string s, AngleUnits units)
 {
     Angle res = new Angle();
     switch (units)
     {
         case AngleUnits.Radians:
             res.AsRad = s.ToDouble();
             break;
         case AngleUnits.Grads:
             res.AsGrad = s.ToDouble();
             break;
         case AngleUnits.Degrees:
             res.AsDeg = ConvertDegText(s);
             break;
         default:
             throw new Exception("Angle.FormString(). Not supported units: " + units.ToString());
     }
     return res;
 }
Ejemplo n.º 35
0
 public Angle(double value, AngleUnits units)
 {
     Value = 0.0;
     SetAngle(value, units);
 }
Ejemplo n.º 36
0
 public string ToString(AngleUnits units)
 {
     return ToString(units, null, DegreesFormat.DegMinSec);
 }
Ejemplo n.º 37
0
 public static decimal Normalize(decimal value, AngleUnits units)  //reverts angles to between 0 and 360 degrees in their respective units.
 {
     if (units == AngleUnits.Degrees)
     {
         if (value < 0M)
         {
             while (value < 0M)
             {
                 value = value + 360M;
             }
         }
         if (value > 360M)
         {
             while (value > 360M)
             {
                 value = value - 360M;
             }
         }
     }
     if (units == AngleUnits.Gradians)
     {
         if (value < 0M)
         {
             while (value < 0M)
             {
                 value = value + 400M;
             }
         }
         if (value > 400M)
         {
             while (value > 400M)
             {
                 value = value - 400M;
             }
         }
     }
     if (units == AngleUnits.Radians)
     {
         if (value < 0M)
         {
             while (value < 0M)
             {
                 value = value + twoPi;
             }
         }
         if (value > twoPi)
         {
             while (value > twoPi)
             {
                 value = value - twoPi;
             }
         }
     }
     if (units == AngleUnits.Turns)
     {
         if (value < 0M)
         {
             while (value < 0M)
             {
                 value = value + 1M;
             }
         }
         if (value > 1M)
         {
             while (value > 1M)
             {
                 value = value - 1M;
             }
         }
     }
     return(value);
 }
Ejemplo n.º 38
0
 public Angle(decimal value, AngleUnits units = AngleUnits.Degrees)
 {
     _Units = units;
     Value  = value;
 }
Ejemplo n.º 39
0
 internal void SetAngle(double value, AngleUnits units)
 {
     switch (units)
     {
         case AngleUnits.Radians:
             AsRad = value;
             break;
         case AngleUnits.Grads:
             AsGrad = value;
             break;
         case AngleUnits.Degrees:
             AsDeg = value;
             break;
         default:
             throw new Exception("Unsupported AngleUnits: " + units.ToString());
     }
 }
Ejemplo n.º 40
0
 /// <summary>
 /// TraverseLeafs to access the angle value as specified units
 /// </summary>
 /// <param name="units">Units to provide angle value in</param>
 /// <returns>The angle value in specified units</returns>
 public double Value(AngleUnits units)
 {
     return(units == AngleUnits.DEG ? Deg : Rad);
 }
Ejemplo n.º 41
0
        public string ToString(AngleUnits units, string precision, DegreesFormat degFormat)
        {
            switch (units)
            {
                case AngleUnits.Radians:
                    return this.AsRad.ToString(precision);

                case AngleUnits.Grads:
                    return this.AsGrad.ToString(precision);

                case AngleUnits.Degrees:
                    return ToDegreesString(degFormat, precision);
            }
            return this.Value.ToString(precision);
        }