Вход
Приветствую Вас Гость
 

easy.math.qsp v. 2.4.0

Операции с дробными числами

#dz#

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

$args[0] - обрабатываемое число, только в текстовом виде.
 args[1] - разряд до которого требуется удалить нули. 1 - до целых, 10 - до десятых, 100 - до сотых и т.д, по умолчанию 1.
 $result - текстовое значение вида 000.000

Результат работы функции:
$func('#dz#','64',100)='64'
$func('#dz#','64.0080000',1)='64.008'
$func('#dz#','64.0080000',100)='64.008'
$func('#dz#','64.0080000',10000)='64.0080'

#indiv#

Вычисляет рациональное частное от целых чисел.

 args[0] - делимое;
 args[1] - делитель, по умолчанию = 100;
 args[2] - точность вычисления. 1 - до целых, 10 - до десятых, 100 - до сотых и т.д. По умолчанию, вычисляет до девятого знака после запятой (максимальное значение аргумента).
 $result - текстовое значение вида 000.000

Использует функцию #dz#

Имеются ограничения на значения аргументов (для QSP 5.7.0 в пределах [-2147483648 ... 2147483647]).

Результат работы функции:
$func('#indiv#',-950000,1000)='-950'
$func('#indiv#',64)='0.64'
$func('#indiv#',64,8,1)='8'
$func('#indiv#',64,7,100000)='9.14285'
$func('#indiv#',64,7)='9.142857142'
$func('#indiv#',8,125)='0.064'
$func('#indiv#',150,100,10)='1.5'
$func('#indiv#',200,100,10)='2'

#undiv#

Переводит рациональное число в целое (фактически умножает рациональное число на круглое число, с округлением-отсечением дробной части).

$args[0] - рациональное число
 args[1] - точность перевода 10 - один знак после запятой, 100 - два знака, и т.д, по умолчанию до последнего знака после запятой
  result - целое число

Не использует дополнительных функций, однако есть ограничение на значения аргументов и результата (для QSP 5.7.0 в пределах [-2147483648 ... 2147483647]).

Результат работы функции:
func('#undiv#','1',1000)=1000
func('#undiv#','-1',1000)=-1000
func('#undiv#','0.123',100)=12
func('#undiv#','0.123',10)=1
func('#undiv#','0.123')=123
func('#undiv#','1.23')=123

#razdiv#

Получает разрядность дробной части числа в виде целого круглого числа

$args[0] - число в текстовом виде
  result - число, в числовом виде (соответственно для QSP 5.7.0 в пределах [-2147483648 ... 2147483647])

Результат работы функции:
$func('#razdiv#','0.64') = 100
$func('#razdiv#','0.064') = 1000
$func('#razdiv#','0.640') = 1000
$func('#razdiv#','0.647777') = 1000000
$func('#razdiv#','-7777.64') = 100
$func('#razdiv#','-7777.646666666666666666666666') = -1593835520 & ! - превышено допустимое значение, результат неверен!!!

#rounddiv#

Округляет число до указанной разрядности

возможны варианты 1, 10, 100, 1000 и т.п., и 0.1, 0.01 и т.п.

$args[0] - рациональное число в текстовом виде;
$args[1] - разрядность. Возможны варианты: 1, 10, 100, 1000 и т.п., и 0.1, 0.01 и т.п.;
$args[2] - [up] в сторону увеличения, [down] - с округлением-отсечением; если не указано, используются правила округления к ближайшему целому.

Функция работоспособна, но не доработана (актуально для версии библиотеки 2.1.4 и ниже). Использует функции #dz#, #zero#.

Результат работы функции:
$func("#rounddiv#","945.459","0.1")   = '945.5'
$func("#rounddiv#","945.459","0.1",'[down]')='945.5'
$func("#rounddiv#","945.444","0.1",'[up]')='945.5'
$func("#rounddiv#","945.459","0.01")  = '945.46'
$func("#rounddiv#","945.459","0.001") = '945.459'
$func("#rounddiv#","945.459","1")     = '945'
$func("#rounddiv#","945.459","10")    = '950'
$func("#rounddiv#","945.459","100")   = '900'
$func("#rounddiv#","-945.459","10")   = '-950'
$func("#rounddiv#","-945.459","0.01") = '-945.46'

