/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <param name="decimalDigit"> CDigit должно быть целым, неотрицательным. </param>
/// <param name="unit"></param>
/// <param name="result"> Сюда записывается результат. </param>
/// <returns> <paramref name="result"/> </returns>
/// <exception cref="ArgumentException">
/// Если decimalDigit меньше нуля или не целое.
/// </exception>
public static StringBuilder ConvertToString(decimal decimalDigit, IUnit unit, StringBuilder result)
{
string error = CheckDigit(decimalDigit);
if (error != null) throw new ArgumentException(error, "число");
// Целочисленные версии работают в разы быстрее, чем decimal.
if (decimalDigit <= uint.MaxValue)
{
ConvertToString((uint)decimalDigit, unit, result);
}
else if (decimalDigit <= ulong.MaxValue)
{
ConvertToString((ulong)decimalDigit, unit, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
decimal div1000 = Math.Floor(decimalDigit / 1000);
HightDigitClassesToString(div1000, 0, mySb);
DigitClassToString((uint)(decimalDigit - div1000 * 1000), unit, mySb);
}
return result;
}
public static void Main(string[] args)
{
MyStringBuilder s = "hello";
s += " world";
Console.WriteLine(s);
}
static void Main(string[] args)
{
//string은 불변으로 추가하려면 많은 메모리 사용
MyStringBuilder s = "hello ";
s += "world";
Console.WriteLine(s);
}
static void Main(string[] args)
{
MyStringBuilder msb = "fatih";
msb += " mert";
Console.WriteLine(msb);
Console.ReadKey();
}
public void Should_Create_Default_My_String_Builder()
{
//act
var builder = new MyStringBuilder();
//assert
builder.Length.ShouldBeEquivalentTo(0);
builder.Capacity.ShouldBeEquivalentTo(4);
}
//----------------------------------------------------------------------------------------------------------------------------------------------
protected void addInuse(MyStringBuilder builder)
{
if (mInusedList.Contains(builder))
{
logError("加入已使用列表失败");
return;
}
// 加入使用列表
mInusedList.Add(builder);
}
public string Invoke(string[] args)
{
MyStringBuilder s = args[0];
for (int i = 1; i < args.Length; i++)
{
s += args[i]; //when implicit conversion created from MyStringBuilder to string, + operator works like append in strings
}
return(s.ToString());
}
protected void addUnuse(MyStringBuilder builder)
{
// 加入未使用列表
if (mUnusedList.Contains(builder))
{
logError("加入未使用列表失败");
return;
}
mUnusedList.Add(builder);
}
protected void addUnuse(MyStringBuilder builder)
{
// 加入未使用列表
if (mUnusedList.Contains(builder))
{
logError("builder is in Unused list! can not add again!");
return;
}
mUnusedList.Add(builder);
}
public void Append(string data)
{
var sb = new MyStringBuilder();
sb.Append(data);
Assert.AreEqual(data.Length, sb.Count);
Assert.AreEqual(data, sb.ToString());
Assert.AreEqual(data.Length, sb.ToString().Length);
}
private static string b2h(byte[] b, int offset, int len)
{
var sb = new MyStringBuilder();
for (int i = offset, j = offset + len; i < j; i++)
{
sb.Append(b[i].ToString("X2"));
}
return(sb.ToString());
}
public void Clear(string data)
{
var sb = new MyStringBuilder();
sb.Append(data);
sb.Clear();
Assert.AreEqual(0, sb.Count);
Assert.AreEqual(string.Empty, sb.ToString());
Assert.AreEqual(0, sb.ToString().Length);
}
static void Main(string[] args)
{
var msb = new MyStringBuilder();
msb.Append("Ljubo");
msb.Append(" idiot!");
Console.WriteLine(msb);
Console.ReadLine();
}
public void Should_Throw_If_SetIndexer_Index_OutRange()
{
//arrange
string str = "hello";
//act
MyStringBuilder builder = new MyStringBuilder(str);
Action act = () => builder[str.Length] = 's';
//assert
act.ShouldThrow <ArgumentOutOfRangeException>();
}
public void Should_Not_Create_My_String_Builder_With_Negative_Capacity()
{
//arrange
int capacity = -1;
MyStringBuilder builder;
//act
Action act = () => builder = new MyStringBuilder(capacity);
//assert
act.ShouldThrow <ArgumentOutOfRangeException>();
}
public void AppendLine(string data)
{
var sb = new MyStringBuilder();
sb.AppendLine(data);
var newLineLength = Environment.NewLine.Length;
Assert.AreEqual(data.Length + newLineLength, sb.Count);
Assert.AreEqual(data + Environment.NewLine, sb.ToString());
Assert.AreEqual(data.Length + newLineLength, sb.ToString().Length);
}
public void Should_Create_My_String_Builder_With_Capacity()
{
//arrange
int capacity = 8;
//act
var builder = new MyStringBuilder(capacity);
//assert
builder.Length.ShouldBeEquivalentTo(0);
builder.Capacity.ShouldBeEquivalentTo(8);
}
public override void Пропись(MyStringBuilder sb, uint числоЕдиниц, одЧисло род)
{
sb.Append(this.названиеДесятка);
if (числоЕдиниц == 0)
{
// После "двадцать", "тридцать" и т.д. не пишут "ноль" (единиц)
}
else
{
sb.Append(ПрописьЦифры(числоЕдиниц, род));
}
}
static void Main(string[] args)
{
var cb = new CodeBuilder();
cb.AppendLine("class Foo")
.AppendLine("{")
.AppendLine("}");
WriteLine(cb);
WriteLine();
// adapter-decorator
MyStringBuilder s = "hello ";
s += "world"; // will work even without op+ in MyStringBuilder
// why? you figure it out!
WriteLine(s);
WriteLine();
// multiple inheritance
var dragon = new Dragon {
Weight = 123
};
dragon.Fly();
dragon.Crawl();
WriteLine();
// dynamic decorator composition
var square = new Square(1.23f);
WriteLine(square.AsString());
var redSquare = new ColoredShape(square, "red");
WriteLine(redSquare.AsString());
var redHalfTransparentSquare = new TransparentShape(redSquare, 0.5f);
WriteLine(redHalfTransparentSquare.AsString());
// static decorator composition
ColoredShape <Circle> blueCircle = new ColoredShape <Circle>("blue");
WriteLine(blueCircle.AsString());
TransparentShape <ColoredShape <Square> > blackHalfSquare = new TransparentShape <ColoredShape <Square> >(0.4f);
WriteLine(blackHalfSquare.AsString());
ColoredShape <TransparentShape <Circle> > whiteHalfCircle = new ColoredShape <TransparentShape <Circle> >("white");
WriteLine(whiteHalfCircle.AsString());
}
public override void Пропись(MyStringBuilder sb, uint числоЕдиниц, одЧисло род)
{
sb.Append(this.названиеДесятка);
if (числоЕдиниц == 0)
{
// ##### "########", "########" # #.#. ## ##### "####" (######)
}
else
{
sb.Append(ПрописьЦифры(числоЕдиниц, род));
}
}
public override void ToDigitString(MyStringBuilder sb, uint countOfUnits, DigitKindAndQuantity digitKind)
{
sb.Append(this.decadeName);
if (countOfUnits == 0)
{
// После "двадцать", "тридцать" и т.д. не пишут "ноль" (единиц)
}
else
{
sb.Append(UnityToString(countOfUnits, digitKind));
}
}
public SQLiteData query(int id, out SQLiteData data)
{
if (mDataList.TryGetValue(id, out data))
{
return(data);
}
MyStringBuilder condition = newBuilder();
appendConditionInt(condition, SQLiteData.ID, id, EMPTY);
parseReader(doQuery(valueDestroyBuilder(condition)), out data);
mDataList.Add(id, data);
return(data);
}
public void Should_Get_SetIndexer()
{
//arrange
string str = "hello";
MyStringBuilder builder = new MyStringBuilder(str);
//act
builder[0] = 'H';
//assert
builder.ToString()[0].ShouldBeEquivalentTo('H');
}
public override void ToWords(MyStringBuilder sb, uint numberUnits, GenitiveNumber kind)
{
sb.Append(this.decadeName);
if (numberUnits == 0)
{
// После "двадцать", "тридцать" и т.д. не пишут "ноль" (единиц)
}
else
{
sb.Append(ToWordsNumbers(numberUnits, kind));
}
}
public void Should_Throw_If_GetIndexer_Index_OutRange()
{
//arrange
string str = "hello";
var ch = '\0';
//act
MyStringBuilder builder = new MyStringBuilder(str);
Action act = () => ch = builder[-1];
//assert
act.ShouldThrow <ArgumentOutOfRangeException>();
}
public void Should_Create_My_String_Builder_With_String()
{
//arrange
string str = "hello";
//act
MyStringBuilder builder = new MyStringBuilder(str);
//assert
builder.Length.ShouldBeEquivalentTo(str.Length);
builder.Capacity.ShouldBeEquivalentTo(str.Length);
builder.ToString().ShouldBeEquivalentTo(str);
}
private void GetMarkedPreOrderTraversal(MyBinarySearchTreeNode <int> root,
MyStringBuilder result)
{
if (root == null)
{
result.Append("*");
return;
}
result.Append(root.Data.ToString());
GetMarkedPreOrderTraversal(root.Left, result);
GetMarkedPreOrderTraversal(root.Right, result);
}
public void Should_Check_Remove()
{
//arrange
string str = "Hello";
string resultStr = "Heo";
MyStringBuilder builder = new MyStringBuilder(str);
//act
var result = builder.Remove(2, 2);
//assert
result.ToString().ShouldBeEquivalentTo(resultStr);
}
public void Should_Get_GetIndexer()
{
//arrange
string str = "hello";
//act
MyStringBuilder builder = new MyStringBuilder(str);
//assert
for (int i = 0; i < str.Length; i++)
{
str[i].ShouldBeEquivalentTo(builder[i]);
}
}
public void Should_Check_Insert()
{
//arrange
string str1 = "Hello";
string str2 = "hello";
string resultStr = "Hehellollo";
MyStringBuilder builder = new MyStringBuilder(str1);
//act
var result = builder.Insert(2, str2);
//assert
result.ToString().ShouldBeEquivalentTo(resultStr);
}
public void Should_Check_Equals_True()
{
//arrange
string str = "Hello";
MyStringBuilder builder1 = new MyStringBuilder(str);
MyStringBuilder builder2 = new MyStringBuilder(str);
//act
var result = builder1.Equals(builder2);
//assert
result.ShouldBeEquivalentTo(true);
}
public override void ToDigitString(MyStringBuilder sb, uint countOfUnits, DigitKindAndQuantity digitKind)
{
sb.Append(stringLikeDecade[countOfUnits]);
}
static void ПрописьСтаршихКлассов(uint число, int номерКласса, MyStringBuilder sb)
{
if (число == 0) return; // конец рекурсии
// Записать в StringBuilder пропись старших классов.
uint div1000 = число / 1000;
ПрописьСтаршихКлассов(div1000, номерКласса + 1, sb);
uint числоДо999 = число - div1000 * 1000;
if (числоДо999 == 0) return;
ПрописьКласса(числоДо999, Классы[номерКласса], sb);
}
static void HightDigitClassesToString(uint uintDigit, int digitClassNumber, MyStringBuilder sb)
{
if (uintDigit == 0) return; // конец рекурсии
// Записать в StringBuilder пропись старших классов.
uint div1000 = uintDigit / 1000;
HightDigitClassesToString(div1000, digitClassNumber + 1, sb);
uint digitBefore999 = uintDigit - div1000 * 1000;
if (digitBefore999 == 0) return;
DigitClassToString(digitBefore999, DigitClasses[digitClassNumber], sb);
}
public static StringBuilder SpellOut(ulong number, IMeasureUnit mu, StringBuilder result)
{
if (number <= uint.MaxValue)
{
SpellOut((uint) number, mu, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
ulong div1000 = number/1000;
SpellOutСтаршихКлассов(div1000, 0, mySb);
SpellOutUnit((uint) (number - div1000*1000), mu, mySb);
}
return result;
}
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <returns> <paramref name="result"/> </returns>
public static StringBuilder ConvertToString(ulong ulongDigit, IUnit unit, StringBuilder result)
{
if (ulongDigit <= uint.MaxValue)
{
ConvertToString((uint)ulongDigit, unit, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
ulong div1000 = ulongDigit / 1000;
HightDigitClassesToString(div1000, 0, mySb);
DigitClassToString((uint)(ulongDigit - div1000 * 1000), unit, mySb);
}
return result;
}
public abstract void SpellOut(MyStringBuilder sb, uint numberЕдиниц, NumberForm род);
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <param name="число"> Число должно быть целым, неотрицательным. </param>
/// <param name="еи"></param>
/// <param name="result"> Сюда записывается результат. </param>
/// <returns> <paramref name="result"/> </returns>
/// <exception cref="ArgumentException">
/// Если число меньше нуля или не целое.
/// </exception>
public static StringBuilder Propis(decimal число, IЕдиницаИзмерения еи, StringBuilder result)
{
string error = ПроверитьЧисло(число);
if (error != null) throw new ArgumentException(error, "число");
if (число < 0)
{
result.Append("минус ");
число = Convert.ToDecimal(число.ToString().Remove(0, 1));
}
// Целочисленные версии работают в разы быстрее, чем decimal.
if (число <= uint.MaxValue)
{
Propis((uint)число, еи, result);
}
else if (число <= ulong.MaxValue)
{
Propis((ulong)число, еи, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
decimal div1000 = Math.Floor(число / 1000);
ПрописьСтаршихКлассов(div1000, 0, mySb);
ПрописьКласса((uint)(число - div1000 * 1000), еи, mySb);
}
return result.Replace(result.ToString().Substring(0,1), result.ToString().Substring(0,1).ToUpper(),0,1);
}
public override void Propis(MyStringBuilder sb, uint числоЕдиниц, РодЧисло род)
{
sb.Append(ПрописьЦифры(числоЕдиниц, род));
}
public override void Propis(MyStringBuilder sb, uint числоЕдиниц, РодЧисло род)
{
sb.Append(this.названиеДесятка);
if (числоЕдиниц == 0)
{
// После "двадцать", "тридцать" и т.д. не пишут "ноль" (единиц)
}
else
{
sb.Append(ПрописьЦифры(числоЕдиниц, род));
}
}
public abstract void Propis(MyStringBuilder sb, uint числоЕдиниц, РодЧисло род);
public override void Propis(MyStringBuilder sb, uint числоЕдиниц, РодЧисло род)
{
sb.Append(ПрописьНаДцать[числоЕдиниц]);
}
public override void SpellOut(MyStringBuilder sb, uint numberЕдиниц, NumberForm род)
{
sb.Append(this.названиеДесятка);
if (numberЕдиниц == 0)
{
// После "двадцать", "тридцать" и т.д. не пишут "ноль" (единиц)
}
else
{
sb.Append(SpellOutЦифры(numberЕдиниц, род));
}
}
public override void SpellOut(MyStringBuilder sb, uint numberЕдиниц, NumberForm род)
{
sb.Append(SpellOutНаДцать[numberЕдиниц]);
}
public override void SpellOut(MyStringBuilder sb, uint numberЕдиниц, NumberForm род)
{
sb.Append(SpellOutЦифры(numberЕдиниц, род));
}
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <param name="число">
/// Число должно быть целым, неотрицательным, не большим <see cref="MaxDouble"/>.
/// </param>
/// <param name="еи"></param>
/// <param name="result"> Сюда записывается результат. </param>
/// <exception cref="ArgumentException">
/// Если число меньше нуля, не целое или больше <see cref="MaxDouble"/>.
/// </exception>
/// <returns> <paramref name="result"/> </returns>
/// <remarks>
/// float по умолчанию преобразуется к double, поэтому нет перегрузки для float.
/// В результате ошибок округления возможно расхождение цифр прописи и
/// строки, выдаваемой double.ToString ("R"), начиная с 17 значащей цифры.
/// </remarks>
public static StringBuilder Propis(double число, IЕдиницаИзмерения еи, StringBuilder result)
{
string error = ПроверитьЧисло(число);
if (error != null) throw new ArgumentException(error, "число");
if (число < 0)
{
result.Append("минус ");
число = Convert.ToDouble(число.ToString().Remove(0, 1));
}
if (число <= uint.MaxValue)
{
Propis((uint)число, еи, result);
}
else if (число <= ulong.MaxValue)
{
// Propis с ulong выполняется в среднем в 2 раза быстрее.
Propis((ulong)число, еи, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
double div1000 = Math.Floor(число / 1000);
ПрописьСтаршихКлассов(div1000, 0, mySb);
ПрописьКласса((uint)(число - div1000 * 1000), еи, mySb);
}
return result.Replace(result.ToString().Substring(0, 1), result.ToString().Substring(0, 1).ToUpper(),0,1);
}
private static void SpellOutUnit(uint numberLT999, IMeasureUnit unit, MyStringBuilder sb)
{
uint numberN = numberLT999%10;
uint number10n = (numberLT999/10)%10;
uint number100n = (numberLT999/100)%10;
sb.Append(Сотни[number100n]);
if ((numberLT999%100) != 0)
{
Tens[number10n].SpellOut(sb, numberN, unit.NumberForm);
}
// Добавить название класса в нужной форме.
sb.Append(Normalize(unit, numberLT999));
}
public override void ToDigitString(MyStringBuilder sb, uint countOfUnits, DigitKindAndQuantity digitKind)
{
sb.Append(UnityToString(countOfUnits, digitKind));
}
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <returns> <paramref name="result"/> </returns>
public static StringBuilder ConvertToString(uint uintDigit, IUnit unit, StringBuilder result)
{
MyStringBuilder mySb = new MyStringBuilder(result);
if (uintDigit == 0)
{
mySb.Append("ноль");
mySb.Append(unit.GenitivePlural);
}
else
{
uint div1000 = uintDigit / 1000;
HightDigitClassesToString(div1000, 0, mySb);
DigitClassToString(uintDigit - div1000 * 1000, unit, mySb);
}
return result;
}
public override void ToDigitString(MyStringBuilder sb, uint countOfUnits, DigitKindAndQuantity digitKind)
{
sb.Append(this.decadeName);
if (countOfUnits == 0)
{
// После "двадцать", "тридцать" и т.д. не пишут "ноль" (единиц)
}
else
{
sb.Append(UnityToString(countOfUnits, digitKind));
}
}
private static void SpellOutСтаршихКлассов(uint number, int номерКласса, MyStringBuilder sb)
{
if (number == 0) return; // конец рекурсии
// Записать в StringBuilder SpellOut старших классов.
uint div1000 = number/1000;
SpellOutСтаршихКлассов(div1000, номерКласса + 1, sb);
uint numberДо999 = number - div1000*1000;
if (numberДо999 == 0) return;
SpellOutUnit(numberДо999, Классы[номерКласса], sb);
}
public abstract void ToDigitString(MyStringBuilder sb, uint countOfUnits, DigitKindAndQuantity digitKind);
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <returns> <paramref name="result"/> </returns>
public static StringBuilder Propis(ulong число, IЕдиницаИзмерения еи, StringBuilder result)
{
if (число <= uint.MaxValue)
{
Propis((uint)число, еи, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
ulong div1000 = число / 1000;
ПрописьСтаршихКлассов(div1000, 0, mySb);
ПрописьКласса((uint)(число - div1000 * 1000), еи, mySb);
}
return result.Replace(result.ToString().Substring(0, 1), result.ToString().Substring(0, 1).ToUpper(),0,1);
}
/// <summary>
/// Формирует запись класса с названием, например,
/// "125 тысяч", "15 рублей".
/// Для 0 записывает только единицу измерения в род.мн.
/// </summary>
private static void DigitClassToString(uint digitBefore999, IUnit unit, MyStringBuilder sb)
{
uint countOfUnity = digitBefore999 % 10;
uint countOfDecades = (digitBefore999 / 10) % 10;
uint countOfHundreds = (digitBefore999 / 100) % 10;
sb.Append(Hundreds[countOfHundreds]);
if ((digitBefore999 % 100) != 0)
{
Decades[countOfDecades].ToDigitString(sb, countOfUnity, unit.DigitKindAndQuantity);
}
// Добавить название класса в нужной форме.
sb.Append(ConformCurrencyTypeWithDigit(unit, digitBefore999));
}
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <returns> <paramref name="result"/> </returns>
public static StringBuilder Propis(uint число, IЕдиницаИзмерения еи, StringBuilder result)
{
MyStringBuilder mySb = new MyStringBuilder(result);
if (число == 0)
{
mySb.Append("ноль");
mySb.Append(еи.РодМнож);
}
else
{
uint div1000 = число / 1000;
ПрописьСтаршихКлассов(div1000, 0, mySb);
ПрописьКласса(число - div1000 * 1000, еи, mySb);
}
return result;
}
/// <summary>
/// Формирует запись класса с названием, например,
/// "125 тысяч", "15 рублей".
/// Для 0 записывает только единицу измерения в род.мн.
/// </summary>
private static void ПрописьКласса(uint числоДо999, IЕдиницаИзмерения класс, MyStringBuilder sb)
{
uint числоЕдиниц = числоДо999 % 10;
uint числоДесятков = (числоДо999 / 10) % 10;
uint числоСотен = (числоДо999 / 100) % 10;
sb.Append(Сотни[числоСотен]);
if ((числоДо999 % 100) != 0)
{
Десятки[числоДесятков].Propis(sb, числоЕдиниц, класс.РодЧисло);
}
// Добавить название класса в нужной форме.
sb.Append(Согласовать(класс, числоДо999));
}
/// <summary>
/// Получить SpellOut числа с согласованной единицей измерения.
/// </summary>
/// <returns> <paramref name="result"/> </returns>
public static StringBuilder SpellOut(uint number, IMeasureUnit mu, StringBuilder result)
{
MyStringBuilder mySb = new MyStringBuilder(result);
if (number == 0)
{
mySb.Append("ноль");
//mySb.Append(mu.РодМнож);
}
else
{
uint div1000 = number/1000;
SpellOutСтаршихКлассов(div1000, 0, mySb);
SpellOutUnit(number - div1000*1000, mu, mySb);
}
return result;
}
/// <summary>
/// Записывает в <paramref name="sb"/> пропись числа, начиная с самого
/// старшего класса до класса с номером <paramref name="номерКласса"/>.
/// </summary>
/// <param name="sb"></param>
/// <param name="число"></param>
/// <param name="номерКласса">0 = класс тысяч, 1 = миллионов и т.д.</param>
/// <remarks>
/// В методе применена рекурсия, чтобы обеспечить запись в StringBuilder
/// в нужном порядке - от старших классов к младшим.
/// </remarks>
static void ПрописьСтаршихКлассов(decimal число, int номерКласса, MyStringBuilder sb)
{
if (число == 0) return; // конец рекурсии
// Записать в StringBuilder пропись старших классов.
decimal div1000 = Math.Floor(число / 1000);
ПрописьСтаршихКлассов(div1000, номерКласса + 1, sb);
uint числоДо999 = (uint)(число - div1000 * 1000);
if (числоДо999 == 0) return;
ПрописьКласса(числоДо999, Классы[номерКласса], sb);
}
/// <summary>
/// Получить пропись числа с согласованной единицей измерения.
/// </summary>
/// <param name="doubleDigit">
/// CDigit должно быть целым, неотрицательным, не большим <see cref="MaxDouble"/>.
/// </param>
/// <param name="unit"></param>
/// <param name="result"> Сюда записывается результат. </param>
/// <exception cref="ArgumentException">
/// Если doubleDigit меньше нуля, не целое или больше <see cref="MaxDouble"/>.
/// </exception>
/// <returns> <paramref name="result"/> </returns>
/// <remarks>
/// float по умолчанию преобразуется к double, поэтому нет перегрузки для float.
/// В результате ошибок округления возможно расхождение цифр прописи и
/// строки, выдаваемой double.ToString ("R"), начиная с 17 значащей цифры.
/// </remarks>
public static StringBuilder ConvertToString(double doubleDigit, IUnit unit, StringBuilder result)
{
string error = CheckDigit(doubleDigit);
if (error != null) throw new ArgumentException(error, "число");
if (doubleDigit <= uint.MaxValue)
{
ConvertToString((uint)doubleDigit, unit, result);
}
else if (doubleDigit <= ulong.MaxValue)
{
// SumConvertToString с ulong выполняется в среднем в 2 раза быстрее.
ConvertToString((ulong)doubleDigit, unit, result);
}
else
{
MyStringBuilder mySb = new MyStringBuilder(result);
double div1000 = Math.Floor(doubleDigit / 1000);
HightDigitClassesToString(div1000, 0, mySb);
DigitClassToString((uint)(doubleDigit - div1000 * 1000), unit, mySb);
}
return result;
}
static void HightDigitClassesToString(double doubleDigit, int digitClassNumber, MyStringBuilder sb)
{
if (doubleDigit == 0) return; // конец рекурсии
// Записать в StringBuilder пропись старших классов.
double div1000 = Math.Floor(doubleDigit / 1000);
HightDigitClassesToString(div1000, digitClassNumber + 1, sb);
uint digitBefore999 = (uint)(doubleDigit - div1000 * 1000);
if (digitBefore999 == 0) return;
DigitClassToString(digitBefore999, DigitClasses[digitClassNumber], sb);
}
