scilab/modules/graphics/src/c/BasicAlgos.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2006 - INRIA - Fabrice Leray
   4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
   5  *
   6  * This file must be used under the terms of the CeCILL.
   7  * This source file is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at
  10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  11  *
  12  */
  13
  14 /*------------------------------------------------------------------------*/
  15 /* file: BasicAlgos.c                                                     */
  16 /* desc : Several basic algorithms which can be used in several places in */
  17 /*        the code.                                                       */
  18 /*------------------------------------------------------------------------*/
  19 #include <string.h>
  20 #include "BasicAlgos.h"
  21 #include "MALLOC.h"
  22 #include "core_math.h"
  23 #include "freeArrayOfString.h"
  24 /*------------------------------------------------------------------------*/
  25 double sciFindStPosMin(const double x[], int n)
  26 {
  27     double min = -1.0;
  28     int i = 0;
  29
  30     if (n <= 0)
  31     {
  32         return min;
  33     }
  34
  35     for (i = 0; i < n; i++)
  36     {
  37         if (x[i] > 0)
  38         {
  39             min = x[i];
  40             break;
  41         }
  42     }
  43
  44     for (; i < n ; i++)
  45     {
  46         if (x[i] > 0.0 && x[i] < min)
  47         {
  48             min = x[i];
  49         }
  50     }
  51
  52     /* if we have found at least one positive value in x, min strictly positive */
  53     return min;
  54 }
  55 /*------------------------------------------------------------------------*/
  56 int checkMonotony(const double vector[], int nbElement)
  57 {
  58     int i = 0;
  59     if ( vector[1] >= vector[0] )
  60     {
  61         /* might be increasing */
  62         for ( i = 1 ; i < nbElement - 1 ; i++ )
  63         {
  64             if ( vector[i + 1] < vector[i] )
  65             {
  66                 /* not increasing */
  67                 return 0 ;
  68             }
  69         }
  70         return 1 ;
  71     }
  72     else
  73     {
  74         /* might be decreasing */
  75         for ( i = 1 ; i < nbElement - 1 ; i++ )
  76         {
  77             if ( vector[i + 1] > vector[i] )
  78             {
  79                 /* not decreasing */
  80                 return 0 ;
  81             }
  82         }
  83         return -1 ;
  84
  85     }
  86     return 0 ;
  87
  88 }
  89 /*------------------------------------------------------------------------*/
  90 BOOL containsOneFiniteElement(const double vector[], int nbElement)
  91 {
  92     int i = 0;
  93     for (i = 0; i < nbElement; i++)
  94     {
  95         if (finite(vector[i]))
  96         {
  97             return TRUE;
  98         }
  99     }
 100     return FALSE;
 101 }
 102 /*------------------------------------------------------------------------*/
 103 void doubleArrayCopy(double dest[], const double src[], int nbElement)
 104 {
 105     memcpy( dest, src, nbElement * sizeof(double) ) ;
 106 }
 107 /*------------------------------------------------------------------------*/
 108 void intArrayCopy(int dest[], const int src[], int nbElement)
 109 {
 110     memcpy( dest, src, nbElement * sizeof(int) ) ;
 111 }
 112 /*------------------------------------------------------------------------*/
 113 void stringArrayCopy(char * dest[], char * src[], int nbElement)
 114 {
 115     int i = 0;
 116     for ( i = 0 ; i < nbElement ; i++ )
 117     {
 118         int elemSize =  (int)strlen( src[i] ) + 1 ;
 119         FREE( dest[i] ) ;
 120
 121         dest[i] = MALLOC( elemSize * sizeof(char) ) ;
 122
 123         if ( dest[i] == NULL )
 124         {
 125             destroyStringArray( dest, nbElement ) ;
 126             return ;
 127         }
 128
 129         strcpy( dest[i], src[i] ) ;
 130     }
 131 }
 132 /*------------------------------------------------------------------------*/
 133 void setDoubleArraySingleValue(double dest[], double value, int nbElement)
 134 {
 135     int i = 0;
 136     for ( i = 0 ; i < nbElement ; i++ )
 137     {
 138         dest[i] = value ;
 139     }
 140 }
 141 /*------------------------------------------------------------------------*/
 142 double* createNewArrayFromSource(int destSize, const double src[], int srcSize)
 143 {
 144     int i = 0;
 145     int endCopy = Min( destSize, srcSize ) ;
 146     /* create new array */
 147     double * dest = MALLOC( destSize * sizeof(double) ) ;
 148
 149     if ( dest == NULL )
 150     {
 151         return NULL ;
 152     }
 153
 154     /* copy the element which needs to be copied */
 155     memcpy( dest, src, endCopy * sizeof( double ) ) ;
 156
 157     for ( i = endCopy ; i < destSize ; i++ )
 158     {
 159         dest[i] = 0.0 ;
 160     }
 161
 162     return dest ;
 163
 164 }
 165 /*------------------------------------------------------------------------*/
 166 void destroyStringArray(char * src[], int nbStrings)
 167 {
 168     freeArrayOfString(src, nbStrings);
 169 }
 170 /*--------------------------------------------------------------------------*/
 171 double* createDoubleArrayCopy(const double src[], int nbElement)
 172 {
 173     double * res = MALLOC( nbElement * sizeof(double) ) ;
 174
 175     if ( res == NULL )
 176     {
 177         return NULL ;
 178     }
 179
 180     memcpy( res, src, nbElement * sizeof(double) ) ;
 181
 182     return res ;
 183 }
 184 /*--------------------------------------------------------------------------*/
 185 int * createIntArrayCopy(const int src[], int nbElement)
 186 {
 187     int * res = MALLOC( nbElement * sizeof(int) ) ;
 188
 189     if ( res == NULL )
 190     {
 191         return NULL ;
 192     }
 193
 194     memcpy( res, src, nbElement * sizeof(int) ) ;
 195
 196     return res ;
 197 }
 198 /*--------------------------------------------------------------------------*/
 199 char ** createStringArrayCopy(char * src[], int nbElement)
 200 {
 201     char ** res = createStringArray(nbElement);
 202     if ( res == NULL )
 203     {
 204         return NULL ;
 205     }
 206
 207     stringArrayCopy( res, src, nbElement ) ;
 208
 209     return res ;
 210
 211 }
 212 /*--------------------------------------------------------------------------*/
 213 char ** createStringArray(int nbElement)
 214 {
 215     int i = 0;
 216     char ** res = MALLOC( nbElement * sizeof(char *) ) ;
 217
 218     if ( res == NULL )
 219     {
 220         return NULL ;
 221     }
 222
 223     for ( i = 0 ; i < nbElement; i++ )
 224     {
 225         res[i] = NULL ;
 226     }
 227
 228     return res ;
 229 }
 230 /*--------------------------------------------------------------------------*/