## Diff code: bcmod

 Function: Description: Get the modulus of the left_operand using modulus.
bcmod version 507bcmod version 521
1/*
1/*
2Note: this function is a hack, and it only supports the use cases I require at
2Note: this function is a hack, and it only supports the use cases I require at
3the moment, being: arbitrary precision integer left_operand and native precision positive integer modulus (must fit in a native number, i.e. a double).
3the moment, being: an arbitrary precision decimal left_operand and native precision positive decimal modulus (must fit in a native number, i.e. a double).
4*/
4*/
5function bcmod( left_operand, modulus ) {
5function bcmod( left_operand, modulus ) {
6  // John was here!
7  // Key was here!
6  var i, d;
8  var i, d;
7  function split( operand ) {
9  function split( operand ) {
8    var parts = operand.split( '.' );
10    var parts = operand.split( '.' );
9    var i = parts[ 0 ];
11    var i = parts[ 0 ];
10    var d = '0.' + ( parts.length > 1 ? parts[ 1 ] : '0' );
12    var d = '0.' + ( parts.length > 1 ? parts[ 1 ] : '0' );
11    return { i: i, d: d };
13    return { "i": i, "d": d };
12  }
14  }
13  //modulus = Math.round( parseFloat( modulus ) );
15  //modulus = Math.round( parseFloat( modulus ) );
14  modulus = parseFloat( modulus );
16  modulus = parseFloat( modulus );
15  modulus = abs( modulus );
17  modulus = abs( modulus );
16  if ( modulus === 0 ) { return null; }
18  if ( modulus === 0 ) { return null; }
17  var take = 4;
19  var take = 4;
18  var modulus_limit = Math.pow( 10, take );
20  var modulus_limit = Math.pow( 10, take );
19  if ( modulus >= modulus_limit ) {
21  if ( modulus >= modulus_limit ) {
20    throw new Error( "Modulus cannot be " + modulus_limit + " or greater." );
22    throw new Error( "Modulus cannot be " + modulus_limit + " or greater." );
21  }
23  }
22  var result = 0;
24  var result = 0;
23  var r = split( left_operand );
25  var r = split( left_operand );
24  i = r.i; d = r.d;
26  i = r.i; d = r.d;
27    read_length = i.length < take ? i.length : ( take );
29    read_length = i.length < take ? i.length : ( take );
28    var result = i.substr( 0, take );
30    var result = i.substr( 0, take );
29    i = i.substr( take );
31    i = i.substr( take );
30    return result;
32    return result;
31  }
33  }
32  function round( value ) {
34  function round( value ) {
35    //console.log( "V:" + value );
33               //0.8999999999999997
36               //0.8999999999999997
34               //0.09999999999999984
37               //0.09999999999999984
35               //0.29999999999999993
38               //0.29999999999999993
36               //0.7999999999999998
39               //0.7999999999999998
37               //0.8999999999999999
40               //0.8999999999999999
38               //0.10000000000000009
41               //0.10000000000000009
39               //0.029999999999999985
42               //0.029999999999999985
40    var units = '0.0000000000000000';
43    var units = '0.0000000000000000';
41    function get_chars( s ) {
44    function get_chars( s ) {
42      var result = [];
45      var result = [];
43      for ( var i = 0, il = s.length; i < il; i++ ) {
46      for ( var j = 0, jl = s.length; j < jl; j++ ) {
44        result.unshift( s.charAt( i ) );
47        result.unshift( s.charAt( j ) );
45      }
48      }
46      return result;
49      return result;
47    }
50    }
48    value = value.toString();
51    value = value.toString();
49    var d_chars = get_chars( split( value ).d.substring( 0, units.length ) );
52    var r = split( value );
50    var carry;
53    var d_chars = get_chars( r.d.substring( 0, units.length ) );
54    //console.log( "D:" + d_chars.toString() );
55    var carry = 0;
51    for ( var ci = 0, cl = d_chars.length; ci < cl; ci++ ) {
56    for ( var ci = 0, cl = d_chars.length; ci < cl; ci++ ) {
52      var c = d_chars[ ci ];
57      var c = d_chars[ ci ];
53      if ( ! /^[0-9]\$/.test( c ) ) { break; }
58      if ( ! /^[0-9]\$/.test( c ) ) { break; }
54      if ( ci === 0 ) {
59      if ( ci === 0 && cl >= units.length ) {
55        carry = Math.round( parseFloat( '0.' + c ) );
60        carry = Math.round( parseFloat( '0.' + c ) );
56        d_chars[ ci ] = '0';
61        d_chars[ ci ] = '0';
57      }
62      }
58      else {
63      else {
59        var v = parseInt( c ) + carry;
64        var v = parseInt( c ) + carry;
60        if ( v >= 10 ) {
65        if ( v >= 10 ) {
61          carry = 1;
66          carry = 1;
62          v -= 10;
67          v -= 10;
63        }
68        }
64        else {
69        else {
65          carry = 0;
70          carry = 0;
66        }
71        }
67        d_chars[ ci ] = v.toString();
72        d_chars[ ci ] = v.toString();
68      }
73      }
69    }
74    }
70    return ( parseInt( i ) + carry ).toString() +
75    var result = ( parseInt( r.i ) + carry ).toString() +
71      array_reverse( d_chars.slice( 0, -1 ) ).join( '' ).replace( /[0.]*\$/, '' );
76      array_reverse( d_chars.slice( 0, -1 ) ).join( '' ).replace( /[0.]*\$/, '' );
77    //console.log( "N:" + result );
78    return result;
72  }
79  }
73  do {
80  do {
74    var n = parseInt( read() );
81    var n = parseInt( read() );
75    //console.log( result );
82    //console.log( result );
76    result = ( result * Math.pow( 10, read_length ) + n ) % modulus;
83    result = ( result * Math.pow( 10, read_length ) + n ) % modulus;
77    var temp = round( result );
84    var temp = parseFloat( round( result ) );
78    console.log( "R:" + result );
85    //console.log( "R:" + result );
79    console.log( "T:" + temp );
86    //console.log( "T:" + temp );
80    if ( ( temp - modulus ) >= 0 ) {
87    if ( ( temp - modulus ) >= 0 ) {
81      temp -= modulus;
88      temp -= modulus;
82      console.log( "T:" + temp );
89      //console.log( "T:" + temp );
90      result = temp;
83    }
91    }
84  }
92  }
85  while ( i.length > 0 );
93  while ( i.length > 0 );
86  result += parseFloat( d );
94  result += parseFloat( d );
87  var test = result - modulus;
95  var test = result - modulus;
88  result = test < 0 ? result : test;
96  result = test < 0 ? result : test;
89  result = round( result );
97  result = round( result );
90  console.log( result );
98  //console.log( result );
91  console.log();
99  //console.log();
92  return result;
100  return result;
93}
101}