File: ca.sh
   1 #!/bin/sh
   2 
   3 # The MIT License (MIT)
   4 #
   5 # Copyright © 2024 pacman64
   6 #
   7 # Permission is hereby granted, free of charge, to any person obtaining a copy
   8 # of this software and associated documentation files (the “Software”), to deal
   9 # in the Software without restriction, including without limitation the rights
  10 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 # copies of the Software, and to permit persons to whom the Software is
  12 # furnished to do so, subject to the following conditions:
  13 #
  14 # The above copyright notice and this permission notice shall be included in
  15 # all copies or substantial portions of the Software.
  16 #
  17 # THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23 # SOFTWARE.
  24 
  25 
  26 # ca [expression]
  27 #
  28 # CAlculator is an easier-to-use version of bc (basic calculator) where
  29 #
  30 #   - you give the expression as an argument, while bc reads it from stdin
  31 #   - you can use either ** or ^ to raise powers
  32 #   - you can use [ and ] or ( and ) interchangeably
  33 #   - the number of decimals is 6 by default
  34 #   - automatically includes the extended bc math library via option -l
  35 #   - there are several extra predefined values and functions (see below)
  36 #
  37 #
  38 # Predefined functions and values, besides the ones `bc` already comes with
  39 #
  40 #
  41 # nano   a billionth
  42 # micro  a millionth
  43 # milli  a thousandth
  44 #
  45 # kilo   1000
  46 # mega   a million
  47 # giga   a billion
  48 # tera   a thousand billion / trillion
  49 # peta   a million billion / quadrillion
  50 # exa    a quintillion
  51 # zetta  a sixtillion
  52 #
  53 # binkilo   1024
  54 # binmega   1024 * 1024
  55 # bingiga   1024 * 1024 * 1024
  56 # bintera   1024 * 1024 * 1024 * 1024
  57 # binpeta   1024 * 1024 * 1024 * 1024 * 1024
  58 # binexa    1024 * 1024 * 1024 * 1024 * 1024 * 1024
  59 # binzetta  1024 * 1024 * 1024 * 1024 * 1024 * 1024
  60 #
  61 # kb  1024
  62 # mb  1024 * 1024
  63 # gb  1024 * 1024 * 1024
  64 # tb  1024 * 1024 * 1024 * 1024
  65 # pb  1024 * 1024 * 1024 * 1024 * 1024
  66 #
  67 # kib  1024
  68 # mib  1024 * 1024
  69 # gib  1024 * 1024 * 1024
  70 # tib  1024 * 1024 * 1024 * 1024
  71 # pib  1024 * 1024 * 1024 * 1024 * 1024
  72 #
  73 # mol      1 mole, the exact avogadro number
  74 # mole     the exact avogadro number
  75 #
  76 # cup2l    liters in 1 cup
  77 # floz2ml  milliliters in 1 fluid ounce
  78 # gal2l    liters in 1 gallon
  79 # in2cm    centimeters in 1 inch
  80 # lb2kg    kilograms in 1 pound
  81 # mi2km    kilometers in 1 mile
  82 # mpg2kpl  kilometers per liter in 1 mile per gallon
  83 # nmi2km   kilometers in 1 nautical mile
  84 # oz2g     grams in 1 weight ounce
  85 # psi2pa   pascals in 1 pound per square-inch
  86 # ton2kg   kilograms in 1 american ton
  87 # yd2m     meters in 1 yard
  88 #
  89 # eu()          approximate Euler's number
  90 # pi()          approximate any circle's circumference/diameter ratio
  91 # tau()         2*pi; approximate any circle's circumference/radius ratio
  92 # abs(x)        the absolute value function
  93 # cbrt(x)       the cube root function
  94 # exp(x)        the exponential function; alias for bc's e
  95 # ln(x)         natural logarithm; an alias for bc's l
  96 # log(x)        natural logarithm; an alias for bc's l
  97 # log2(x)       base-2 logarithm
  98 # log10(x)      base-10 logarithm
  99 # sin(x)        the sine
 100 # cos(x)        the cosine
 101 # atan(x)       the arc-tangent
 102 # hypot(x, y)   length of the hypothenuse
 103 # mod(x, y)     modulus function, which is different from the % operator
 104 # round0(x)     round to integer
 105 # round1(x)     round to 1 decimal place
 106 # ...
 107 # round20(x)    round to 20 decimal places
 108 # round(x, d)   round to the given number of decimal digits; can be negative
 109 # fac(x)        factorial
 110 # com(n, k)     number of combinations
 111 # comb(n, k)    number of combinations
 112 # per(n, k)     number of permutations
 113 # perm(n, k)    number of permutations
 114 # lcm(x, y)     least-common multiple
 115 # gcd(x, y)     greatest-common divisor
 116 # min(x, y)     the minimum of 2 numbers
 117 # max(x, y)     the maximum of 2 numbers
 118 # isprime(x)    check if number is prime
 119 # lgamma(x)     lanczos approximation of the log-gamma function
 120 # lbeta(x, y)   lanczos approximation of the log-beta function
 121 # gamma(x)      approximation of the gamma function
 122 # beta(x)       approximation of the beta function
 123 # logistic(x)   the logistic function
 124 # mix(x, y, k)  interpolate 2 numbers; extrapolates when k is outside [0, 1]
 125 # clamp(x, min, max)  trap a number in the range given
 126 # wrap(x, min, max)  normalize a number in the range given
 127 
 128 
 129 # handle help options
 130 case "$1" in
 131     -h|--h|-help|--help)
 132         # show help message, extracting the info-comment at the start
 133         # of this file, and quit
 134         awk '/^# +ca/, /^$/ { gsub(/^# ?/, ""); print }' "$0"
 135         exit 0
 136     ;;
 137 esac
 138 
 139 (
 140 
 141 # ensure output is all on 1 line, define several funcs and values, then
 142 # inject the expression given as this script's arguments, transformed
 143 # according to the rules described above
 144 BC_LINE_LENGTH=0 bc -l << ENDOFSCRIPT
 145 scale = 20;
 146 
 147 femto = 0.000000000000001;
 148 pico = 0.000000000001;
 149 nano = 0.000000001;
 150 micro = 0.000001;
 151 milli = 0.001;
 152 
 153 kilo = 1000;
 154 mega = 1000 * kilo;
 155 giga = 1000 * mega;
 156 tera = 1000 * giga;
 157 peta = 1000 * tera;
 158 exa =  1000 * peta;
 159 zetta =  1000 * exa;
 160 
 161 binkilo = 1024;
 162 binmega = 1024 * binkilo;
 163 bingiga = 1024 * binmega;
 164 bintera = 1024 * bingiga;
 165 binpeta = 1024 * bintera;
 166 binexa = 1024 * binpeta;
 167 binzetta = 1024 * binexa;
 168 
 169 kb = 1024;
 170 mb = 1024 * kb;
 171 gb = 1024 * mb;
 172 tb = 1024 * gb;
 173 pb = 1024 * tb;
 174 eb = 1024 * pb;
 175 zb = 1024 * eb;
 176 
 177 kib = 1024;
 178 mib = 1024 * kib;
 179 gib = 1024 * mib;
 180 tib = 1024 * gib;
 181 pib = 1024 * tib;
 182 zib = 1024 * pib;
 183 
 184 mol = 602214076000000000000000;
 185 mole = 602214076000000000000000;
 186 
 187 cup2l = 0.23658824;
 188 floz2ml = 29.5735295625;
 189 ft2mt = 0.3048;
 190 gal2l = 3.785411784;
 191 in2cm = 2.54;
 192 lb2kg = 0.45359237;
 193 mi2km = 1.609344;
 194 mpg2kpl = 0.425143707;
 195 nmi2km = 1.852;
 196 oz2g = 28.349523125
 197 psi2pa = 6894.757293168;
 198 ton2kg = 907.18474;
 199 yd2m = 0.9144;
 200 
 201 ft2mt = ft2m;
 202 ga2l = gal2l;
 203 ga2lt = gal2l;
 204 gal2lt = gal2l;
 205 lb2k = lb2kg;
 206 nm2km = nmi2km;
 207 tn2kg = ton2kg;
 208 yd2mt = yd2m;
 209 
 210 hour = 3600;
 211 day = 24 * hour;
 212 week = 7 * day;
 213 
 214 hr = hour;
 215 wk = week;
 216 
 217 define eu() { return e(1); }
 218 define pi() { return 4*a(1); }
 219 define tau() { return 8*a(1); }
 220 
 221 define deg(x) { return 180 * x / pi(); }
 222 define rad(x) { return pi() * x / 180; }
 223 
 224 define abs(x) { if (x >= 0) return x else return -x; }
 225 define cbrt(x) { return x^(1/3); }
 226 define exp(x) { return e(x); }
 227 define ln(x) { return l(x); }
 228 # define log(base, x) { return l(x) / l(base); }
 229 define log(x) { return l(x); }
 230 define log2(x) { return l(x) / l(2); }
 231 define log10(x) { return l(x) / l(10); }
 232 
 233 define sin(x) { return s(x); }
 234 define cos(x) { return c(x); }
 235 define tan(x) { return s(x) / c(x); }
 236 define cot(x) { return c(x) / s(x); }
 237 define atan(x) { return a(x); }
 238 define sinh(x) { return (e(x) - e(-x)) / 2; }
 239 define cosh(x) { return (e(x) + e(-x)) / 2; }
 240 define tanh(x) { return (e(x) - e(-x)) / (e(x) + e(-x)); }
 241 define coth(x) { return (e(x) + e(-x)) / (e(x) - e(-x)); }
 242 define hypot(x, y) { return sqrt(x*x + y*y); }
 243 define sinc(x) { if (x == 0) return 1 else return s(x) / x; }
 244 
 245 define min(x, y) { if (x <= y) return x else return y; }
 246 define max(x, y) { if (x >= y) return x else return y; }
 247 
 248 define mod(x, y) {
 249     auto s, m;
 250     s = scale;
 251     scale = 0;
 252     m = x % y;
 253     scale = s;
 254     return m;
 255 }
 256 
 257 define round0(x) {
 258     auto i;
 259     i = x - mod(x, 1);
 260     if (x - i >= 0.5) {
 261         return i + 1;
 262     }
 263     return i;
 264 }
 265 
 266 define round(x, d) {
 267     auto k;
 268     k = 10^d;
 269     return round0(x * k) / k;
 270 }
 271 
 272 define round1(x) { return round(x, 1); }
 273 define round2(x) { return round(x, 2); }
 274 define round3(x) { return round(x, 3); }
 275 define round4(x) { return round(x, 4); }
 276 define round5(x) { return round(x, 5); }
 277 define round6(x) { return round(x, 6); }
 278 define round7(x) { return round(x, 7); }
 279 define round8(x) { return round(x, 8); }
 280 define round9(x) { return round(x, 9); }
 281 define round10(x) { return round(x, 10); }
 282 define round11(x) { return round(x, 11); }
 283 define round12(x) { return round(x, 12); }
 284 define round13(x) { return round(x, 13); }
 285 define round14(x) { return round(x, 14); }
 286 define round15(x) { return round(x, 15); }
 287 define round16(x) { return round(x, 16); }
 288 define round17(x) { return round(x, 17); }
 289 define round18(x) { return round(x, 18); }
 290 define round19(x) { return round(x, 19); }
 291 define round20(x) { return round(x, 20); }
 292 
 293 define fac(x) {
 294     auto y;
 295     if (x < 0) {
 296         return 0;
 297     }
 298     y = 1;
 299     for (i = 2; i <= x; i++) {
 300         y *= i;
 301     }
 302     return y;
 303 }
 304 
 305 define per(n, k) {
 306     auto p;
 307     if (n < k) {
 308         return 0;
 309     }
 310     p = 1;
 311     for (i = k + 1; i <= n; i++) {
 312         p *= i;
 313     }
 314     return p;
 315 }
 316 
 317 define perm(n, k) { return per(n, k); }
 318 
 319 define com(n, k) { if (n < k) return 0 else return per(n, k) / fac(k); }
 320 define comb(n, k) { return com(n, k); }
 321 define gcd(x, y) { return x * y / lcm(x, y); }
 322 
 323 define lcm(x, y) {
 324     auto a, b;
 325 
 326     /* the LCM is defined only for positive integers */
 327     if (mod(x, 1) != 0 || x < 1 || mod(y, 1) != 0 || y < 1) {
 328         return 0;
 329     }
 330 
 331     a = min(x, y);
 332     b = max(x, y);
 333 
 334     z = b;
 335     while (mod(z, a) != 0) {
 336         z += b;
 337     }
 338     return z;
 339 }
 340 
 341 define isprime(n) {
 342     auto div;
 343 
 344     if (mod(n, 1) != 0 || n < 2) {
 345         return 0;
 346     }
 347 
 348     /* 2 is the only even prime number */
 349     if (mod(n, 2) == 0) {
 350         return n == 2;
 351     }
 352 
 353     /*
 354         even numbers have already been handled, so only odd numbers
 355         make it here: only check up to the square-root, so the loop
 356         has O(n**1.5) time-complexity
 357     */
 358     for (div = 3; div <= sqrt(n); div += 2) {
 359         if (mod(n, div) == 0) {
 360             return 0;
 361         }
 362     }
 363     return 1;
 364 }
 365 
 366 /*
 367 I adapted an implementation of Lanczos' log-gamma approximation I found at
 368 http://introcs.cs.princeton.edu/java/91float/Gamma.java.html
 369 */
 370 define lgamma(x) {
 371     auto tmp, a, b, c, d;
 372     tmp = (x - 0.5) * l(x + 4.5) - (x + 4.5);
 373     a = 76.18009173 / (x + 0) - 86.50532033 / (x + 1);
 374     b = 24.01409822 / (x + 2) - 1.231739516 / (x + 3);
 375     c = 0.00120858003 / (x + 4) - 0.00000536382 / (x + 5);
 376     d = sqrt(2 * 3.14159265358979323844);
 377     #d = sqrt(2 * pi());
 378     return tmp + l((1.0 + a + b + c) * d);
 379 }
 380 
 381 define lbeta(x, y) { return lgamma(x) + lgamma(y) - lgamma(x + y); }
 382 
 383 define gamma(x) { return e(lgamma(x)); }
 384 define beta(x, y) { return e(lbeta(x, y)); }
 385 define logistic(x) { return 1 / (1 + e(-x)); }
 386 
 387 define mix(x, y, k) { return x + (1 - k) * (y - x); }
 388 define clamp(x, min, max) { return max(min(max, x), min); }
 389 define wrap(x, min, max) { return (x - min) / (max - min); }
 390 define unwrap(x, min, max) { return (max - min) * x + min; }
 391 
 392 $(echo "$@" | sed 's/^+//g; s/_//g; s/\*\*/^/g; s/\[/(/g; s/\]/)/g')
 393 ENDOFSCRIPT
 394 
 395 # ensure the result shows at least a zero before the decimal dot, then
 396 # rid the result of trailing zero decimals and/or trailing decimal dots
 397 ) | sed -E 's/^\./0./; s/^-\./-0./; s/(\.[0-9]+[1-9]+)0+$/\1/; s/\.0*$//'