GNU BC: Как полезен “модуль” (%) с масштабом, отличным от 0?

Это самоотвеченный вопрос, исследование, которое разумно задать для вопроса, идет в части ответа. Пожалуйста, не ставьте минусы, потому что вы считаете, что я недостаточно исследовал для ответа. Спасибо. В любом случае, нет описания (которое я могу найти) этой характеристики % в этом сайте.

При использовании bc оператор % утверждается, что вычисляет “остаток”, и да, он работает для целых чисел и когда масштаб равен нулю:

$ bc <<<' scale=0; 27 % 7 '
6

Но он не дает “целый остаток”, если масштаб не ноль:

$ bc <<<' scale=10; 27 % 7 '
.0000000003

Почему (или как) это определение оператора % модуль полезно?

Оператор % явно определен в руководстве bc как ^[a] :

# Определение внутреннего оператора %:
define internalmod(n,d,s) { auto r,oldscale;
                           oldscale=scale; r=n/d;
                           s=max(s+scale(d),scale(n)); 
                           scale=s; r = n-(r)*d;
                           scale=oldscale; return(r) }

Предполагая, что max было определено как:

define max(x,y){ if(x>y){return(x)};return(y) }

Как это длинное определение полезно?

1. Целый остаток

   Я покажу как функцию internalmod, так и результаты оператора %, чтобы доказать, что они эквивалентны для некоторых следующих операций.

   Если числа целые, и масштаб установлен на 0, это функция целого остатка.

   $ bc <<<'n=17; d=3; scale=0;a=internalmod(n,d,scale);b=n%d;print a," ",b,"\n"'
   2 2
   $ bc <<<'n=17; d=6; scale=0;a=internalmod(n,d,scale);b=n%d;print a," ",b,"\n"'
   5 5
   

   Это не то же самое, что и математическая функция мод. Я решу это ниже.

2. Дробный остаток
   Если число n является более длинным десятичным числом, и мы изменим масштаб, мы получим:

   $ bc <<<'n=17.123456789;d=1; scale=0 ;a=internalmod(n,d,scale);b=n%d;
                     print a," ",b,"\n"'
   .123456789 .123456789
   
   $ bc <<<'n=17.123456789;d=1; scale=3 ;a=internalmod(n,d,scale);b=n%d;
                     print a," ",b,"\n"'
   .000456789 .000456789
   

   Обратите внимание, что здесь первые 3 десятичных знака были удалены, и остаток, который дан, исходит с четвертого десятичного знака.

   $ bc <<<'n=17.123456789;d=1; scale=7 ;a=internalmod(n,d,scale);b=n%d;
                     print a," ",b,"\n"'
   .000000089 .000000089
   

   Это показывает, что остаток стал более универсальным благодаря этому определению.

   Теперь это: остаток после значения масштаба.

3. Изменение масштаба

   Изменение масштаба требуется, потому что число d (делитель) может иметь больше десятичных знаков, чем n. В этом случае нужно больше десятичных знаков, чтобы получить более точный результат от деления:

   $ bc <<<'n=17.123456789; d=1.00000000001; scale=0;
            a=internalmod(n,d,scale);   b=n%d;
            print a," ",scale(a)," -- ", b," ",scale(b),"\n"'
   .12345678883 11 -- .12345678883 11
   

   И если изменить масштаб:

   $ bc <<<'n=17.123456789; d=1.00000000001; scale=5;
            a=internalmod(n,d,scale);    b=n%d;
            print a," ",scale(a)," -- ", b," ",scale(b),"\n"'
   .0000067888287655 16 -- .0000067888287655 16
   

   Как видно выше, значение масштаба изменяется для представления разумно точного результата деления для любого значения n, d и scale.

   Я предположу, что по сравнению между internalmod и оператором % оба были доказаны как эквивалентные.

4. Недоразумение

   Будьте осторожны, потому что игра с значением d может стать запутанной:

   $ bc <<<'n=17.123456789; d=10; scale=3; a=n%d;
                     print a," ",scale(a),"\n"'
   .003456789 9
   

   И:

   $ bc <<<'n=17.123456789; d=1000; scale=3; a=n%d;
                     print a," ",scale(a),"\n"'
   .123456789 9
   

   Это: значение d (выше 1) изменит эффект установленного значения масштаба.

   Вероятно, для значений d, отличающихся от 1, вам следует использовать scale=0 (если вы действительно знаете, что делаете).

