Пояснительнаязаписка
«Реализация класса больших чисел»
ВведениеПостановка задачи
Реализовать средствамиязыка С++ класс больших целых чисел. Для написания класса были выделеныследующие задачи:
· Организовать чтение из консоли ипечать в консоль целых чисел, длина которых превышает 232разрядов (стандартный тип long)
· Реализовать выполнение арифметическихоперации с данными числами:
o Сложение
o Вычитание
o Произведение
o Нахождение целой части от деления
o Нахождение остатка от деления
o Возведение в степень
Факториал/>Ход решения
Первым делом была выбранаструктура класса больших целых чисел. Так как число может быть какположительным, так и отрицательным было введено символьное поле, отвечающее зазнак числа «+» или «–». Само число решено было записывать с помощью очереди сдвусторонним доступом (deque) – контейнер из стандартной библиотеки шаблонов (STL). Очередьпредставляет собой динамический массив с множеством стандартных методов для егообработки. «Цифру» каждого разряда большого числа мы будем помещать всоответствующую ячейку массива. Например, число 12345, записанное с помощью deque mas; будетвыгледеть как набор элементов этого массива: mas[0] = 1, mas[1] = 2, mas[2] = 3, mas[3] = 4, mas[4] = 5. Такжекласс будет содержать некоторое количество методов, для решения поставленныхзадач. Класс будет иметь название BigInteger. Структура класса изображена на рисунке 1.
/>
Рис. 1. Схема класса BigInteger
Далее перешли к разработкеметодов класса. Сначала для непосредственной работы с большими числами былиреализованы методы для чтения числа из консоли и печати в консоль – chtenie() и vector_print(BigInteger)соответственно.
Метод chtenie()считывает в виде строки данные введенные в консоль. Затем проверяет первыйсимвол строки на наличие знака «–». Потом посимвольно, используявспомогательную строку, содержащую цифры («0123456789»), заносит каждую цифру вконец очереди-массива. На выходе мы получаем большое число, содержащее знак «»,либо «–». Также в методе используется вспомогательный метод dell_null(BigInteger),который возвращает число, удаляя впереди стоящие ничего не значащие нули (т.е.00123 –> 123).
Метод vector_print(BigInteger)выполняет печать в консоль числа, предварительно задействовав, описанный вышевспомогательный метод dell_null(BigInteger). Сначала происходит печать знака числа, затем, используяцикл, выполняется печать каждого элемента очереди-массива. Результаты работыметодов представлены на рисунке 2.
/>
Рис. 2. Ввод-вывод большогоположительного и отрицательного числа в консоль
Затем был реализован методсложения двух больших чисел summa (BigIneger, BigInteger). Сначала метод проверяет знаки переданных ему чисел, еслизнаки разные, он, немного модифицируя знаки, передает числа методу,вычисляющему разность двух больших чисел, речь о котором пойдет дальше. Если жезнаки чисел одинаковые, непосредственно происходит операция их сложения.Принцип основан на сложении «столбиком». Находим «длину» минимального поразрядам числа, затем складываем поразрядно числа в пределах этой «длины»,добавляя 1, если сумма на предыдущем шаге была > 9, находим остаток отделения полученного числа на 10 (int % 10) изаписываем его в разряд, над которым выполнялась операция. После того, какразряды у одного из чисел закончатся, «добиваем» результирующее число цифрамииз оставшихся разрядов большего числа. Естественно, чтобы произвести операцию спервым разрядом, нужно обратиться к последнему элементу нашей очереди массива.Пример сложения представлен на рисунке 3.
/>
Рис. 3. Операциясложения
Следующей операцией надбольшими числами стала операция вычитания, представленная методом rasnost (BigInteger, BigInteger).Вначале метод проверяет знаки переданных ему чисел, если знаки чисел равные (сучетом знака разности), то метод передает числа методу summa (BigInteger, BigInteger).Например, 12 – (-7). Метод передаст 12 и 7 для обработки методу summa (BigInteger, BigInteger).Если знаки чисел разные, то происходит операция вычитания. Принцип основан навычитании «столбиком». Находим число с меньшим количеством разрядов (меньшей«длиной»), ставим его вторым. И начинаем поразрядно вычитать. При этом, если вразряде первого числа значение больше, чем в разряде второго числа, прибавляемк разности этих чисел 10. Но на следующем шаге вычитаем 1 из следующегополученного результата поразрядного вычитания. Выполняем эти действия, пока незакончатся разряды наименьшего числа, затем «добиваем» результирующее числоцифрами из оставшихся нетронутыми разрядов большего числа. Пример вычитанияпредставлен на рисунке 4.
/>
Рис. 4. Операциявычитания
После того, как былиреализованы операции сложения и вычитания, перешли к написанию операцииумножения, которую выполняет метод proisvedenie (BigInteger, BigInteger). Также в его основе лежит принцип умножения «столбиком».Выбираем одно из больших чисел, и поэтапно умножаем числа из каждого разрядаэтого большого числа, на другое большое число. В результате на каждом шаге унас получаются «промежуточные» большие числа, суммируя которые с помощьюописанного выше метода summa (BigInteger, BigInteger) мы получаем необходимый нам результат. При этом незабываем в зависимости от разряда множителя «добивать» начальные разряды«промежуточных» больших чисел нулями. Как и в предыдущих операциях при поразрядномперемножении в результат мы записываем остаток от деления на 10 и, еслирезультат поразрядного перемножения больше либо равен 10, то на следующем шагеперемножения мы прибавляем число равное целой части от деления предыдущегорезультата на 10. Также для ускорения процесса перемножения были выделеныособые случаи – умножение на 0 и на 1. Пример перемножения двух больших чиселпредставлен на рисунке 5.
/>
Рис. 5. Операция умножения
После реализации методаперемножения двух больших чисел операции возведения числа в степень и операциявзятия факториала числа не представляют большой трудности, так как могут бытьвыражены через умножение. Метод stepen (BigInteget, int), представляющий операцию возведения в степень большогочисла, принимает в качестве аргументов само большое число и целое число,задающее степень, в которую необходимо возвести большое число. Метод вызываетоперацию перемножения числа на само себя в цикле, количество шагов которогоравно заданной степени. После выполнения данного цикла получаем нужную намстепень большого числа. Метод factorial(BigInteger), представляющий операцию получения факториала большогочисла, мог быть выполнен двумя способами: используя рекурсию или используяитерацию, т.е. цикл. Был выбран второй вариант, так как он болеепроизводительный и не требует повторного вызова метода factorial(BigInteger),что замедляло бы работу программы. Для перемножения здесь использовалосьвспомогательное большое число, которое изначально приравнивалось к числу,факториал которого нужно было найти. Затем на каждом шаге итерации оноуменьшалось на 1. На каждом шаге это число умножалось на ранее полученныйрезультат, т.е. получалась выражение вида N!=((N*N-1)*N-2*)…*1. Послевыполнения данного цикла получаем факториал заданного числа.
/>
Рисунок 6. Вычислениефакториала 1000
Построение проектаосуществлялось в режиме Release. Технические характеристики компьютера, на которомвыполнялись расчеты, представлены на рисунке 7.
/>
Рисунок 7. Техническиехарактеристики
Для того, чтобы исключить возможное влияние операционной системы навремя выполнения вычисления, был проведен численный эксперимент, результатыкоторого представлены в таблице 1.
Таблица 1. Время вычисленияфакториала 1000Порядковый номер вычисления Время вычисления, сек 1 2,446 2 2,448 3 2,426 4 2,451 5 2,441 6 2,442 7 2,442 8 2,443 Среднее время вычисления 2,442
Таким образом, программавычисляет факториал 1000 в среднем за 2,442 секунды.
Пожалуй, самой сложной дляреализации, является операция деления и нахождение остатка от деления двухбольших чисел. Методы соответствующие данным операциям были названы delenie (BigInteger, BigInteger) и ostasok_delenie (BigInteger, BigInteger)соответсвенно. В основе лежит принцип деления «столбиком». Пример работыалгоритма приведен на рисунке 8.
/>
Рис. 8. Операцияделения и нахождение остатка от деления
Ход алгоритма следующий:сравниваем делитель с делимым, прибавляя поразрядно по одной цифре к делителю вслучае, если получившийся делитель меньше делимого, при этом в частноезаписываем 0. На рисунке 8 видно этот этап: 27985. После этого запускается цикл по нахождению следующейцифры частного. На каждом шаге делитель прибавляется на величину равную самомуделителю, пока он не станет больше либо равен нашему промежуточному делимому, т.е.21367. Шаг цикла, на котором выполнится данное условие, и будет искомой цифройдля частного. Затем вычитаем из промежуточного делимого полученное в ходе циклачисло и получаем промежуточный остаток. Так как он точно меньше делителя (всвязи с предыдущими условиями), добавляем к нему следующую не задействованнуюцифру делимого и переходим к первому шагу алгоритма. Алгоритм считаетсявыполненным, если получается остаток, меньший делителя и не осталось ни однойнезадействованной цифры делимого. В зависимости от задачи, метод возвращаетлибо частное, либо остаток от деления.
Для удобства пользователейбыл введен еще один метод vishislenie(), который предоставляет возможность выполнятьвышеперечисленные арифметические операции с двумя или одним большим числомпутем простого ввода необходимого для вычисления выражения. Пример работы данногометода приведен на рисунке 9.
факториал большой число перемножение
/>Рис. 9. Режим вычисления выражений/>
ВыводыТаким образом, в ходе написания программы,поставленные задачи были полностью выполнены: сделаны механизмы чтения и печатив консоль больших чисел, реализованы арифметические операции.Производительность программы, на мой взгляд, достаточно высокая, что былодостигнуто за счет некоторой оптимизации кода (в основном в результатепереработки операции произведения). Небольшое замедление программы возможновследствии того, что использован контейнер стандартной библиотеки шаблонов.Этот недостаток компенсируется простотой использования стандартного контейнераи множеством поставляемых с ним методов отладки, проверкой ошибок на этапекомпиляции программы и механизмом исключений. Немаловажным является реализацияметода предоставляющего пользователям в удобной форме производить вычисления сбольшими целыми числами./>
Список используемой литературы
1. Лаптев В.В., Морозов А.В. «Объектно-ориентированноепрограммирование. Задачи и упражнения». Издательство: «Питер» 2007 г.
2. Лафоре Р. «Объектно-ориентированное программирование вС++». Издательство: «Питер», 2004 г.
Приложение
Листинг 1. Файл BigInteger.h класс BigInteger.
#include
#include // очередь (из библиотеки STL)
#include
using namespace std;
// Класс больших целых чисел
class BigInteger {
deque vect; // «содержит» число
char znak; // знак числа
public: BigInteger()
{
vect = deque();
znak = ‘ ‘;
}
// ___________________ Сравнение модулей большихчисел____________
int sravnenie (BigInteger big1, BigIntegerbig2)
{
if (big1.vect.size() >big2.vect.size()) return 1; // 1, если первое число > второго
if (big1.vect.size()
if (big1.vect.size() == big2.vect.size())
{
for (int i = 0; i
{
if (big1.vect.at(i) > big2.vect.at(i))return 1;
if (big1.vect.at(i)
}
return 0; // 0, если числа равны
}
}
// ___________________ Чтение числа из консоли___________________
BigInteger chtenie()
{
BigInteger big;
string temp = «0123456789»; // вспомогательная строка
string minus = «–»;
string str;
cin >> str;
if (str.at(0) == minus.at(0)) big.znak = ‘-‘; // определениезнака числа
for (int i = 0; i
for (int j = 0; j
if (str.at(i) == temp.at(j))big.vect.push_back(j);
return dell_null(big);
}
// ___________________ Функция удаления нулей из началачисла ____
BigInteger dell_null (BigInteger big)
{
while (big.vect.size() > 1)
{
if (big.vect.at(0)!= 0) break;
else {big.vect.pop_front();}
}
return big;
}
// ___________________ Печать числа в консоль____________________
void vector_print (BigInteger big)
{
big = dell_null(big); // убираем нули из начала числа
if (big.vect.size() == 1 && big.vect.at(0) == 0)big.znak = ‘ ‘; // если число равно 0, то не ставим знак
if (big.znak == ‘-‘) // если число отрицательное, сначалапечатаем знак –
cout
for (int i = 0; i
cout
}
// ___________________ Сумма больших чисел_______________________
BigInteger summa (BigInteger big1,BigInteger big2)
{
if (big1.znak!= big2.znak) // если разные знаки, тоотправляем на метод разность
{
if (big1.znak == ‘-‘) // заменяем – x+y наy-x
{
big1.znak = ‘ ‘;
return rasnost (big2, big1);
}
else // заменяем x+-y наx-y
{
big2.znak = ‘ ‘;
return rasnost (big1, big2);
}
}
deque summa = deque(); // сюдазаписывается результат
int temp = 0; // 1 для добавления к старшему разряду
int metka = 0; // для вычисления позиции, с которой остаютсяразряды только одного числа
if (big1.vect.size() >= big2.vect.size()) // ставимбольшее число на первое место
{
for (int i = big1.vect.size() – 1, j = big2.vect.size() –1; j >=0; i–, j–) // начиная с первых разрядов складываем числа
{
summa.push_front((big1.vect.at(i) +big2.vect.at(j) + temp)%10);
if ((big1.vect.at(i) + big2.vect.at(j) +temp) >= 10) temp = 1; else temp = 0; // прибавляем 1 на следующем шаге, если сумма больше 10
metka = i;
}
for (int i = metka-1; i >= 0; i–) // начиная с позицииметки добиваем цифрами из большего числа, учитывая возможное прибавление 1
{
summa.push_front((big1.vect.at(i)+temp)%10);
if ((big1.vect.at(i) + temp) == 10) temp =1; else temp = 0;
}
if (temp == 1) summa.push_front(1); // срабатывает в случаекогда увеличивается разряд, например 99+1=100
}
else
{
for (int i = big2.vect.size() – 1, j= big1.vect.size() – 1; j >=0; i–, j–)
{
summa.push_front((big2.vect.at(i) +big1.vect.at(j) + temp)%10);
if ((big2.vect.at(i) + big1.vect.at(j) +temp) >= 10) temp = 1; else temp = 0;
metka = i;
}
for (int i = metka-1; i >= 0; i–)
{
summa.push_front((big2.vect.at(i)+temp)%10);
if ((big2.vect.at(i) + temp) == 10) temp =1; else temp = 0;
}
if (temp == 1) summa.push_front(1);
}
big1.vect = summa;
return big1;
}
// ________________________ Разность больших чисел________________
BigInteger rasnost (BigInteger big1,BigInteger big2)
{
if (big2.znak == ‘-‘) big2.znak = ‘ ‘; // x–y преобразуем вx+y и передаем в метод суммы
else big2.znak = ‘-‘;
if (big1.znak == big2.znak) return summa (big1,big2); // – x-y преобразуем в – (x+y) передаем методу суммы
deque rasn = deque(); // сюдазаписывается разность
int temp = 0; // 1 для вычитания из старшего разряда
int metka = 0; // для вычисления позиции, с которой остаютсяразряды только одного числа
big1 = dell_null(big1); // предварительно удаляем незначащиенули из начала числа
big2 = dell_null(big2);
if (sravnenie (big1, big2)!= -1) // ставим большее числосверху в столбике
{
for (int i = big1.vect.size() – 1, j= big2.vect.size() – 1; j >=0; i–, j–)
{
if ((big1.vect.at(i) – big2.vect.at(j) +temp) >= 0) // поразрядно вычитаем
{
rasn.push_front (big1.vect.at(i) – big2.vect.at(j)+ temp);
temp = 0;
}
else
{
rasn.push_front (big1.vect.at(i) – big2.vect.at(j)+ 10 + temp); // заимствуем 1 из старшего разряда
temp = -1;
}
metka = i;
}
for (int i = metka-1; i >= 0; i–) // добиваем числамиоставшихся разрядов, учитывая -1
{
rasn.push_front (abs((big1.vect.at(i)+temp+10)%10));
if ((temp == -1) &&(big1.vect.at(i) + temp)
}
big1.vect = rasn;
return big1;
}
else
{
for (int i = big2.vect.size() – 1, j= big1.vect.size() – 1; j >=0; i–, j–)
{
if ((big2.vect.at(i) – big1.vect.at(j) +temp) >= 0)
{
rasn.push_front (big2.vect.at(i) – big1.vect.at(j)+ temp);
temp = 0;
}
else
{
rasn.push_front (big2.vect.at(i) – big1.vect.at(j)+ 10 + temp);
temp = -1;
}
metka = i;
}
for (int i = metka-1; i >= 0; i–)
{
rasn.push_front (abs((big2.vect.at(i)+temp+10)%10));
if ((temp == -1) &&(big2.vect.at(i) + temp)
}
big2.vect = rasn;
return big2;
}
}
// _______________________ Произведение больших чисел_____________
BigInteger proisvedenie (BigInteger big1,BigInteger big2)
{
BigInteger proisv;
proisv.vect.push_back(0);
BigInteger reserv;
BigInteger reserv2;
for (int i = big1.vect.size() – 1,count = 0; i >= 0; i –, count++)
{
if (big1.vect.at(i) == 0) {} // умножение на 0
else
if (big1.vect.at(i) == 1) // умножение на 1, простоприбавляем число с «добитыми» нулями
{
reserv2.vect = big2.vect;
for (int k = 0; k
reserv2.vect.push_back(0);
proisv = summa (reserv2, proisv);
}
else
{
int temp = 0;
for (int k = 0; k
reserv.vect.push_front(0);
for (int j = big2.vect.size() – 1; j>=0; j–) // умножаем первое число на «цифру» из разряда учитывая temp
{
reserv.vect.push_front((big1.vect.at(i)*big2.vect.at(j)+ temp)%10);
if ((big1.vect.at(i)*big2.vect.at(j) +temp) >=10) temp = (big1.vect.at(i)*big2.vect.at(j) + temp)/10; else temp =0;
}
if (temp!=0) reserv.vect.push_front(temp); //при увеличении разрядов числа
proisv = summa (reserv, proisv); // складываем предыдущиерезультаты
reserv.vect.clear();
}
}
if (big1.znak!= big2.znak)
proisv.znak = ‘-‘;
return proisv;
}
// __________________ Возведение в степень большого числа_________
BigInteger stepen (BigInteger big, intsteps)
{
BigInteger step;
//deque step =deque();
step.vect = big.vect; // постоянный множитель
for (int i = 1; i
big = proisvedenie (big, step);
if (steps% 2 == 0)
big.znak = ‘ ‘;
return big;
}
// __________________ Факториал большого числа____________________
BigInteger faktorial (BigInteger big)
{
big.znak = ‘ ‘;
BigInteger fak;
fak.vect.push_back(1);
BigInteger edinica;
edinica.vect.push_back(1); // для уменьшения на 1
{
while (big.vect.size()!= 0 &&big.vect.at(0)!= 0) //пока число не стало равным 0
{
fak = proisvedenie (big, fak);
big = rasnost (big, edinica);
big = dell_null(big);
fak = dell_null(fak);
}
}
return fak;
}
// __________________ Деление больших чисел_______________________
BigInteger delenie (BigInteger delimoe,BigInteger delitel)
{
BigInteger chastnoe;
BigInteger ostatok;
BigInteger reserv2;
BigInteger reserv3;
reserv2.vect = delitel.vect;
for (int i = 0; i
{
ostatok = dell_null(ostatok);
ostatok.vect.push_back (delimoe.vect.at(i)); //промежуточный остаток
if (sravnenie (ostatok, delitel) == -1) {chastnoe.vect.push_back(0);} //пока промежуточный остаток больше делителя пишем в частное0
else
{
for (int j = 0; j
{
if (sravnenie (ostatok, reserv2) == -1) // промежуточныйостаток меньше делителя*j
{
chastnoe.vect.push_back(j);
ostatok = rasnost (ostatok, reserv3);
reserv2.vect = delitel.vect;
break;
}
if (sravnenie (ostatok, reserv2) == 0) //промежуточный остаток кратный делителю
{
chastnoe.vect.push_back (j+1);
ostatok.vect.clear();
reserv2.vect = delitel.vect;
break;
}
reserv3 = reserv2;
reserv2 = summa (reserv2, delitel); // прибавляем самделитель, пока не станет больше остатка
}
}
} // цифры делимого заканчиваются и остаток меньше делимого,цикл завершается
if (delimoe.znak!= delitel.znak)chastnoe.znak = ‘-‘;
return chastnoe;
}
// __________________ Остаток от деления больших чисел____________
BigInteger ostatok_delenie (BigInteger delimoe,BigInteger delitel)
{ // все как в методе delenie(), только возвращаем нечастное, а остаток
BigInteger chastnoe;
BigInteger ostatok;
BigInteger reserv2;
BigInteger reserv3;
reserv2.vect = delitel.vect;
for (int i = 0; i
{
ostatok = dell_null(ostatok);
ostatok.vect.push_back (delimoe.vect.at(i));
if (sravnenie (ostatok, delitel) == -1) {chastnoe.vect.push_back(0);}
else
{
for (int j = 0; j
{
if (sravnenie (ostatok, reserv2) == -1)
{
chastnoe.vect.push_back(j);
ostatok = rasnost (ostatok, reserv3);
reserv2.vect = delitel.vect;
break;
}
if (sravnenie (ostatok, reserv2) == 0)
{
chastnoe.vect.push_back (j+1);
ostatok.vect.clear();
reserv2.vect = delitel.vect;
break;
}
reserv3 = reserv2;
reserv2 = summa (reserv2, delitel);
}
}
}
if (ostatok.vect.size() == 0)ostatok.vect.push_back(0);
return ostatok;
}
// _________ Метод для использования выражений длявычисления _____
BigInteger vichislenie()
{
BigInteger big1;
BigInteger big2;
string temp = «0123456789»;
string snaki = «-+*/%!^»;
string str;
cin >> str; // считываем строку и в зависимости отзнака выбираем действие с числами через switch
int perekluchatel = -1;
if (str.at(0) == snaki.at(0)) big1.znak =’-‘;
for (int i = 0; i
{
for (int j = 0; j
{
if ((perekluchatel == -1) &&(str.at(i) == temp.at(j))) {big1.vect.push_back(j); break;}
if ((perekluchatel!= -1) &&(str.at(i) == temp.at(j))) {big2.vect.push_back(j); break;}
}
if (perekluchatel == -1)
for (int j = 0; j
{
if ((str.at(i) == snaki.at(j)) &&(i!= 0))
{
perekluchatel = j;
if (perekluchatel == 5) break;
if (str.at (i+1) == snaki.at(0)) big2.znak= ‘-‘; break;
}
}
}
cout
switch(perekluchatel)
{
case 0:
{
return rasnost (big1, big2); break;
}
case 1:
{
return summa (big1, big2); break;
}
case 2:
{
return proisvedenie (big1, big2); break;
}
case 3:
{
return delenie (big1, big2); break;
}
case 4:
{
return ostatok_delenie (big1, big2);break;
}
case 5:
{
return faktorial(big1); break;
}
case 6:
{
BigInteger edinica;
edinica.vect.push_back(1);
BigInteger dvoika;
dvoika.vect.push_back(2);
BigInteger step;
step.vect = big1.vect;
BigInteger tempbig2;
tempbig2.vect = big2.vect;
big2.znak = ‘ ‘;
while (big2.vect.size()!= 0 &&big2.vect.at(0)!= 1)
{
big1 = proisvedenie (big1, step);
big2 = rasnost (big2, edinica);
big2 = dell_null(big2);
}
BigInteger proverka = ostatok_delenie (tempbig2,dvoika);
if (proverka.vect.at(0) == 0)
big1.znak = ‘ ‘;
return big1;
break;
}
}
}
};
Листинг 2. Файл Main.cpp
#include
#include «BigInteger.h» // подключаем класс больших целых чисел
void main() // функция использующая большие целые числа
{
setlocale (LC_CTYPE, «Russian»);
BigInteger bint1;
BigInteger bint2;
BigInteger summ;
BigInteger rasn;
BigInteger proisv;
BigInteger step;
BigInteger fak;
BigInteger chastnoe;
int x, y; // переключатели режима вычисления
bool flag = true;
cout »;
cin >> y;
if (y == 1)
{
cout
while (true)
{
BigInteger resultat;
resultat = resultat.vichislenie();
resultat.vector_print(resultat);
cout
}
}
else
{
cout
bint1 = bint1.chtenie();
cout
bint2 = bint2.chtenie();
while (flag == true)
{
cout
cout
cout
cout
cout
cout
cout
cout
cout
cout
cout »;
cin >> x;
switch(x)
{
case 1:
{
cout
summ = summ.summa (bint1, bint2);
summ.vector_print(summ);
break;
}
case 2:
{
cout
rasn = rasn.rasnost (bint1, bint2);
rasn.vector_print(rasn);
break;
}
case 3:
{
cout
proisv = proisv.proisvedenie (bint1,bint2);
proisv.vector_print(proisv);
break;
}
case 4:
{
cout
chastnoe = chastnoe.delenie (bint1,bint2);
chastnoe.vector_print(chastnoe);
break;
}
case 5:
{
cout
chastnoe = chastnoe.ostatok_delenie (bint1,bint2);
chastnoe.vector_print(chastnoe);
break;
}
case 6:
{
int st;
cout
cin >> st;
cout
step = step.stepen (bint1, st);
step.vector_print(step);
break;
}
case 7:
{
cout
fak = fak.faktorial(bint1);
fak.vector_print(fak);
break;
}
case 8:
{
bint1 = BigInteger();
cout
bint1 = bint1.chtenie();
bint2 = BigInteger();
cout
bint2 = bint2.chtenie();
break;
}
case 9:
{
flag = false;
break;
}
default:
{
cout