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 = 0.;
  28     int i = 0;
  29
  30     if (n <= 0)
  31     {
  32         return -1.0;
  33     }
  34
  35     min = x[0];
  36
  37     for (i = 1 ; i < n ; i++)
  38     {
  39         if (x[i] > 0.0 && x[i] < min)
  40         {
  41             min = x[i];
  42         }
  43     }
  44
  45     /* if we have found at least one positive value in x, min strictly positive */
  46     return min;
  47 }
  48 /*------------------------------------------------------------------------*/
  49 int checkMonotony(const double vector[], int nbElement)
  50 {
  51     int i = 0;
  52     if ( vector[1] >= vector[0] )
  53     {
  54         /* might be increasing */
  55         for ( i = 1 ; i < nbElement - 1 ; i++ )
  56         {
  57             if ( vector[i + 1] < vector[i] )
  58             {
  59                 /* not increasing */
  60                 return 0 ;
  61             }
  62         }
  63         return 1 ;
  64     }
  65     else
  66     {
  67         /* might be decreasing */
  68         for ( i = 1 ; i < nbElement - 1 ; i++ )
  69         {
  70             if ( vector[i + 1] > vector[i] )
  71             {
  72                 /* not decreasing */
  73                 return 0 ;
  74             }
  75         }
  76         return -1 ;
  77
  78     }
  79     return 0 ;
  80
  81 }
  82 /*------------------------------------------------------------------------*/
  83 BOOL containsOneFiniteElement(const double vector[], int nbElement)
  84 {
  85     int i = 0;
  86     for (i = 0; i < nbElement; i++)
  87     {
  88         if (finite(vector[i]))
  89         {
  90             return TRUE;
  91         }
  92     }
  93     return FALSE;
  94 }
  95 /*------------------------------------------------------------------------*/
  96 void doubleArrayCopy(double dest[], const double src[], int nbElement)
  97 {
  98     memcpy( dest, src, nbElement * sizeof(double) ) ;
  99 }
 100 /*------------------------------------------------------------------------*/
 101 void intArrayCopy(int dest[], const int src[], int nbElement)
 102 {
 103     memcpy( dest, src, nbElement * sizeof(int) ) ;
 104 }
 105 /*------------------------------------------------------------------------*/
 106 void stringArrayCopy(char * dest[], char * src[], int nbElement)
 107 {
 108     int i = 0;
 109     for ( i = 0 ; i < nbElement ; i++ )
 110     {
 111         int elemSize =  (int)strlen( src[i] ) + 1 ;
 112         FREE( dest[i] ) ;
 113
 114         dest[i] = MALLOC( elemSize * sizeof(char) ) ;
 115
 116         if ( dest[i] == NULL )
 117         {
 118             destroyStringArray( dest, nbElement ) ;
 119             return ;
 120         }
 121
 122         strcpy( dest[i], src[i] ) ;
 123     }
 124 }
 125 /*------------------------------------------------------------------------*/
 126 void setDoubleArraySingleValue(double dest[], double value, int nbElement)
 127 {
 128     int i = 0;
 129     for ( i = 0 ; i < nbElement ; i++ )
 130     {
 131         dest[i] = value ;
 132     }
 133 }
 134 /*------------------------------------------------------------------------*/
 135 double* createNewArrayFromSource(int destSize, const double src[], int srcSize)
 136 {
 137     int i = 0;
 138     int endCopy = Min( destSize, srcSize ) ;
 139     /* create new array */
 140     double * dest = MALLOC( destSize * sizeof(double) ) ;
 141
 142     if ( dest == NULL )
 143     {
 144         return NULL ;
 145     }
 146
 147     /* copy the element which needs to be copied */
 148     memcpy( dest, src, endCopy * sizeof( double ) ) ;
 149
 150     for ( i = endCopy ; i < destSize ; i++ )
 151     {
 152         dest[i] = 0.0 ;
 153     }
 154
 155     return dest ;
 156
 157 }
 158 /*------------------------------------------------------------------------*/
 159 void destroyStringArray(char * src[], int nbStrings)
 160 {
 161     freeArrayOfString(src, nbStrings);
 162 }
 163 /*--------------------------------------------------------------------------*/
 164 double* createDoubleArrayCopy(const double src[], int nbElement)
 165 {
 166     double * res = MALLOC( nbElement * sizeof(double) ) ;
 167
 168     if ( res == NULL )
 169     {
 170         return NULL ;
 171     }
 172
 173     memcpy( res, src, nbElement * sizeof(double) ) ;
 174
 175     return res ;
 176 }
 177 /*--------------------------------------------------------------------------*/
 178 int * createIntArrayCopy(const int src[], int nbElement)
 179 {
 180     int * res = MALLOC( nbElement * sizeof(int) ) ;
 181
 182     if ( res == NULL )
 183     {
 184         return NULL ;
 185     }
 186
 187     memcpy( res, src, nbElement * sizeof(int) ) ;
 188
 189     return res ;
 190 }
 191 /*--------------------------------------------------------------------------*/
 192 char ** createStringArrayCopy(char * src[], int nbElement)
 193 {
 194     char ** res = createStringArray(nbElement);
 195     if ( res == NULL )
 196     {
 197         return NULL ;
 198     }
 199
 200     stringArrayCopy( res, src, nbElement ) ;
 201
 202     return res ;
 203
 204 }
 205 /*--------------------------------------------------------------------------*/
 206 char ** createStringArray(int nbElement)
 207 {
 208     int i = 0;
 209     char ** res = MALLOC( nbElement * sizeof(char *) ) ;
 210
 211     if ( res == NULL )
 212     {
 213         return NULL ;
 214     }
 215
 216     for ( i = 0 ; i < nbElement; i++ )
 217     {
 218         res[i] = NULL ;
 219     }
 220
 221     return res ;
 222 }
 223 /*--------------------------------------------------------------------------*/