#+#

Функция сложения. Может суммировать целые и дробные числа любого знака любой длины (ограничение на значение текстовых переменных для QSP 5.7.0 около 2Гб).

Использует функции #zero#, #add#, #dev#, #dz#. Каждая из этих функций включает в себя один и более циклов, в результате чего могут наблюдаться заметные подвисания плеера для ОЧЕНЬ больших чисел. Вычисления могут оказаться долгими, но они будет произведены - результат гарантирован.

$args[0] ... $args[8] - девять слагаемых. Могут быть переданы в числовом виде (для QSP 5.7.0 в пределах [-2147483648 ... 2147483647]).
 $result - всегда текстовое значение.

Результат работы функции:
$func('#+#','9.05',"-9") = '0.05'
$func('#+#','9.05',"-9.05") = '0'
$func('#+#','9.05',"9") = '18.05'
$func('#+#','9.05',"9.55","9.25") = '27.85'
$func('#+#','9.99',"9.999","9.9") = '29.889'
$func('#+#','384.384',"92.8",3) = '480.184'
$func('#+#','283','126') = '409'
$func('#+#','283','-126') = '157'
$func('#+#','-283','126') = '-157'
$func('#+#','-283','-126') = '-409'
$func("#+#","-234","125","-13.7890303","3484889") = '3484766.2109697'

Будьте внимательны. Функция работает с переменными minus_em_plus, i_em_plus, o_em_plus, len_em_plus. Если вы используете такие же переменные в своей игре, переименуйте переменные в функции.

#*#

Перемножает несколько чисел любой длины.

Внимание! Функция использует функции #add#, #zero#, #dz#, каждая из которых основана на циклических расчётах. Сама функция использует для подсчёта 4 цикла, что может замедлять работу программ при вычислении больших значений. Тем не менее функция работает, хотя и несколько подвешивает игру, если выполнять несколько умножений подряд.

$args[0] ... $args[8] - девять множителей. Могут быть переданы в числовом виде (для QSP 5.7.0 в пределах [-2147483648 ... 2147483647]).
 $result - всегда текстовое значение.

Результат работы функции:
$func('#*#',"38.4","2.5") = '96'
$func('#*#','9.05',"-9.05") = '-81.9025'
$func('#*#','9.05',"10") = '90.5'
$func('#*#','9.05',"9.55","9.25") = '799.454375'
$func('#*#','9.99',"-9.999","9.9") = '-988.911099'
$func('#*#','2','2','2','2','2','2','2','2','2') = '512'
$func('#*#','-2','-2','-2','-2','-2','-2','-2','-2','-2') = '-512'

#:#

Функция деления любого числа на любое.

$args[0] - делимое, только текстовое
$args[1] - делитель, только текстовое
 args[2] - точность 1 -целые- 10 десятые доли, 100 сотые, 1000 - тысячные.
 $result - частное, текстовое значение

Используются функции #dz#, #zero#, #dev#.

Результат работы функции:
$func('#:#','9.05',"-9",10000) = '-1.0055'
$func('#:#','9.05','-9.05',10000) = '-1'
$func('#:#','9.05',"10") = '0.905'
$func('#:#','9.05',"9.55",10000) = '0.9476'
$func('#:#','9.99',"9.999",10000) = '0.999'
$func('#:#','9.99',"9.999",1000000) = '0.999099'
$func('#:#','-1.69',"1.3",10000) = '-1.3'
$func('#:#','1.69',"1.3",10000) = '1.3'
$func('#:#','-1.69',"-1.3",10000) = '1.3'
$func('#:#','1.69',"-1.3",10000) = '-1.3'

Прежде данная функция выглядела так:

# #:#
$args[9]=$args[9]
$args[0]=$func('#dz#',$args[0],1)
$args[1]=$func('#dz#',$args[1],1)
args[2] = args[2]
args['max']=max(func('#razdiv#',$args[0]),func('#razdiv#',$args[1]))
args[0] = func('#undiv#',$args[0],args['max'])
args[1] = func('#undiv#',$args[1],args['max'])
$result=$func('#indiv#',args[0],args[1],args[2])
--- #:# ---------------------------------

