API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 10th, 2013
38
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 11.65 KB | None | 0 0
raw download clone embed print report
  1. // ====================== //
  2. // McTwist's Math library //
  3. // ====================== //
  4. // Integer allowed only
  5.  
  6. function Math::onAdd(%this)
  7. {
  8.     if (!isObject(%this))
  9.         return;
  10.    
  11.     %this.secure = 1;
  12. }
  13.  
  14. // Set secure mode
  15. function Math::secure(%secure)
  16. {
  17.     %this.secure = %secure;
  18. }
  19.  
  20. // Get maximum
  21. function Math::max(%a, %b)
  22. {
  23.     if (Math.secure)
  24.     {
  25.         %a = filterString(%a, "0123456789-");
  26.         %b = filterString(%b, "0123456789-");
  27.     }
  28.     %as = strlen(%a);
  29.     %bs = strlen(%b);
  30.     // A is bigger
  31.     if (%as > %bs)
  32.         return %a;
  33.     // B is bigger
  34.     else if (%as < %bs)
  35.         return %b;
  36.    
  37.     // Deeper comparison
  38.     for (%i = 0; %i < %as; %i++)
  39.     {
  40.         %c = getSubStr(%a, %i, 1);
  41.         %d = getSubStr(%b, %i, 1);
  42.         // A is bigger
  43.         if (%c > %d)
  44.             return %a;
  45.         else if (%c < %d)
  46.         // B is bigger
  47.             return %b;
  48.     }
  49.     // Equal
  50.     return %a;
  51. }
  52.  
  53. // Get minimum
  54. function Math::min(%a, %b)
  55. {
  56.     if (Math.secure)
  57.     {
  58.         %a = filterString(%a, "0123456789-");
  59.         %b = filterString(%b, "0123456789-");
  60.     }
  61.     %as = strlen(%a);
  62.     %bs = strlen(%b);
  63.     // B is smaller
  64.     if (%as > %bs)
  65.         return %b;
  66.     // A is smaller
  67.     else if (%as < %bs)
  68.         return %a;
  69.    
  70.     // Deeper comparison
  71.     for (%i = 0; %i < %as; %i++)
  72.     {
  73.         %c = getSubStr(%a, %i, 1);
  74.         %d = getSubStr(%b, %i, 1);
  75.         // B is smaller
  76.         if (%c > %d)
  77.             return %b;
  78.         // A is smaller
  79.         else if (%c < %d)
  80.             return %a;
  81.     }
  82.     // Equal
  83.     return %a;
  84. }
  85.  
  86. // Remove decimals
  87. function Math::floatLength(%num, %length)
  88. {
  89.     if (Math.secure)
  90.         %num = filterString(%num, "0123456789-.");
  91.    
  92.     // Split number
  93.     %float = nextToken(%num, "int", ".");
  94.    
  95.     // Remove extras
  96.     %float = getSubStr(%float, 0, %length);
  97.    
  98.     // Add zeroes
  99.     while (strlen(%float) < %length)
  100.         %float = %float @ "0";
  101.    
  102.     // Decimals
  103.     if (%float !$= "")
  104.         %int = %int @ "." @ %float;
  105.    
  106.     return %result;
  107. }
  108.  
  109. // Round
  110. function Math::round(%number)
  111. {
  112.    
  113. }
  114.  
  115. // Floor
  116. function Math::floor(%number)
  117. {
  118.     if (Math.secure)
  119.         %num = filterString(%num, "0123456789-.");
  120.    
  121.     // Split number
  122.     %float = nextToken(%num, "int", ".");
  123.     return %int;
  124. }
  125.  
  126. // Ceil
  127. function Math::ceil(%number)
  128. {
  129.     if (Math.secure)
  130.         %num = filterString(%num, "0123456789-.");
  131.    
  132.     // Split number
  133.     %float = nextToken(%num, "int", ".");
  134.     if (Math::max(%float, "0") $= "0")
  135.         %int = Math::add(%int, "1");
  136.     return %int;
  137. }
  138.  
  139. // Clean up dirty number
  140. function Math::clean(%num, %point)
  141. {
  142.     if (Math.secure)
  143.         %num = filterString(%num, "0123456789-.");
  144.     // Handle negative number
  145.     if (strpos(%num, "-") == 0)
  146.     {
  147.         %num = getSubStr(%num, 1, strlen(%num));
  148.         %neg = 1;
  149.     }
  150.     // Remove zeroes
  151.     while (getSubStr(%num, 0, 1) $= "0" && strlen(%num) > 1)
  152.         %num = getSubStr(%num, 1, strlen(%num));
  153.    
  154.     // Handle floats
  155.     %float = nextToken(%num, "int", ".");
  156.     if (%point && %float !$= "")
  157.     {
  158.         // Remove zeroes
  159.         while (getSubStr(%float, strlen(%float)-1, 1) $= "0")
  160.             %float = getSubStr(%float, 0, strlen(%float)-1);
  161.         %num = %int;
  162.         if (%float !$= "")
  163.             %num = %num @ "." @ %float;
  164.     }
  165.     else
  166.         %num = %int;
  167.    
  168.     // Add negative
  169.     if (%neg && %num !$= "0")
  170.         %num = "-" @ %num;
  171.    
  172.     return %num;
  173. }
  174.  
  175. // Addition
  176. function Math::add(%a, %b)
  177. {
  178.     if (Math.secure)
  179.     {
  180.         %a = filterString(%a, "0123456789-");
  181.         %b = filterString(%b, "0123456789-");
  182.     }
  183.     %result = "";
  184.     %extra = 0;
  185.     // Handle negative numbers
  186.     if (strpos(%a, "-") == 0)
  187.     {
  188.         %a = getSubStr(%a, 1, strlen(%a));
  189.         %an = 1;
  190.     }
  191.     if (strpos(%b, "-") == 0)
  192.     {
  193.         %b = getSubStr(%b, 1, strlen(%b));
  194.         %bn = 1;
  195.     }
  196.     %a = "0" @ %a;
  197.     %b = "0" @ %b;
  198.    
  199.     %max = getMax(strlen(%a), strlen(%b));
  200.     // Flip them
  201.     for (%i = 0; %i < %max; %i++)
  202.     {
  203.         %c = getSubStr(%a, %i, 1);
  204.         %d = getSubStr(%b, %i, 1);
  205.         if (%c !$= "")
  206.             %cf = %c @ %cf;
  207.         if (%d !$= "")
  208.             %df = %d @ %df;
  209.     }
  210.     %a = %cf;
  211.     %b = %df;
  212.     //echo(%a SPC %b);
  213.     %negative = 0;
  214.     // Calculate
  215.     for (%i = 0; %i < %max; %i++)
  216.     {
  217.         %c = (%an ? -1 : 1) * getSubStr(%a, %i, 1);
  218.         %d = (%bn ? -1 : 1) * getSubStr(%b, %i, 1);
  219.         %e = %c + %d + %extra;
  220.         %negative = (%e < 0);
  221.         if (%negative)
  222.             %e += 10;
  223.         %result = getSubStr(%e, strlen(%e)-1, 1) @ %result;
  224.         %extra = getSubStr(%e, 0, strlen(%e)-1);
  225.         if (%negative)
  226.             %extra = -1;
  227.         //echo(%c @ "+" @ %d @ "=" @ %e SPC %result SPC %extra);
  228.     }
  229.    
  230.     // Remove zeroes
  231.     while (getSubStr(%result, 0, 1) $= "0" && strlen(%result) > 1)
  232.         %result = getSubStr(%result, 1, strlen(%result));
  233.    
  234.     // Handle negative number
  235.     if (%negative)
  236.     {
  237.         %filler = "";
  238.         %size = strlen(%result);
  239.         for (%i = 0; %i < %size; %i++)
  240.             %filler = "0" @ %filler;
  241.         %filler = "1" @ %filler;
  242.         %result = "-" @ Math::add(%filler, "-" @ %result);
  243.     }
  244.    
  245.     return %result;
  246. }
  247.  
  248. // Old method
  249. function Math::add2(%a, %b)
  250. {
  251.     %result = "";
  252.     %extra = 0;
  253.    
  254.     %max = getMax(strlen(%a), strlen(%b));
  255.     // Flip them
  256.     for (%i = 0; %i < %max; %i++)
  257.     {
  258.         %c = getSubStr(%a, %i, 1);
  259.         %d = getSubStr(%b, %i, 1);
  260.         if (%c !$= "")
  261.             %cf = %c @ %cf;
  262.         if (%d !$= "")
  263.             %df = %d @ %df;
  264.     }
  265.     %a = %cf;
  266.     %b = %df;
  267.     // Calculate
  268.     for (%i = 0; %i < %max; %i++)
  269.     {
  270.         %c = getSubStr(%a, %i, 1) << 0;
  271.         %d = getSubStr(%b, %i, 1) << 0;
  272.         %e = %c + %d + %extra;
  273.         %result = getSubStr(%e, strlen(%e)-1, 1) @ %result;
  274.         %extra = getSubStr(%e, 0, strlen(%e)-1);
  275.         //echo(%result SPC %extra);
  276.     }
  277.    
  278.     return %result;
  279. }
  280.  
  281. // Subtraction
  282. function Math::sub(%a, %b)
  283. {
  284.     if (Math.secure)
  285.         %b = filterString(%b, "0123456789-");
  286.     if (strpos(%b, "-") == 0)
  287.         %b = getSubStr(%b, 1, strlen(%b));
  288.     else
  289.         %b = "-" @ %b;
  290.     return Math::add(%a, %b);
  291. }
  292.  
  293. // Multiplication
  294. function Math::mul(%a, %b)
  295. {
  296.     if (Math.secure)
  297.     {
  298.         %a = filterString(%a, "0123456789-");
  299.         %b = filterString(%b, "0123456789-");
  300.     }
  301.     %result = "";
  302.     %extra = 0;
  303.    
  304.     // Handle negative numbers
  305.     if (strpos(%a, "-") == 0)
  306.     {
  307.         %a = getSubStr(%a, 1, strlen(%a));
  308.         %neg = !%neg;
  309.     }
  310.     if (strpos(%b, "-") == 0)
  311.     {
  312.         %b = getSubStr(%b, 1, strlen(%b));
  313.         %neg = !%neg;
  314.     }
  315.    
  316.     %a = "0" @ %a;
  317.     %b = "0" @ %b;
  318.    
  319.     %max = getMax(strlen(%a), strlen(%b));
  320.     // Flip them
  321.     for (%i = 0; %i < %max; %i++)
  322.     {
  323.         %c = getSubStr(%a, %i, 1);
  324.         %d = getSubStr(%b, %i, 1);
  325.         if (%c !$= "")
  326.             %cf = %c @ %cf;
  327.         if (%d !$= "")
  328.             %df = %d @ %df;
  329.     }
  330.     %a = %cf;
  331.     %b = %df;
  332.     //echo(%a SPC %b);
  333.     // Calculate
  334.     for (%i = 0; %i < %max*%max; %i++)
  335.     {
  336.         %p = %i % %max;
  337.         %n = mFloor(%i / %max);
  338.         // Add leading zeroes
  339.         if (%p $= 0)
  340.         {
  341.             for (%o = 0; %o < %n; %o++)
  342.                 %result[%n] = "0" @ %result[%n];
  343.         }
  344.        
  345.         %c = getSubStr(%a, %p, 1) * 1;
  346.         %d = getSubStr(%b, %n, 1) * 1;
  347.         %e = (%c * %d) + %extra;
  348.         %result[%n] = getSubStr(%e, strlen(%e)-1, 1) @ %result[%n];
  349.         %extra = getSubStr(%e, 0, strlen(%e)-1);
  350.         //echo(%c @ "+" @ %d @ "=" @ %e SPC %result[%n] SPC %extra);
  351.     }
  352.    
  353.     //while (getSubStr(%result, 0, 1) $= "0")
  354.     //  %result = getSubStr(%result, 1, strlen(%result));
  355.     // Remove zeroes
  356.     while (getSubStr(%result, 0, 1) $= "0" && strlen(%result) > 1)
  357.         %result = getSubStr(%result, 1, strlen(%result));
  358.    
  359.     // Add together
  360.     %result = %result[0];
  361.     for (%i = 1; %i < %max; %i++)
  362.         %result = Math::add(%result, %result[%i]);
  363.    
  364.     // Negative number
  365.     if (%neg)
  366.         %result = "-" @ %result;
  367.    
  368.     return %result;
  369. }
  370.  
  371. // Division
  372. function Math::div(%a, %b)
  373. {
  374.     if (Math.secure)
  375.     {
  376.         %a = filterString(%a, "0123456789-");
  377.         %b = filterString(%b, "0123456789-");
  378.     }
  379.     %result = "";
  380.     %rest = 0;
  381.    
  382.     // Handle negative numbers
  383.     if (strpos(%a, "-") == 0)
  384.     {
  385.         %a = getSubStr(%a, 1, strlen(%a));
  386.         %neg = !%neg;
  387.     }
  388.     if (strpos(%b, "-") == 0)
  389.     {
  390.         %b = getSubStr(%b, 1, strlen(%b));
  391.         %neg = !%neg;
  392.     }
  393.    
  394.     // Lower than 1
  395.     if (Math::max(%a, %b) $= %b)
  396.         return "1";
  397.    
  398.     %max = strlen(%a);
  399.    
  400.     // Divide
  401.     %c = "";
  402.     for (%i = 0; %i < %max; %i++)
  403.     {
  404.         %p = 0;
  405.        
  406.         %c = %c @ getSubStr(%a, %i, 1);
  407.         %p = mFloor(%c / %b);
  408.         //echo(%c SPC %p);
  409.         // Too smal division
  410.         if (%p < 1)
  411.         {
  412.             %result = %result @ "0";
  413.             continue;
  414.         }
  415.        
  416.         // Get rest
  417.         %c = %c % %b;
  418.         //echo(%c SPC %p);
  419.         %result = %result @ %p;
  420.     }
  421.    
  422.     // Remove leading zeroes
  423.     while (getSubStr(%result, 0, 1) $= "0" && strlen(%result) > 1)
  424.         %result = getSubStr(%result, 1, strlen(%result));
  425.    
  426.     // Negative number
  427.     if (%neg)
  428.         %result = "-" @ %result;
  429.    
  430.     return %result;
  431. }
  432.  
  433. // Modulus
  434. function Math::mod(%number, %mod)
  435. {
  436.     if (Math.secure)
  437.     {
  438.         %number = filterString(%number, "0123456789-");
  439.         %mod = filterString(%mod, "0123456789-");
  440.     }
  441.     %take = 5;
  442.     %result = "";
  443.    
  444.     // Calculate modulus
  445.     %size = strlen(%number);
  446.     for (%i = 0; %i < %size; %i += %take)
  447.     {
  448.         %a = %result @ getSubStr(%number, %i, %take);
  449.         %result = %a % %mod;
  450.     }
  451.    
  452.     return %result;
  453. }
  454.  
  455. // Power of
  456. function Math::pow(%number, %pow)
  457. {
  458.     if (Math.secure)
  459.     {
  460.         %number = filterString(%number, "0123456789-");
  461.         %pow = filterString(%pow, "0123456789-");
  462.     }
  463.     if (%pow $= "0" || getSubStr(%pow, 0, 1) $= "-")
  464.         return "1";
  465.     // Do-while, Old-school power with multiplication
  466.     %result = %number;
  467.     %pow = Math::sub(%pow, "1");
  468.     while (%pow !$= "0")
  469.     {
  470.         %result = Math::mul(%result, %number);
  471.         %pow = Math::sub(%pow, "1");
  472.     }
  473.     return %result;
  474. }
  475.  
  476. // Shift a number left or right
  477. function Math::shift(%num, %shift)
  478. {
  479.     if (Math.secure)
  480.     {
  481.         %num = filterString(%num, "0123456789-");
  482.         %shift = filterString(%shift, "0123456789-");
  483.     }
  484.     // No changes
  485.     if (%shift $= "0")
  486.         return %num;
  487.     // Slow, but works
  488.     if (getSubStr(%shfit, 0, 1) $= "-")
  489.         return Math::div(%num, Math::pow("2", Math::sub(%shift, "1")));
  490.     else
  491.         return Math::mul(%num, Math::pow("2", Math::sub(%shift, "1")));
  492. }
  493.  
  494. // Base converstion
  495. function Math::base(%number, %base)
  496. {
  497.     // Invalid base
  498.     if (%base <= 1)
  499.         return %number;
  500.     // Character base
  501.     if (%base <= 64)
  502.     {
  503.         %string = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
  504.     }
  505.     // Binary base
  506.     else
  507.     {
  508.         //warn("Math::base - Base too large");
  509.         //return %number;
  510.         for (%i = 0; %i < 256; %i++)
  511.             %string = %string @ chr(%i);
  512.     }
  513.     %base = getSubStr(%string, 0, %base);
  514.     if (Math.secure)
  515.         %number = filterString(%number, %base);
  516.     return Math::base2dec(%number, %base);
  517. }
  518.  
  519. // Decimal conversion
  520. function Math::dec(%number, %base)
  521. {
  522.     // Invalid base
  523.     if (%base <= 1)
  524.         return %number;
  525.     // Character base
  526.     if (%base <= 64)
  527.     {
  528.         %string = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_";
  529.     }
  530.     // Binary base
  531.     else
  532.     {
  533.         //warn("Math::base - Base too large");
  534.         //return %number;
  535.         for (%i = 0; %i < 256; %i++)
  536.             %string = %string @ chr(%i);
  537.     }
  538.     if (Math.secure)
  539.         %number = filterString(%number, "0123456789");
  540.     return Math::dec2base(%number, getSubStr(%string, 0, %base));
  541. }
  542.  
  543. // Decimal to base conversion
  544. function Math::dec2base(%num, %digits)
  545. {
  546.     if (Math.secure)
  547.         %num = filterString(%num, "0123456789");
  548.    
  549.     %size = strlen(%num);
  550.     %base = strlen(%digits);
  551.     %result = "";
  552.    
  553.     // Calculate character through number
  554.     while (%num > %base-1)
  555.     {
  556.         %rest = Math::mod(%num, %base);
  557.         %num = Math::div(%num, %base);
  558.         %result = getSubStr(%digits, %rest, 1) @ %result;
  559.     }
  560.     %result = getSubStr(%digits, %num, 1) @ %result;
  561.     return %result;
  562. }
  563.  
  564. // Base to decimal conversion
  565. function Math::base2dec(%num, %digits)
  566. {
  567.     if (Math.secure)
  568.         %num = filterString(%num, %digits);
  569.    
  570.     %size = strlen(%num);
  571.     %base = strlen(%digits);
  572.     %result = "0";
  573.    
  574.     // Calculate number through character
  575.     for (%i = 0; %i < %size; %i++)
  576.     {
  577.         %element = strpos(%digits, getSubStr(%num, %i, 1));
  578.         %power = Math::pow(%base, %size-%i-1);
  579.         %result = Math::add(%result, Math::mul(%element, %power));
  580.     }
  581.    
  582.     return %result;
  583. }
  584.  
  585. // Create namespace object
  586. if (!isObject(Math))
  587. {
  588.     new ScriptObject(Math);
  589. }
  590.  
  591. // Convert number to character
  592. function chr(%n)
  593. {
  594.     %n = Math::dec2base(%n, "0123456789ABCDEF");
  595.     if (strlen(%n) < 2)
  596.         %n = "0" @ %n;
  597.     return eval("%z = \"\\x" @ %n @ "\";");
  598. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!