Длинная арифметика
 

Всем привет. Появилась потребность реализовать операции( +,-,*,/) для чисел большой длины.
Для меня наиболее понятен метод, при котором длинное число делится и заносится в массив по 4 эл-та в ячейку.
Может есть какие-нибудь другие методы, которые проще и удобнее реализовать?

Число большой длины - Ne±E и вычисляйте на здоровье.

А можно поподробнее? Или, где можно почитать?
Я хотел число, например, длины 64 занести в массив из 16 ячеек. И потом доставать из каждого массива. Но я не знаю, как реализовать действия над ними.

Например, есть число 12345678912345678912345678912345678912345678912345 67891234567891 длины 64 символа, и его требуется умножить на такое же число.

Если это число перевести в шестнадцатеричную систему, то получается 30046031AC0B18000000000000000000000000000000000000 000

JavDev,
http://alexbardas.github.io/bignumber.js/

Это число умноженное на него JS отобразит как 1.5241578780673678546105778311536e+62

Вот такое и надо, только свое написать:(
Спасибо, буду разбираться:)

JavDev,
https://github.com/MikeMcl/bignumber.js
https://github.com/jtobey/javascript-bignum

:)
реализация вычитания
http://javascript.ru/forum/showthrea...635#post268635

Спасибо. А не подскажете как работает этот кусок кода?

for (var i = 0, b = 0, c = 0; i < len; i++) {
          b = max[i] - (min[i] || 0) + c;
          result[i] = b < 0 ? (c = -1, 10 + b) : (c = 0, b)
      }

Как я понимаю, чтобы изменить вычитание на, например, умножение нужно исправить

max[i] * (min[i] || 0)

и что-то еще

JavDev,
100 - 78
проход по массиву max = [0,0,1] , min = [8,7], c = 0
1 шаг
b = 0 - (8 || 0) + 0;
b = -8
b < 0 result[i] = 10 + -8 = 2 , c = -1
result = [2]
2 шаг
b = 0 - (7 || 0) + -1;
b = -8
b < 0 result[i] = 10 + -8 = 2 , c = -1
result = [2,2]
3 шаг
b = 1 - (null|| 0) + -1;
b = 0
b == 0 result[i] = 0, c = 0
result = [2,2,0]
result.reverse() ...
result = "22"
100 - 78 = 22
алгоритм умножения не знаю

большие числа сложение
 

JavDev,

var max = "9999" , min = "9";

function difference(max, min) {
      max = max.split('')
          .reverse();
      max.push(0);
      min = min.split('')
          .reverse();
      var len = max.length,
          result = [];
      for (var i = 0, b = 0, c = 0; i < len; i++) {
          b = +max[i] + (+min[i] || 0) + c;
          result[i] = b > 9 ? (c = (b/10|0), b % 10) : (c = 0, b)
      }
      return result.reverse()
          .join('')
          .replace(/^0+/, '');
  }
 alert(difference(max,min) )

JavDev,
на всякий случай -- сложение и вычитание в примерах для неотрицательных чисел.

рони,
Спасибо большое:) А алгоритм умножения принципиально отличается?
Если просто поменять знак, то на какие-то числа работает, а на какие-то нет.

надо смотреть ... а так можно использовать сложение миллиарды раз ... :)

порядок действий в умножении реализуется по очень простому правилу:

По умолчанию, при отсутствии дополнительных элементов, они выполняются в порядке написания. 15 - 3 + 7 = 19

При наличии скобок сначала выполняется действие, в них заключенное. 15 - (3 + 7) = 5

При появлении знаков или первыми выполняются они, лишь затем сложение или вычитание. 2 + 2 х 2 = 2 + 4 = 6 2 + 2 ÷ 2 = 2 + 1 = 3

Скобки могут частично ослабить эти правила, так как действие в них заключенное всегда выполняется в первую очередь. (2 + 2) х 2 = 4 х 2 = 8 (2 + 2) ÷ 2 = 4 ÷ 2 = 2

Если в скобки заключено сложное выражение, внутри них работают стандартные правила. (4 + 7 - 1) + 5 = (11 - 1) + 5 = 15 (5 + 3 х 2) - 4 = (5 + 6) - 4 = 11 - 4 = 7

При появлении двух и более знаков или нужно учитывать их очередность. 5 х 2 - 8 ÷ 4 = 10 - 2 = 8