git.sesse.net Git - vlc/blob - modules/visualization/galaktos/builtin_funcs.c

   1 /*****************************************************************************
   2  * builtin_funcs.c:
   3  *****************************************************************************
   4  * Copyright (C) 2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Cyril Deguet <asmax@videolan.org>
   8  *          code from projectM http://xmms-projectm.sourceforge.net
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25
  26 #include <math.h>
  27 /* Values to optimize the sigmoid function */
  28 #define R  32767
  29 #define RR 65534
  30
  31 inline double int_wrapper(double * arg_list) {
  32
  33   return floor(arg_list[0]);
  34
  35 }
  36
  37
  38 inline double sqr_wrapper(double * arg_list) {
  39
  40     return pow(2, arg_list[0]);
  41 }
  42
  43
  44 inline double sign_wrapper(double * arg_list) {
  45
  46     return -arg_list[0];
  47 }
  48
  49 inline double min_wrapper(double * arg_list) {
  50
  51     if (arg_list[0] > arg_list[1])
  52         return arg_list[1];
  53
  54     return arg_list[0];
  55 }
  56
  57 inline double max_wrapper(double * arg_list) {
  58
  59     if (arg_list[0] > arg_list[1])
  60       return arg_list[0];
  61
  62     return arg_list[1];
  63 }
  64
  65 /* consult your AI book */
  66 inline double sigmoid_wrapper(double * arg_list) {
  67   return (RR / (1 + exp( -(((double)(arg_list[0])) * arg_list[1]) / R) - R));
  68 }
  69
  70
  71 inline double bor_wrapper(double * arg_list) {
  72
  73     return (double)((int)arg_list[0] || (int)arg_list[1]);
  74 }
  75
  76 inline double band_wrapper(double * arg_list) {
  77     return (double)((int)arg_list[0] && (int)arg_list[1]);
  78 }
  79
  80 inline double bnot_wrapper(double * arg_list) {
  81     return (double)(!(int)arg_list[0]);
  82 }
  83
  84 inline double if_wrapper(double * arg_list) {
  85
  86         if ((int)arg_list[0] == 0)
  87             return arg_list[2];
  88         return arg_list[1];
  89 }
  90
  91
  92 inline double rand_wrapper(double * arg_list) {
  93   double l;
  94
  95   //  printf("RAND ARG:(%d)\n", (int)arg_list[0]);
  96   l = (double)((rand()) % ((int)arg_list[0]));
  97   //printf("VAL: %f\n", l);
  98   return l;
  99 }
 100
 101 inline double equal_wrapper(double * arg_list) {
 102
 103     return (arg_list[0] == arg_list[1]);
 104 }
 105
 106
 107 inline double above_wrapper(double * arg_list) {
 108
 109     return (arg_list[0] > arg_list[1]);
 110 }
 111
 112
 113 inline double below_wrapper(double * arg_list) {
 114
 115     return (arg_list[0] < arg_list[1]);
 116 }
 117
 118 inline double sin_wrapper(double * arg_list) {
 119     return (sin (arg_list[0]));
 120 }
 121
 122
 123 inline double cos_wrapper(double * arg_list) {
 124     return (cos (arg_list[0]));
 125 }
 126
 127 inline double tan_wrapper(double * arg_list) {
 128     return (tan(arg_list[0]));
 129 }
 130
 131 inline double asin_wrapper(double * arg_list) {
 132     return (asin (arg_list[0]));
 133 }
 134
 135 inline double acos_wrapper(double * arg_list) {
 136     return (acos (arg_list[0]));
 137 }
 138
 139 inline double atan_wrapper(double * arg_list) {
 140     return (atan (arg_list[0]));
 141 }
 142
 143 inline double atan2_wrapper(double * arg_list) {
 144   return (atan2 (arg_list[0], arg_list[1]));
 145 }
 146
 147 inline double pow_wrapper(double * arg_list) {
 148   return (pow (arg_list[0], arg_list[1]));
 149 }
 150
 151 inline double exp_wrapper(double * arg_list) {
 152   return (exp(arg_list[0]));
 153 }
 154
 155 inline double abs_wrapper(double * arg_list) {
 156   return (fabs(arg_list[0]));
 157 }
 158
 159 inline double log_wrapper(double *arg_list) {
 160   return (log (arg_list[0]));
 161 }
 162
 163 inline double log10_wrapper(double * arg_list) {
 164   return (log10 (arg_list[0]));
 165 }
 166
 167 inline double sqrt_wrapper(double * arg_list) {
 168   return (sqrt (arg_list[0]));
 169 }
 170
 171
 172 inline double nchoosek_wrapper(double * arg_list) {
 173       unsigned long cnm = 1UL;
 174       int i, f;
 175       int n, m;
 176
 177       n = (int)arg_list[0];
 178       m = (int)arg_list[1];
 179
 180       if (m*2 >n) m = n-m;
 181       for (i=1 ; i <= m; n--, i++)
 182       {
 183             if ((f=n) % i == 0)
 184                   f   /= i;
 185             else  cnm /= i;
 186             cnm *= f;
 187       }
 188       return (double)cnm;
 189 }
 190
 191
 192 inline double fact_wrapper(double * arg_list) {
 193
 194
 195   int result = 1;
 196
 197   int n = (int)arg_list[0];
 198
 199   while (n > 1) {
 200     result = result * n;
 201     n--;
 202   }
 203   return (double)result;
 204 }