Roo.form.DayPicker - final tweaks and documentation rebuild

[roojs1] / docs / symbols / src / Roo_util_Math.js.html

diff --git a/docs/symbols/src/Roo_util_Math.js.html b/docs/symbols/src/Roo_util_Math.js.html
index cc863b0..6f2a2f6 100644 (file)
--- a/docs/symbols/src/Roo_util_Math.js.html
+++ b/docs/symbols/src/Roo_util_Math.js.html
@@ -17,7 +17,7 @@
  */
 
 </span><span class="jsdoc-var">Roo.util.Math </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">num</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">roundType</span><span class="jsdoc-syntax">){
-       </span><span class="jsdoc-var">this.ctor</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">num</span><span class="jsdoc-syntax">,</span><span class="jsdoc-var">precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">roundType</span><span class="jsdoc-syntax">);
+    </span><span class="jsdoc-var">this.ctor</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">num</span><span class="jsdoc-syntax">,</span><span class="jsdoc-var">precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">roundType</span><span class="jsdoc-syntax">);
 };
 
 </span><span class="jsdoc-var">Roo.util.Math.ROUND_HALF_EVEN </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">Roo.util.Math.ROUND_HALF_DOWN </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">Roo.util.Math.ROUND_HALF_UP </span><span class="jsdoc-syntax">=
@@ -61,11 +61,11 @@
  */
     </span><span class="jsdoc-var">add </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">num</span><span class="jsdoc-syntax">)
     {
-               </span><span class="jsdoc-var">num </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">num</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">);
+        </span><span class="jsdoc-var">num </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">num</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">);
         
         </span><span class="jsdoc-keyword">if </span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this._s </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">num._s</span><span class="jsdoc-syntax">) { </span><span class="jsdoc-comment">//netagive...
             </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">num._s </span><span class="jsdoc-syntax">^= 1, </span><span class="jsdoc-var">this.subtract</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">num</span><span class="jsdoc-syntax">);
-               }
+        }
         
         </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), 
             </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o._d</span><span class="jsdoc-syntax">, 
@@ -74,22 +74,22 @@
             </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">num._f</span><span class="jsdoc-syntax">, 
             </span><span class="jsdoc-var">num </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">Math.max</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">), 
             </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">;
-               
+        
         </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">&amp;&amp; ((</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) &gt; 0 ? </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">, 1) : </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">, -</span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">, 1));
-               </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a.length</span><span class="jsdoc-syntax">) == (</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.length</span><span class="jsdoc-syntax">) ?
+        </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a.length</span><span class="jsdoc-syntax">) == (</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.length</span><span class="jsdoc-syntax">) ?
                 </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">: (
                     (</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) &gt; 0 ? </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) : </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">, -</span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">)
                 )</span><span class="jsdoc-var">.length</span><span class="jsdoc-syntax">;
                 
-               </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= 0; </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">; 
+        </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= 0; </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">; 
             </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[--</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] = </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] + </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] + </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">) / 10 &gt;&gt;&gt; 0, 
             </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] %= 10
         );
         </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">num </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">a.unshift</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">);
         </span><span class="jsdoc-var">o._f </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">num</span><span class="jsdoc-syntax">;
         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">o.round</span><span class="jsdoc-syntax">();
-                
-       },
+         
+    },
     
 </span><span class="jsdoc-comment">/**
  * Subtract number
@@ -97,20 +97,20 @@
  * @return {Object} The result
  */
     
