static void Main(string[] args)
{
string numbers = "0123456789" + //Алфавит для перебора
"abcdefghijklmnopqrstuvwxyz" +
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var NS = new NumSystem(numbers); //Инициализация
NS.setAbcNumber("pf16"); //Установка начального числа
for (int i = 0; i < 20; i++)
{
Console.WriteLine("https://prnt.sc/1n{0}", NS.NextAbc());
}
Console.ReadLine();
}
public void SetNumberSystem(NumSystem numberSystem)
{
currentNumSystem = numberSystem;
}
/// <summary>
/// Konvertuje číslo na řetězec.
/// </summary>
/// <description>
/// Konvertuje číslo na řetězec v zadané číselné soustavě na počet zadaných desetinných míst.
/// Převod o jiných soustav než desítkových je limitován velikostí integer, v takovém případě vrací "NaN".
/// </description>
/// <param name="value">Hodnota, která ma být prevedena na číslo</param>
/// <param name="numbase">Základ soustavy ve které se vypíše viz. <see cref="NumSystem"></param>
///
/// <param name="format">
/// Formátovací řetězec
/// <list>
/// <item>Výchozí nastavení formátu je na 4 desetinná místa.</item>
/// <item>
/// pokud: numbase je NumSystem.Dec (desítková soustava)
/// * Očekává formátovací řetězec dle standardu <a href="https://msdn.microsoft.com/en-us//library/dwhawy9k(v=vs.110).aspx">.net</a>
/// * Pokud je prázdný řetězec použije se výchozí nastavení.
/// </item>
/// <item>
/// jinak: numbase je jiná soustava
/// * Očekává číslo, které představuje počet desetinných míst.
/// * Pokud nebude validní, použije se výchozí nastavení.
/// </item>
/// </list>
/// </param>
///
/// <returns>
/// číslo v podobě řetězce v požadované číselné soustavě.
/// * pokud je <c>value > 'int max'</c> a numbase není NumSystem.Dec potom rací "NaN".
/// </returns>
public static string ToString(double value, NumSystem numbase, string format)
{
if (double.IsNaN(value))
{
return("NaN");
}
if (double.IsInfinity(value) || double.IsPositiveInfinity(value))
{
return("INF");
}
if (double.IsNegativeInfinity(value))
{
return("-INF");
}
NumberFormatInfo f = new NumberFormatInfo();
f.NumberGroupSeparator = "";
if ((int)numbase == 10) //v případě, že je soustava desítková, lze vypsat hodnotu přes standartní metodu
{
if (format != "")
{
return(value.ToString(format, f));
}
else
{
return(value.ToString(f));
}
}
if (value > int.MaxValue || value < int.MinValue)
{
throw new FormatException("Převáděné číslo je mimo rozsah.");
//return "NaN";
}
string resultstr = "";
if (value < 0) //pokud je číslo záp**né, vloží se mínus a zbytek se převede jako kladné
{
value = Math.Abs(value);
resultstr = "-";
}
//převáděné číslo se rozloží na celou část a desetinnou
double intvalue = extractInt(value); //celá část
double fractionalDigits = value - intvalue; //desetinná část
int digit; //proměnná pro mezivýsledky, vždy jeden znak
resultstr += Convert.ToString((int)intvalue, (int)numbase); //celá část čísla se převede pomocí standartní metody
if (fractionalDigits == 0)
{
return(resultstr);
}
resultstr += "."; //vložení desetinné tečky
for (int i = 0; i < c_stringDefaultPrecision; i++) //převod desetinné části s požadovanou přesností
{
fractionalDigits *= (int)numbase;
if (fractionalDigits == 0) //pokud je zbytek nulový, není důvod pokračovat
{
break;
}
digit = (int)extractInt(fractionalDigits);
resultstr += PrintDigit(digit);
fractionalDigits -= digit;
}
return(postprocessStr(resultstr));
}
/// <summary>
/// Konvertuje řetězec na číslo s pohyblivou desetinnou čárkou.
/// </summary>
/// <param name="input">Řetězec obsahující číslo ve specifikované číselné soustavě</param>
/// <param name="numsystem">Číselná soustava ve které je řetězec zapsán <see cref="NumSystem"></param>
///
/// <returns>Vrací převedené číslo. Pokud je řetězec roven "NaN" vrací NaN, pokud je "INF" nebo "-INF" vrací double.PositiveInfinity nebo double.NegativeInfinity.</returns>
///
/// <exception cref="ArgumentNullException">Input je **null**. (pouze při převodu z desítkového čísla.)
/// viz. <a href="https://msdn.microsoft.com/en-us/library/system.argumentnullexception(v=vs.110).aspx">ArgumentNullException Class</a></exception>
/// <exception cref="OverflowException">Číslo přessahuje maximální nebo minimální rozsah. (pouze při převodu z desítkového čísla.)
/// viz. <a href="https://msdn.microsoft.com/en-us/library/system.overflowexception(v=vs.110).aspx">OverflowException Class</a></exception>
/// <exception cref="FormatException">Vyjímka je vyhozena, pokud vstupní řetězec není platné číslo v dané soustavě. Metoda přijímá desetinnou tečku ".", nikoliv čárku ",".</exception>
///
public static double ToDouble(string input, NumSystem numsystem)
{
if (input == "NaN")
{
return(double.NaN);
}
if (input == "INF")
{
return(double.PositiveInfinity);
}
if (input == "-INF")
{
return(double.NegativeInfinity);
}
// pokud prevadime z desiktove, tak praci za nas udela knihovna ... plus jeste vyhodi spravne chyby
if (numsystem == NumSystem.Dec)
{
double res = double.NaN;
try
{
res = double.Parse(input, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
if (ex is FormatException || ex is ArgumentException)
{
throw new FormatException("Převáděné číslo není platné.");
}
else
{
throw ex;
}
}
return(res);
}
double result = 0;
int charVal;
int dotPos = input.IndexOf('.');
int power;
bool negativFlag = false;
if (dotPos != -1)
{
power = dotPos - 1;
}
else
{
power = input.Length - 1;
}
if (input[0] == '-')//pokud je cislo zaporne je nastaven flag a power aby se spravne umocnovalo
{
negativFlag = true;
power--;
}
for (int i = negativFlag ? 1 : 0; i < input.Length; i++)
{
if (i == dotPos)
{
continue;
}
if (!digitToInt(input[i], out charVal, (int)numsystem))
{
//throw new ArgumentException("Argument neobsahuje validní znaky", "input");
// vyhodime trochu standartnejsi chybu
throw new FormatException("Převáděné číslo není platné.");
}
result += charVal * Math.Pow((int)numsystem, power);
power--;
}
if (negativFlag)//pokud byl flag nastaven vraci se vysledek zaporny
{
return(-result);
}
return(result);
}
public string GetAsString(NumSystem numbase, string format)
{
string result = NumberConverter.ToString(Value, numbase, format);
return(result);
}
