scilab/modules/signal_processing/sci_gateway/c/sci_conv2.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2012 - INRIA - Serge STEER
   4  *
   5  * This file must be used under the terms of the CeCILL.
   6  * This source file is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at
   9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12 /*--------------------------------------------------------------------------*/
  13 #include "core_math.h"
  14 #include "stack-c.h"
  15 #include "gw_signal.h"
  16 #include "MALLOC.h"
  17 #include "api_scilab.h"
  18 #include "localization.h"
  19 #include "Scierror.h"
  20 #include "conv2.h"
  21 /*--------------------------------------------------------------------------*/
  22 int sci_conv2(char *fname,unsigned long fname_len)
  23 {
  24     SciErr sciErr;
  25     int *piAddr = NULL;
  26     char *option = NULL;
  27     int iopt = 1;
  28     double *Outr = NULL,*Outi = NULL;
  29     int mOut = 0, nOut = 0;
  30     int iType = 0;
  31     int edgM = 0, edgN = 0;
  32     int rhs = Rhs;
  33
  34     /* Check if last argument is one of the string "full", "same","valid" */
  35     sciErr = getVarAddressFromPosition(pvApiCtx, Rhs, &piAddr);
  36     if(sciErr.iErr)
  37     {
  38         printError(&sciErr, 0);
  39         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, Rhs);
  40         return 0;
  41     }
  42
  43     if (isStringType(pvApiCtx, piAddr))
  44     {
  45         CheckRhs(3,4);
  46         if(isScalar(pvApiCtx, piAddr))
  47         {
  48             if (getAllocatedSingleString(pvApiCtx, piAddr, &option)==0)
  49             {
  50                 if (strcmp("full", option) == 0)
  51                 {
  52                     iopt=1;
  53                 }
  54                 else if (strcmp("same", option) == 0)
  55                 {
  56                     iopt=2;
  57                 }
  58                 else if (strcmp("valid", option) == 0)
  59                 {
  60                     iopt=3;
  61                 }
  62                 else
  63                 {
  64                     Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"),
  65                         fname, Rhs, "\"full\", \"same\"","\"valid\"");
  66                     freeAllocatedSingleString(option);
  67                     option = NULL;
  68                     return 0;
  69                 }
  70                 freeAllocatedSingleString(option);
  71                 option = NULL;
  72                 rhs=Rhs-1;
  73             }
  74             else
  75             {
  76                 Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"),
  77                     fname, Rhs, "\"full\", \"same\"","\"valid\"");
  78                 return 0;
  79             }
  80         }
  81     }
  82     else
  83     {
  84         CheckRhs(2,3);
  85     }
  86
  87     if (rhs==3)
  88     {
  89         /*separable conv2(C,R,A)*/
  90         double *Cr = NULL,*Ci = NULL;
  91         double *Rr = NULL,*Ri = NULL;
  92         double *Ar = NULL,*Ai = NULL;
  93         int mC = 0, nC = 0, mR = 0, nR = 0, mA = 0, nA = 0;
  94
  95         /* get and check C */
  96         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
  97         if(sciErr.iErr)
  98         {
  99             printError(&sciErr, 0);
 100             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 101             return 0;
 102         }
 103
 104         //check type
 105         sciErr = getVarType(pvApiCtx, piAddr, &iType);
 106         if(sciErr.iErr)
 107         {
 108             printError(&sciErr, 0);
 109             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 110             return 0;
 111         }
 112
 113         if(iType != sci_matrix)
 114         {
 115             Scierror(999,_("%s: Wrong type for argument %d: Real vector expected.\n"),
 116                 fname, 1);
 117             return 0;
 118         }
 119
 120         //get complexity
 121         if (isVarComplex(pvApiCtx, piAddr))
 122         {
 123             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mC, &nC, &Cr, &Ci);
 124             if(sciErr.iErr)
 125             {
 126                 printError(&sciErr, 0);
 127                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 128                 return 0;
 129             }
 130
 131         }
 132         else
 133         {
 134             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mC, &nC, &Cr);
 135             if(sciErr.iErr)
 136             {
 137                 printError(&sciErr, 0);
 138                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 139                 return 0;
 140             }
 141
 142         }
 143         if (mC>1 && nC>1)
 144         {
 145             /*check if vector*/
 146             Scierror(999,_("%s: Wrong type for argument %d: Real or complex vector expected.\n"),
 147                 fname, 1);
 148             return 0;
 149         }
 150         mC = mC*nC;
 151
 152         /* get and check R */
 153         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
 154         if(sciErr.iErr)
 155         {
 156             printError(&sciErr, 0);
 157             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 158             return 0;
 159         }
 160
 161         //check type
 162         sciErr = getVarType(pvApiCtx, piAddr, &iType);
 163         if(sciErr.iErr)
 164         {
 165             printError(&sciErr, 0);
 166             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 167             return 0;
 168         }
 169
 170         if(iType != sci_matrix)
 171         {
 172             Scierror(999,_("%s: Wrong type for argument %d: Real or complex vector expected.\n"),
 173                 fname, 2);
 174             return 0;
 175         }
 176
 177         //get complexity
 178         if (isVarComplex(pvApiCtx, piAddr))
 179         {
 180             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mR, &nR, &Rr, &Ri);
 181             if(sciErr.iErr)
 182             {
 183                 printError(&sciErr, 0);
 184                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 185                 return 0;
 186             }
 187
 188         }
 189         else
 190         {
 191             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mR, &nR, &Rr);
 192             if(sciErr.iErr)
 193             {
 194                 printError(&sciErr, 0);
 195                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 196                 return 0;
 197             }
 198
 199         }
 200
 201         if (mR>1 && nR>1)
 202         {
 203             /*check if vector*/
 204             Scierror(999,_("%s: Wrong type for argument %d: Real vector expected.\n"),
 205                 fname, 2);
 206             return 0;
 207         }
 208
 209         nR = nR*mR;
 210         /* get and check A */
 211         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr);
 212         if(sciErr.iErr)
 213         {
 214             printError(&sciErr, 0);
 215             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 216             return 0;
 217         }
 218
 219         //check type
 220         sciErr = getVarType(pvApiCtx, piAddr, &iType);
 221         if(sciErr.iErr)
 222         {
 223             printError(&sciErr, 0);
 224             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 225             return 0;
 226         }
 227
 228         if(iType != sci_matrix)
 229         {
 230             Scierror(999,_("%s: Wrong type for argument %d: Real or complex matrix expected.\n"),
 231                 fname, 3);
 232             return 0;
 233         }
 234
 235         //get complexity
 236         if (isVarComplex(pvApiCtx, piAddr))
 237         {
 238             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mA, &nA, &Ar, &Ai);
 239             if(sciErr.iErr)
 240             {
 241                 printError(&sciErr, 0);
 242                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 243                 return 0;
 244             }
 245
 246         }
 247         else
 248         {
 249             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mA, &nA, &Ar);
 250             if(sciErr.iErr)
 251             {
 252                 printError(&sciErr, 0);
 253                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
 254                 return 0;
 255             }
 256
 257         }
 258
 259         //Compute result sizes
 260         if (iopt == 1 )
 261         {
 262             if (mC==0||nR==0)
 263             {
 264                 mOut= mA;
 265                 nOut= nA;
 266             }
 267             else
 268             {
 269                 mOut= mA + mC - 1;
 270                 nOut= nA + nR - 1;
 271             }
 272             edgM= mC - 1;
 273             edgN= nR - 1;
 274         }
 275         else if ( iopt == 2 )
 276         {
 277             mOut= mA;
 278             nOut= nA;
 279             edgM= ( mC - 1) /2;
 280             edgN= ( nR - 1) /2;
 281         }
 282         else if (iopt==3)
 283         {
 284             if (mC==0||nR==0)
 285             {
 286                 mOut= mA;
 287                 nOut= nA;
 288             }
 289             else
 290             {
 291                 mOut= Max(0,mA - mC + 1);
 292                 nOut= Max(0,nA - nR + 1);
 293             }
 294             edgM = edgN= 0;
 295         }
 296
 297         if (Ri==NULL&&Ci==NULL&&Ai==NULL)
 298         {
 299             //real case
 300             double *Tr = NULL;
 301             //Allocate result
 302             sciErr = allocMatrixOfDouble(pvApiCtx,Rhs+1,mOut,nOut,&Outr);
 303             if(sciErr.iErr)
 304             {
 305                 printError(&sciErr, 0);
 306                 return 0;
 307             }
 308
 309             sciErr = allocMatrixOfDouble(pvApiCtx,Rhs+2,1,nA,&Tr);
 310             if(sciErr.iErr)
 311             {
 312                 printError(&sciErr, 0);
 313                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
 314                 return 0;
 315             }
 316
 317             conv2_separable_R(Rr,nR,Cr,mC,Ar,mA,nA,Outr,mOut,nOut,edgM,edgN,Tr);
 318         }
 319         else
 320         {
 321             double *Tr = NULL,*Ti = NULL;
 322             //Allocate result
 323             sciErr = allocComplexMatrixOfDouble(pvApiCtx,Rhs+1,mOut,nOut,&Outr,&Outi);
 324             if(sciErr.iErr)
 325             {
 326                 printError(&sciErr, 0);
 327                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
 328                 return 0;
 329             }
 330
 331             sciErr = allocComplexMatrixOfDouble(pvApiCtx,Rhs+2,1,nA,&Tr,&Ti);
 332             if(sciErr.iErr)
 333             {
 334                 printError(&sciErr, 0);
 335                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
 336                 return 0;
 337             }
 338
 339             conv2_separable_C(Rr,Ri,nR,Cr,Ci,mC,Ar,Ai,mA,nA,Outr,Outi,mOut,nOut,edgM,edgN,Tr,Ti);
 340         }
 341     }
 342     else
 343     {
 344         /*conv2(A,B)*/
 345         double *Ar = NULL,*Ai = NULL;
 346         double *Br = NULL,*Bi = NULL;
 347         int mA,nA,mB,nB;
 348
 349         /* get and check A */
 350         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
 351         if(sciErr.iErr)
 352         {
 353             printError(&sciErr, 0);
 354             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 355             return 0;
 356         }
 357
 358         //check type
 359         sciErr = getVarType(pvApiCtx, piAddr, &iType);
 360         if(sciErr.iErr)
 361         {
 362             printError(&sciErr, 0);
 363             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 364             return 0;
 365         }
 366
 367         if(iType != sci_matrix)
 368         {
 369             Scierror(999,_("%s: Wrong type for argument %d: Real or complex matrix expected.\n"),
 370                 fname, 1);
 371             return 0;
 372         }
 373
 374         //get complexity
 375         if (isVarComplex(pvApiCtx, piAddr))
 376         {
 377             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mA, &nA, &Ar, &Ai);
 378             if(sciErr.iErr)
 379             {
 380                 printError(&sciErr, 0);
 381                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 382                 return 0;
 383             }
 384
 385         }
 386         else
 387         {
 388             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mA, &nA, &Ar);
 389             if(sciErr.iErr)
 390             {
 391                 printError(&sciErr, 0);
 392                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
 393                 return 0;
 394             }
 395
 396         }
 397
 398         /* get and check B */
 399         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
 400         if(sciErr.iErr)
 401         {
 402             printError(&sciErr, 0);
 403             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 404             return 0;
 405         }
 406
 407         //check type
 408         sciErr = getVarType(pvApiCtx, piAddr, &iType);
 409         if(sciErr.iErr)
 410         {
 411             printError(&sciErr, 0);
 412             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 413             return 0;
 414         }
 415
 416         if(iType != sci_matrix)
 417         {
 418             Scierror(999,_("%s: Wrong type for argument %d: Real or complex matrix expected.\n"),
 419                 fname, 2);
 420             return 0;
 421         }
 422
 423         //get complexity
 424         if (isVarComplex(pvApiCtx, piAddr))
 425         {
 426             sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &mB, &nB, &Br, &Bi);
 427             if(sciErr.iErr)
 428             {
 429                 printError(&sciErr, 0);
 430                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 431                 return 0;
 432             }
 433
 434         }
 435         else
 436         {
 437             sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &mB, &nB, &Br);
 438             if(sciErr.iErr)
 439             {
 440                 printError(&sciErr, 0);
 441                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
 442                 return 0;
 443             }
 444
 445         }
 446
 447         if (iopt==1)
 448         {
 449             if (mA==0)
 450             {
 451                 mOut= mB;
 452                 nOut= nB;
 453             }
 454             else if (mB ==0)
 455             {
 456                 mOut= mA;
 457                 nOut= nA;
 458             }
 459             else
 460             {
 461                 mOut= mA + Max(0,mB - 1);
 462                 nOut= nA +  Max(0,nB - 1);
 463             }
 464             edgM= mB - 1;
 465             edgN= nB - 1;
 466         }
 467         else if (iopt==2)
 468         {
 469             mOut= mA;
 470             nOut= nA;
 471             edgM= ( mB - 1) /2;
 472             edgN= ( nB - 1) /2;
 473         }
 474         else if (iopt==3)
 475         {
 476             if (mB ==0)
 477             {
 478                 mOut=mA;
 479                 nOut=nA;
 480             }
 481             else
 482             {
 483                 mOut= Max(0,mA - mB + 1);
 484                 nOut= Max(0,nA - nB + 1);
 485             }
 486             edgM= edgN= 0;
 487         }
 488
 489         if (Ai==NULL&&Bi==NULL)
 490         {
 491             //real case
 492             //Allocate result
 493             sciErr = allocMatrixOfDouble(pvApiCtx, Rhs+1,mOut,nOut,&Outr);
 494             if(sciErr.iErr)
 495             {
 496                 printError(&sciErr, 0);
 497                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
 498                 return 0;
 499             }
 500
 501             conv2_R(Ar,mA,nA,Br,mB,nB,Outr,mOut,nOut,edgM,edgN);
 502         }
 503         else
 504         {
 505             //Allocate result
 506             sciErr = allocComplexMatrixOfDouble(pvApiCtx,Rhs+1,mOut,nOut,&Outr,&Outi);
 507             if(sciErr.iErr)
 508             {
 509                 printError(&sciErr, 0);
 510                 Scierror(999,_("%s: Memory allocation error.\n"), fname);
 511                 return 0;
 512             }
 513
 514             conv2_C(Ar,Ai,mA,nA,Br,Bi,mB,nB,Outr,Outi,mOut,nOut,edgM,edgN);
 515         }
 516     }
 517
 518     LhsVar(1) = Rhs+1;
 519     PutLhsVar();
 520     return 0;
 521 }
 522 /*--------------------------------------------------------------------------*/