-       </span><span class="jsdoc-var">subtract </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
-               </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this._s </span><span class="jsdoc-syntax">!= (</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">._s</span><span class="jsdoc-syntax">)
-                       </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n._s </span><span class="jsdoc-syntax">^= 1, </span><span class="jsdoc-var">this.add</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">);
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o.abs</span><span class="jsdoc-syntax">()</span><span class="jsdoc-var">.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n.abs</span><span class="jsdoc-syntax">()) + 1, </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">o</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">d </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">;
-               </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">&amp;&amp; ((</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) &gt; 0 ? </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">, 1) : </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">, -</span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">, 1));
-               </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a.length</span><span class="jsdoc-syntax">) == (</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.length</span><span class="jsdoc-syntax">) ? </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">: ((</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) &gt; 0 ? </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) : </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">, -</span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">.length</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">;){
-                       </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[--</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] &lt; </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">]){
-                               </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">&amp;&amp; !</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[--</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">]; </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">] = 9);
-                               --</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">], </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] += 10;
-                       }
-                       </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] = </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] - </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">];
-               }
-               </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">|| (</span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">^= 1), </span><span class="jsdoc-var">o._f </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">o._d </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">o.round</span><span class="jsdoc-syntax">();
-       },
+    </span><span class="jsdoc-var">subtract </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
+        </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this._s </span><span class="jsdoc-syntax">!= (</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">._s</span><span class="jsdoc-syntax">)
+            </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n._s </span><span class="jsdoc-syntax">^= 1, </span><span class="jsdoc-var">this.add</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">);
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o.abs</span><span class="jsdoc-syntax">()</span><span class="jsdoc-var">.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n.abs</span><span class="jsdoc-syntax">()) + 1, </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">o</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">d </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">;
+        </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">&amp;&amp; ((</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) &gt; 0 ? </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">, 1) : </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">, -</span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">, 1));
+        </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a.length</span><span class="jsdoc-syntax">) == (</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.length</span><span class="jsdoc-syntax">) ? </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">: ((</span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) &gt; 0 ? </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) : </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">, -</span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">.length</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">;){
+            </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[--</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] &lt; </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">]){
+                </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">&amp;&amp; !</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[--</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">]; </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">] = 9);
+                --</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">], </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] += 10;
+            }
+            </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] = </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] - </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">];
+        }
+        </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">|| (</span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">^= 1), </span><span class="jsdoc-var">o._f </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">o._d </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">o.round</span><span class="jsdoc-syntax">();
+    },
     
     
 </span><span class="jsdoc-comment">/**
@@ -118,9 +118,9 @@
  * @param {Object|Number} value to mutiply
  * @return {Object} The result
  */    
-       </span><span class="jsdoc-var">multiply </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">)
+    </span><span class="jsdoc-var">multiply </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">)
     {
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), 
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), 
             </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o._d.length </span><span class="jsdoc-syntax">&gt;= (</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">._d.length</span><span class="jsdoc-syntax">,
             </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">._d</span><span class="jsdoc-syntax">,
             </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">o</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">._d</span><span class="jsdoc-syntax">, 
@@ -129,7 +129,7 @@
             </span><span class="jsdoc-var">x </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0,</span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">), 
             </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">s</span><span class="jsdoc-syntax">;
             
-               </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">;   </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">; 
+        </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">;   </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">; 
                 </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">s.unshift</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">), 
                 </span><span class="jsdoc-var">x.set</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">x.add</span><span class="jsdoc-syntax">(</span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">s.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">)))
         ) {
@@ -143,7 +143,7 @@
         
        </span><span class="jsdoc-comment">// console.log(o);
         
-               </span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">n._s</span><span class="jsdoc-syntax">;
+        </span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">n._s</span><span class="jsdoc-syntax">;
         </span><span class="jsdoc-var">o._f </span><span class="jsdoc-syntax">= (
                     (</span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">+ </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">o._f </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">) &gt;= (</span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">o._d </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">x._d</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.length</span><span class="jsdoc-syntax">) ? 
                         </span><span class="jsdoc-var">this._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">+ 1, 1)</span><span class="jsdoc-var">.length </span><span class="jsdoc-syntax">: 
@@ -151,38 +151,38 @@
             </span><span class="jsdoc-syntax">) - </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">; 
             
         </span><span class="jsdoc-keyword">return  </span><span class="jsdoc-var">o.round</span><span class="jsdoc-syntax">();
-       },
+    },
     
