public void TestPositiveIntegerConstrucor()
{
HugeNumber result = new HugeNumber(12);
HugeNumber expected = new HugeNumber()
{
false, false, true, true, true
};
CollectionAssert.AreEqual(expected, result, "Failed on conversion of 12");
result = new HugeNumber(11);
expected = new HugeNumber()
{
true, true, true, true, true
};
CollectionAssert.AreEqual(expected, result, "Failed on conversion of 11");
result = new HugeNumber(13);
expected = new HugeNumber()
{
true, false, true, true, true
};
CollectionAssert.AreEqual(expected, result, "Failed on conversion of 13");
result = new HugeNumber(15);
expected = new HugeNumber()
{
true, true, false, false, true
};
CollectionAssert.AreEqual(expected, result, "Failed on conversion of 15");
}
static public HugeNumber operator -(HugeNumber sNumberA, HugeNumber sNumberB)
{
HugeNumber sNumberHuge;
HugeNumber sNumberSmall;
bool bIsCompare = CheckIsCompareUnit(sNumberA, sNumberB, out sNumberHuge, out sNumberSmall);
if (bIsCompare)
{
return(new HugeNumber(sNumberA._dNumber - sNumberB._dNumber, sNumberHuge._eUnit));
}
else
{
bool bIsNegative = sNumberA.p_eUnit < sNumberB.p_eUnit;
int iUnitOffset = sNumberHuge._eUnit - sNumberSmall._eUnit;
for (int i = 0; i < iUnitOffset; i++)
{
sNumberSmall._dNumber *= 0.001;
}
HugeNumber sReturnNumber = new HugeNumber(sNumberHuge._dNumber - sNumberSmall._dNumber, sNumberHuge._eUnit);
if (bIsNegative)
{
sReturnNumber._dNumber *= -1;
}
return(sReturnNumber);
}
}
public void TestAdd()
{
HugeNumber eleven = new HugeNumber()
{
true, true, true, true, true
};
HugeNumber twelve = new HugeNumber()
{
false, false, true, true, true
};
HugeNumber thirteen = new HugeNumber()
{
true, false, true, true, true
};
HugeNumber twentythree = new HugeNumber {
true, true, false, true, false, true, true
};
HugeNumber minus_twentythree = twentythree.Negate();
CollectionAssert.AreEqual(twentythree, eleven + twelve, "Add failed 11+12.");
CollectionAssert.AreEqual(twentythree, twelve + eleven, "Add failed 12+11.");
CollectionAssert.AreEqual(new HugeNumber()
{
true
}, twelve + eleven.Negate(), "Add failed 12+-11.");
CollectionAssert.AreEqual(new HugeNumber()
{
}, twentythree + minus_twentythree, "Add failed 23+-23.");
}
public void TestSubtract()
{
HugeNumber eleven = new HugeNumber()
{
true, true, true, true, true
};
HugeNumber twelve = new HugeNumber()
{
false, false, true, true, true
};
HugeNumber thirteen = new HugeNumber()
{
true, false, true, true, true
};
HugeNumber one = new HugeNumber {
true
};
CollectionAssert.AreEqual(one.Negate(), eleven - twelve, "Add failed 11-12.");
CollectionAssert.AreEqual(one, twelve - eleven, "Add failed 12-11.");
HugeNumber twentythree = new HugeNumber {
true, true, false, true, false, true, true
};
CollectionAssert.AreEqual(twentythree, twelve - eleven.Negate(), "Add failed 12--11.");
}
private void TestCase_Operator_1()
{
Debug.Log("Start TestCase_Operator_1");
HugeNumber sHugeNum1 = new HugeNumber(123, HugeNumber.EUnit.None);
HugeNumber sHugeNum2 = new HugeNumber(456, HugeNumber.EUnit.None);
Debug.Log(sHugeNum1 + sHugeNum2);
Debug.Log(sHugeNum1 + sHugeNum2 - sHugeNum1);
sHugeNum1 = new HugeNumber(100, HugeNumber.EUnit.A);
sHugeNum2 = new HugeNumber(100, HugeNumber.EUnit.B);
Debug.Log(sHugeNum1 + sHugeNum2);
Debug.Log(sHugeNum1 + sHugeNum2 - sHugeNum1);
//CManagerProfiler.instance.DoStartTestCase( "Test" );
sHugeNum1 = new HugeNumber(1, HugeNumber.EUnit.A);
sHugeNum2 = new HugeNumber(1, HugeNumber.EUnit.C);
HugeNumber sHugeNum3 = sHugeNum2;
for (int i = 0; i < 1000; i++)
{
sHugeNum3 += sHugeNum1;
}
sHugeNum3 += new HugeNumber(999, HugeNumber.EUnit.B);
//CManagerProfiler.instance.DoFinishTestCase( "Test" );
//CManagerProfiler.instance.DoPrintResult(false);
Debug.Log(sHugeNum3);
}
public void HugeNumber_ToStringTest()
{
int iValue = 1000;
string striValueString = "1A";
HugeNumber sHugeNumber = new HugeNumber(iValue);
Assert.IsTrue(sHugeNumber.ToString() == striValueString);
}
public void AddNumber(HugeNumber number)
{
string finalNumberValue = "";
int numberIterator = numberValue.Length - 1;
// when sum of 2 chars is bigger than 10 then add 1 in next iteration
bool addOneNext = false;
for (int i = number.numberValue.Length - 1; i >= 0; i--)
{
int num = number.numberValue[i] - '0';
// when current number is lower than other then insert rest from other on front
if (numberIterator < 0)
{
if (addOneNext)
{
num++;
addOneNext = false;
}
finalNumberValue = finalNumberValue.Insert(0, num.ToString());
continue;
}
int current = numberValue[numberIterator] - '0';
int final = num + current;
// if previous sum was >10 then add 1
if (addOneNext)
{
final++;
addOneNext = false;
}
string finalString = final.ToString();
// if sum is >=10 then remove 1 to add to next iteration
if (final >= 10)
{
addOneNext = true;
finalString = finalString.Substring(1);
}
numberIterator--;
finalNumberValue = finalNumberValue.Insert(0, finalString);
}
// if other number is lower than current then add what's left from current number
if (numberIterator >= 0)
{
finalNumberValue = finalNumberValue.Insert(0, numberValue.Substring(0, numberIterator + 1));
}
else if (addOneNext)
{
finalNumberValue = finalNumberValue.Insert(0, "1");
}
numberValue = finalNumberValue;
}
/// <summary>
/// Calculates the approximate area of a point on a map projection with the given
/// characteristics, by transforming the point and its nearest neighbors to latitude and
/// longitude, calculating the midpoints between them, and calculating the area of the
/// region enclosed within those midpoints.
/// </summary>
/// <param name="radius">The radius of the planet.</param>
/// <param name="x">The x coordinate of a point on a map projection, with zero as the
/// westernmost point.</param>
/// <param name="y">The y coordinate of a point on a map projection, with zero as the
/// northernmost point.</param>
/// <param name="resolution">The vertical resolution of the projection.</param>
/// <param name="options">
/// The map projection options used to generate the map used.
/// </param>
/// <returns>The area of the given point, in m².</returns>
public static HugeNumber GetAreaOfPoint(
HugeNumber radius,
int x, int y,
int resolution,
MapProjectionOptions options) => GetAreaOfPointFromRadiusSquared(
radius.Square(),
x, y,
(int)Math.Floor(resolution * options.AspectRatio),
resolution,
options);
public void TestCopyConstructor()
{
HugeNumber original = new HugeNumber()
{
true, false, true, false, true, true
};
HugeNumber copy = new HugeNumber(original);
CollectionAssert.AreEqual(original, copy, "Copy constructor failed.");
}
/// <summary>
/// Initializes a new instance of <see cref="StarSystemChildDefinition"/>.
/// </summary>
/// <param name="density">The density of this type of child within the containing parent
/// region.</param>
/// <param name="spectralClass">The <see cref="Stars.SpectralClass"/> of the
/// primary star of the star system.</param>
/// <param name="luminosityClass">
/// The <see cref="Stars.LuminosityClass"/> of the primary star of the star
/// system.
/// </param>
/// <param name="populationII">True if the primary star of the star system is to be a
/// Population II star.</param>
/// <param name="allowBinary">
/// Whether a multiple-star system will satisfy this definition.
/// </param>
public StarSystemChildDefinition(
HugeNumber density,
SpectralClass?spectralClass = null,
LuminosityClass?luminosityClass = null,
bool populationII = false,
bool allowBinary = true) : base(StarSystem._StarSystemSpace, density)
{
StarType = StarType.MainSequence;
SpectralClass = spectralClass;
LuminosityClass = luminosityClass;
PopulationII = populationII;
AllowBinary = allowBinary;
}
public void SubtractNumber(HugeNumber number)
{
string finalNumberValue = "";
int lengthDifference = numberValue.Length - number.numberValue.Length;
// Initially take carry zero
int carry = 0;
// Traverse from end of both strings
for (int i = number.numberValue.Length - 1; i >= 0; i--)
{
// Do school mathematics, compute
// difference of current digits and carry
int subtraction = ((numberValue[i + lengthDifference] - '0') - (number.numberValue[i] - '0') - carry);
if (subtraction < 0)
{
subtraction = subtraction + 10;
carry = 1;
}
else
{
carry = 0;
}
finalNumberValue += subtraction.ToString();
}
// subtract remaining digits of numberValue[]
for (int i = lengthDifference - 1; i >= 0; i--)
{
if (numberValue[i] == '0' && carry > 0)
{
finalNumberValue += "9";
continue;
}
int subtraction = ((numberValue[i] - '0') - carry);
// remove preceding 0's
if (i > 0 || subtraction > 0)
{
finalNumberValue += subtraction.ToString();
}
carry = 0;
}
// reverse resultant string
char[] reveerseResultArray = finalNumberValue.ToCharArray();
Array.Reverse(reveerseResultArray);
numberValue = new string(reveerseResultArray);
}
public void TestNegate()
{
HugeNumber input = new HugeNumber()
{
true, true, false, false, true
}; // 15
HugeNumber expected = new HugeNumber()
{
true, false, false, false, true, true
}; // -15
HugeNumber result = input.Negate();
CollectionAssert.AreEqual(expected, result, "Failed on negate of 15.");
CollectionAssert.AreEqual(input, result.Negate(), "Failed on negate of -15.");
}
public void TestToString()
{
HugeNumber result = new HugeNumber()
{
true, true, false, false, true
};
string expected = "11001";
Assert.AreEqual(expected, result.ToString(), "ToString failed for 15.");
result = new HugeNumber()
{
true, false, true, false, true, true
};
expected = "101011";
Assert.AreEqual(expected, result.ToString(), "ToString failed for -11.");
}
public void TestNegativeIntegerConstrucor()
{
HugeNumber result = new HugeNumber(-12);
HugeNumber expected = new HugeNumber()
{
false, false, true, false, true, true
};
CollectionAssert.AreEqual(expected, result, "Failed on conversion of -12.");
result = new HugeNumber(-11);
expected = new HugeNumber()
{
true, false, true, false, true, true
};
CollectionAssert.AreEqual(expected, result, "Failed on conversion of -11.");
}
public void TestToInt()
{
HugeNumber result = new HugeNumber()
{
true, true, false, false, true
};
long expected = 15;
Assert.AreEqual(expected, result.ToLong(), "ToLong failed for 15.");
result = new HugeNumber()
{
true, false, true, false, true, true
};
expected = -11;
Assert.AreEqual(expected, result.ToLong(), "ToLong failed for 15.");
}
public void TestCompare()
{
HugeNumber eleven = new HugeNumber()
{
true, true, true, true, true
};
HugeNumber twelve = new HugeNumber()
{
false, false, true, true, true
};
HugeNumber thirteen = new HugeNumber()
{
true, false, true, true, true
};
Assert.AreEqual(1, twelve.CompareTo(eleven), "Compare 12 > 11 failed.");
Assert.AreEqual(0, twelve.CompareTo(twelve), "Compare 12 == 12 failed.");
Assert.AreEqual(-1, twelve.CompareTo(thirteen), "Compare 12 < 13 failed.");
HugeNumber sixtyfour = new HugeNumber()
{
false, false, false, false, false, false, true
};
Assert.AreEqual(-1, twelve.CompareTo(sixtyfour), "Compare 12 < 64 failed.");
HugeNumber five = new HugeNumber()
{
true, false, true
};
Assert.AreEqual(1, twelve.CompareTo(five), "Compare 12 > 5 failed.");
HugeNumber minus_fifteen = new HugeNumber()
{
true, false, false, false, true, true
}; // -15
Assert.AreEqual(1, twelve.CompareTo(minus_fifteen), "Compare 12 > -15 failed.");
Assert.AreEqual(-1, minus_fifteen.CompareTo(twelve), "Compare -15 < 12 failed.");
Assert.IsTrue(twelve > eleven, "Compare 12 > 11 failed.");
Assert.IsFalse(eleven > twelve, "Compare 11 < 12 failed.");
Assert.IsFalse(twelve < eleven, "Compare 12 > 11 failed.");
Assert.IsTrue(eleven < twelve, "Compare 11 < 12 failed.");
Assert.IsTrue(twelve == twelve, "Compare 12 == 12 failed.");
Assert.IsTrue(twelve <= twelve, "Compare 12 <= 12 failed.");
Assert.IsFalse(twelve <= eleven, "Compare 12 <= 11 failed.");
Assert.IsTrue(twelve >= twelve, "Compare 12 <= 12 failed.");
Assert.IsTrue(twelve >= eleven, "Compare 12 <= 11 failed.");
}
private void TestCase_Operator_2()
{
Debug.Log("Start TestCase_Operator_2");
SCManagerProfiler.DoStartTestCase("Test");
for (int i = 0; i < 1000; i++)
{
HugeNumber sHugeNum1 = new HugeNumber(1, HugeNumber.EUnit.None);
HugeNumber sHugeNum2 = sHugeNum1 * 100000000;
HugeNumber sHugeNum3 = new HugeNumber(1, HugeNumber.EUnit.G);
sHugeNum3 += sHugeNum2;
sHugeNum3 -= sHugeNum2;
}
SCManagerProfiler.DoFinishTestCase("Test");
SCManagerProfiler.DoPrintResult(false);
}
private void TestCase_InitNumber()
{
Debug.Log("Start TestCase_InitNumber");
HugeNumber sHugeNum = new HugeNumber(100, HugeNumber.EUnit.None);
Debug.Log(sHugeNum);
sHugeNum = new HugeNumber(1234100.1234, HugeNumber.EUnit.None);
Debug.Log(sHugeNum);
sHugeNum = new HugeNumber(0.1234567, HugeNumber.EUnit.A);
Debug.Log(sHugeNum);
sHugeNum = new HugeNumber(1234100.1234, HugeNumber.EUnit.G);
Debug.Log(sHugeNum);
}
static void Main()
{
// Write a program to calculate n! for each n in the range [1..100].
// Implement first a method that multiplies a number represented as array of digits by given integer number.
int n = 100;
// We will use the class HugeNumber we created in Problem 8
HugeNumber factorial = new HugeNumber(new byte[] { 1 });
for (int i = 1; i <= n; i++)
{
factorial = factorial * i;
Console.WriteLine("{0}! = {1}", i, factorial);
if (i != n)
{
Console.Write("Press any key to see the next factorial...");
Console.ReadKey(true);
Console.Clear();
}
}
}
public bool CanSubtract(HugeNumber number)
{
int numberLength = number.numberValue.Length;
if (numberValue.Length < numberLength)
{
return(false);
}
if (numberValue.Length > numberLength)
{
return(true);
}
for (int i = 0; i < numberValue.Length; i++)
{
if (numberValue[i] < number.numberValue[i])
{
return(false);
}
}
return(true);
}
public void TestAddPerformance()
{
Random rnd = new Random(23);
for (int i = 0; i < 100; ++i)
{
int a = rnd.Next(short.MaxValue);
int b = rnd.Next() * rnd.Next(short.MaxValue);
HugeNumber x = new HugeNumber(a);
HugeNumber y = new HugeNumber(b);
HugeNumber z = x + y;
Assert.AreEqual(a + b, z.ToLong(), "Addition failed.");
Assert.AreEqual(a + b, (y + x).ToLong(), "Addition failed.");
}
for (int i = 0; i < 100; ++i)
{ // big numbers
long a = rnd.Next(short.MaxValue) * int.MaxValue;
long b = rnd.Next(short.MaxValue) * rnd.Next(short.MaxValue) * int.MaxValue;
HugeNumber x = new HugeNumber(a);
HugeNumber y = new HugeNumber(b);
HugeNumber z = x + y;
Assert.AreEqual(0, (z).ToLong() - (a + b), "Addition failed.");
}
for (int i = 0; i < 1000; ++i)
{
int a = -rnd.Next(short.MaxValue); // test with negatives
int b = rnd.Next(short.MaxValue) * rnd.Next(short.MaxValue);
HugeNumber x = new HugeNumber(a);
HugeNumber y = new HugeNumber(b);
HugeNumber z = x + y;
Assert.AreEqual(a + b, z.ToLong(), "Addition failed.");
Assert.AreEqual(a + b, (y + x).ToLong(), "Addition failed.");
}
int v = rnd.Next(short.MaxValue);
HugeNumber V = new HugeNumber(v);
Assert.AreEqual(0, (V + V.Negate()).ToLong(), "Addition to 0 failed.");
}
public OrbitalParameters(
HugeNumber orbitedMass,
Vector3 <HugeNumber> orbitedPosition,
HugeNumber periapsis,
double eccentricity,
double inclination,
double angleAscending,
double argumentOfPeriapsis,
double trueAnomaly,
bool circular = false,
bool fromEccentricity = false)
{
Circular = circular;
FromEccentricity = fromEccentricity;
OrbitedMass = orbitedMass;
OrbitedPosition = orbitedPosition;
Periapsis = periapsis;
Eccentricity = eccentricity;
Inclination = inclination;
AngleAscending = angleAscending;
ArgumentOfPeriapsis = argumentOfPeriapsis;
TrueAnomaly = trueAnomaly;
}
static public bool CheckIsCompareUnit(HugeNumber sNumberA, HugeNumber sNumberB, out HugeNumber sNumberHuge, out HugeNumber sNumberSmall)
{
bool bIsCompare = true;
if (sNumberA._eUnit > sNumberB._eUnit)
{
sNumberHuge = sNumberA;
sNumberSmall = sNumberB;
bIsCompare = false;
}
else if (sNumberA._eUnit < sNumberB._eUnit)
{
sNumberHuge = sNumberB;
sNumberSmall = sNumberA;
bIsCompare = false;
}
else if (sNumberA._dNumber > sNumberB._dNumber)
{
sNumberHuge = sNumberA;
sNumberSmall = sNumberB;
bIsCompare = true;
}
else if (sNumberA._dNumber < sNumberB._dNumber)
{
sNumberHuge = sNumberB;
sNumberSmall = sNumberA;
bIsCompare = true;
}
else
{
sNumberHuge = new HugeNumber();
sNumberSmall = new HugeNumber();
}
return(bIsCompare);
}
/// <summary> /// Initializes a new instance of <see cref="PlanetChildDefinition"/>. /// </summary> /// <param name="density"> /// The density of this type of child within the containing parent region. /// </param> /// <param name="planemoType"> /// The type of <see cref="Planetoid"/>. /// </param> public PlanetChildDefinition(HugeNumber density, PlanetType planemoType = PlanetType.Dwarf) : base(Planetoid.GetSpaceForType(planemoType), density) => PlanetType = planemoType;
public PlanetaryRing(bool icy, HugeNumber innerRadius, HugeNumber outerRadius)
{
Icy = icy;
InnerRadius = innerRadius;
OuterRadius = outerRadius;
}
/// <summary> /// Gets an <see cref="OrbitalParameters"/> instance which defines a circular orbit. /// </summary> /// <param name="orbitedMass"> /// The mass of the object or system being orbited, in kg. /// </param> /// <param name="orbitedPosition"> /// The position of the object or system being orbited at the epoch, as a vector in the same /// reference frame as the orbiting object. /// </param> public static OrbitalParameters GetCircular(HugeNumber orbitedMass, Vector3 <HugeNumber> orbitedPosition) => new(
static void Test()
{
HugeNumber a, b, c;
Random rand = new Random();
while (true)
{
Console.ReadKey(true);
long num1 = rand.Next(1000);
long num2 = rand.Next(20);
long sum = num1 + num2;
a = new HugeNumber(num1.ToString());
b = new HugeNumber(num2.ToString());
c = a + b;
Console.WriteLine("{0} + {1} = {2}", a, b, c);
long result = long.Parse(c.ToString());
if (result != sum)
{
Console.Write("Wrong! This is the correct result: ");
Console.WriteLine("{0} + {1} = {2}", num1, num2, sum);
}
}
}
static void Main()
{
Console.WriteLine("Enter some big positive integers:");
Console.Write("a = ");
HugeNumber a = new HugeNumber(Console.ReadLine());
Console.Write("b = ");
HugeNumber b = new HugeNumber(Console.ReadLine());
HugeNumber c = a + b;
Console.WriteLine("{0} + {1} = {2}", a, b, c);
Console.WriteLine("\nWorks with arrays as well:");
a = new HugeNumber(new byte[] { 3, 2, 1 });
b = new HugeNumber(new byte[] { 6, 5, 4 });
Console.WriteLine("{0} + {1} = {2}", a, b, a + b);
//Test();
}
/// <summary>
/// Initializes a new instance of <see cref="StarSystemChildDefinition"/>.
/// </summary>
/// <param name="density">The density of this type of child within the containing parent
/// region.</param>
public StarSystemChildDefinition(HugeNumber density) : base(StarSystem._StarSystemSpace, density)
{
}
// Multiplication (int * HugeNumber)
public static HugeNumber operator *(int small, HugeNumber big)
{
HugeNumber result = new HugeNumber(new byte[] { 0 });
for (int i = 0; i < small; i++)
{
result = result + big;
}
return result;
}
public void MultiplyByNumber(HugeNumber number)
{
string finalNumberValue = "";
if (numberValue.Length == 0 || number.numberValue.Length == 0 ||
numberValue == "0" || number.numberValue == "0")
{
numberValue = "0";
return;
}
// will keep the result number in vector
// in reverse order
int[] resultReversed = new int[numberValue.Length + number.numberValue.Length];
// Below two indexes are used to
// find positions in result.
int indexN1 = 0;
int i;
// Go from right to left in num1
for (i = numberValue.Length - 1; i >= 0; i--)
{
int carry = 0;
int n1 = numberValue[i] - '0';
// To shift position to left after every
// multipliccharAtion of a digit in num2
int indexN2 = 0;
// Go from right to left in num2
for (int j = number.numberValue.Length - 1; j >= 0; j--)
{
// Take current digit of second number
int n2 = number.numberValue[j] - '0';
// Multiply with current digit of first number
// and add result to previously stored result
// charAt current position.
int sum = n1 * n2 + resultReversed[indexN1 + indexN2] + carry;
// Carry for next itercharAtion
carry = sum / 10;
// Store result
resultReversed[indexN1 + indexN2] = sum % 10;
indexN2++;
}
// store carry in next cell
if (carry > 0)
{
resultReversed[indexN1 + indexN2] += carry;
}
// To shift position to left after every
// multipliccharAtion of a digit in num1.
indexN1++;
}
// ignore '0's from the right
i = resultReversed.Length - 1;
while (i >= 0 && resultReversed[i] == 0)
{
i--;
}
// If all were '0's - means either both
// or one of num1 or num2 were '0'
if (i == -1)
{
numberValue = "0";
return;
}
while (i >= 0)
{
finalNumberValue += (resultReversed[i--]);
}
numberValue = finalNumberValue;
}
/// <summary>
/// Initializes a new instance of <see cref="SurfaceRegion"/>.
/// </summary>
/// <param name="planet">The planet on which this region is found.</param>
/// <param name="position">The normalized position vector of this region.</param>
/// <param name="latitudeRange">
/// <para>
/// The range of latitudes encompassed by this region, as an angle (in radians).
/// </para>
/// <para>
/// Maximum value is π (a full hemisphere, which produces the full globe).
/// </para>
/// </param>
public SurfaceRegion(Planetoid planet, Vector3 <HugeNumber> position, HugeNumber latitudeRange)
: base(planet.Id, new Frustum <HugeNumber>(2, position * (planet.Shape.ContainingRadius + planet.Atmosphere.AtmosphericHeight), HugeNumber.Min(latitudeRange, HugeNumber.Pi), 0))
{
}
/// <summary>
/// Initializes a new instance of <see cref="ChildDefinition"/>.
/// </summary>
/// <param name="space">The radius of the open space required for this child type.</param>
/// <param name="density">
/// The density of this type of child within the containing parent region.
/// </param>
/// <param name="structureType">The type of this child.</param>
public ChildDefinition(HugeNumber space, HugeNumber density, CosmicStructureType structureType)
{
Density = density;
Space = space;
StructureType = structureType;
}
/// <summary>
/// Initializes a new instance of <see cref="SurfaceRegion"/>.
/// </summary>
/// <param name="planet">The planet on which this region is found.</param>
/// <param name="latitude">The latitude of the center of the region.</param>
/// <param name="longitude">The longitude of the center of the region.</param>
/// <param name="latitudeRange">
/// <para>
/// The range of latitudes encompassed by this region, as an angle (in radians).
/// </para>
/// <para>
/// Maximum value is π (a full hemisphere, which produces the full globe).
/// </para>
/// </param>
public SurfaceRegion(Planetoid planet, double latitude, double longitude, HugeNumber latitudeRange)
: base(planet.Id, new Frustum <HugeNumber>(2, planet.LatitudeAndLongitudeToVector(latitude, longitude) * (planet.Shape.ContainingRadius + planet.Atmosphere.AtmosphericHeight), HugeNumber.Min(latitudeRange, HugeNumber.Pi), 0))
{
}
