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

easy.math.qsp v. 3.1.0

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

em.dz

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

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

Результат работы функции:
@em.dz('64',100) & !@ '64'
@em.dz('64.0080000',1) & !@ '64.008'
@em.dz('64.0080000',100) & !@ '64.008'
@em.dz('64.0080000',10000) & !@ '64.0080'

em.indiv

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

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

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

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

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

em.undiv

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

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

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

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

em.divdigs

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

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

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

em.round

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

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

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

Использует функции em.dz, em.zero.

Результат работы функции:
@em.round("945.459","0.1") & !@ '945.5'
@em.round("945.459","0.1",'[down]') & !@ '945.4'
@em.round("945.444","0.1",'[up]') & !@ '945.5'
@em.round("945.459","0.01") & !@ '945.46'
@em.round("945.459","0.001") & !@ '945.459'
@em.round("945.459","1") & !@ '945'
@em.round("945.459","10") & !@ '950'
@em.round("945.459","100") & !@ '900'
@em.round("-945.459","10") & !@ '-950'
@em.round("-945.459","0.01") & !@ '-945.46'

em.add

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

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

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

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

em.mult

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

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

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

Результат работы функции:
@em.mult("38.4","2.5") & !@ '96'
@em.mult('9.05',"-9.05") & !@ '-81.9025'
@em.mult('9.05',"10") & !@ '90.5'
@em.mult('9.05',"9.55","9.25") & !@ '799.454375'
@em.mult('9.99',"-9.999","9.9") & !@ '-988.911099'
@em.mult('2','2','2','2','2','2','2','2','2') & !@ '512'
@em.mult('-2','-2','-2','-2','-2','-2','-2','-2','-2') & !@ '-512'

em.div

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

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

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

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

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

em.simpl

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

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

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

Результат работы функции:
@em.simpl('9.05',"-9") & !@ '9.05'
@em.simpl('9.05','-9.05') & !@ '9.05'
@em.simpl('9.05',"10") & !@ '10'
@em.simpl('9.05',"9.55") & !@ '9.55'
@em.simpl('9.99',"9.999") & !@ '9.999'
@em.simpl('-1.69',"1.3") & !@ '1.3'
@em.simpl('-1.69',"-1.3") & !@ '-1.3'
@em.simpl('1.69',"1.3") & !@ '1.69'
@em.simpl('1.69',"-1.3") & !@ '1.69'

Внимание!!! Результаты функции даются в обработке функцией em.dz, а значит они могут отличаться по количеству символов с данными, передаваемыми в аргументах. Корректное сравнение возможно только при предварительном приведении чисел к общему виду через em.dz:

$first=@em.dz("19.050000")
$second=@em.dz("19.05")
@em.simpl($first,$second)

em.sqrt

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

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

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

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

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

Результат работы функции:
@em.sqrt('1000',10000) & !@ 31.6227
@em.sqrt('16',10000) & !@ 4
@em.sqrt('257',100000) & !@ 16.03121
@em.sqrt('257',10000) & !@ 16.0312
@em.sqrt('257',1000) & !@ 16.031
@em.sqrt('257',100) & !@ 16.03
@em.sqrt('2.1',100) & !@ 1.44
@em.sqrt('259',100) & !@ 16.09
@em.sqrt('260',100) & !@ 16.12
@em.sqrt('1.69',100) & !@ 1.3
@em.sqrt('0.69',10000) & !@ 0.8306

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

Текущий вариант функции даёт полторы секунды задержки на все вычисления! И это без указания первого приближения, т.е. приближения берутся те, которые предоставляет сама функция.

Aleks Versus'Easy Libraries'2013-

Aleks Versus'Game Adventure Making'Really Unimaginable Stories'2013-

Наверх