-       </span><span class="jsdoc-var">divide </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
-               </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">)) == </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">)
-                       </span><span class="jsdoc-keyword">throw new </span><span class="jsdoc-var">Error</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;Division by 0&quot;</span><span class="jsdoc-syntax">);
-               </span><span class="jsdoc-keyword">else if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this </span><span class="jsdoc-syntax">== </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">)
-                       </span><span class="jsdoc-keyword">return new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">);
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">n._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">o._f</span><span class="jsdoc-syntax">,
-               </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.length </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">s</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">f </span><span class="jsdoc-syntax">= 1, </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">e </span><span class="jsdoc-syntax">= 0;
-               </span><span class="jsdoc-var">r._s </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">n._s</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r.precision </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">Math.max</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">n.precision</span><span class="jsdoc-syntax">),
-               </span><span class="jsdoc-var">r._f </span><span class="jsdoc-syntax">= +</span><span class="jsdoc-var">r._d.pop</span><span class="jsdoc-syntax">(), </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">&gt; </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">Math.abs</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">));
-               </span><span class="jsdoc-var">n._f </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.length</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b._s </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">false</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.round</span><span class="jsdoc-syntax">();
-               </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">); </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[0] == </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">a.shift</span><span class="jsdoc-syntax">());
-               </span><span class="jsdoc-var">out</span><span class="jsdoc-syntax">:
-               </span><span class="jsdoc-keyword">do</span><span class="jsdoc-syntax">{
-                       </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">== </span><span class="jsdoc-string">&quot;0&quot; </span><span class="jsdoc-syntax">&amp;&amp; (</span><span class="jsdoc-var">n._d </span><span class="jsdoc-syntax">= [], </span><span class="jsdoc-var">n._f </span><span class="jsdoc-syntax">= 0); </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">&lt; </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1; ++</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">){
-                               (</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">+ 1 == </span><span class="jsdoc-var">a.length</span><span class="jsdoc-syntax">, (!</span><span class="jsdoc-var">f </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">&gt; 1 || (</span><span class="jsdoc-var">e </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">== </span><span class="jsdoc-string">&quot;0&quot; </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] == </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">)))
-                               &amp;&amp; (</span><span class="jsdoc-var">r._f </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">r._d.length </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">r._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r._d.push</span><span class="jsdoc-syntax">(0));
-                               (</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] == </span><span class="jsdoc-string">&quot;0&quot; </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">== </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">) || (</span><span class="jsdoc-var">n._d.push</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">]), ++</span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">);
-                               </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">e</span><span class="jsdoc-syntax">)
-                                       </span><span class="jsdoc-keyword">break </span><span class="jsdoc-var">out</span><span class="jsdoc-syntax">;
-                               </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1 &amp;&amp; (</span><span class="jsdoc-var">r._f </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">r._d.length </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">r._f</span><span class="jsdoc-syntax">, 1)) || (</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= 0))
-                                       </span><span class="jsdoc-keyword">while</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">r._d.push</span><span class="jsdoc-syntax">(0), </span><span class="jsdoc-var">n._d.push</span><span class="jsdoc-syntax">(0), ++</span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1);
-                       }
-                       </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">f </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1 &amp;&amp; !(</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= 0))
-                               </span><span class="jsdoc-keyword">while</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">r._d.push</span><span class="jsdoc-syntax">(0) : </span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= 1, </span><span class="jsdoc-var">n._d.push</span><span class="jsdoc-syntax">(0), ++</span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1);
-                       </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">s </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">= 0; </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">y </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">s.add</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">)) + 1 &amp;&amp; ++</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">s.set</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">y</span><span class="jsdoc-syntax">));
-                       </span><span class="jsdoc-var">n.set</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n.subtract</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">s</span><span class="jsdoc-syntax">)), !</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">r._f </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">r._d.length </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">r._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r._d.push</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">);
-               }
-               </span><span class="jsdoc-keyword">while</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">&lt; </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">|| </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">) &amp;&amp; (</span><span class="jsdoc-var">r._d.length </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">r._f</span><span class="jsdoc-syntax">) &lt;= </span><span class="jsdoc-var">r.precision</span><span class="jsdoc-syntax">);
-               </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r.round</span><span class="jsdoc-syntax">();
-       },
+    </span><span class="jsdoc-var">divide </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
+        </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">)) == </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">)
+            </span><span class="jsdoc-keyword">throw new </span><span class="jsdoc-var">Error</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;Division by 0&quot;</span><span class="jsdoc-syntax">);
+        </span><span class="jsdoc-keyword">else if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this </span><span class="jsdoc-syntax">== </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">)
+            </span><span class="jsdoc-keyword">return new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">);
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">n._d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">o._f</span><span class="jsdoc-syntax">,
+        </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.length </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">s</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">f </span><span class="jsdoc-syntax">= 1, </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">e </span><span class="jsdoc-syntax">= 0;
+        </span><span class="jsdoc-var">r._s </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">n._s</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r.precision </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">Math.max</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">n.precision</span><span class="jsdoc-syntax">),
+        </span><span class="jsdoc-var">r._f </span><span class="jsdoc-syntax">= +</span><span class="jsdoc-var">r._d.pop</span><span class="jsdoc-syntax">(), </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">o._zeroes</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">&gt; </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">: </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">Math.abs</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">));
+        </span><span class="jsdoc-var">n._f </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.length</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b._s </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">false</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b.round</span><span class="jsdoc-syntax">();
+        </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">); </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[0] == </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">a.shift</span><span class="jsdoc-syntax">());
+        </span><span class="jsdoc-var">out</span><span class="jsdoc-syntax">:
+        </span><span class="jsdoc-keyword">do</span><span class="jsdoc-syntax">{
+            </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">== </span><span class="jsdoc-string">&quot;0&quot; </span><span class="jsdoc-syntax">&amp;&amp; (</span><span class="jsdoc-var">n._d </span><span class="jsdoc-syntax">= [], </span><span class="jsdoc-var">n._f </span><span class="jsdoc-syntax">= 0); </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">&lt; </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1; ++</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">){
+                (</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">+ 1 == </span><span class="jsdoc-var">a.length</span><span class="jsdoc-syntax">, (!</span><span class="jsdoc-var">f </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">c </span><span class="jsdoc-syntax">&gt; 1 || (</span><span class="jsdoc-var">e </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">== </span><span class="jsdoc-string">&quot;0&quot; </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] == </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">)))
+                &amp;&amp; (</span><span class="jsdoc-var">r._f </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">r._d.length </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">r._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r._d.push</span><span class="jsdoc-syntax">(0));
+                (</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] == </span><span class="jsdoc-string">&quot;0&quot; </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">== </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">) || (</span><span class="jsdoc-var">n._d.push</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">]), ++</span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">);
+                </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">e</span><span class="jsdoc-syntax">)
+                    </span><span class="jsdoc-keyword">break </span><span class="jsdoc-var">out</span><span class="jsdoc-syntax">;
+                </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1 &amp;&amp; (</span><span class="jsdoc-var">r._f </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">r._d.length </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">r._f</span><span class="jsdoc-syntax">, 1)) || (</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= 0))
+                    </span><span class="jsdoc-keyword">while</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">r._d.push</span><span class="jsdoc-syntax">(0), </span><span class="jsdoc-var">n._d.push</span><span class="jsdoc-syntax">(0), ++</span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1);
+            }
+            </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">f </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1 &amp;&amp; !(</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= 0))
+                </span><span class="jsdoc-keyword">while</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">r._d.push</span><span class="jsdoc-syntax">(0) : </span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= 1, </span><span class="jsdoc-var">n._d.push</span><span class="jsdoc-syntax">(0), ++</span><span class="jsdoc-var">n._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">) == -1);
+            </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">s </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">j </span><span class="jsdoc-syntax">= 0; </span><span class="jsdoc-var">n.compare</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">y </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">s.add</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">)) + 1 &amp;&amp; ++</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">s.set</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">y</span><span class="jsdoc-syntax">));
+            </span><span class="jsdoc-var">n.set</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n.subtract</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">s</span><span class="jsdoc-syntax">)), !</span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">r._f </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">r._d.length </span><span class="jsdoc-syntax">&amp;&amp; ++</span><span class="jsdoc-var">r._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r._d.push</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">j</span><span class="jsdoc-syntax">);
+        }
+        </span><span class="jsdoc-keyword">while</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">&lt; </span><span class="jsdoc-var">a.length </span><span class="jsdoc-syntax">|| </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">) &amp;&amp; (</span><span class="jsdoc-var">r._d.length </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">r._f</span><span class="jsdoc-syntax">) &lt;= </span><span class="jsdoc-var">r.precision</span><span class="jsdoc-syntax">);
+        </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r.round</span><span class="jsdoc-syntax">();
+    },
         
 </span><span class="jsdoc-comment">/**
  * Modulus number
@@ -190,72 +190,72 @@
  * @return {Object} The result
  */    
     
