private void SetTimeRemaining()
{
_wordsRemaining = SelectedItem.WordCount - SelectedItem.WordsRead;
_milliseconds = MathsHelpers.DisplayTimePerWordGroup(SelectedItem.WordCount, _settingsService.WordsPerMin, _settingsService.WordsAtATime);
TimeRemaining = MathsHelpers.TimeToReadArticle(_milliseconds, _wordsRemaining, _settingsService.WordsAtATime);
ReadPercentage = SelectedItem.PercentageRead;
}
public void TestToDegrees()
{
double angleRads = Math.PI;
double result = MathsHelpers.ToDegrees(angleRads);
double expected = 180;
Assert.IsTrue(Helpers.WithinTolerance(result, expected));
}
public void TestToRadians()
{
double angleDegrees = 45;
double result = MathsHelpers.ToRadians(angleDegrees);
double expected = Math.PI / 4;
Assert.IsTrue(Helpers.WithinTolerance(result, expected));
}
public void TestDayLengthToRotation()
{
Vector result = MathsHelpers.DayLengthToRotation(AstrophysicalConstants.Earth_Radius, 24, TimeMeasure.Hour);
Vector expected = CommonAstroObjects.Earth.AngularVelocity;
Assert.IsTrue(Helpers.WithinTolerance(result, expected));
}
private static void GetTiltHeadingAndDistanceFromCameraAndTargetPosition(LatLong interestPoint, LatLongAltitude cameraPosition, out double tiltDegrees, out double headingDegrees, out double distance)
{
double distanceAlongGround = LatLong.EstimateGreatCircleDistance(interestPoint, cameraPosition.GetLatLong());
double cameraAltitude = cameraPosition.GetAltitude();
distance = Math.Sqrt(distanceAlongGround * distanceAlongGround + cameraAltitude * cameraAltitude);
headingDegrees = cameraPosition.BearingTo(interestPoint);
tiltDegrees = MathsHelpers.Rad2Deg(Math.PI * 0.5 - Math.Atan2(cameraAltitude, distanceAlongGround));
}
/// <summary>
/// If value is a numeral type (except <see cref="Complex"/>), it is to double and multiplied by <see cref="_Multiplier"/>.
/// Otherwise returns the value without changing it.
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="language"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, string language)
{
if (MathsHelpers.TryCastToDouble(value, out var casted))
{
return(casted * _Multiplier);
}
return(value);
}
private void AngleSlider_ValueChanged(object sender, ValueChangedEventArgs e)
{
//this.StartStopAnimation(shouldStop: true);
Pendulum.StartAngle = e.NewValue;
_pendulumString.Rotation = (float)MathsHelpers.ToDegrees(e.NewValue);
UpdateLabels();
}
/// <summary>
/// Get a bearing / direction between the current lat-long and the lat-long provided.
/// </summary>
/// <param name="toPoint">The point the returned bearing should point towards.</param>
public double BearingTo(LatLong toPoint)
{
double deltaLong = toPoint.GetLongitudeInRadians() - GetLongitudeInRadians();
double toLatitudeInRadians = toPoint.GetLatitudeInRadians();
double y = Math.Sin(deltaLong) * Math.Cos(toLatitudeInRadians);
double x = Math.Cos(GetLatitudeInRadians()) * Math.Sin(toLatitudeInRadians) - Math.Sin(GetLatitudeInRadians()) * Math.Cos(toLatitudeInRadians) * Math.Cos(deltaLong);
double bearing = Math.Atan2(y, x);
return(MathsHelpers.Rad2Deg((bearing + Math.PI * 2) % (Math.PI * 2)));
}
private void UpdateLabels()
{
Device.BeginInvokeOnMainThread(() =>
{
LambdaBeforeLabel.Text = $"{Scatter.IncidentPhotonWavelength * 1E9:G3}nm";
LambdaAfterLabel.Text = $"{ScatterResult.ResultantPhotonWavelength * 1E9:G3}nm";
PhotonAngleLabel.Text = $"{MathsHelpers.ToDegrees(ScatterResult.ResultantPhotonAngle).DecimalPoints(0)}°";
ElectronAngleLabel.Text = $"{-MathsHelpers.ToDegrees(ScatterResult.ElectronAngle).DecimalPoints(0)}°";
ElectronVLabel.Text = $"{(ScatterResult.ElectronVelocity.Abs() / 3E8):G3}c";
});
}
private void ManagerOnDataRequested(DataTransferManager sender, DataRequestedEventArgs args)
{
var request = args.Request;
request.Data.Properties.Title = SelectedItem.Title;
var milliseconds = MathsHelpers.DisplayTimePerWordGroup(SelectedItem.WordCount, _settingsService.WordsPerMin, _settingsService.WordsAtATime);
var time = MathsHelpers.TimeToReadArticle(milliseconds, SelectedItem.WordCount, _settingsService.WordsAtATime);
var message = string.Format(_loader.GetString("ShareText"), SelectedItem.Title, SelectedItem.Url, time.ToFriendlyText());
request.Data.Properties.Description = message;
request.Data.SetText(message);
}
public void TestComptonScatter()
{
ComptonScatter scatter = new ComptonScatter(0.24E-9);
var result = scatter.PerformScatter(MathsHelpers.ToRadians(60));
Assert.IsTrue(MathsHelpers.WithinTolerance(result.ResultantPhotonWavelength, 0.2412E-9));
Assert.IsTrue(MathsHelpers.WithinTolerance(result.ResultantPhotonEnergy.ElectronVolts, 5141));
Assert.IsTrue(MathsHelpers.WithinTolerance(result.IncidentPhotonEnergy.ElectronVolts, 5167));
Assert.IsTrue(MathsHelpers.WithinTolerance(result.ElectronEnergy.ElectronVolts, 26));
Assert.IsTrue(MathsHelpers.WithinTolerance(result.ElectronAngle, MathsHelpers.ToRadians(59.7)));
}
private void UpdateLabels()
{
bool justShowZero = Pendulum.StartAngle == 0 || Pendulum.StringLength == 0;
Device.BeginInvokeOnMainThread(() =>
{
AngleLabel.Text = $"{(justShowZero ? 0 : MathsHelpers.ToDegrees(Pendulum.StartAngle).DecimalPoints(2))}°";
StringLengthLabel.Text = $"{Pendulum.StringLength.DecimalPoints(2)} m";
PeriodLabel.Text = $"T = {(justShowZero ? 0 : Pendulum.Period.DecimalPoints(2))} s";
FrequencyLabel.Text = $"f = {Pendulum.Frequency.DecimalPoints(2)} Hz";
AngularFrequencyLabel.Text = $"ω = {Pendulum.AngularFrequency.DecimalPoints(2)} rad/s";
});
}
private void Done()
{
SelectedItem.WordsRead = 0;
_roamingSettings.Remove(SelectedItem.InternalId);
ShowFinishedScreen = true;
var milliseconds = MathsHelpers.DisplayTimePerWordGroup(SelectedItem.WordCount, _settingsService.WordsPerMin, _settingsService.WordsAtATime);
var time = MathsHelpers.TimeToReadArticle(milliseconds, SelectedItem.WordCount, _settingsService.WordsAtATime);
var format = SelectedItem.WordCount > 1 ? _loader.GetString("FinishedReadingWordsText") : _loader.GetString("FinishedReadingWordText");
FinishedText = SelectedItem.WordCount > 1 ? string.Format(format, SelectedItem.WordCount, time.ToFriendlyText()) : string.Format(format, time.ToFriendlyText());
}
private void StartButton_Clicked(object sender, EventArgs e)
{
if (_isRunning)
{
ResetPositions();
}
ScatterResult = Scatter.PerformScatter(MathsHelpers.ToRadians(Rand.Next(-180, 181)));
UpdateLabels();
this.ElectronStartPos = ElectronNode.Position;
_isRunning = true;
}
/// <summary>
/// Converts a number to SIString using <see cref="CSharpEnhanced.Helpers.SIHelpers.ToS"/>
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="language"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, string language)
{
if (MathsHelpers.TryCastToDouble(value, out var result))
{
return(_ExcludeSmallPrefixes ?
SIHelpers.ToSIStringExcludingSmallPrefixes(result, _Unit, _RoundToDigit, _MidpointRounding, _UseFullName) :
SIHelpers.ToSIString(result, _Unit, _RoundToDigit, _MidpointRounding, _UseFullName));
}
if (value is Complex c)
{
return(_ExcludeSmallPrefixes ?
SIHelpers.ToAltSIStringExcludingSmallPrefixes(c, _Unit, _RoundToDigit, _MidpointRounding, _UseFullName) :
SIHelpers.ToAltSIString(c, _Unit, _RoundToDigit, _MidpointRounding, _UseFullName));
}
return(0);
}
private void OnWordsAtATimeChanged()
{
_settingsService.WordsAtATime = MathsHelpers.RoundedWordsPerMin(WordsAtATime);
}
static void Main(string[] args)
{
double a = 180;
double a1 = MathsHelpers.ConvertAngle(a, AngleUnit.Degrees, AngleUnit.Radians);
double a2 = MathsHelpers.ConvertAngle(a, AngleUnit.Degrees, AngleUnit.Turns);
double a3 = MathsHelpers.ConvertAngle(a, AngleUnit.Degrees, AngleUnit.Degrees);
a = Math.PI;
double a4 = MathsHelpers.ConvertAngle(a, AngleUnit.Radians, AngleUnit.Degrees);
double a5 = MathsHelpers.ConvertAngle(a, AngleUnit.Radians, AngleUnit.Turns);
double a6 = MathsHelpers.ConvertAngle(a, AngleUnit.Radians, AngleUnit.Radians);
a = 0.5;
double a7 = MathsHelpers.ConvertAngle(a, AngleUnit.Turns, AngleUnit.Degrees);
double a8 = MathsHelpers.ConvertAngle(a, AngleUnit.Turns, AngleUnit.Degrees);
double a9 = MathsHelpers.ConvertAngle(a, AngleUnit.Turns, AngleUnit.Turns);
//var a = MathsHelpers.CalculateMidPoints(0, 5, 5);
//var b = MathsHelpers.CalculateMidPoints(1, 1, 1);
//var c = MathsHelpers.CalculateMidPoints(1, 1, 0);
//var dd = MathsHelpers.CalculateMidPoints(1, 2, -1);
//double val = -9.9998;
////while(true)
//Console.WriteLine(val.RoundToDigit(4));
//IEnumerable<string> enn = new string[] { "Test1", "Test2" };
//var en = enn;
//en = en.Concat("Test3");
//foreach(var item in enn)
//{
// Console.WriteLine(item);
//}
//Console.WriteLine(SIHelpers.ToSIString(new Complex(Math.PI * 10000, Math.PI * 1000), "V", 4));
//var x = new ControlledObservableCollection<string>((y) => Console.WriteLine("Added " + y), (y) => Console.WriteLine("Removed " + y));
//x.Add("Test");
//x[0] = "Another test";
//x.RemoveAt(0);
//x.Add("Test1");
//x.Add("Test2");
//x.Add("Test3");
//x.Move(0, 2);
//x.Clear();
//var result = LinearEquations.SimplifiedGaussJordanElimination(
// new Complex[,] { { 1, 2, 0, 1, 0, 1 }, { 1, 1, 0, 0, 0, 1 }, { 0, 0, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 2 }, { 0, 0, 0, 0, 0, 0 }, { 2, 1, 0, 0, 0, 0 } },
// new Complex[] { 0, 0, 0, 5 , 0, 4}, true);
//string s = "5uV";
//var ss = SIHelpers.ParseSIString(s);
//Complex c = new Complex(0, 0);
//Console.WriteLine(SIHelpers.ToAltSIStringExcludingSmallPrefixes(c, "V"));
//c = new Complex(-21000, 220);
//Console.WriteLine(SIHelpers.ToAltSIStringExcludingSmallPrefixes(c, "Volts", true, true));
//c = new Complex(-21000, 0);
//Console.WriteLine(SIHelpers.ToAltSIStringExcludingSmallPrefixes(c, "Volts", true, true));
double d = 0.010000001;
double d1 = 10.00002000004;
double d2 = 9.99997000009;
double d3 = 0.00999997000009;
double d4 = 100;
double d5 = 0.1;
//
Console.WriteLine(MathsHelpers.RoundToDigit(d, 4));
Console.WriteLine(MathsHelpers.RoundToDigit(d1, 4));
Console.WriteLine(MathsHelpers.RoundToDigit(d2, 4));
Console.WriteLine(MathsHelpers.RoundToDigit(d3, 4));
Console.WriteLine(MathsHelpers.RoundToDigit(d4, 4));
Console.WriteLine(MathsHelpers.RoundToDigit(d5, 4));
Console.ReadLine();
}
public static DoubleVector3 LatLongAltToEcefDegrees(double latitudeInRadians, double longitudeInRadians, double altitudeInMeters)
{
LatLongAltitude latLongAlt = new LatLongAltitude(MathsHelpers.Rad2Deg(latitudeInRadians), MathsHelpers.Rad2Deg(longitudeInRadians), altitudeInMeters);
return(latLongAlt.ToECEF());
}
private void OnWordsPerMinChanged()
{
_settingsService.WordsPerMin = MathsHelpers.RoundedWordsPerMin(WordsPerMin);
}
public static bool WithinTolerance(double a, double b)
{
return(MathsHelpers.WithinTolerance(a, b));
}
public static bool operator !=(Temperature A, Temperature B)
{
return(!MathsHelpers.WithinTolerance(A.Kelvin, B.Kelvin));
}
/// <summary>
/// Returns the angle θ of the pendulum after t seconds has elapsed
/// <para>
/// Uses θ = θ_0 cos(wt), where θ_0 = Pendulum.StartAngle
/// </para>
/// </summary>
/// <param name="tSeconds"></param>
/// <returns></returns>
public double AngleAfterTime(double tSeconds)
{
return(MathsHelpers.ToDegrees(this.StartAngle * Math.Cos(this.AngularFrequency * tSeconds)));
}
