/// <summary>
/// Returns given number as string of number always in Exponent formn.
/// </summary>
private string Return_Force_Exponent_Notation(IBack_Parser Back_Parser, string comma_Type)
{
// Exponent notation expresses number as a product of coeficient and exponent
// after the "E" character meaning exponent with subscripted decimal number
// been base of current numeral system. Coeficient if is longer than one digit
// it contains a comma sign right after the first digit.
// https://en.wikipedia.org/wiki/Scientific_notation#E-notation
string output = Back_Parser.Get_Coeficient;
if (output.Length > 1)
{
output = output.Insert(1, comma_Type);
}
output += Exponent_Sign(Back_Parser.Numeral_System_Type);
output += Back_Parser.Exponent_In_Numeral_System_To_String(Back_Parser.Get_Exponent_Value);
if (Back_Parser.Numeral_System_Type > 14)
{
output += ")";
}
return(output);
}
/// <summary>
/// Returns given number as string in form of engineering or forced comma notation
/// according to order of magnitue.
/// </summary>
private string Return_Normal_Notation(IBack_Parser Back_Parser, string comma_Type)
{
// Normal notation expresses number in engineering or forced comma notation according
// to order of magnitue. For numbers that would need more than 30 digits (or long
// as precition if precition of numeral systems is longer than 30) they would be
// returned in exponent notation. If shorter than as it was described the number will be
// returned in force radix base notation.
short coeficient_Length = (short)Back_Parser.Get_Coeficient.Length;
byte precition = Back_Parser.Numeral_System_Precition;
if (precition < 30)
{
precition = 30;
}
if ((Back_Parser.Get_Exponent_Value > 0 && Back_Parser.Get_Exponent_Value < precition) ||
(Back_Parser.Get_Exponent_Value <= 0 && coeficient_Length - Back_Parser.Get_Exponent_Value < precition))
{
return(Return_Force_Radix_Base_Notation(Back_Parser, comma_Type));
}
else
{
return(Return_Force_Exponent_Notation(Back_Parser, comma_Type));
}
}
/// <summary>
/// Returns given number in given positonal numeral system.
/// </summary>
private string Positional_Numeral_System(double number, Number_Notation Number_Notation, sbyte numeral_System_Type, string comma_Type)
{
Double_Precition_Decomposer Decomposer = new Double_Precition_Decomposer(number);
IBack_Parser Back_Parser = Construnct_Positional_Back_Parser(numeral_System_Type, Decomposer);
return((Decomposer.Is_Negative ? "-" : String.Empty) +
Return_Notation_Selector(Back_Parser, Number_Notation, comma_Type));
}
/// <summary>
/// Returns given number as string in form of engineering notation.
/// </summary>
private string Return_Engineering_Notation(IBack_Parser Back_Parser, string comma_Type)
{
// Engineering notation expresses number as a product of coeficient and exponent presented
// as power of base of mumeral system, as in scientific notation but forced to round down
// the exponent to full multplication of 3. As a consequence the comma sign
// maybe placed somewhere between four of first significant digits of the coeficient.
// https://en.wikipedia.org/wiki/Engineering_notation
string output = Back_Parser.Get_Coeficient;
short current_Exponent = Back_Parser.Get_Exponent_Value;
byte comma_shift = 0;
while (current_Exponent % 3 != 0)
{
comma_shift++;
current_Exponent--;
}
if (comma_shift == 0)
{
if (Back_Parser.Get_Coeficient.Length > 1)
{
output = output.Insert(1, comma_Type);
}
}
else if (Back_Parser.Get_Coeficient.Length > comma_shift)
{
output = output.Insert(comma_shift + 1, comma_Type);
}
else if (comma_shift == Back_Parser.Get_Coeficient.Length)
{
output += '0';
}
else if (comma_shift == 2 && Back_Parser.Get_Coeficient.Length == 1)
{
output += "00";
}
output += Scientific_Exponent(Back_Parser.Exponent_In_Numeral_System_To_String(current_Exponent), Back_Parser.Numeral_System_Type);
return(output);
}
/// <summary>
/// Returns given number as string in form of number always rooted on zeroeth order of magnitude.
/// </summary>
private string Return_Force_Radix_Base_Notation(IBack_Parser Back_Parser, string comma_Type)
{
// Force radix base notation expresses number always rooted on (radix) zeroeth
// order of magnitude no matter how many zeroes may need to print it.
// In simplier cases the comma sign will be placed among digits or will be not printed
// at all in cases of integer numbers not divisible by base of their numeral sytem.
// Normalized notations methods in those simplier cases will call this method
// to return forced radix base notation.
StringBuilder output = new StringBuilder();
if (Back_Parser.Get_Exponent_Value < 0)
{
output.Append("0,");
for (int i = Back_Parser.Get_Exponent_Value + 1; i < 0; i++)
{
output.Append(0);
}
output.Append(Back_Parser.Get_Coeficient);
}
else
{
output.Append(Back_Parser.Get_Coeficient);
short comma_Position = (short)(Back_Parser.Get_Exponent_Value - output.Length + 1);
if (comma_Position < 0)
{
output.Insert(Back_Parser.Get_Exponent_Value + 1, comma_Type);
}
else if (comma_Position > 0)
{
for (int i = 0; i < comma_Position; i++)
{
output.Append(0);
}
}
}
return(output.ToString());
}
/// <summary>
/// Returns given number as string always in form of scientific notation.
/// </summary>
private string Return_Force_Scientific_Notation(IBack_Parser Back_Parser, string comma_Type)
{
// Scientific notation expresses number as a product of coeficient and exponent presented
// as power of base of mumeral system. Coeficient if is longer than one digit it contains
// a comma sign right after the first digit.
// https://en.wikipedia.org/wiki/Scientific_notation
string output = Back_Parser.Get_Coeficient;
if (output.Length > 1)
{
output = output.Insert(1, comma_Type);
}
output += Scientific_Exponent(
Back_Parser.Exponent_In_Numeral_System_To_String(Back_Parser.Get_Exponent_Value),
Back_Parser.Numeral_System_Type);
return(output);
}
/// <summary>
/// Returns given number as string in form of scientifc or forced comma notation
/// for short numbers.
/// </summary>
private string Return_Scienfic_Normalized_Notation(IBack_Parser Back_Parser, string comma_Type)
{
// Scienfic normalized notation expresses number in scienfic or forced radix base notation
// according to order of magnitue and length of the number. For numbers that
// in forced radix base notation would need to add zeroes to the number it would be
// returned in scienfic notation. In other case the number will be returned
// in force radix base notation.
int precition = Back_Parser.Numeral_System_Precition;
short exponent_Value = Back_Parser.Get_Exponent_Value;
if ((exponent_Value > 0 && exponent_Value < precition) && exponent_Value <= 0 &&
0 - Back_Parser.Get_Coeficient.Length - exponent_Value > precition)
{
return(Return_Force_Radix_Base_Notation(Back_Parser, comma_Type));
}
else
{
return(Return_Force_Scientific_Notation(Back_Parser, comma_Type));
}
}