-       </span><span class="jsdoc-var">mod </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
-               </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">this.subtract</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this.divide</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.intPart</span><span class="jsdoc-syntax">()</span><span class="jsdoc-var">.multiply</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">));
-       },
+    </span><span class="jsdoc-var">mod </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
+        </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">this.subtract</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this.divide</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.intPart</span><span class="jsdoc-syntax">()</span><span class="jsdoc-var">.multiply</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">));
+    },
     
 </span><span class="jsdoc-comment">/**
  * To Power number
  * @param {Object|Number} value to power by
  * @return {Object} The result
  */        
-       </span><span class="jsdoc-var">pow </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">;
-               </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">.intPart</span><span class="jsdoc-syntax">()) == 0) </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">o.set</span><span class="jsdoc-syntax">(1);
-               </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">Math.abs</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">); --</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">o.set</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o.multiply</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">)));
-               </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">&lt; 0 ? </span><span class="jsdoc-var">o.set</span><span class="jsdoc-syntax">((</span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(1, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">.divide</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o</span><span class="jsdoc-syntax">)) : </span><span class="jsdoc-var">o</span><span class="jsdoc-syntax">;
-       },
+    </span><span class="jsdoc-var">pow </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">;
+        </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">.intPart</span><span class="jsdoc-syntax">()) == 0) </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">o.set</span><span class="jsdoc-syntax">(1);
+        </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">Math.abs</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">); --</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">; </span><span class="jsdoc-var">o.set</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o.multiply</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">)));
+        </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">&lt; 0 ? </span><span class="jsdoc-var">o.set</span><span class="jsdoc-syntax">((</span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(1, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">))</span><span class="jsdoc-var">.divide</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o</span><span class="jsdoc-syntax">)) : </span><span class="jsdoc-var">o</span><span class="jsdoc-syntax">;
+    },
     </span><span class="jsdoc-comment">/**
  * Set number
  * @param {Object|Number} value to set object to
  * @return {Object} This
  */    
     
