Rename a few parameters and locals named x, y, z

[xonotic/xonotic-data.pk3dir.git] / qcsrc / lib / math.qh

diff --git a/qcsrc/lib/math.qh b/qcsrc/lib/math.qh
index 24d004166cfd4bec600b102eb50a9198757e5e58..92d45bf142573663919fcfe5b6f93f09dc2a8f16 100644 (file)
--- a/qcsrc/lib/math.qh
+++ b/qcsrc/lib/math.qh
@@ -1,5 +1,4 @@
-#ifndef MATH_H
-#define MATH_H
+#pragma once
 
 void mean_accumulate(entity e, .float a, .float c, float mean, float value, float weight)
 {
@@ -16,8 +15,8 @@ float mean_evaluate(entity e, .float a, .float c, float mean)
        else return pow(e.(a) / e.(c), 1.0 / mean);
 }
 
-#define MEAN_ACCUMULATE(prefix, v, w) mean_accumulate(self, prefix##_accumulator, prefix##_count, prefix##_mean, v, w)
-#define MEAN_EVALUATE(prefix) mean_evaluate(self, prefix##_accumulator, prefix##_count, prefix##_mean)
+#define MEAN_ACCUMULATE(s, prefix, v, w) mean_accumulate(s, prefix##_accumulator, prefix##_count, prefix##_mean, v, w)
+#define MEAN_EVALUATE(s, prefix) mean_evaluate(s, prefix##_accumulator, prefix##_count, prefix##_mean)
 #define MEAN_DECLARE(prefix, m) float prefix##_mean = m; .float prefix##_count, prefix##_accumulator
 
 /** Returns a random number between -1.0 and 1.0 */
@@ -83,12 +82,12 @@ vector bezier_quadratic_getderivative(vector a, vector b, vector c, float t)
               + (b - a) * 2;
 }
 
-float cubic_speedfunc(float startspeedfactor, float endspeedfactor, float x)
+float cubic_speedfunc(float startspeedfactor, float endspeedfactor, float spd)
 {
        return (((startspeedfactor + endspeedfactor - 2
-                ) * x - 2 * startspeedfactor - endspeedfactor + 3
-               ) * x + startspeedfactor
-              ) * x;
+                ) * spd - 2 * startspeedfactor - endspeedfactor + 3
+               ) * spd + startspeedfactor
+              ) * spd;
 }
 
 bool cubic_speedfunc_is_sane(float startspeedfactor, float endspeedfactor)
@@ -184,61 +183,118 @@ float almost_in_bounds(float a, float b, float c)
        return b == median(a - eps, b, c + eps);
 }
 
+float ExponentialFalloff(float mindist, float maxdist, float halflifedist, float d)
+{
+       if (halflifedist > 0) return pow(0.5, (bound(mindist, d, maxdist) - mindist) / halflifedist);
+       else if (halflifedist < 0) return pow(0.5, (bound(mindist, d, maxdist) - maxdist) / halflifedist);
+       else return 1;
+}
+
 float power2of(float e)
 {
        return pow(2, e);
 }
 
-float log2of(float x)
+float log2of(float e)
 {
        // NOTE: generated code
-       if (x > 2048)
-               if (x > 131072)
-                       if (x > 1048576)
-                               if (x > 4194304) return 23;
+       if (e > 2048)
+               if (e > 131072)
+                       if (e > 1048576)
+                               if (e > 4194304) return 23;
                                else
-                                       if (x > 2097152) return 22;
+                                       if (e > 2097152) return 22;
                                        else return 21;
                        else
-                               if (x > 524288) return 20;
+                               if (e > 524288) return 20;
                                else
-                                       if (x > 262144) return 19;
+                                       if (e > 262144) return 19;
                                        else return 18;
                else
-                       if (x > 16384)
-                               if (x > 65536) return 17;
+                       if (e > 16384)
+                               if (e > 65536) return 17;
                                else
-                                       if (x > 32768) return 16;
+                                       if (e > 32768) return 16;
                                        else return 15;
                        else
-                               if (x > 8192) return 14;
+                               if (e > 8192) return 14;
                                else
-                                       if (x > 4096) return 13;
+                                       if (e > 4096) return 13;
                                        else return 12;
        else
-               if (x > 32)
-                       if (x > 256)
-                               if (x > 1024) return 11;
+               if (e > 32)
+                       if (e > 256)
+                               if (e > 1024) return 11;
                                else
-                                       if (x > 512) return 10;
+                                       if (e > 512) return 10;
                                        else return 9;
                        else
-                               if (x > 128) return 8;
+                               if (e > 128) return 8;
                                else
-                                       if (x > 64) return 7;
+                                       if (e > 64) return 7;
                                        else return 6;
                else
-                       if (x > 4)
-                               if (x > 16) return 5;
+                       if (e > 4)
+                               if (e > 16) return 5;
                                else
-                                       if (x > 8) return 4;
+                                       if (e > 8) return 4;
                                        else return 3;
                        else
-                               if (x > 2) return 2;
+                               if (e > 2) return 2;
                                else
-                                       if (x > 1) return 1;
+                                       if (e > 1) return 1;
                                        else return 0;
 }
 
-
-#endif
+/** ax^2 + bx + c = 0 */
+vector solve_quadratic(float a, float b, float c)
+{
+       vector v;
+       float D;
+       v = '0 0 0';
+       if (a == 0)
+       {
+               if (b != 0)
+               {
+                       v.x = v.y = -c / b;
+                       v.z = 1;
+               }
+               else
+               {
+                       if (c == 0)
+                       {
+                               // actually, every number solves the equation!
+                               v.z = 1;
+                       }
+               }
+       }
+       else
+       {
+               D = b * b - 4 * a * c;
+               if (D >= 0)
+               {
+                       D = sqrt(D);
+                       if (a > 0)  // put the smaller solution first
+                       {
+                               v.x = ((-b) - D) / (2 * a);
+                               v.y = ((-b) + D) / (2 * a);
+                       }
+                       else
+                       {
+                               v.x = (-b + D) / (2 * a);
+                               v.y = (-b - D) / (2 * a);
+                       }
+                       v.z = 1;
+               }
+               else
+               {
+                       // complex solutions!
+                       D = sqrt(-D);
+                       v.x = -b / (2 * a);
+                       if (a > 0) v.y =  D / (2 * a);
+                       else v.y = -D / (2 * a);
+                       v.z = 0;
+               }
+       }
+       return v;
+}