5. Математический мод

   Поскольку мы так глубоко погружаемся в функции мод, нам, вероятно, следует уточнить реальный эффект % в bc. Оператор % в bc использует “усеченное деление”. То есть оно округляется к 0. Это важно для отрицательных значений как n, так и/или d:

   $ bc <<<'scale=0; n=13; d=7; n%d; '
   6
   
   $ bc <<<'scale=0; n=13; d=-7; n%d; '
   6
   

   Знак остатка следует за знаком делимого.

   $ bc <<<'scale=0; n=-13; d=7; n%d; '
   -6
   
   $ bc <<<'scale=0; n=-13; d=-7; n%d; '
   -6
   

   В то время как правильный математический мод должен давать всегда положительный остаток.

   Чтобы получить эту (целочисленную) функцию мод, используйте:

   # Модуль с всегда положительным остатком (евклидово деление).
   define modeuclid(x,div)  {  if(div!=int(div)){
                               "ошибка: делитель должен быть целым ";return(0)};
                               return(x - div*int(x/div))  }
   

   И (тогда) это будет работать:

   $ bc <<<"n=7.123456789; d=5; modeuclid(34.123456789,7)"
   6.123456789
   

^[a]

expr % expr
Результат выражения – это “остаток”, и он вычисляется следующим образом. Чтобы вычислить a%b, сначала вычисляется a/b до десятичных знаков масштаба. Этот результат используется для вычисления a-(a/b)*b до масштаба максимум scale+scale(b) и scale(a).
Если масштаб установлен в ноль и оба выражения являются целыми, это выражение является функцией целого остатка.

Для кода bc, следующий за точкой, где было введено это примечание, чтобы работать правильно, определите псевдоним как:

$ alias bc="bc -l "$HOME/.func.bc""

И создайте файл с именем $HOME/.func.bc, который содержит (по крайней мере):

# Внутреннее определение оператора %:
define internalmod(n,d,s) { auto r,oldscale;
                           oldscale=scale; r=n/d;
                           s=max(s+scale(d),scale(n)); 
                           scale=s; r = n-(r)*d;
                            scale=oldscale; return(r) } 
# Функция max
define max(x,y){ if(x>y){return(x)};return(y) }

# Целая часть числа по направлению к 0:  -1.99 -> -1, 0.99 -> 0
define int(x)        {  auto os;os=scale;scale=0;
                        x=sgn(x)*abs(x)/1;scale=os;return(x)  }

define sgn (x)       {  if (x<0){x=-1};if(x>0){x=1};return(x) };
define abs (x)       {  if (x<0) x=-x; return x }; 

# Модуль с всегда положительным остатком (евклидово деление).
define modeuclid(x,div)  {  if(div!=int(div)){
                           "ошибка: делитель должен быть целым ";return(0)};
                           return(x - div*int(x/div))  }

Функцию мод для любого числа (целого или нет) можно определить как:

# Модуль с всегда положительным остатком (евклидово деление).
define modeuclid(x,div)  {  div=abs(div);return(x - div*floor(x/div))  }

# Округление вниз до целого ниже x (в сторону -бесконечности).
define floor (x)         {  auto os,y;os=scale;scale=0;
            y=x/1;if(y>x){y-=1};scale=os;return(y) };

Это определение абсолютно допустимо и правильно по математическим правилам, однако оно может стать довольно запутанным при попытке применить его в реальных случаях, просто говоря.

Описание BC и его операторов является частью стандарта POSIX. В настоящее время оно доступно здесь:

https://pubs.opengroup.org/onlinepubs/9699919799/utilities/bc.html

a % b определяется как a – (a / b) * b и вычисляется до масштаба max(scale + scale(b), scale(a)).

Это имеет место в GNU BC в текущей версии 1.07.1. Для BSD BC является лишь оболочкой для DC, и DC использует “bn” для “%”.

В C-BC это также правда. C-BC, исходный код которого архивирован здесь:

https://github.com/RockBrentwood/CBC

является большим расширением BC, гораздо ближе к C и (в основном) является надмножеством GNU BC и BSD BC.