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 }
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)); }
public Position(AngleUnits angles, AltitudeUnits alts) { latitude = 0; longitude = 0; altitude = 0; altitude_units = alts; angle_units = angles; }
public Position() { latitude = 0; longitude = 0; altitude = 0; altitude_units = AltitudeUnits.Feet; angle_units = AngleUnits.Degrees; }
public Position(AngleUnits angles, AltitudeUnits alts) { this.latitude = 0; this.longitude = 0; this.altitude = 0; this.altitude_units = alts; this.angle_units = angles; }
public Position() { this.latitude = 0; this.longitude = 0; this.altitude = 0; this.altitude_units = AltitudeUnits.Feet; this.angle_units = AngleUnits.Degrees; }
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); }
public override Double Compute(AngleUnits angleUnit) { try { return(Helpers.IsNumericValue(this.Expression) ? Double.Parse(this.Expression) : Double.NaN); } catch { return(Double.NaN); } }
public Angle(double value, AngleUnits units) { switch (units) { case AngleUnits.DEGREES: this._value = Globals.Deg2Rad(value); break; default: this._value = Globals.NormalizeRads(value); break; } }
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); } }
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()); } }
/// <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); }
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); } }
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); } }
/// <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); } }
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); } }
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); } }
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); } }
/// <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"); } }
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"); } }
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); }
/// <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; } }
/// <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
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); }
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); } }
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; }
public Angle(double value, AngleUnits units) { Value = 0.0; SetAngle(value, units); }
public string ToString(AngleUnits units) { return ToString(units, null, DegreesFormat.DegMinSec); }
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); }
public Angle(decimal value, AngleUnits units = AngleUnits.Degrees) { _Units = units; Value = value; }
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()); } }
/// <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); }
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); }