-       </span><span class="jsdoc-var">set </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">)
+    </span><span class="jsdoc-var">set </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">)
     {
-               </span><span class="jsdoc-var">this.ctor</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">);
+        </span><span class="jsdoc-var">this.ctor</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">);
         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">;
-       },
+    },
 </span><span class="jsdoc-comment">/**
  * Compare number
  * @param {Object|Number} value to compare to
  * @return {boolean} true if the same
  */        
     
-       </span><span class="jsdoc-var">compare </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= [-1, 1], </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">;
-               </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a._s </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">b._s</span><span class="jsdoc-syntax">)
-                       </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">a._s </span><span class="jsdoc-syntax">? -1 : 1;
-               </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">)
-                       </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">[(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">&gt; </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) ^ </span><span class="jsdoc-var">a._s</span><span class="jsdoc-syntax">];
-               </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a._d</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.length</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b._d</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.length</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= -1, </span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">Math.min</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">); ++</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">&lt; </span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">;)
-                       </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] != </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">])
-                               </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">[(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] &gt; </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">]) ^ </span><span class="jsdoc-var">a._s</span><span class="jsdoc-syntax">];
-               </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">[(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">&gt; </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) ^ </span><span class="jsdoc-var">a._s</span><span class="jsdoc-syntax">] : 0;
-       },
+    </span><span class="jsdoc-var">compare </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">), </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b._f</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= [-1, 1], </span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">;
+        </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a._s </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">b._s</span><span class="jsdoc-syntax">)
+            </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">a._s </span><span class="jsdoc-syntax">? -1 : 1;
+        </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">)
+            </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">[(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">&gt; </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) ^ </span><span class="jsdoc-var">a._s</span><span class="jsdoc-syntax">];
+        </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">a </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">a._d</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.length</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b._d</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.length</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">= -1, </span><span class="jsdoc-var">l </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">Math.min</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">la</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">); ++</span><span class="jsdoc-var">i </span><span class="jsdoc-syntax">&lt; </span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">;)
+            </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] != </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">])
+                </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">[(</span><span class="jsdoc-var">a</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">] &gt; </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">i</span><span class="jsdoc-syntax">]) ^ </span><span class="jsdoc-var">a._s</span><span class="jsdoc-syntax">];
+        </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">lb </span><span class="jsdoc-syntax">? </span><span class="jsdoc-var">r</span><span class="jsdoc-syntax">[(</span><span class="jsdoc-var">la </span><span class="jsdoc-syntax">&gt; </span><span class="jsdoc-var">lb</span><span class="jsdoc-syntax">) ^ </span><span class="jsdoc-var">a._s</span><span class="jsdoc-syntax">] : 0;
+    },
 </span><span class="jsdoc-comment">/**
  * negate number 
  * @return {Object} the result
  */            
