tools/fuzzy.c

   1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
   2  * RICE 4.0x              Copyright (C) 1993             Rene' Jager *
   3  *                                                                   *
   4  *                                                                   *
   5  * This toolbox is free software; you can redistribute it and/or     *
   6  * modify it under the terms of the GNU General Public License as    *
   7  * published by the Free Software Foundation; either version 2 of    *
   8  * the License, or (at your option) any later version.               *
   9  *                                                                   *
  10  * This toolbox is distributed in the hope that it will be useful,   *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the      *
  13  * GNU General Public License for more details.                      *
  14  *                                                                   *
  15  * You should have received a copy of the GNU General Public License *
  16  * along with this toolbox; if not, write to the:                    *
  17  *                                                                   *
  18  *    Free Software Foundation, Inc.                                 *
  19  *    675 Mass Ave, Cambridge                                        *
  20  *    MA 02139, USA.                                                 *
  21  *                                                                   *
  22  * See the RICE documentation for more information on the toolbox.   *
  23  * The file COPYING for the complete GNU General Public License.     *
  24  *                                                                   *
  25  * You can reach me by (preferably e-mail):                          *
  26  *                                                                   *
  27  *    Rene' Jager                                                    *
  28  *                                                                   *
  29  *    Delft University of Technology                                 *
  30  *    Department of Electrical Engineering                           *
  31  *    Control Laboratory                                             *
  32  *                                                                   *
  33  *    Room ET 12.06                                                  *
  34  *                                                                   *
  35  *    Mekelweg 4                                                     *
  36  *    P.O.Box 5031                                                   *
  37  *    2600 GA  Delft                                                 *
  38  *    The Netherlands                                                *
  39  *                                                                   *
  40  *    e-mail: R.Jager@ET.TUDelft.NL                                  *
  41  *    phone:  +31-15-78 51 14                                        *
  42  *    fax:    +31-15-62 67 38                                        *
  43  *    telex:  38151 butud nl                                         *
  44  *                                                                   *
  45  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  46
  47 /*
  48    File:   fuzzy.c
  49    Author: Rene' Jager
  50    Update: March 1, 1992
  51    Info:   utility source file, see file fuzzy.doc
  52 */
  53
  54
  55 /* header file */
  56
  57 #include <fuzzy.h>
  58
  59
  60 /* macro's */
  61
  62 #define MAX(a,b) ((a) > (b) ? (a) : (b))
  63 #define MIN(a,b) ((a) < (b) ? (a) : (b))
  64 #define SQR(a)   ((a) * (a))
  65
  66
  67 /* smooth membership function(s) */
  68
  69 float fpi(float val, float p1, float p2, float p3, float p4)
  70 {
  71    if(p2 <= val && val <= p3)
  72       return 1.0;
  73    if(val <= p1 || p4 <= val)
  74       return 0.0;
  75    if(p1 < val && val <= (p1 + p2)/2.0)
  76       return 2.0*SQR(val - p1)/SQR(p2 - p1);
  77    if((p1 + p2)/2.0 <= val && val < p2)
  78       return 1.0 - 2.0*SQR(val - p2)/SQR(p1 - p2);
  79    if(p3 < val && val <= (p3 + p4)/2.0)
  80       return 1.0 - 2.0*SQR(val - p3)/SQR(p3 - p4);
  81    if((p3 + p4)/2.0 <= val && val < p4)
  82       return 2.0*SQR(val - p4)/SQR(p3 - p4);
  83
  84    return 0.0;
  85 }
  86
  87
  88 /* hard membership function(s) */
  89
  90 float ftrapezium(float val, float p1, float p2, float p3, float p4)
  91 {
  92    if(p2 <= val && val <= p3)
  93       return 1.0;
  94    if(val <= p1 || p4 <= val)
  95       return 0.0;
  96    if(p1 < val && val < p2)
  97       return (val - p1)/(p2 - p1);
  98    if(p3 < val && val < p4)
  99       return (p4 - val)/(p4 - p3);
 100
 101    return 0.0;
 102 }
 103
 104
 105 /* indexed-centre-of-gravity */
 106
 107 float ficog(int len, float *set, float lim)
 108 {
 109    register int i;
 110    float up = 0.0, low = 0.0;
 111
 112    for(i = 1; i <= len; set++, i++)
 113       if(*set >= lim)
 114       {
 115          up += *set*i;
 116          low += *set;
 117       }
 118
 119    up -= 1.0;
 120
 121    if(low == 0.0)
 122       return -1.0;
 123
 124    return up/low;
 125 }
 126
 127
 128 /* centre-of-gravity */
 129
 130 float fcog(int len, float *set)
 131 {
 132    register int i;
 133    float up = 0.0, low = 0.0;
 134
 135    for(i = 1; i <= len; set++, i++)
 136    {
 137       up += *set*i;
 138       low += *set;
 139    }
 140
 141    up -= 1.0;
 142
 143    if(low == 0.0)
 144       return -1.0;
 145
 146    return up/low;
 147 }
 148
 149
 150 /* mean-of-maximum */
 151
 152 float fmom(int len, float *set)
 153 {
 154    int low = 0;
 155    float up = 0.0, top;
 156
 157    top = fhgt(len, set);
 158    set += len;
 159
 160    while(len)
 161    {
 162       if(*set == top)
 163       {
 164          up += len;
 165          low++;
 166       }
 167       set--;
 168       len--;
 169    }
 170
 171    up -= 1.0;
 172
 173    if(low == 0)
 174       return -1.0;
 175
 176    return up/low;
 177 }
 178
 179
 180 /* general norm operators */
 181
 182 float *fnorm(int len, float *dest, float *src, float (*norm)(float, float))
 183 {
 184    float *save = dest;
 185
 186    if(len < 0)
 187       while(len++)
 188       {
 189          *dest = (*norm)(*dest, *src);
 190          dest++;
 191       }
 192    else
 193       while(len--)
 194       {
 195          *dest = (*norm)(*dest, *src);
 196          dest++;
 197          src++;
 198       }
 199
 200    return save;
 201 }
 202
 203
 204 float *fxnorm(int len, float *dest, float *src,
 205               float (*norm)(float, float, float), float par)
 206 {
 207    float *save = dest;
 208
 209    if(len < 0)
 210       while(len++)
 211       {
 212          *dest = (*norm)(*dest, *src, par);
 213          dest++;
 214       }
 215    else
 216       while(len--)
 217       {
 218          *dest = (*norm)(*dest, *src, par);
 219          dest++;
 220          src++;
 221       }
 222
 223    return save;
 224 }
 225
 226
 227 /* intersection operators */
 228
 229 float *fzand(int len, float *dest, float *src)
 230 {
 231    float *save = dest;
 232
 233    if(len < 0)
 234       while(len++)
 235       {
 236          *dest = MIN(*dest, *src);
 237          dest++;
 238       }
 239    else
 240       while(len--)
 241       {
 242          *dest = MIN(*dest, *src);
 243          dest++;
 244          src++;
 245       }
 246
 247    return save;
 248 }
 249
 250
 251 float *fpand(int len, float *dest, float *src)
 252 {
 253    float *save = dest;
 254
 255    if(len < 0)
 256       while(len++)
 257       {
 258          *dest = *dest * *src;
 259          dest++;
 260       }
 261    else
 262       while(len--)
 263       {
 264          *dest = *dest * *src;
 265          dest++;
 266          src++;
 267       }
 268
 269    return save;
 270 }
 271
 272
 273 float *fland(int len, float *dest, float *src)
 274 {
 275    float *save = dest;
 276
 277    if(len < 0)
 278       while(len++)
 279       {
 280          *dest = MAX(*dest + *src - 1.0, 0.0);
 281          dest++;
 282       }
 283    else
 284       while(len--)
 285       {
 286          *dest = MAX(*dest + *src - 1.0, 0.0);
 287          dest++;
 288          src++;
 289       }
 290
 291    return save;
 292 }
 293
 294
 295 /* union operators */
 296
 297 float *fzor(int len, float *dest, float *src)
 298 {
 299    float *save = dest;
 300
 301    if(len < 0)
 302       while(len++)
 303       {
 304          *dest = MAX(*dest, *src);
 305          dest++;
 306       }
 307    else
 308       while(len--)
 309       {
 310          *dest = MAX(*dest, *src);
 311          dest++;
 312          src++;
 313       }
 314
 315    return save;
 316 }
 317
 318
 319 float *fpor(int len, float *dest, float *src)
 320 {
 321    float *save = dest;
 322
 323    if(len < 0)
 324       while(len++)
 325       {
 326          *dest = *dest + *src - *dest * *src;
 327          dest++;
 328       }
 329    else
 330       while(len--)
 331       {
 332          *dest = *dest + *src - *dest * *src;
 333          dest++;
 334          src++;
 335       }
 336
 337    return save;
 338 }
 339
 340
 341 float *flor(int len, float *dest, float *src)
 342 {
 343    float *save = dest;
 344
 345    if(len < 0)
 346       while(len++)
 347       {
 348          *dest = MIN(*dest + *src, 1.0);
 349          dest++;
 350       }
 351    else
 352       while(len--)
 353       {
 354          *dest = MIN(*dest + *src, 1.0);
 355          dest++;
 356          src++;
 357       }
 358
 359    return save;
 360 }
 361
 362
 363 /* negation operator */
 364
 365 float *fnot(int len, float *dest)
 366 {
 367    float *save = dest;
 368
 369    while(len--)
 370    {
 371       *dest = 1.0 - *dest;
 372       dest++;
 373    }
 374
 375    return save;
 376 }
 377
 378
 379 /* height */
 380
 381 float fhgt(int len, float *set)
 382 {
 383    float value = 0.0;
 384
 385    while(len--)
 386    {
 387       value = MAX(value, *set);
 388       set++;
 389    }
 390
 391    return value;
 392 }
 393
 394
 395 /* alpha-cut and strong alpha-cut */
 396
 397 float *fcut(int len, float *dest, float *src, float cut)
 398 {
 399    float *save = dest;
 400
 401    while(len--)
 402    {
 403       *dest = (*src >= cut) ? *src : 0.0;
 404       dest++;
 405       src++;
 406    }
 407
 408    return save;
 409 }
 410
 411
 412 float *fscut(int len, float *dest, float *src, float cut)
 413 {
 414    float *save = dest;
 415
 416    while(len--)
 417    {
 418       *dest = (*src > cut) ? *src : 0.0;
 419       dest++;
 420       src++;
 421    }
 422
 423    return save;
 424 }
 425
 426
 427
 428 #ifdef TEST_FUZZY
 429
 430 #include <stdio.h>
 431
 432 int main()
 433 {
 434    float val;
 435    val = fpi(0.1, 1.0, 2.0, 3.0, 4.0);
 436    printf("val = %f\n", val);
 437    val = fpi(1.1, 1.0, 2.0, 3.0, 4.0);
 438    printf("val = %f\n", val);
 439    val = fpi(1.6, 1.0, 2.0, 3.0, 4.0);
 440    printf("val = %f\n", val);
 441    val = fpi(2.1, 1.0, 2.0, 3.0, 4.0);
 442    printf("val = %f\n", val);
 443    val = fpi(3.1, 1.0, 2.0, 3.0, 4.0);
 444    printf("val = %f\n", val);
 445    val = fpi(3.6, 1.0, 2.0, 3.0, 4.0);
 446    printf("val = %f\n", val);
 447    val = fpi(4.1, 1.0, 2.0, 3.0, 4.0);
 448    printf("val = %f\n", val);
 449    return 0;
 450 }
 451
 452 #endif