Это давало повышенную скорость работы. Где-то в 10 раз быстрее. Однако это и накладывало некоторые ограничения на аргументы. Например, старая версия функции неверно вычисляла вот такие значения:

$func('#:#','3123.869504',"3.7",1000000)= '-316.512916'

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

$func('#:#','3123.869504',"3.7",1000000)= '844.289055'

#sim#

Функция сравнивает два числа и выдаёт в результат большее.

Функция использует функции #dz#, #zero#, соответственно для неё актуальны все ограничения связанные с этими функциями.

$args[0] - первое число, только текстовое значение
$args[1] - второе число, только текстовое значение
 $result - результат, текстовое значение

Результат работы функции:
$func('#sim#','9.05',"-9") = '9.05'
$func('#sim#','9.05','-9.05') = '9.05'
$func('#sim#','9.05',"10") = '10'
$func('#sim#','9.05',"9.55") = '9.55'
$func('#sim#','9.99',"9.999") = '9.999'
$func('#sim#','-1.69',"1.3") = '1.3'
$func('#sim#','-1.69',"-1.3") = '-1.3'
$func('#sim#','1.69',"1.3") = '1.69'
$func('#sim#','1.69',"-1.3") = '1.69'

Внимание, результаты функции даются в обработке функцией #dz#, а значит они могут отличаться по количеству символов с данными, передаваемыми в аргументах. Будьте аккуратны при использовании сравнений.

#sqrt#

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

$args[0] - число, текстовое значение
 args[1] - точность. Целое число: 100 - сотые, 1000 - тысячные и т.д.
$args[2] - первое приближение, только текстовое значение. Вы можете указать примерно чему будет равен результат. Это ускорит вычисление

Как работает:

Существует простое линейное уравнение, повторяя вычисление которого несколько раз, мы получаем корень числа с некоторой погрешностью. Чем чаще мы производим вычисление, тем точнее результат. Округление числа производится до требуемого знака после запятой. Когда предыдущее вычисленное значение становится равно предыдущему, проверяется погрешность вычисления. Если погрешность не превышает 0.00000001, число принимается. В противном случае выдаётся ноль.

Функция использует #:#, #*#, #+#, в связи с чем к ней применимы те же ограничения, что и к этим функциям. Так же поскольку производится несколько десятков и сотен циклических вычислений, функция может заметно подвешивать игру даже при вычислении небольших значений. В настоящее время функция позволяет использовать значение первого приближения, чтобы сократить время расчётов. Значение необходимо передавать вторым аргументом ($args[2]). В будущем таблицы приближений небольших чисел будут непосредственно встроены в функцию.

Результат работы функции:

Даётся в условной записи. Функции в QSP по-прежнему вызываются с помощью ключевого слова $func.

$func('#sqrt#','1000',10000,"31")
#SQRT# 1000, точность 10000 = 31.6227
#SQRT# 16, точность 10000 = 4
#SQRT# 257, точность 100000 = 16.03121
#SQRT# 257, точность 10000 = 16.0312
#SQRT# 257, точность 1000 = 16.031
#SQRT# 257, точность 100 = 16.03
#SQRT# 2.1, точность 100 = 1.44
#SQRT# 259, точность 100 = 16.09
#SQRT# 260, точность 100 = 16.12
#SQRT# 1.69, точность 100 = 1.3
#SQRT# 0.69, точность 10000 = 0.8306

при вычислении без первого приближения расчёт для всех значений в совокупности даёт 9 секунд задержки. При вычислении с первым приближением близким по значению к результату, время на все вычисления составило 3 секунды задержки. Наибольшее количество времени ушло на вычисление корня из 1000, причём без первого приближения это время оказалось в два раза больше, чем с первым приближением.

#invert#

Простая функция . Подставляет в начало строки '-', если его там нет, и убирает, если он там есть.

$args[0] - строка (по идее число в текстовой записи)
 $result - полученная строка

Честно говоря необходимость в этой функции отпала, когда была разработана вторая версия библиотеки. Поскольку я не помню, где ещё я мог использовать эту функцию, я её оставил. Тем не менее может пригодиться, скажем, для быстрого инвертирования шестнадцатеричных чисел.

Наверх