-       </span><span class="jsdoc-var">negate </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(){
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">); 
+    </span><span class="jsdoc-var">negate </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(){
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">); 
         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n._s </span><span class="jsdoc-syntax">^= 1, </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">;
-       },
+    },
 </span><span class="jsdoc-comment">/**
  * abs number 
  * @return {Object} the result
  */                
-       </span><span class="jsdoc-var">abs </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(){
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">);
+    </span><span class="jsdoc-var">abs </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(){
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">);
         </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n._s </span><span class="jsdoc-syntax">= 0, </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">;
-       },
+    },
 </span><span class="jsdoc-comment">/**
  * integer part of number
  * @return {Object} the result
  */        
-       </span><span class="jsdoc-var">intPart </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(){
-               </span><span class="jsdoc-keyword">return new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">this._s </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;-&quot; </span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">) + (</span><span class="jsdoc-var">this._d.slice</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this._f</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) || </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">));
-       },
+    </span><span class="jsdoc-var">intPart </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(){
+        </span><span class="jsdoc-keyword">return new </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">((</span><span class="jsdoc-var">this._s </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;-&quot; </span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.precision</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">) + (</span><span class="jsdoc-var">this._d.slice</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">this._f</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) || </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">));
+    },
 </span><span class="jsdoc-comment">/**
  * value of thenumber
  * @return {String} the result
@@ -267,10 +267,10 @@
  * value of the number
  * @return {String} the result
  */            
