JAVASCRIPT   11

math.js

Guest on 26th May 2021 11:00:10 PM

  1. var   UTL_PID180                                      = Math.PI / 180;
  2. var   UTL_180DPI                                = 180 / Math.PI;
  3.  
  4. function math_getSpheresCollisionBOOL(vct0, vct1){
  5.       var xdiff               = vct0.x - vct1.x;
  6.       var ydiff               = vct0.y - vct1.y;
  7.       var d                   = Math.sqrt(xdiff * xdiff + ydiff * ydiff);
  8.       return d <= (vct0.r + vct1.r);
  9. }
  10.  
  11. function math_deg2Rad(deg){
  12.       return deg * UTL_PID180;
  13. }
  14.  
  15. function math_rad2Deg(rad){
  16.       return rad * UTL_180DPI;
  17. }
  18.  
  19. function math_dotproduct2D(v1, v2){
  20.       return ((v1.x * v2.x) + (v1.y * v2.y));
  21. }          
  22.  
  23. function math_normalize2D(vct){
  24.       var mag                                         = Math.sqrt((vct.x * vct.x) + (vct.y * vct.y));
  25.       if (mag == 0){
  26.             mag = 1;
  27.       }
  28.      
  29.       vct.x                                           /= mag;
  30.       vct.y                                           /= mag;
  31.       return vct;
  32. }          
  33.  
  34. function math_closestPointOnLine(p1, p2, pt){
  35.       var vct1;
  36.       var vct2;
  37.       var vct3;
  38.      
  39.       vct1.x                                          = pt.x - p1.x;
  40.       vct1.y                                          = pt.y - p1.y;
  41.      
  42.       vct2.x                                          = p2.x - p1.x;
  43.       vct2.y                                          = p2.y - p1.y;
  44.      
  45.       vct2                                      = math_normalize2D(vct2);
  46.      
  47.       var d                                     = Math.sqrt((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
  48.      
  49.       var bounds                                = math_dotproduct2D(vct2, vct1);
  50.      
  51.       if (bounds <= 0){
  52.             return p1;
  53.       }
  54.      
  55.       if (bounds >= d){
  56.             return p2;
  57.       }
  58.      
  59.       vct3.x                                          = p1.x + vct2.x * bounds;
  60.       vct3.y                                          = p1.y + vct2.y * bounds;
  61.      
  62.       return vct3;
  63. }          
  64.  
  65. function math_buildRGB(r, g, b){
  66.       return (b | (g << 8) | (r << 16));
  67. }
  68.  
  69. function math_splitRGB(rgb){
  70.       var srgb;
  71.      
  72.       srgb.b                                    = (rgb % 256);
  73.       srgb.g                                    = (rgb & -16711936) / 256;
  74.       srgb.r                                    = (rgb & 16711680 ) / 65536;
  75.      
  76.       return srgb;
  77. }          
  78.  
  79. function math_randRange(min, max){
  80.       return Math.floor(Math.random() * (max - min + 1)) + min;
  81. }
  82.  
  83. function math_getDirMC2D(from, to){
  84.       var dir
  85.       dir.x                                     = to.x - from.x;
  86.       dir.y                                     = to.y - from.y;
  87.      
  88.       var mag                                   = Math.sqrt((dir.x * dir.x) + (dir.y * dir.y));
  89.       if (mag == 0)
  90.       {
  91.             mag = 1;
  92.       }
  93.      
  94.       dir.x                                     /= mag;
  95.       dir.y                                     /= mag;
  96.      
  97.       return dir;
  98. }
  99.  
  100. function math_angleBTWlines2D(commonPoint, lineEnd1, lineEnd2){
  101.       var v1;
  102.       var v2;
  103.      
  104.       v1.x                                = lineEnd1.x - commonPoint.x;
  105.       v1.y                                = lineEnd1.y - commonPoint.y;
  106.      
  107.       v2.x                                = lineEnd2.x - commonPoint.x;
  108.       v2.y                                = lineEnd2.y - commonPoint.y;
  109.      
  110.       return math_angleBTWvectors2D(v1, v2);
  111. }
  112.  
  113. function math_angleBTWvectors2D(v1, v2){
  114.       var dot                             = ((v1.x * v2.x) + (v1.y * v2.y));
  115.       var mag1                            = Math.sqrt((v1.x * v1.x) + (v1.y * v1.y));
  116.       var mag2                            = Math.sqrt((v2.x * v2.x) + (v2.y * v2.y));
  117.       var magMul                          = mag1 * mag2;
  118.       var ang                                   = Math.acos(dot / magMul);
  119.       if ( isNaN(ang))
  120.       {
  121.             return 0;
  122.       }
  123.      
  124.       return ang;
  125. }
  126.  
  127.  
  128. function math_crossProduct2D(vct1, vct2){
  129.       var pRet;
  130.      
  131.       pRet.x                                    = (vct1.y * 1) - (1 * vct2.y);
  132.       pRet.y                                    = (1 * vct2.x) - (vct1.x * 1);
  133.      
  134.       return pRet;
  135. }
  136.  
  137. function math_randRange(min, max){
  138.       return Math.floor(Math.random() * (max - min + 1)) + min;
  139. }
  140.  
  141. function math_clamp(THETA_MIN, THETA_MAX, LOW_LIMIT, HIGH_LIMIT, THETA){     
  142.       var theta                           = 1/(THETA_MAX-THETA_MIN) * (THETA - THETA_MIN);
  143.       if(theta > 1){ return HIGH_LIMIT; }
  144.       if(theta < 0){ return LOW_LIMIT; }
  145.       return LOW_LIMIT + (HIGH_LIMIT - LOW_LIMIT) * theta;
  146. }
  147.  
  148. function math_quantomize(array){
  149.       var len                             = array.length;
  150.      
  151.       var a                               = 0;
  152.       var b                               = 0;
  153.       var temp;
  154.      
  155.       for (var i = 0; i<array.length; i++)
  156.       {
  157.            
  158.             a                             = Math.floor(Math.random()*len);
  159.             b                             = Math.floor(Math.random()*len);
  160.            
  161.             temp                          = array[a];
  162.             array[a]                      = array[b];
  163.             array[b]                      = temp;
  164.       }
  165. }
  166.  
  167. function math_rotatePoint(vct, ang){
  168.       var o
  169.       o.x                                 = vct.x * Math.cos(ang) - vct.y * Math.sin(ang);
  170.       o.y                                 = vct.y * Math.cos(ang) + vct.x * Math.sin(ang);
  171.       return o
  172. }
  173.  
  174. var aGAUSS                                = new Array();
  175. aGAUSS[0]                                 = {x:  0.285561, y:  0.188437};
  176. aGAUSS[1]                                 = {x:  0.360176, y: -0.065688};
  177. aGAUSS[2]                                 = {x: -0.111751, y:  0.275019};
  178. aGAUSS[3]                                 = {x: -0.055918, y: -0.215197};
  179. aGAUSS[4]                                 = {x: -0.080231, y: -0.470965};
  180. aGAUSS[5]                                 = {x:  0.138721, y:  0.409168};
  181. aGAUSS[6]                                 = {x:  0.384120, y:  0.458500};
  182. aGAUSS[7]                                 = {x: -0.454968, y:  0.134088};
  183. aGAUSS[8]                                 = {x:  0.179271, y: -0.331196};
  184. aGAUSS[9]                                 = {x: -0.307049, y: -0.364927};
  185. aGAUSS[10]                                = {x:  0.105354, y: -0.010099};
  186. aGAUSS[11]                                = {x: -0.154180, y:  0.021794};
  187. aGAUSS[12]                                = {x: -0.370135, y: -0.116425};
  188. aGAUSS[13]                                = {x:  0.451636, y: -0.300013};
  189. aGAUSS[14]                                = {x: -0.370610, y:  0.387504};
  190.  
  191. function math_getGauss(){
  192.       return aGAUSS[math_randRange(0, 14)];

Raw Paste


Login or Register to edit or fork this paste. It's free.