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