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 #include <stdio.h>
  28 /* Values to optimize the sigmoid function */
  29 #define R  32767
  30 #define RR 65534
  31
  32 inline double int_wrapper(double * arg_list) {
  33
  34   return floor(arg_list[0]);
  35
  36 }
  37
  38
  39 inline double sqr_wrapper(double * arg_list) {
  40
  41         return pow(2, arg_list[0]);
  42 }
  43
  44
  45 inline double sign_wrapper(double * arg_list) {
  46
  47         return -arg_list[0];
  48 }
  49
  50 inline double min_wrapper(double * arg_list) {
  51
  52         if (arg_list[0] > arg_list[1])
  53                 return arg_list[1];
  54
  55         return arg_list[0];
  56 }
  57
  58 inline double max_wrapper(double * arg_list) {
  59
  60         if (arg_list[0] > arg_list[1])
  61           return arg_list[0];
  62
  63         return arg_list[1];
  64 }
  65
  66 /* consult your AI book */
  67 inline double sigmoid_wrapper(double * arg_list) {
  68   return (RR / (1 + exp( -(((double)(arg_list[0])) * arg_list[1]) / R) - R));
  69 }
  70
  71
  72 inline double bor_wrapper(double * arg_list) {
  73
  74         return (double)((int)arg_list[0] || (int)arg_list[1]);
  75 }
  76
  77 inline double band_wrapper(double * arg_list) {
  78         return (double)((int)arg_list[0] && (int)arg_list[1]);
  79 }
  80
  81 inline double bnot_wrapper(double * arg_list) {
  82         return (double)(!(int)arg_list[0]);
  83 }
  84
  85 inline double if_wrapper(double * arg_list) {
  86
  87                 if ((int)arg_list[0] == 0)
  88                         return arg_list[2];
  89                 return arg_list[1];
  90 }
  91
  92
  93 inline double rand_wrapper(double * arg_list) {
  94   double l;
  95
  96   //  printf("RAND ARG:(%d)\n", (int)arg_list[0]);
  97   l = (double)((rand()) % ((int)arg_list[0]));
  98   //printf("VAL: %f\n", l);
  99   return l;
 100 }
 101
 102 inline double equal_wrapper(double * arg_list) {
 103
 104         return (arg_list[0] == arg_list[1]);
 105 }
 106
 107
 108 inline double above_wrapper(double * arg_list) {
 109
 110         return (arg_list[0] > arg_list[1]);
 111 }
 112
 113
 114 inline double below_wrapper(double * arg_list) {
 115
 116         return (arg_list[0] < arg_list[1]);
 117 }
 118
 119 inline double sin_wrapper(double * arg_list) {
 120         return (sin (arg_list[0]));
 121 }
 122
 123
 124 inline double cos_wrapper(double * arg_list) {
 125         return (cos (arg_list[0]));
 126 }
 127
 128 inline double tan_wrapper(double * arg_list) {
 129         return (tan(arg_list[0]));
 130 }
 131
 132 inline double asin_wrapper(double * arg_list) {
 133         return (asin (arg_list[0]));
 134 }
 135
 136 inline double acos_wrapper(double * arg_list) {
 137         return (acos (arg_list[0]));
 138 }
 139
 140 inline double atan_wrapper(double * arg_list) {
 141         return (atan (arg_list[0]));
 142 }
 143
 144 inline double atan2_wrapper(double * arg_list) {
 145   return (atan2 (arg_list[0], arg_list[1]));
 146 }
 147
 148 inline double pow_wrapper(double * arg_list) {
 149   return (pow (arg_list[0], arg_list[1]));
 150 }
 151
 152 inline double exp_wrapper(double * arg_list) {
 153   return (exp(arg_list[0]));
 154 }
 155
 156 inline double abs_wrapper(double * arg_list) {
 157   return (fabs(arg_list[0]));
 158 }
 159
 160 inline double log_wrapper(double *arg_list) {
 161   return (log (arg_list[0]));
 162 }
 163
 164 inline double log10_wrapper(double * arg_list) {
 165   return (log10 (arg_list[0]));
 166 }
 167
 168 inline double sqrt_wrapper(double * arg_list) {
 169   return (sqrt (arg_list[0]));
 170 }
 171
 172
 173 inline double nchoosek_wrapper(double * arg_list) {
 174       unsigned long cnm = 1UL;
 175       int i, f;
 176       int n, m;
 177
 178       n = (int)arg_list[0];
 179       m = (int)arg_list[1];
 180
 181       if (m*2 >n) m = n-m;
 182       for (i=1 ; i <= m; n--, i++)
 183       {
 184             if ((f=n) % i == 0)
 185                   f   /= i;
 186             else  cnm /= i;
 187             cnm *= f;
 188       }
 189       return (double)cnm;
 190 }
 191
 192
 193 inline double fact_wrapper(double * arg_list) {
 194
 195
 196   int result = 1;
 197
 198   int n = (int)arg_list[0];
 199
 200   while (n > 1) {
 201     result = result * n;
 202     n--;
 203   }
 204   return (double)result;
 205 }