-       </span><span class="jsdoc-var">toString </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(){
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">;
-               </span><span class="jsdoc-keyword">return </span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;-&quot; </span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) + (</span><span class="jsdoc-var">o._d.slice</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">o._f</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) || </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">) + (</span><span class="jsdoc-var">o._f </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">o._d.length </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;.&quot; </span><span class="jsdoc-syntax">+ </span><span class="jsdoc-var">o._d.slice</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o._f</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) : </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">);
-       },
+    </span><span class="jsdoc-var">toString </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(){
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">o </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">;
+        </span><span class="jsdoc-keyword">return </span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o._s </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;-&quot; </span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) + (</span><span class="jsdoc-var">o._d.slice</span><span class="jsdoc-syntax">(0, </span><span class="jsdoc-var">o._f</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) || </span><span class="jsdoc-string">&quot;0&quot;</span><span class="jsdoc-syntax">) + (</span><span class="jsdoc-var">o._f </span><span class="jsdoc-syntax">!= </span><span class="jsdoc-var">o._d.length </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;.&quot; </span><span class="jsdoc-syntax">+ </span><span class="jsdoc-var">o._d.slice</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">o._f</span><span class="jsdoc-syntax">)</span><span class="jsdoc-var">.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) : </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">);
+    },
 </span><span class="jsdoc-comment">/**
  * value of the number at a fixed precission
  * @return {String} the result
@@ -292,28 +292,28 @@
         
     },
     </span><span class="jsdoc-comment">//private
-       </span><span class="jsdoc-var">_zeroes </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">t</span><span class="jsdoc-syntax">){
-               </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">s </span><span class="jsdoc-syntax">= [</span><span class="jsdoc-string">&quot;push&quot;</span><span class="jsdoc-syntax">, </span><span class="jsdoc-string">&quot;unshift&quot;</span><span class="jsdoc-syntax">][</span><span class="jsdoc-var">t </span><span class="jsdoc-syntax">|| 0];
-               </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(++</span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">; --</span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">;  </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">s</span><span class="jsdoc-syntax">](0));
-               </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">;
-       },
+    </span><span class="jsdoc-var">_zeroes </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">t</span><span class="jsdoc-syntax">){
+        </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">s </span><span class="jsdoc-syntax">= [</span><span class="jsdoc-string">&quot;push&quot;</span><span class="jsdoc-syntax">, </span><span class="jsdoc-string">&quot;unshift&quot;</span><span class="jsdoc-syntax">][</span><span class="jsdoc-var">t </span><span class="jsdoc-syntax">|| 0];
+        </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(++</span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">; --</span><span class="jsdoc-var">l</span><span class="jsdoc-syntax">;  </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">s</span><span class="jsdoc-syntax">](0));
+        </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">;
+    },
     </span><span class="jsdoc-comment">//private    
-       </span><span class="jsdoc-var">round </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">()
+    </span><span class="jsdoc-var">round </span><span class="jsdoc-syntax">: </span><span class="jsdoc-keyword">function</span><span class="jsdoc-syntax">()
     {
         </span><span class="jsdoc-keyword">var </span><span class="jsdoc-var">m </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">Roo.util.Math</span><span class="jsdoc-syntax">;
-               
+        
         </span><span class="jsdoc-keyword">if </span><span class="jsdoc-syntax">(</span><span class="jsdoc-keyword">typeof</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">m._rounding</span><span class="jsdoc-syntax">) != </span><span class="jsdoc-string">'undefined'</span><span class="jsdoc-syntax">) </span><span class="jsdoc-keyword">return </span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">; </span><span class="jsdoc-comment">// stop recursion..
         </span><span class="jsdoc-var">m._rounding </span><span class="jsdoc-syntax">= </span><span class="jsdoc-keyword">true</span><span class="jsdoc-syntax">;
-               
+        
         </span><span class="jsdoc-keyword">var   </span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this.roundType</span><span class="jsdoc-syntax">,
             </span><span class="jsdoc-var">b </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this._d</span><span class="jsdoc-syntax">, 
             </span><span class="jsdoc-var">d</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">p</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">x</span><span class="jsdoc-syntax">;
         </span><span class="jsdoc-comment">//console.log(b.join(','));    
-               </span><span class="jsdoc-keyword">while</span><span class="jsdoc-syntax">( </span><span class="jsdoc-var">this._f </span><span class="jsdoc-syntax">&gt; 1 &amp;&amp; !</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[0]) {
+        </span><span class="jsdoc-keyword">while</span><span class="jsdoc-syntax">( </span><span class="jsdoc-var">this._f </span><span class="jsdoc-syntax">&gt; 1 &amp;&amp; !</span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[0]) {
             --</span><span class="jsdoc-var">this._f</span><span class="jsdoc-syntax">;
             </span><span class="jsdoc-var">b.shift</span><span class="jsdoc-syntax">();
         }
-               </span><span class="jsdoc-comment">//console.log(b.join(','));    
+        </span><span class="jsdoc-comment">//console.log(b.join(','));    
         </span><span class="jsdoc-keyword">for</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">d </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this._f</span><span class="jsdoc-syntax">, 
             </span><span class="jsdoc-var">p </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">this.precision </span><span class="jsdoc-syntax">+ </span><span class="jsdoc-var">d</span><span class="jsdoc-syntax">, 
             </span><span class="jsdoc-var">n </span><span class="jsdoc-syntax">= </span><span class="jsdoc-var">b</span><span class="jsdoc-syntax">[</span><span class="jsdoc-var">p</span><span class="jsdoc-syntax">];
@@ -323,14 +323,14 @@
             </span><span class="jsdoc-var">b.pop</span><span class="jsdoc-syntax">()
         );
             
-               </span><span class="jsdoc-var">x </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">this._s </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;-&quot; </span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) + (</span><span class="jsdoc-var">p </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">d </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;0.&quot; </span><span class="jsdoc-syntax">+ </span><span class="jsdoc-var">this._zeroes</span><span class="jsdoc-syntax">([], </span><span class="jsdoc-var">p </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">d </span><span class="jsdoc-syntax">- 1)</span><span class="jsdoc-var">.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) : </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) + 1;
+         </span><span class="jsdoc-var">x </span><span class="jsdoc-syntax">= (</span><span class="jsdoc-var">this._s </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;-&quot; </span><span class="jsdoc-syntax">: </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) + (</span><span class="jsdoc-var">p </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">d </span><span class="jsdoc-syntax">? </span><span class="jsdoc-string">&quot;0.&quot; </span><span class="jsdoc-syntax">+ </span><span class="jsdoc-var">this._zeroes</span><span class="jsdoc-syntax">([], </span><span class="jsdoc-var">p </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">d </span><span class="jsdoc-syntax">- 1)</span><span class="jsdoc-var">.join</span><span class="jsdoc-syntax">(</span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) : </span><span class="jsdoc-string">&quot;&quot;</span><span class="jsdoc-syntax">) + 1;
         
        
-
-  
-        </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b.length </span><span class="jsdoc-syntax">&gt; </span><span class="jsdoc-var">p </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">){
-            </span><span class="jsdoc-comment">//console.log(&quot;rounding&quot; +n + &quot; Method? &quot; + r);
-                       </span><span class="jsdoc-keyword">if </span><span class="jsdoc-syntax">(
+         
+        </span><span class="jsdoc-keyword">if</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">b.length </span><span class="jsdoc-syntax">&gt; </span><span class="jsdoc-var">p </span><span class="jsdoc-syntax">&amp;&amp; </span><span class="jsdoc-keyword">typeof</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">n</span><span class="jsdoc-syntax">) != </span><span class="jsdoc-string">'undefined'</span><span class="jsdoc-syntax">) {
+        </span><span class="jsdoc-comment">//if(b.length &gt; p &amp;&amp; n){
+            //console.log(&quot;rounding&quot; +n + &quot; Method? &quot; + r);
+            </span><span class="jsdoc-keyword">if </span><span class="jsdoc-syntax">(
                 (</span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">m.ROUND_UP</span><span class="jsdoc-syntax">) ||
                 (</span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">m.ROUND_CEIL </span><span class="jsdoc-syntax">&amp;&amp; !</span><span class="jsdoc-var">this._s</span><span class="jsdoc-syntax">) ||
                 (</span><span class="jsdoc-var">r </span><span class="jsdoc-syntax">== </span><span class="jsdoc-var">m.ROUND_FLOOR </span><span class="jsdoc-syntax">&amp;&amp;  </span><span class="jsdoc-var">this._s</span><span class="jsdoc-syntax">) ||
@@ -346,8 +346,8 @@
                 </span><span class="jsdoc-comment">//this.precision--;
             </span><span class="jsdoc-syntax">}
 
-                       </span><span class="jsdoc-var">b.splice</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">p</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b.length </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">p</span><span class="jsdoc-syntax">);
-               }
-               </span><span class="jsdoc-keyword">return delete </span><span class="jsdoc-var">m._rounding</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">;
-       }
+            </span><span class="jsdoc-var">b.splice</span><span class="jsdoc-syntax">(</span><span class="jsdoc-var">p</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">b.length </span><span class="jsdoc-syntax">- </span><span class="jsdoc-var">p</span><span class="jsdoc-syntax">);
+        }
+        </span><span class="jsdoc-keyword">return delete </span><span class="jsdoc-var">m._rounding</span><span class="jsdoc-syntax">, </span><span class="jsdoc-var">this</span><span class="jsdoc-syntax">;
+    }
 };</span></code></body></html>
\ No newline at end of file