SAGA API  v9.9
mat_tools.h
Go to the documentation of this file.
1 
3 // //
4 // SAGA //
5 // //
6 // System for Automated Geoscientific Analyses //
7 // //
8 // Application Programming Interface //
9 // //
10 // Library: SAGA_API //
11 // //
12 //-------------------------------------------------------//
13 // //
14 // mat_tools.h //
15 // //
16 // Copyright (C) 2005 by Olaf Conrad //
17 // //
18 //-------------------------------------------------------//
19 // //
20 // This file is part of 'SAGA - System for Automated //
21 // Geoscientific Analyses'. //
22 // //
23 // This library is free software; you can redistribute //
24 // it and/or modify it under the terms of the GNU Lesser //
25 // General Public License as published by the Free //
26 // Software Foundation, either version 2.1 of the //
27 // License, or (at your option) any later version. //
28 // //
29 // This library is distributed in the hope that it will //
30 // be useful, but WITHOUT ANY WARRANTY; without even the //
31 // implied warranty of MERCHANTABILITY or FITNESS FOR A //
32 // PARTICULAR PURPOSE. See the GNU Lesser General Public //
33 // License for more details. //
34 // //
35 // You should have received a copy of the GNU Lesser //
36 // General Public License along with this program; if //
37 // not, see <http://www.gnu.org/licenses/>. //
38 // //
39 //-------------------------------------------------------//
40 // //
41 // contact: Olaf Conrad //
42 // Institute of Geography //
43 // University of Goettingen //
44 // Goldschmidtstr. 5 //
45 // 37077 Goettingen //
46 // Germany //
47 // //
48 // e-mail: oconrad@saga-gis.org //
49 // //
51 
52 //---------------------------------------------------------
53 #ifndef HEADER_INCLUDED__SAGA_API__mat_tools_H
54 #define HEADER_INCLUDED__SAGA_API__mat_tools_H
55 
56 
58 // //
59 // //
60 // //
62 
63 //---------------------------------------------------------
80 // //
83 
84 //---------------------------------------------------------
85 #include "geo_tools.h"
86 
87 
89 // //
90 // //
91 // //
93 
94 //---------------------------------------------------------
95 #ifndef M_PI
96 #define M_PI 3.141592653589793
97 #endif
98 
99 #define M_PI_045 (M_PI / 4.)
100 #define M_PI_090 (M_PI / 2.)
101 #define M_PI_135 (M_PI * 3. / 4.)
102 #define M_PI_180 (M_PI)
103 #define M_PI_225 (M_PI * 5. / 4.)
104 #define M_PI_270 (M_PI * 3. / 2.)
105 #define M_PI_315 (M_PI * 7. / 4.)
106 #define M_PI_360 (M_PI * 2.)
107 
108 #define M_RAD_TO_DEG (180. / M_PI)
109 #define M_DEG_TO_RAD (M_PI / 180.)
110 
111 //---------------------------------------------------------
112 #define M_EULER 2.718281828459045
113 
114 //---------------------------------------------------------
115 #define N_MEGABYTE_BYTES 0x100000
116 
117 //---------------------------------------------------------
118 #ifdef FLT_EPSILON
119  #define M_FLT_EPSILON FLT_EPSILON
120 #else
121  #define M_FLT_EPSILON 1.192092896e-07F
122 #endif
123 
124 #ifdef DBL_EPSILON
125  #define M_DBL_EPSILON DBL_EPSILON
126 #else
127  #define M_DBL_EPSILON 2.2204460492503131e-016
128 #endif
129 
130 // >>> DEPRECATED >>> //
131 #define M_ALMOST_ZERO (1.e-03)
132 #define M_TINY (1.e-20)
133 // <<< DEPRECATED <<< //
134 
135 
136 //---------------------------------------------------------
137 #define M_SQR(x) ((x) * (x))
138 #define M_SQRT(x) sqrt((double)(x))
139 #define M_GET_LENGTH(x, y) sqrt((double)((x)*(x) + (y)*(y)))
140 
141 #define M_GET_MIN(a, b) (((a) < (b)) ? (a) : (b))
142 #define M_GET_MAX(a, b) (((a) > (b)) ? (a) : (b))
143 #define M_SET_MINMAX(min, max, x) if( min > x ) { min = x; } else if( max < x ) { max = x; }
144 
145 #define M_SET_SIGN(x, sign) ((sign) < 0 ? (x < 0 ? x : -x) : (x > 0 ? x : -x))
146 
147 #define M_HAS_DECIMALS(x) (x - floor(x) > 0.)
148 
149 //---------------------------------------------------------
150 #define SG_ROUND_TO_BYTE(x) ((BYTE )(x < 0. ? x - 0.5 : x + 0.5))
151 #define SG_ROUND_TO_CHAR(x) ((char )(x < 0. ? x - 0.5 : x + 0.5))
152 #define SG_ROUND_TO_WORD(x) ((WORD )(x < 0. ? x - 0.5 : x + 0.5))
153 #define SG_ROUND_TO_SHORT(x) ((short)(x < 0. ? x - 0.5 : x + 0.5))
154 #define SG_ROUND_TO_DWORD(x) ((DWORD)(x < 0. ? x - 0.5 : x + 0.5))
155 #define SG_ROUND_TO_INT(x) ((int )(x < 0. ? x - 0.5 : x + 0.5))
156 #define SG_ROUND_TO_LONG(x) ((long )(x < 0. ? x - 0.5 : x + 0.5))
157 #define SG_ROUND_TO_ULONG(x) ((uLong)(x < 0. ? x - 0.5 : x + 0.5))
158 #define SG_ROUND_TO_SLONG(x) ((sLong)(x < 0. ? x - 0.5 : x + 0.5))
159 
160 
162 // //
163 // //
164 // //
166 
167 //---------------------------------------------------------
168 SAGA_API_DLL_EXPORT double SG_Get_Square (double Value);
169 
170 SAGA_API_DLL_EXPORT double SG_Get_Rounded (double Value, int Decimals = 0);
171 SAGA_API_DLL_EXPORT double SG_Get_Rounded_To_SignificantFigures (double Value, int Decimals);
172 
173 //---------------------------------------------------------
174 SAGA_API_DLL_EXPORT int SG_Get_Digit_Count (int Number);
175 
176 //---------------------------------------------------------
177 SAGA_API_DLL_EXPORT CSG_String SG_Get_Double_asString (double Number, int Width = -1, int Precision = -1, bool bScientific = false);
178 
179 //---------------------------------------------------------
180 SAGA_API_DLL_EXPORT int SG_Compare_Int (const void *a, const void *b);
181 SAGA_API_DLL_EXPORT int SG_Compare_Double (const void *a, const void *b);
182 SAGA_API_DLL_EXPORT int SG_Compare_Char_Ptr (const void *a, const void *b);
183 
184 //---------------------------------------------------------
185 SAGA_API_DLL_EXPORT double SG_Degree_To_Decimal ( double Deg, double Min, double Sec);
186 SAGA_API_DLL_EXPORT void SG_Decimal_To_Degree (double Value, double &Deg, double &Min, double &Sec);
187 
188 
190 // //
191 // //
192 // //
194 
195 //---------------------------------------------------------
196 typedef int (* TSG_PFNC_Compare) (const sLong a, const sLong b);
197 
198 //---------------------------------------------------------
199 class SAGA_API_DLL_EXPORT CSG_Index
200 {
201 public:
202  class CSG_Index_Compare
203  {
204  public:
205  CSG_Index_Compare(void) {}
206  virtual ~CSG_Index_Compare(void) {}
207 
208  virtual int Compare (const sLong a, const sLong b) = 0;
209  };
210 
211 
212 public:
213  CSG_Index(void);
214  virtual ~CSG_Index(void);
215 
216  CSG_Index (sLong nValues, CSG_Index_Compare &Compare);
217  bool Create (sLong nValues, CSG_Index_Compare &Compare);
218 
219  CSG_Index (sLong nValues, CSG_Index_Compare *pCompare);
220  bool Create (sLong nValues, CSG_Index_Compare *pCompare);
221 
222  CSG_Index (sLong nValues, int *Values, bool bAscending = true);
223  bool Create (sLong nValues, int *Values, bool bAscending = true);
224 
225  CSG_Index (sLong nValues, double *Values, bool bAscending = true);
226  bool Create (sLong nValues, double *Values, bool bAscending = true);
227 
228  CSG_Index (sLong nValues, TSG_PFNC_Compare fCompare);
229  bool Create (sLong nValues, TSG_PFNC_Compare fCompare);
230 
231  bool Destroy (void);
232 
233  bool Invert (void);
234 
235  void Show_Progress (bool bProgress = true);
236 
237  bool Add_Entry (sLong Position = -1);
238  bool Del_Entry (sLong Position = -1);
239 
240  bool is_Okay (void) const { return( m_nValues > 0 ); }
241  sLong Get_Count (void) const { return( m_nValues ); }
242 
243  sLong Get_Index (sLong Position, bool Ascending = true) const
244  {
245  return( Position < 0 || Position >= m_nValues ? -1 : m_Index[Ascending ? Position : m_nValues - 1 - Position] );
246  }
247 
248  sLong operator [] (sLong Position) const
249  {
250  return( Position < 0 || Position >= m_nValues ? -1 : m_Index[Position] );
251  }
252 
253 
254 private:
255 
256  bool m_bProgress;
257 
258  sLong m_nValues, *m_Index;
259 
260 
261  void _On_Construction (void);
262 
263  bool _Set_Array (sLong nValues);
264  bool _Set_Index (CSG_Index_Compare *pCompare);
265 
266 };
267 
268 
270 // //
271 // //
272 // //
274 
275 //---------------------------------------------------------
276 class SAGA_API_DLL_EXPORT CSG_PriorityQueue
277 {
278 public:
279 
280  //-----------------------------------------------------
281  class CSG_PriorityQueueItem
282  {
283  public:
284  CSG_PriorityQueueItem(void) {}
285 
286  virtual int Compare (CSG_PriorityQueueItem *pItem) = 0;
287 
288  };
289 
290  //-----------------------------------------------------
291  CSG_PriorityQueue(size_t maxSize = 256);
292 
293  virtual ~CSG_PriorityQueue(void);
294 
295  void Create (size_t maxSize = 256);
296  void Destroy (void);
297 
298  //-----------------------------------------------------
299  bool is_Empty (void) const { return( m_nItems == 0 ); }
300  size_t Get_Size (void) const { return( m_nItems ); }
301  CSG_PriorityQueueItem * Get_Item (size_t i) const { return( m_Items[i] ); }
302 
303  void Add (CSG_PriorityQueueItem *pItem);
304 
305  CSG_PriorityQueueItem * Peek (void) const { return( Minimum() ); }
306  CSG_PriorityQueueItem * Poll (void);
307 
308  //-----------------------------------------------------
309  CSG_PriorityQueueItem * Minimum (void) const
310  {
311  if( m_nItems )
312  {
313  if( m_pLeaf[0] )
314  {
315  return( m_pLeaf[0]->Minimum() );
316  }
317 
318  return( m_Items[0] );
319  }
320 
321  return( NULL );
322  }
323 
324  CSG_PriorityQueueItem * Maximum (void) const
325  {
326  if( m_nItems )
327  {
328  if( m_pLeaf[1] )
329  {
330  return( m_pLeaf[1]->Maximum() );
331  }
332 
333  return( m_Items[m_nItems - 1] );
334  }
335 
336  return( NULL );
337  }
338 
339 
340 private:
341 
342  size_t m_nItems, m_maxSize;
343 
344  CSG_PriorityQueue *m_pLeaf[2];
345 
346  CSG_PriorityQueueItem **m_Items;
347 
348 
349  size_t _Insert_Position (CSG_PriorityQueueItem *pItem);
350 
351 };
352 
353 
355 // //
356 // //
357 // //
359 
360 //---------------------------------------------------------
361 class SAGA_API_DLL_EXPORT CSG_Vector
362 {
363 public:
364  CSG_Vector(void);
365  virtual ~CSG_Vector(void);
366 
367  CSG_Vector (const CSG_Vector &Vector);
368  bool Create (const CSG_Vector &Vector);
369 
370  CSG_Vector (sLong n, const double *Data = NULL);
371  bool Create (sLong n, const double *Data = NULL);
372 
373  bool Destroy (void);
374 
375  bool Set_Rows (sLong nRows);
376  bool Add_Rows (sLong nRows);
377  bool Del_Rows (sLong nRows);
378  bool Add_Row (double Value = 0.);
379  bool Del_Row (sLong Row = -1);
380 
381  sLong Get_Row_Count (void) const { return( m_Array.Get_Size () ); }
382  sLong Get_Size (void) const { return( m_Array.Get_Size () ); }
383  size_t Get_uSize (void) const { return( m_Array.Get_uSize() ); }
384  int Get_N (void) const { return( (int)m_Array.Get_Size() ); }
385 
386  double * Get_Data (void) const { return( (double *)m_Array.Get_Array() ); }
387  double Get_Data (sLong x) const { return( Get_Data()[x] ); }
388  double operator () (sLong x) const { return( Get_Data()[x] ); }
389  double & operator [] (sLong x) { return( Get_Data()[x] ); }
390  double & operator [] (size_t x) { return( Get_Data()[x] ); }
391  double & operator [] (int x) { return( Get_Data()[x] ); }
392  const double & operator [] (sLong x) const { return( Get_Data()[x] ); }
393  const double & operator [] (size_t x) const { return( Get_Data()[x] ); }
394  const double & operator [] (int x) const { return( Get_Data()[x] ); }
395  operator const double * (void) const { return( Get_Data() ); }
396 
397  CSG_String to_String (int Width = -1, int Precision = -1, bool bScientific = false, const SG_Char *Separator = NULL) const;
398  bool from_String (const CSG_String &String);
399 
400  bool is_Null (void) const;
401  bool is_Equal (const CSG_Vector &Vector) const;
402  bool is_Collinear (const CSG_Vector &Vector) const;
403 
404  bool Assign (double Scalar);
405  bool Assign (const CSG_Vector &Vector);
406  bool Add (double Scalar);
407  bool Add (const CSG_Vector &Vector);
408  bool Subtract (const CSG_Vector &Vector);
409  bool Multiply (double Scalar);
410  bool Multiply (const CSG_Vector &Vector);
411  bool Multiply_Cross (const CSG_Vector &Vector);
412  double Multiply_Scalar (const CSG_Vector &Vector) const;
413  bool Multiply (const class CSG_Matrix &Matrix);
414 
415  bool operator == (const CSG_Vector &Vector) const { return( is_Equal(Vector) ); }
416  bool operator != (const CSG_Vector &Vector) const { return( !is_Equal(Vector) ); }
417  CSG_Vector & operator = (double Scalar);
418  CSG_Vector & operator = (const CSG_Vector &Vector);
419  CSG_Vector & operator += (double Scalar);
420  CSG_Vector & operator += (const CSG_Vector &Vector);
421  CSG_Vector & operator -= (double Scalar);
422  CSG_Vector & operator -= (const CSG_Vector &Vector);
423  CSG_Vector & operator *= (double Scalar);
424  CSG_Vector & operator *= (const CSG_Vector &Vector);
425  CSG_Vector & operator *= (const class CSG_Matrix &Matrix);
426  CSG_Vector operator + (double Scalar) const;
427  CSG_Vector operator + (const CSG_Vector &Vector) const;
428  CSG_Vector operator - (double Scalar) const;
429  CSG_Vector operator - (const CSG_Vector &Vector) const;
430  CSG_Vector operator * (double Scalar) const;
431  double operator * (const CSG_Vector &Vector) const;
432 
433  bool Set_Zero (void);
434  bool Set_Unity (void);
435 
436  bool Flip_Values (void);
437 
438  bool Sort (bool bAscending = true);
439 
440  double Get_Length (void) const;
441  CSG_Vector Get_Scalar_Product (const CSG_Vector &Vector) const;
442  CSG_Vector Get_Cross_Product (const CSG_Vector &Vector) const;
443  double Get_Angle (const CSG_Vector &Vector) const;
444  CSG_Vector Get_Unity (void) const;
445 
446  typedef double const * const_iterator;
447 
448  const_iterator begin (void) const { return( Get_Data() ); }
449  const_iterator end (void) const { return( Get_Data() + Get_Size() ); }
450  const_iterator cbegin (void) const { return( Get_Data() ); }
451  const_iterator cend (void) const { return( Get_Data() + Get_Size() ); }
452 
453 
454 private:
455 
456  CSG_Array m_Array;
457 
458 };
459 
460 //---------------------------------------------------------
461 SAGA_API_DLL_EXPORT CSG_Vector operator * (double Scalar, const CSG_Vector &Vector);
462 
463 //---------------------------------------------------------
464 SAGA_API_DLL_EXPORT bool SG_VectorR2_Rotate (double &x, double &y, double Angle);
465 SAGA_API_DLL_EXPORT bool SG_VectorR2_Rotate (double Vector[2], double Angle);
466 SAGA_API_DLL_EXPORT bool SG_VectorR2_Rotate (CSG_Vector &Vector , double Angle);
467 
468 SAGA_API_DLL_EXPORT bool SG_VectorR3_Rotate (double Vector[3], size_t Axis, double Angle);
469 SAGA_API_DLL_EXPORT bool SG_VectorR3_Rotate (CSG_Vector &Vector , size_t Axis, double Angle);
470 
471 
473 // //
474 // //
475 // //
477 
478 //---------------------------------------------------------
479 class SAGA_API_DLL_EXPORT CSG_Matrix
480 {
481 public:
482  CSG_Matrix(void);
483  virtual ~CSG_Matrix(void);
484 
485  CSG_Matrix (const CSG_Matrix &Matrix);
486  bool Create (const CSG_Matrix &Matrix);
487 
488  CSG_Matrix (sLong nCols, sLong nRows, const double *Data = NULL);
489  bool Create (sLong nCols, sLong nRows, const double *Data = NULL);
490 
491  CSG_Matrix (sLong nCols, sLong nRows, const double **Data);
492  bool Create (sLong nCols, sLong nRows, const double **Data);
493 
494  bool Destroy (void);
495 
496  bool Set_Size (sLong nRows, sLong nCols);
497  bool Set_Cols (sLong nCols);
498  bool Set_Rows (sLong nRows);
499  bool Add_Cols (sLong nCols);
500  bool Add_Rows (sLong nRows);
501  bool Del_Cols (sLong nCols);
502  bool Del_Rows (sLong nRows);
503  bool Add_Col ( const double *Data = NULL);
504  bool Add_Col ( const CSG_Vector &Data);
505  bool Add_Row ( const double *Data = NULL);
506  bool Add_Row ( const CSG_Vector &Data);
507  bool Ins_Col (sLong Col, const double *Data = NULL);
508  bool Ins_Col (sLong Col, const CSG_Vector &Data);
509  bool Ins_Row (sLong Row, const double *Data = NULL);
510  bool Ins_Row (sLong Row, const CSG_Vector &Data);
511  bool Set_Col (sLong Col, const double *Data);
512  bool Set_Col (sLong Col, const CSG_Vector &Data);
513  bool Set_Col ( const CSG_Vector &Data);
514  bool Set_Row (sLong Row, const double *Data);
515  bool Set_Row (sLong Row, const CSG_Vector &Data);
516  bool Set_Row ( const CSG_Vector &Data);
517  bool Del_Col (sLong Col);
518  bool Del_Row (sLong Row);
519  CSG_Vector Get_Col (sLong Col) const;
520  CSG_Vector Get_Row (sLong Row) const;
521 
522  int Get_NX (void) const { return( (int)m_nx ); }
523  int Get_NY (void) const { return( (int)m_ny ); }
524  sLong Get_NCols (void) const { return( m_nx ); }
525  sLong Get_NRows (void) const { return( m_ny ); }
526 
527  operator const double ** (void) const { return( (const double **)m_z ); }
528  double ** Get_Data (void) const { return( m_z ); }
529 
530  double operator () (sLong Row, sLong Col) const { return( m_z[Row][Col] ); }
531  double * operator [] (sLong Row) const { return( m_z[Row] ); }
532  double * operator [] (size_t Row) const { return( m_z[Row] ); }
533  double * operator [] (int Row) const { return( m_z[Row] ); }
534 
535  CSG_String to_String (int Width = -1, int Precision = -1, bool bScientific = false, const SG_Char *Separator = NULL) const;
536  bool from_String (const CSG_String &String);
537 
538  bool is_Square (void) const { return( m_nx > 0 && m_nx == m_ny ); }
539  bool is_Equal (const CSG_Matrix &Matrix) const;
540 
541  bool Assign (double Scalar);
542  bool Assign (const CSG_Matrix &Matrix);
543  bool Add (double Scalar);
544  bool Add (const CSG_Matrix &Matrix);
545  bool Subtract (const CSG_Matrix &Matrix);
546  bool Multiply (double Scalar);
547  CSG_Vector Multiply (const CSG_Vector &Vector) const;
548  CSG_Matrix Multiply (const CSG_Matrix &Matrix) const;
549 
550  bool operator == (const CSG_Matrix &Matrix) const;
551  CSG_Matrix & operator = (double Scalar);
552  CSG_Matrix & operator = (const CSG_Matrix &Matrix);
553  CSG_Matrix & operator += (double Scalar);
554  CSG_Matrix & operator += (const CSG_Matrix &Matrix);
555  CSG_Matrix & operator -= (double Scalar);
556  CSG_Matrix & operator -= (const CSG_Matrix &Matrix);
557  CSG_Matrix & operator *= (double Scalar);
558  CSG_Matrix & operator *= (const CSG_Matrix &Matrix);
559  CSG_Matrix operator + (double Scalar) const;
560  CSG_Matrix operator + (const CSG_Matrix &Matrix) const;
561  CSG_Matrix operator - (double Scalar) const;
562  CSG_Matrix operator - (const CSG_Matrix &Matrix) const;
563  CSG_Matrix operator * (double Scalar) const;
564  CSG_Vector operator * (const CSG_Vector &Vector) const;
565  CSG_Matrix operator * (const CSG_Matrix &Matrix) const;
566 
567  bool Set_Zero (void);
568  bool Set_Identity (void);
569  bool Set_Transpose (void);
570  bool Set_Inverse (bool bSilent = true, int nSubSquare = 0);
571 
572  double Get_Determinant (void) const;
573  CSG_Matrix Get_Transpose (void) const;
574  CSG_Matrix Get_Inverse (bool bSilent = true, int nSubSquare = 0) const;
575 
576 
577 private:
578 
579  sLong m_nx, m_ny;
580 
581  double **m_z;
582 
583 
584  void _On_Construction (void);
585 
586 };
587 
588 //---------------------------------------------------------
589 SAGA_API_DLL_EXPORT CSG_Matrix operator * (double Scalar, const CSG_Matrix &Matrix);
590 
591 //---------------------------------------------------------
592 SAGA_API_DLL_EXPORT CSG_Matrix SG_Matrix_Get_Rotation (double R , bool bDegree = false);
593 SAGA_API_DLL_EXPORT CSG_Matrix SG_Matrix_Get_Rotation (double Rx, double Ry, double Rz, bool bDegree = false);
594 
595 //---------------------------------------------------------
596 SAGA_API_DLL_EXPORT bool SG_Matrix_LU_Decomposition (int n, int *Permutation, double **Matrix , bool bSilent = true, int *nRowChanges = NULL);
597 SAGA_API_DLL_EXPORT bool SG_Matrix_LU_Solve (int n, const int *Permutation, const double **Matrix, double *Vector, bool bSilent = true);
598 
599 SAGA_API_DLL_EXPORT bool SG_Matrix_Solve (CSG_Matrix &Matrix, CSG_Vector &Vector, bool bSilent = true);
600 SAGA_API_DLL_EXPORT bool SG_Matrix_Eigen_Reduction (const CSG_Matrix &Matrix, CSG_Matrix &Eigen_Vectors, CSG_Vector &Eigen_Values, bool bSilent = true);
601 
602 
604 // //
605 // //
606 // //
608 
609 //---------------------------------------------------------
610 class SAGA_API_DLL_EXPORT CSG_Grid_Radius
611 {
612 public:
613  CSG_Grid_Radius(int maxRadius = 0);
614  ~CSG_Grid_Radius(void);
615 
616  bool Create (int maxRadius);
617  void Destroy (void);
618 
619  int Get_Maximum (void) { return( m_maxRadius ); }
620 
621  int Get_nPoints (void) { return( m_nPoints ); }
622  int Get_nPoints (int iRadius) { return( iRadius >= 0 && iRadius < m_maxRadius ? m_nPoints_R[iRadius] : 0 ); }
623 
624  double Get_Point (int iPoint, int &x, int &y)
625  {
626  if( iPoint >= 0 && iPoint < m_nPoints )
627  {
628  x = m_Points[iPoint].x;
629  y = m_Points[iPoint].y;
630 
631  return( m_Points[iPoint].d ); // Distance...
632  }
633 
634  return( -1. );
635  }
636 
637  double Get_Point (int iPoint, int xOffset, int yOffset, int &x, int &y)
638  {
639  double d;
640 
641  if( (d = Get_Point(iPoint, x, y)) >= 0. )
642  {
643  x += xOffset;
644  y += yOffset;
645  }
646 
647  return( d );
648  }
649 
650  double Get_Point (int iRadius, int iPoint, int &x, int &y)
651  {
652  if( iRadius >= 0 && iRadius <= m_maxRadius && iPoint >= 0 && iPoint < m_nPoints_R[iRadius] )
653  {
654  x = m_Points_R[iRadius][iPoint].x;
655  y = m_Points_R[iRadius][iPoint].y;
656 
657  return( m_Points_R[iRadius][iPoint].d ); // Distance...
658  }
659 
660  return( -1. );
661  }
662 
663  double Get_Point (int iRadius, int iPoint, int xOffset, int yOffset, int &x, int &y)
664  {
665  double d;
666 
667  if( (d = Get_Point(iRadius, iPoint, x, y)) >= 0. )
668  {
669  x += xOffset;
670  y += yOffset;
671  }
672 
673  return( d );
674  }
675 
676 
677 private:
678 
679  int m_maxRadius, m_nPoints, *m_nPoints_R;
680 
681  typedef struct SSG_Grid_Radius
682  {
683  int x, y;
684 
685  double d;
686  }
687  TSG_Grid_Radius;
688 
689  TSG_Grid_Radius *m_Points, **m_Points_R;
690 
691 };
692 
693 
695 // //
696 // //
697 // //
699 
700 //---------------------------------------------------------
701 class SAGA_API_DLL_EXPORT CSG_Random
702 {
703 public:
704  CSG_Random(void);
705 
706  static void Initialize (void);
707  static void Initialize (unsigned int Value);
708 
709  static double Get_Uniform (void);
710  static double Get_Uniform (double min, double max);
711 
712  static double Get_Gaussian (double mean, double stddev);
713 
714 };
715 
716 
718 // //
719 // //
720 // //
722 
723 //---------------------------------------------------------
724 class SAGA_API_DLL_EXPORT CSG_Simple_Statistics
725 {
726 public:
727  CSG_Simple_Statistics(void);
728  CSG_Simple_Statistics(bool bHoldValues);
729  CSG_Simple_Statistics(const CSG_Simple_Statistics &Statistics);
730  CSG_Simple_Statistics(double Mean, double StdDev, sLong Count = 1000);
731  CSG_Simple_Statistics(const CSG_Vector &Values, bool bHoldValues = false);
732 
733  bool Create (bool bHoldValues = false);
734  bool Create (const CSG_Simple_Statistics &Statistics);
735  bool Create (double Mean, double StdDev, sLong Count = 1000);
736  bool Create (const CSG_Vector &Values, bool bHoldValues = false);
737 
738  void Invalidate (void);
739  bool Evaluate (void);
740 
741  int is_Evaluated (void) const { return( m_bEvaluated ); }
742 
743  bool Set_Count (sLong Count);
744 
745  sLong Get_Count (void) const { return( m_nValues ); }
746  double Get_Weights (void) const { return( m_Weights ); }
747 
748  double Get_Minimum (void) { if( m_bEvaluated < 1 ) _Evaluate(1); return( m_Minimum ); }
749  double Get_Maximum (void) { if( m_bEvaluated < 1 ) _Evaluate(1); return( m_Maximum ); }
750  double Get_Range (void) { if( m_bEvaluated < 1 ) _Evaluate(1); return( m_Range ); }
751  double Get_Sum (void) { if( m_bEvaluated < 1 ) _Evaluate(1); return( m_Sum ); }
752  double Get_Sum_Of_Squares (void) { if( m_bEvaluated < 1 ) _Evaluate(1); return( m_Sum2 ); }
753  double Get_Mean (void) { if( m_bEvaluated < 1 ) _Evaluate(1); return( m_Mean ); }
754  double Get_Variance (void) { if( m_bEvaluated < 1 ) _Evaluate(1); return( m_Variance ); }
755  double Get_StdDev (void) { if( m_bEvaluated < 1 ) _Evaluate(1); return( m_StdDev ); }
756 
757  double Get_Kurtosis (void) { if( m_bEvaluated < 2 ) _Evaluate(2); return( m_Kurtosis ); }
758  double Get_Skewness (void) { if( m_bEvaluated < 2 ) _Evaluate(2); return( m_Skewness ); }
759  double Get_SkewnessPearson (void);
760 
761  double Get_Quantile (double Quantile);
762  double Get_Percentile (double Percentile);
763  double Get_Median (void);
764  double Get_Gini (void);
765 
766  sLong Get_IndexOfMinimum (void);
767  sLong Get_IndexOfMaximum (void);
768 
769  sLong Get_nValues_Above (double Threshold, bool bEquals = false);
770  sLong Get_nValues_Below (double Threshold, bool bEquals = false);
771 
772  void Add (const CSG_Simple_Statistics &Statistics);
773 
774  void Add_Value (double Value, double Weight = 1.);
775 
776  double * Get_Values (void) const { return( (double *)m_Values.Get_Array() ); }
777  double Get_Value (sLong i) const { return( i >= 0 && i < (sLong)m_Values.Get_Size() ? Get_Values()[i] : m_Mean ); }
778  double operator [] (sLong i) const { return( i >= 0 && i < (sLong)m_Values.Get_Size() ? Get_Values()[i] : m_Mean ); }
779 
780 
781  CSG_Simple_Statistics & operator = (const CSG_Simple_Statistics &Statistics) { Create(Statistics); return( *this ); }
782  CSG_Simple_Statistics & operator += (const CSG_Simple_Statistics &Statistics) { Add(Statistics); return( *this ); }
783  CSG_Simple_Statistics & operator += (double Value) { Add_Value(Value); return( *this ); }
784 
785 
786 protected:
787 
788  bool m_bSorted;
789 
790  int m_bEvaluated;
791 
792  sLong m_nValues;
793 
794  double m_Weights, m_Sum, m_Sum2, m_Minimum, m_Maximum, m_Range, m_Mean, m_Variance, m_StdDev, m_Kurtosis, m_Skewness, m_Gini;
795 
796  CSG_Array m_Values;
797 
798 
799  void _Evaluate (int Level = 1);
800 
801 };
802 
803 
805 // //
806 // //
807 // //
809 
810 //---------------------------------------------------------
811 class SAGA_API_DLL_EXPORT CSG_Unique_Value_Statistics
812 {
813 public:
814  CSG_Unique_Value_Statistics (void) {}
815  virtual ~CSG_Unique_Value_Statistics (void) {}
816 
817  virtual void Create (bool bWeights = false) { m_bWeights = bWeights; }
818 
819  int Get_Count (void) const { return( (int)m_Count.Get_Size() ); }
820  int Get_Count (int i) const { return( m_Count[i] ); }
821  double Get_Weight (int i) const { return( m_bWeights ? m_Weight[i] : m_Count[i] ); }
822 
823  virtual int Get_Majority (bool bWeighted = false) const;
824  virtual int Get_Minority (bool bWeighted = false) const;
825 
826  virtual bool Get_Majority (double &Value ) const { return( false ); }
827  virtual bool Get_Majority (double &Value, int &Count) const { return( false ); }
828  virtual bool Get_Minority (double &Value ) const { return( false ); }
829  virtual bool Get_Minority (double &Value, int &Count) const { return( false ); }
830 
831  virtual bool Get_Majority (CSG_String &Value ) const { return( false ); }
832  virtual bool Get_Majority (CSG_String &Value, int &Count) const { return( false ); }
833  virtual bool Get_Minority (CSG_String &Value ) const { return( false ); }
834  virtual bool Get_Minority (CSG_String &Value, int &Count) const { return( false ); }
835 
836 
837 protected:
838 
839  bool m_bWeights{false};
840 
841  CSG_Array_Int m_Count;
842 
843  CSG_Vector m_Weight;
844 
845 };
846 
847 //---------------------------------------------------------
848 class SAGA_API_DLL_EXPORT CSG_Unique_Number_Statistics : public CSG_Unique_Value_Statistics
849 {
850 public:
851  CSG_Unique_Number_Statistics (bool bWeights = false) { Create(bWeights); }
852  virtual ~CSG_Unique_Number_Statistics (void) {}
853 
854  virtual void Create (bool bWeights = false);
855 
856  void operator += (double Value) { Add_Value(Value); }
857  void Add_Value (double Value, double Weight = 1.);
858  double Get_Value (int Index) const { return( m_Value[Index] ); }
859  int Get_Class_Index (double Value) const;
860  bool Get_Class (int Index, double &Value, int &Count) const
861  {
862  if( Index < 0 || Index >= Get_Count() ) return( false );
863 
864  Count = m_Count[Index];
865  Value = m_Value[Index];
866 
867  return( true );
868  }
869 
870  virtual bool Get_Majority (double &Value ) const { int Count; return( Get_Class(CSG_Unique_Value_Statistics::Get_Majority(), Value, Count) ); }
871  virtual bool Get_Majority (double &Value, int &Count) const { return( Get_Class(CSG_Unique_Value_Statistics::Get_Majority(), Value, Count) && Count > 0 ); }
872  virtual bool Get_Minority (double &Value ) const { int Count; return( Get_Class(CSG_Unique_Value_Statistics::Get_Minority(), Value, Count) ); }
873  virtual bool Get_Minority (double &Value, int &Count) const { return( Get_Class(CSG_Unique_Value_Statistics::Get_Minority(), Value, Count) && Count > 0 ); }
874 
875 
876 private:
877 
878  CSG_Vector m_Value;
879 
880 };
881 
882 //---------------------------------------------------------
883 class SAGA_API_DLL_EXPORT CSG_Unique_String_Statistics : public CSG_Unique_Value_Statistics
884 {
885 public:
886  CSG_Unique_String_Statistics (bool bWeights = false) { Create(bWeights); }
887  virtual ~CSG_Unique_String_Statistics (void) {}
888 
889  virtual void Create (bool bWeights = false);
890 
891  void operator += (const CSG_String &Value) { Add_Value(Value); }
892  void Add_Value (const CSG_String &Value, double Weight = 1.);
893  const SG_Char * Get_Value (int Index) const { return( m_Value[Index] ); }
894  int Get_Class_Index (const CSG_String &Value) const;
895  bool Get_Class (int Index, CSG_String &Value, int &Count) const
896  {
897  if( Index < 0 || Index >= Get_Count() ) return( false );
898 
899  Count = m_Count[Index];
900  Value = m_Value[Index];
901 
902  return( true );
903  }
904 
905  virtual bool Get_Majority (CSG_String &Value ) const { int Count; return( Get_Class(CSG_Unique_Value_Statistics::Get_Majority(), Value, Count) ); }
906  virtual bool Get_Majority (CSG_String &Value, int &Count) const { return( Get_Class(CSG_Unique_Value_Statistics::Get_Majority(), Value, Count) && Count > 0 ); }
907  virtual bool Get_Minority (CSG_String &Value ) const { int Count; return( Get_Class(CSG_Unique_Value_Statistics::Get_Minority(), Value, Count) ); }
908  virtual bool Get_Minority (CSG_String &Value, int &Count) const { return( Get_Class(CSG_Unique_Value_Statistics::Get_Minority(), Value, Count) && Count > 0 ); }
909 
910 
911 private:
912 
913  CSG_Strings m_Value;
914 
915 };
916 
917 
919 // //
920 // //
921 // //
923 
924 //---------------------------------------------------------
925 class SAGA_API_DLL_EXPORT CSG_Category_Statistics
926 {
927 public:
928  CSG_Category_Statistics (TSG_Data_Type Type = SG_DATATYPE_String);
929  virtual ~CSG_Category_Statistics (void);
930 
931  void Create (TSG_Data_Type Type = SG_DATATYPE_String);
932  void Destroy (void);
933 
934  TSG_Data_Type Get_Category_Type (void) const;
935 
936  int Add_Value (int Value);
937  int Add_Value (double Value);
938  int Add_Value (const CSG_String &Value);
939 
940  void operator += (int Value) { Add_Value(Value); }
941  void operator += (double Value) { Add_Value(Value); }
942  void operator += (const CSG_String &Value) { Add_Value(Value); }
943 
944  bool Sort (void);
945 
946  int Get_Count (void ) const;
947  int Get_Count (int iCategory) const;
948 
949  int asInt (int iCategory) const;
950  double asDouble (int iCategory) const;
951  CSG_String asString (int iCategory) const;
952 
953  int Get_Category (int Value) const;
954  int Get_Category (double Value) const;
955  int Get_Category (const CSG_String &Value) const;
956 
957  bool Get_Category (int iCategory, int &Value, int &Count) const
958  {
959  Count = Get_Count(iCategory);
960  Value = asInt (iCategory);
961 
962  return( iCategory >= 0 && iCategory < Get_Count() );
963  }
964 
965  bool Get_Category (int iCategory, double &Value, int &Count) const
966  {
967  Count = Get_Count(iCategory);
968  Value = asDouble (iCategory);
969 
970  return( iCategory >= 0 && iCategory < Get_Count() );
971  }
972 
973  bool Get_Category (int iCategory, CSG_String &Value, int &Count) const
974  {
975  Count = Get_Count(iCategory);
976  Value = asString (iCategory);
977 
978  return( iCategory >= 0 && iCategory < Get_Count() );
979  }
980 
981  int Get_Majority (void);
982  bool Get_Majority (int &Value ) { int Count; return( Get_Category(Get_Majority(), Value, Count) ); }
983  bool Get_Majority (double &Value ) { int Count; return( Get_Category(Get_Majority(), Value, Count) ); }
984  bool Get_Majority (CSG_String &Value ) { int Count; return( Get_Category(Get_Majority(), Value, Count) ); }
985  bool Get_Majority (int &Value, int &Count) { return( Get_Category(Get_Majority(), Value, Count) && Count > 0 ); }
986  bool Get_Majority (double &Value, int &Count) { return( Get_Category(Get_Majority(), Value, Count) && Count > 0 ); }
987  bool Get_Majority (CSG_String &Value, int &Count) { return( Get_Category(Get_Majority(), Value, Count) && Count > 0 ); }
988 
989  int Get_Minority (void);
990  bool Get_Minority (int &Value ) { int Count; return( Get_Category(Get_Minority(), Value, Count) ); }
991  bool Get_Minority (double &Value ) { int Count; return( Get_Category(Get_Minority(), Value, Count) ); }
992  bool Get_Minority (CSG_String &Value ) { int Count; return( Get_Category(Get_Minority(), Value, Count) ); }
993  bool Get_Minority (int &Value, int &Count) { return( Get_Category(Get_Minority(), Value, Count) && Count > 0 ); }
994  bool Get_Minority (double &Value, int &Count) { return( Get_Category(Get_Minority(), Value, Count) && Count > 0 ); }
995  bool Get_Minority (CSG_String &Value, int &Count) { return( Get_Category(Get_Minority(), Value, Count) && Count > 0 ); }
996 
997 
998 private:
999 
1000  class CSG_Table *m_pTable;
1001 
1002 };
1003 
1004 
1006 // //
1007 // //
1008 // //
1010 
1011 //---------------------------------------------------------
1012 class SAGA_API_DLL_EXPORT CSG_Histogram
1013 {
1014 public:
1015  CSG_Histogram(void);
1016  virtual ~CSG_Histogram(void);
1017 
1018  bool Destroy (void);
1019 
1020  CSG_Histogram (const CSG_Histogram &Histogram);
1021  bool Create (const CSG_Histogram &Histogram);
1022 
1023  CSG_Histogram (size_t nClasses, double Minimum, double Maximum);
1024  bool Create (size_t nClasses, double Minimum, double Maximum);
1025 
1026  CSG_Histogram (size_t nClasses, const CSG_Vector &Values , double Minimum = 0., double Maximum = 0., size_t maxSamples = 0);
1027  bool Create (size_t nClasses, const CSG_Vector &Values , double Minimum = 0., double Maximum = 0., size_t maxSamples = 0);
1028 
1029  CSG_Histogram (size_t nClasses, class CSG_Table *pTable, int Field, double Minimum = 0., double Maximum = 0., size_t maxSamples = 0);
1030  bool Create (size_t nClasses, class CSG_Table *pTable, int Field, double Minimum = 0., double Maximum = 0., size_t maxSamples = 0);
1031 
1032  CSG_Histogram (size_t nClasses, class CSG_Grid *pGrid , double Minimum = 0., double Maximum = 0., size_t maxSamples = 0);
1033  bool Create (size_t nClasses, class CSG_Grid *pGrid , double Minimum = 0., double Maximum = 0., size_t maxSamples = 0);
1034 
1035  CSG_Histogram (size_t nClasses, class CSG_Grids *pGrids , double Minimum = 0., double Maximum = 0., size_t maxSamples = 0);
1036  bool Create (size_t nClasses, class CSG_Grids *pGrids , double Minimum = 0., double Maximum = 0., size_t maxSamples = 0);
1037 
1038  //-----------------------------------------------------
1039  void Add_Value (double Value);
1040 
1041  bool Add_Histogram (const CSG_Histogram &Histogram );
1042 
1043  bool Scale_Element_Count (double Scale);
1044 
1045  bool Update (void);
1046 
1047  bool is_Okay (void) const { return( m_nClasses && Get_Element_Count() ); }
1048 
1049  size_t Get_Class_Count (void) const { return( m_nClasses ); }
1050 
1051  size_t Get_Element_Count (void) const { return( m_nClasses ? m_Cumulative[m_nClasses - 1] : 0 ); }
1052  size_t Get_Element_Maximum (void) const { return( m_nMaximum ); }
1053 
1054  size_t Get_Elements (int i) const { return( Get_Elements ((size_t)i) ); }
1055  size_t Get_Elements (size_t i) const { return( i < m_nClasses ? m_Elements [i] : 0 ); }
1056 
1057  size_t Get_Cumulative (int i) const { return( Get_Cumulative((size_t)i) ); }
1058  size_t Get_Cumulative (size_t i) const { return( i < m_nClasses ? m_Cumulative[i] : 0 ); }
1059 
1060  double Get_Value (double i) const { return( m_nClasses < 1 ? m_Minimum : m_Minimum + i * m_ClassWidth ); }
1061 
1062  double Get_Break (int i) const { return( Get_Value((double)(i)) ); }
1063  double Get_Break (size_t i) const { return( Get_Value((double)(i)) ); }
1064 
1065  double Get_Center (int i) const { return( Get_Value((double)(i + 0.5)) ); }
1066  double Get_Center (size_t i) const { return( Get_Value((double)(i + 0.5)) ); }
1067 
1068  //-----------------------------------------------------
1069  CSG_Histogram & operator = (const CSG_Histogram &Histogram);
1070 
1071  void operator += (double Value) { Add_Value(Value); }
1072 
1073  size_t operator [] (int i) const { return( Get_Elements(i) ); }
1074  size_t operator [] (size_t i) const { return( Get_Elements(i) ); }
1075 
1076  double Get_Quantile (double Quantile) const;
1077  double Get_Quantile_Value (double Value) const;
1078 
1079  double Get_Percentile (double Percentile) const;
1080  double Get_Percentile_Value(double Value) const;
1081 
1082  const CSG_Simple_Statistics & Get_Statistics (void) const { return( m_Statistics ); }
1083 
1084 
1085 private:
1086 
1087  size_t m_nClasses = 0, m_nMaximum = 0, *m_Elements = NULL, *m_Cumulative = NULL;
1088 
1089  double m_Minimum = 0., m_Maximum = 0., m_ClassWidth = 1.;
1090 
1091  CSG_Simple_Statistics m_Statistics;
1092 
1093 
1094  void _On_Construction (void);
1095 
1096  bool _Create (size_t nClasses, double Minimum, double Maximum);
1097 
1098  bool _Update (sLong nElements);
1099 
1100 };
1101 
1102 
1104 // //
1105 // //
1106 // //
1108 
1109 //---------------------------------------------------------
1110 class SAGA_API_DLL_EXPORT CSG_Natural_Breaks
1111 {
1112 public:
1113  CSG_Natural_Breaks(void);
1114  virtual ~CSG_Natural_Breaks(void);
1115 
1116  CSG_Natural_Breaks (class CSG_Table *pTable, int Field, int nClasses, int Histogram = 0);
1117  bool Create (class CSG_Table *pTable, int Field, int nClasses, int Histogram = 0);
1118 
1119  CSG_Natural_Breaks (class CSG_Grid *pGrid , int nClasses, int Histogram = 0);
1120  bool Create (class CSG_Grid *pGrid , int nClasses, int Histogram = 0);
1121 
1122  CSG_Natural_Breaks (class CSG_Grids *pGrids , int nClasses, int Histogram = 0);
1123  bool Create (class CSG_Grids *pGrids , int nClasses, int Histogram = 0);
1124 
1125  CSG_Natural_Breaks (const CSG_Vector &Values , int nClasses, int Histogram = 0);
1126  bool Create (const CSG_Vector &Values , int nClasses, int Histogram = 0);
1127 
1128  int Get_Count (void) const { return( m_Breaks.Get_N() ); }
1129  double Get_Break (int i) const { return( m_Breaks[i] ); }
1130 
1131  double operator [] (int i) const { return( m_Breaks[i] ); }
1132 
1133 
1134 private:
1135 
1136  CSG_Histogram m_Histogram;
1137 
1138  CSG_Vector m_Breaks, m_Values;
1139 
1140 
1141  bool _Histogram (int nClasses);
1142 
1143  double _Get_Value (int i);
1144 
1145  bool _Calculate (int nClasses);
1146 
1147 };
1148 
1149 
1151 // //
1152 // //
1153 // //
1155 
1156 //---------------------------------------------------------
1157 enum ESG_Cluster_Analysis_Method
1158 {
1159  SG_CLUSTERANALYSIS_Minimum_Distance = 0,
1160  SG_CLUSTERANALYSIS_Hill_Climbing,
1161  SG_CLUSTERANALYSIS_Combined
1162 };
1163 
1164 //---------------------------------------------------------
1165 class SAGA_API_DLL_EXPORT CSG_Cluster_Analysis
1166 {
1167 public:
1168  CSG_Cluster_Analysis(void);
1169  virtual ~CSG_Cluster_Analysis(void);
1170 
1171  bool Create (int nFeatures);
1172  bool Destroy (void);
1173 
1174  bool Add_Element (void);
1175  bool Set_Feature (sLong iElement, int iFeature, double Value);
1176 
1177  sLong Get_Cluster (sLong iElement) const { return( iElement >= 0 && iElement < Get_nElements() ? m_Clusters[iElement] : -1 ); }
1178 
1179  bool Execute (int Method, int nClusters, int nMaxIterations = 0, int Initialization = 0);
1180 
1181  sLong Get_nElements (void) const { return( m_Features.Get_Size() ); }
1182  int Get_nFeatures (void) const { return( m_nFeatures ); }
1183  int Get_nClusters (void) const { return( (int)m_nMembers.Get_Size() ); }
1184 
1185  int Get_Iteration (void) const { return( m_Iteration ); }
1186 
1187  double Get_SP (void) const { return( m_SP ); }
1188 
1189  int Get_nMembers (int iCluster) const { return( m_nMembers[iCluster] ); }
1190  double Get_Variance (int iCluster) const { return( m_Variance[iCluster] ); }
1191  double Get_Centroid (int iCluster, int iFeature) const { return( m_Centroid[iCluster][iFeature] ); }
1192 
1193 
1194 private:
1195 
1196  int m_Iteration, m_nFeatures;
1197 
1198  double m_SP;
1199 
1200  CSG_Array_Int m_Clusters, m_nMembers;
1201 
1202  CSG_Array m_Features;
1203 
1204  CSG_Vector m_Variance;
1205 
1206  CSG_Matrix m_Centroid;
1207 
1208 
1209  bool _Minimum_Distance (bool bInitialize, int nMaxIterations);
1210 
1211  bool _Hill_Climbing (bool bInitialize, int nMaxIterations);
1212 
1213 };
1214 
1215 
1217 // //
1218 // //
1219 // //
1221 
1222 //---------------------------------------------------------
1223 enum ESG_Classify_Supervised
1224 {
1225  SG_CLASSIFY_SUPERVISED_BinaryEncoding = 0,
1226  SG_CLASSIFY_SUPERVISED_ParallelEpiped,
1227  SG_CLASSIFY_SUPERVISED_MinimumDistance,
1228  SG_CLASSIFY_SUPERVISED_Mahalonobis,
1229  SG_CLASSIFY_SUPERVISED_MaximumLikelihood,
1230  SG_CLASSIFY_SUPERVISED_SAM,
1231  SG_CLASSIFY_SUPERVISED_WTA,
1232  SG_CLASSIFY_SUPERVISED_SID,
1233  SG_CLASSIFY_SUPERVISED_SVM
1234 };
1235 
1236 //---------------------------------------------------------
1237 class SAGA_API_DLL_EXPORT CSG_Classifier_Supervised
1238 {
1239 public:
1240  CSG_Classifier_Supervised(void);
1241  virtual ~CSG_Classifier_Supervised(void);
1242 
1243  void Create (int nFeatures);
1244  void Destroy (void);
1245 
1246  bool Load (const CSG_String &File);
1247  bool Save (const CSG_String &File, const SG_Char *Feature_Info = NULL);
1248 
1249  bool Train_Clr_Samples (void);
1250  bool Train_Add_Sample (const CSG_String &Class_ID, const CSG_Vector &Features);
1251  bool Train (bool bClr_Samples = false);
1252 
1253  bool Add_Class (const CSG_String &Class_ID, const CSG_Vector &Mean, const CSG_Vector &Min, const CSG_Vector &Max, const CSG_Matrix &Cov);
1254 
1255  CSG_String Print (void);
1256 
1257  //-----------------------------------------------------
1258  int Get_Feature_Count (void) { return( m_nFeatures ); }
1259 
1260  int Get_Class_Count (void) { return( m_nClasses ); }
1261 
1262  const CSG_String & Get_Class_ID (int iClass) { return( m_pClasses[iClass]->m_ID ); }
1263  double Get_Class_Mean (int iClass, int iFeature) { return( m_pClasses[iClass]->m_Mean[iFeature] ); }
1264  double Get_Class_Minimum (int iClass, int iFeature) { return( m_pClasses[iClass]->m_Min [iFeature] ); }
1265  double Get_Class_Maximum (int iClass, int iFeature) { return( m_pClasses[iClass]->m_Max [iFeature] ); }
1266 
1267  int Get_Class (const CSG_String &Class_ID);
1268  bool Get_Class (const CSG_Vector &Features, int &Class, double &Quality, int Method);
1269 
1270  //-----------------------------------------------------
1271  void Set_Threshold_Distance (double Value);
1272  double Get_Threshold_Distance (void);
1273 
1274  void Set_Threshold_Angle (double Value);
1275  double Get_Threshold_Angle (void);
1276 
1277  void Set_Threshold_Probability (double Value);
1278  double Get_Threshold_Probability (void);
1279 
1280  void Set_Probability_Relative (bool Value);
1281  bool Get_Probability_Relative (void);
1282 
1283  void Set_WTA (int Method, bool bOn);
1284  bool Get_WTA (int Method);
1285 
1286  static CSG_String Get_Name_of_Method (int Method);
1287  static CSG_String Get_Name_of_Quality (int Method);
1288 
1289 
1290 private:
1291 
1292  //-----------------------------------------------------
1293  class CClass
1294  {
1295  public:
1296  CClass(const CSG_String &ID) : m_ID(ID) {}
1297 
1298  CSG_String m_ID;
1299 
1300  double m_Cov_Det, m_Mean_Spectral;
1301 
1302  CSG_Vector m_Mean, m_Min, m_Max;
1303 
1304  CSG_Matrix m_Cov, m_Cov_Inv, m_Samples;
1305 
1306 
1307  bool Train (void);
1308 
1309  };
1310 
1311  //-----------------------------------------------------
1312  bool m_Probability_Relative, m_bWTA[SG_CLASSIFY_SUPERVISED_WTA];
1313 
1314  int m_nFeatures, m_nClasses;
1315 
1316  double m_Threshold_Distance, m_Threshold_Probability, m_Threshold_Angle;
1317 
1318  CSG_String m_Info;
1319 
1320  CClass **m_pClasses;
1321 
1322 
1323  void _Get_Binary_Encoding (const CSG_Vector &Features, int &Class, double &Quality);
1324  void _Get_Parallel_Epiped (const CSG_Vector &Features, int &Class, double &Quality);
1325  void _Get_Minimum_Distance (const CSG_Vector &Features, int &Class, double &Quality);
1326  void _Get_Mahalanobis_Distance (const CSG_Vector &Features, int &Class, double &Quality);
1327  void _Get_Maximum_Likelihood (const CSG_Vector &Features, int &Class, double &Quality);
1328  void _Get_Spectral_Angle_Mapping (const CSG_Vector &Features, int &Class, double &Quality);
1329  void _Get_Spectral_Divergence (const CSG_Vector &Features, int &Class, double &Quality);
1330  void _Get_Winner_Takes_All (const CSG_Vector &Features, int &Class, double &Quality);
1331 
1332 };
1333 
1334 
1336 // //
1337 // //
1338 // //
1340 
1341 //---------------------------------------------------------
1342 #ifdef WITH_MRMR
1343 
1344 //---------------------------------------------------------
1345 enum ESG_mRMR_Method
1346 {
1347  SG_mRMR_Method_MID = 0, // Mutual Information Difference (MID)
1348  SG_mRMR_Method_MIQ // Mutual Information Quotient (MIQ)
1349 };
1350 
1351 //---------------------------------------------------------
1352 class SAGA_API_DLL_EXPORT CSG_mRMR
1353 {
1354 public:
1355 
1356  CSG_mRMR(void);
1357  virtual ~CSG_mRMR(void);
1358 
1359  void Destroy (void);
1360 
1361  static CSG_String Get_Description (void);
1362 
1363  static bool Parameters_Add (class CSG_Parameters *pParameters, class CSG_Parameter *pNode = NULL);
1364  static int Parameters_Enable (class CSG_Parameters *pParameters, class CSG_Parameter *pParameter);
1365 
1366  void Set_Verbose (bool bOn = true) { m_bVerbose = bOn; }
1367 
1368  bool Set_Data (CSG_Table &Data, int ClassField, class CSG_Parameters *pParameters);
1369  bool Set_Data (CSG_Matrix &Data, int ClassField, class CSG_Parameters *pParameters);
1370  bool Set_Data (CSG_Table &Data, int ClassField = 0, double Threshold = -1.);
1371  bool Set_Data (CSG_Matrix &Data, int ClassField = 0, double Threshold = -1.);
1372 
1373  bool Get_Selection (class CSG_Parameters *pParameters);
1374  bool Get_Selection (int nFeatures, int Method);
1375 
1376  int Get_Count (void) const;
1377  int Get_Index (int i) const;
1378  CSG_String Get_Name (int i) const;
1379  double Get_Score (int i) const;
1380 
1381 
1382 private:
1383 
1384  bool m_bDiscretized, m_bVerbose;
1385 
1386  long m_nSamples, m_nVars;
1387 
1388  double **m_Samples;
1389 
1390  CSG_Strings m_VarNames;
1391 
1392  class CSG_Table *m_pSelection;
1393 
1394 
1395  bool Get_Memory (int nVars, int nSamples);
1396 
1397  bool Discretize (double Threshold);
1398 
1399  double Get_MutualInfo (long v1, long v2);
1400  double Get_MutualInfo (double *pab, long pabhei, long pabwid);
1401 
1402  template <class T> double * Get_JointProb (T *img1, T *img2, long len, long maxstatenum, int &nstate1, int &nstate2);
1403  template <class T> void Copy_Vector (T *srcdata, long len, int *desdata, int &nstate);
1404 
1405 
1406  typedef struct SPool
1407  {
1408  char Mask;
1409  long Index;
1410  double mival;
1411  }
1412  TPool;
1413 
1414  static int Pool_Compare (const void *a, const void *b);
1415 
1416 };
1417 
1418 //---------------------------------------------------------
1419 #endif // WITH_MRMR
1420 
1421 
1423 // //
1424 // //
1425 // //
1427 
1428 //---------------------------------------------------------
1429 class SAGA_API_DLL_EXPORT CSG_Spline
1430 {
1431 public:
1432  CSG_Spline(void);
1433  virtual ~CSG_Spline(void);
1434 
1435  void Destroy (void);
1436 
1437  bool Create (double *xValues, double *yValues, int nValues, double yA = 1.0e30, double yB = 1.0e30);
1438  bool Create (double yA = 1.0e30, double yB = 1.0e30);
1439 
1440  void Add (double x, double y);
1441 
1442  int Get_Count (void) const { return( m_x.Get_N() ); }
1443  double Get_xMin (void) const { return( m_x.Get_N() > 0 ? m_x(0 ) : 0. ); }
1444  double Get_xMax (void) const { return( m_x.Get_N() > 0 ? m_x(m_x.Get_Size() - 1) : 0. ); }
1445  double Get_x (int i) const { return( i >= 0 && i < m_x.Get_N() ? m_x(i) : 0. ); }
1446  double Get_y (int i) const { return( i >= 0 && i < m_y.Get_N() ? m_y(i) : 0. ); }
1447 
1448  bool Get_Value (double x, double &y);
1449  double Get_Value (double x);
1450 
1451 
1452 protected:
1453 
1454  bool m_bCreated;
1455 
1456  CSG_Vector m_x, m_y, m_z;
1457 
1458 
1459  bool _Create (double yA, double yB);
1460 
1461 };
1462 
1463 //---------------------------------------------------------
1464 class SAGA_API_DLL_EXPORT CSG_Thin_Plate_Spline
1465 {
1466 public:
1467  CSG_Thin_Plate_Spline(void);
1468  virtual ~CSG_Thin_Plate_Spline(void);
1469 
1470  bool Destroy (void);
1471 
1472  bool Set_Point_Count (int Count) { return( m_Points.Set_Count(Count) ); }
1473  int Get_Point_Count (void) { return( (int)m_Points.Get_Count() ); }
1474 
1475  CSG_Points_3D & Get_Points (void) { return( m_Points ); }
1476 
1477  bool Add_Point (double x, double y, double z) { return( m_Points.Add( x, y, z) ); }
1478  bool Add_Point (const TSG_Point &p, double z) { return( m_Points.Add(p.x, p.y, z) ); }
1479 
1480  bool Set_Point (int Index, double x, double y, double z)
1481  {
1482  if( Index >= 0 && Index < m_Points.Get_Count() )
1483  {
1484  m_Points[Index].x = x;
1485  m_Points[Index].y = y;
1486  m_Points[Index].z = z;
1487 
1488  return( true );
1489  }
1490 
1491  return( false );
1492  }
1493 
1494  bool Set_Point (int Index, const TSG_Point &p, double z) { return( Set_Point(Index, p.x, p.y, z) ); }
1495 
1496  bool Create (double Regularization = 0., bool bSilent = true);
1497 
1498  bool is_Okay (void) { return( m_V.Get_N() > 0 ); }
1499 
1500  double Get_Value (double x, double y);
1501 
1502 
1503 private:
1504 
1505  CSG_Points_3D m_Points;
1506 
1507  CSG_Vector m_V;
1508 
1509 
1510  double _Get_hDistance (TSG_Point_3D A, TSG_Point_3D B);
1511  double _Get_Base_Funtion (double x);
1512  double _Get_Base_Funtion (TSG_Point_3D A, double x, double y);
1513 
1514 };
1515 
1516 
1518 // //
1519 // //
1520 // //
1522 
1523 //---------------------------------------------------------
1524 typedef enum
1525 {
1526  TESTDIST_TYPE_Left = 0,
1527  TESTDIST_TYPE_Right,
1528  TESTDIST_TYPE_Middle,
1529  TESTDIST_TYPE_TwoTail
1530 }
1531 TSG_Test_Distribution_Type;
1532 
1533 //---------------------------------------------------------
1534 class SAGA_API_DLL_EXPORT CSG_Test_Distribution
1535 {
1536 public:
1537 
1538  static double Get_F_Tail_from_R2 (double R2, int nPredictors, int nSamples, TSG_Test_Distribution_Type Type = TESTDIST_TYPE_Right);
1539 
1540  static double Get_F_Tail (double F , int dfn, int dfd, TSG_Test_Distribution_Type Type = TESTDIST_TYPE_Right);
1541  static double Get_F_Inverse (double alpha, int dfn, int dfd, TSG_Test_Distribution_Type Type = TESTDIST_TYPE_Right);
1542 
1543  static double Get_T_Tail (double T , int df, TSG_Test_Distribution_Type Type = TESTDIST_TYPE_Right);
1544  static double Get_T_Inverse (double alpha, int df, TSG_Test_Distribution_Type Type = TESTDIST_TYPE_Right);
1545 
1546  static double Get_Norm_P (double Z);
1547  static double Get_Norm_Z (double P);
1548 
1549 
1550 private:
1551 
1552  static double Get_Gamma (double F, double dfn, double dfd);
1553  static double Get_Log_Gamma (double a);
1554 
1555  static double Get_T_P (double T, int df);
1556  static double Get_T_Z (double T, int df);
1557  static double Get_T_Inv (double p, int df);
1558 
1559  static double _Change_Tail_Type (double p, TSG_Test_Distribution_Type from, TSG_Test_Distribution_Type to, bool bNegative);
1560 
1561 };
1562 
1563 
1565 // //
1566 // //
1567 // //
1569 
1570 //---------------------------------------------------------
1571 // Values: (matrix) array with number of variables = number of rows (x), number of samples = number of columns (y)
1572 SAGA_API_DLL_EXPORT CSG_Matrix SG_Get_Correlation_Matrix (const CSG_Matrix &Values, bool bCovariances = false);
1573 
1574 
1576 // //
1577 // //
1578 // //
1580 
1581 //---------------------------------------------------------
1582 typedef enum
1583 {
1584  REGRESSION_CORR_None = 0,
1585  REGRESSION_CORR_Smith,
1586  REGRESSION_CORR_Wherry_1,
1587  REGRESSION_CORR_Wherry_2,
1588  REGRESSION_CORR_Olkin_Pratt,
1589  REGRESSION_CORR_Pratt,
1590  REGRESSION_CORR_Claudy_3
1591 }
1592 TSG_Regression_Correction;
1593 
1594 //---------------------------------------------------------
1595 SAGA_API_DLL_EXPORT double SG_Regression_Get_Adjusted_R2 (double R2, int nSamples, int nPredictors, TSG_Regression_Correction Correction = REGRESSION_CORR_Wherry_1);
1596 
1597 
1599 // //
1601 
1602 //---------------------------------------------------------
1603 typedef enum
1604 {
1605  REGRESSION_Linear = 0, // Y = a + b * X
1606  REGRESSION_Rez_X, // Y = a + b / X
1607  REGRESSION_Rez_Y, // Y = a / (b - X)
1608  REGRESSION_Pow, // Y = a * X^b
1609  REGRESSION_Exp, // Y = a * e^(b * X)
1610  REGRESSION_Log // Y = a + b * ln(X)
1611 }
1612 TSG_Regression_Type;
1613 
1614 //---------------------------------------------------------
1615 class SAGA_API_DLL_EXPORT CSG_Regression
1616 {
1617 public:
1618  CSG_Regression(void);
1619  virtual ~CSG_Regression(void);
1620 
1621  void Destroy (void);
1622 
1623  bool Set_Values (int nValues, double *x, double *y);
1624  bool Add_Values (double x, double y);
1625 
1626  int Get_Count (void) const { return( (int)m_x.Get_Size() ); }
1627 
1628  double Get_xValue (int i) const { return( i >= 0 && i < Get_Count() ? m_x[i] : 0. ); }
1629  double Get_yValue (int i) const { return( i >= 0 && i < Get_Count() ? m_y[i] : 0. ); }
1630  bool Get_Values (int i, double &x, double &y) const
1631  {
1632  if( i >= 0 && i < Get_Count() )
1633  {
1634  x = m_x[i];
1635  y = m_y[i];
1636 
1637  return( true );
1638  }
1639 
1640  return( false );
1641  }
1642 
1643  double Get_xMin (void) const { return( m_xMin ); }
1644  double Get_xMax (void) const { return( m_xMax ); }
1645  double Get_xMean (void) const { return( m_xMean ); }
1646  double Get_xVariance (void) const { return( m_xVar ); }
1647  double Get_x (double y) const; // returns INF on error, this can be checked using the _finite() function (libc, include <float.h>)...
1648 
1649  double Get_yMin (void) const { return( m_yMin ); }
1650  double Get_yMax (void) const { return( m_yMax ); }
1651  double Get_yMean (void) const { return( m_yMean ); }
1652  double Get_yVariance (void) const { return( m_yVar ); }
1653  double Get_y (double x) const; // returns INF on error, this can be checked using the _finite() function (libc, include <float.h>)...
1654 
1655  double Get_Constant (void) const { return( m_RConst ); }
1656  double Get_Coefficient (void) const { return( m_RCoeff ); }
1657  double Get_R (void) const { return( m_R ); }
1658  double Get_R2 (void) const { return( m_R2 ); }
1659  double Get_R2_Adj (void) const { return( m_R2_Adj ); }
1660  double Get_P (void) const { return( m_P ); }
1661  double Get_StdError (void) const { return( m_SE ); }
1662 
1663  const SG_Char * asString (void);
1664 
1665  TSG_Regression_Type Get_Type (void) const { return( m_Type ); }
1666 
1667  bool Calculate ( TSG_Regression_Type Type = REGRESSION_Linear, bool bStdError = false);
1668  bool Calculate (int nValues, double *x, double *y, TSG_Regression_Type Type = REGRESSION_Linear, bool bStdError = false);
1669 
1670 
1671 protected:
1672 
1673  double m_RConst, m_RCoeff, m_R, m_R2, m_R2_Adj, m_P, m_SE,
1674  m_xMin, m_xMax, m_xMean, m_xVar,
1675  m_yMin, m_yMax, m_yMean, m_yVar;
1676 
1677  CSG_Vector m_x, m_y;
1678 
1679  TSG_Regression_Type m_Type;
1680 
1681 
1682  double _Y_Transform (double x);
1683  double _X_Transform (double y);
1684 
1685 };
1686 
1687 
1689 // //
1691 
1692 //---------------------------------------------------------
1693 enum ESG_Multiple_Regression_Info_Vars
1694 {
1695  MLR_VAR_ID = 0,
1696  MLR_VAR_NAME,
1697  MLR_VAR_RCOEFF,
1698  MLR_VAR_R,
1699  MLR_VAR_R2,
1700  MLR_VAR_R2_ADJ,
1701  MLR_VAR_SE,
1702  MLR_VAR_T,
1703  MLR_VAR_SIG,
1704  MLR_VAR_P
1705 };
1706 
1707 //---------------------------------------------------------
1708 class SAGA_API_DLL_EXPORT CSG_Regression_Multiple
1709 {
1710 public:
1711  CSG_Regression_Multiple(bool bIntercept = true);
1712  virtual ~CSG_Regression_Multiple(void);
1713 
1714  void Destroy (void);
1715 
1716  bool Set_Data (const CSG_Matrix &Samples, CSG_Strings *pNames = NULL);
1717 
1718  void Set_With_Intercept (bool bOn = true) { m_bIntercept = bOn; }
1719  bool Get_With_Intercept (void) const { return( m_bIntercept ); }
1720 
1721  bool Get_Model (const CSG_Matrix &Samples , CSG_Strings *pNames = NULL);
1722  bool Get_Model_Forward (const CSG_Matrix &Samples, double P_in , CSG_Strings *pNames = NULL);
1723  bool Get_Model_Backward (const CSG_Matrix &Samples, double P_out , CSG_Strings *pNames = NULL);
1724  bool Get_Model_Stepwise (const CSG_Matrix &Samples, double P_in, double P_out, CSG_Strings *pNames = NULL);
1725 
1726  bool Get_Model (void);
1727  bool Get_Model_Forward (double P_in);
1728  bool Get_Model_Backward (double P_out);
1729  bool Get_Model_Stepwise (double P_in, double P_out);
1730 
1731  bool Get_CrossValidation (int nSubSamples = 0);
1732 
1733  CSG_String Get_Info (void) const;
1734  class CSG_Table * Get_Info_Regression (void) const { return( m_pRegression ); }
1735  class CSG_Table * Get_Info_Model (void) const { return( m_pModel ); }
1736  class CSG_Table * Get_Info_Steps (void) const { return( m_pSteps ); }
1737 
1738  double Get_R2 (void) const;
1739  double Get_R2_Adj (void) const;
1740  double Get_StdError (void) const;
1741  double Get_F (void) const;
1742  double Get_P (void) const;
1743  double Get_CV_RMSE (void) const;
1744  double Get_CV_NRMSE (void) const;
1745  double Get_CV_R2 (void) const;
1746  int Get_CV_nSamples (void) const;
1747  int Get_DegFreedom (void) const;
1748  int Get_nSamples (void) const;
1749  int Get_nPredictors (void) const;
1750  int Get_Predictor (int i) const { return( i >= 0 && i < Get_nPredictors() ? m_Predictor[i] : -1 ); }
1751 
1752  double Get_RConst (void) const;
1753  const SG_Char * Get_Name (int iVariable) const;
1754  double Get_ID (int iVariable) const { return( Get_Parameter(iVariable, MLR_VAR_ID ) ); }
1755  double Get_RCoeff (int iVariable) const { return( Get_Parameter(iVariable, MLR_VAR_RCOEFF) ); }
1756  double Get_R2_Partial (int iVariable) const { return( Get_Parameter(iVariable, MLR_VAR_R2 ) ); }
1757  double Get_R2_Partial_Adj (int iVariable) const { return( Get_Parameter(iVariable, MLR_VAR_R2_ADJ) ); }
1758  double Get_StdError (int iVariable) const { return( Get_Parameter(iVariable, MLR_VAR_SE ) ); }
1759  double Get_T (int iVariable) const { return( Get_Parameter(iVariable, MLR_VAR_T ) ); }
1760  double Get_P (int iVariable) const { return( Get_Parameter(iVariable, MLR_VAR_SIG ) ); }
1761 
1762  double Get_Parameter (int iVariable, int Parameter) const;
1763 
1764  double Get_Value (const CSG_Vector &Predictors) const;
1765  bool Get_Value (const CSG_Vector &Predictors, double &Value) const;
1766 
1767  double Get_Residual (int iSample) const;
1768  bool Get_Residual (int iSample, double &Residual) const;
1769 
1770  bool Get_Residuals (CSG_Vector &Residuals) const;
1771 
1772 
1773 protected:
1774 
1775  bool m_bIntercept;
1776 
1777  int *m_bIncluded, *m_Predictor, m_nPredictors;
1778 
1779  CSG_Strings m_Names;
1780 
1781  CSG_Matrix m_Samples, m_Samples_Model;
1782 
1783  class CSG_Table *m_pRegression, *m_pModel, *m_pSteps;
1784 
1785 
1786  bool _Initialize (bool bInclude);
1787 
1788  double _Get_F (int nPredictors, int nSamples, double r2_full, double r2_reduced);
1789  double _Get_P (int nPredictors, int nSamples, double r2_full, double r2_reduced);
1790 
1791  bool _Get_Regression (const class CSG_Matrix &Samples);
1792 
1793  int _Get_Step_In (CSG_Matrix &X, double P_in , double &R2, const CSG_Matrix &Samples);
1794  int _Get_Step_Out (CSG_Matrix &X, double P_out, double &R2);
1795 
1796  bool _Set_Step_Info (const CSG_Matrix &X);
1797  bool _Set_Step_Info (const CSG_Matrix &X, double R2_prev, int iVariable, bool bIn);
1798 
1799 };
1800 
1801 
1803 // //
1805 
1806 //---------------------------------------------------------
1807 class SAGA_API_DLL_EXPORT CSG_Regression_Weighted
1808 {
1809 public:
1810  CSG_Regression_Weighted(void);
1811  virtual ~CSG_Regression_Weighted(void);
1812 
1813  bool Destroy (void);
1814 
1815  bool Add_Sample (double Weight, double Dependent, const CSG_Vector &Predictors);
1816  int Get_Sample_Count (void) const { return( m_X.Get_NY() ); }
1817  int Get_Predictor_Count (void) const { return( m_X.Get_NX() - 1 ); }
1818 
1819  bool Calculate (const CSG_Vector &Weights, const CSG_Vector &Dependents, const CSG_Matrix &Predictors, bool bLogistic = false);
1820  bool Calculate (bool bLogistic = false);
1821 
1822  double Get_R2 (void) const { return( m_r2 ); }
1823  const CSG_Vector & Get_RCoeff (void) const { return( m_b ); }
1824  double Get_RCoeff (int i) const { return( m_b[i] ); }
1825  double operator [] (int i) const { return( m_b[i] ); }
1826 
1827  //-----------------------------------------------------
1828  int Get_Log_maxIter (void) const { return( m_Log_maxIter ); }
1829  double Get_Log_Epsilon (void) const { return( m_Log_Epsilon ); }
1830  double Get_Log_Difference (void) const { return( m_Log_Difference ); }
1831 
1832  bool Set_Log_maxIter (int maxIter );
1833  bool Set_Log_Epsilon (double Epsilon );
1834  bool Set_Log_Difference (double Difference);
1835 
1836  //-----------------------------------------------------
1837  bool Get_CrossValidation (int nSubSamples = 0);
1838 
1839  int Get_CV_nSamples (void) const { return( m_CV_nSamples ); }
1840  double Get_CV_RMSE (void) const { return( m_CV_RMSE ); }
1841  double Get_CV_NRMSE (void) const { return( m_CV_NRMSE ); }
1842  double Get_CV_R2 (void) const { return( m_CV_R2 ); }
1843 
1844 
1845 private:
1846 
1847  int m_Log_maxIter, m_CV_nSamples;
1848 
1849  double m_r2, m_Log_Epsilon, m_Log_Difference, m_CV_RMSE, m_CV_NRMSE, m_CV_R2;
1850 
1851  CSG_Vector m_y, m_w, m_b;
1852 
1853  CSG_Matrix m_X;
1854 
1855 
1856  CSG_Vector _Log_Get_Beta (const CSG_Matrix &X, const CSG_Vector &y, const CSG_Vector &w);
1857  CSG_Vector _Log_Get_Beta (const CSG_Vector &b, const CSG_Matrix &X, const CSG_Vector &y, const CSG_Vector &w, const CSG_Vector &p);
1858  CSG_Matrix _Log_Get_Xwp (const CSG_Vector &p, const CSG_Matrix &X, const CSG_Vector &w);
1859  CSG_Vector _Log_Get_Ywp (const CSG_Vector &p, const CSG_Vector &y, const CSG_Vector &w);
1860  CSG_Vector _Log_Get_Props (const CSG_Matrix &X, const CSG_Vector &b);
1861  bool _Log_NoChange (const CSG_Vector &b_old, const CSG_Vector &b_new);
1862  bool _Log_OutOfControl (const CSG_Vector &b_old, const CSG_Vector &b_new);
1863 
1864 };
1865 
1866 
1868 // //
1869 // Formula Parser (A. Ringeler) //
1870 // //
1872 
1873 //---------------------------------------------------------
1874 typedef double (*TSG_Formula_Function_0)(void);
1875 typedef double (*TSG_Formula_Function_1)(double);
1876 typedef double (*TSG_Formula_Function_2)(double, double);
1877 typedef double (*TSG_Formula_Function_3)(double, double, double);
1878 
1879 //---------------------------------------------------------
1880 class SAGA_API_DLL_EXPORT CSG_Formula
1881 {
1882 public:
1883  CSG_Formula(void);
1884  virtual ~CSG_Formula(void);
1885 
1886  bool Destroy (void);
1887 
1888  static CSG_String Get_Help_Operators (bool bHTML = true, const CSG_String Additional[][2] = NULL);
1889 
1890  bool Get_Error (CSG_String &Message);
1891 
1892  bool Add_Function (const char *Name, TSG_Formula_Function_1 Function, int nParameters, bool bVarying = false);
1893 
1894  bool Set_Formula (const CSG_String &Formula);
1895  CSG_String Get_Formula (void) const { return( m_sFormula ); }
1896 
1897  void Set_Variable (char Variable, double Value);
1898 
1899  double Get_Value (void ) const;
1900  double Get_Value (double x ) const;
1901  double Get_Value (const CSG_Vector &Values ) const;
1902  double Get_Value (double *Values, int nValues) const;
1903  double Get_Value (const char *Arguments, ... ) const;
1904 
1905  const char * Get_Used_Variables (void);
1906 
1907 
1908  //-----------------------------------------------------
1909  typedef struct SSG_Function
1910  {
1911  const char *Name;
1912 
1913  TSG_Formula_Function_1 Function;
1914 
1915  int nParameters;
1916 
1917  bool bVarying;
1918  }
1919  TSG_Function;
1920 
1921 
1922 private:
1923 
1924  //-----------------------------------------------------
1925  typedef struct SSG_Formula
1926  {
1927  char *code;
1928 
1929  double *ctable;
1930  }
1931  TSG_Formula;
1932 
1933 
1934  //-----------------------------------------------------
1935  bool m_bError, m_Vars_Used[256];
1936 
1937  int m_Error_Position, m_Length;
1938 
1939  TSG_Formula m_Formula;
1940 
1941  TSG_Function *m_Functions;
1942 
1943 
1944  CSG_String m_sFormula, m_sError;
1945 
1946  const char *m_error;
1947 
1948  int m_pctable;
1949 
1950  double m_Parameters[32], *m_ctable;
1951 
1952 
1953  void _Set_Error (const CSG_String &Error = "");
1954 
1955  double _Get_Value (const double *Parameters, TSG_Formula Function) const;
1956 
1957  int _is_Operand (char c);
1958  int _is_Operand_Code (char c);
1959  int _is_Number (char c);
1960 
1961  int _Get_Function (int i, char *Name, int *nParameters, int *bVarying);
1962  int _Get_Function (const char *Name);
1963 
1964  TSG_Formula _Translate (const char *source, const char *args, int *length, int *error);
1965 
1966  char * _i_trans (char *function, char *begin, char *end);
1967  char * _comp_time (char *function, char *fend, int npars);
1968  int _max_size (const char *source);
1969  char * _my_strtok (char *s);
1970 
1971 };
1972 
1973 
1975 // //
1976 // //
1977 // //
1979 
1980 //---------------------------------------------------------
1981 enum ESG_Trend_String
1982 {
1983  SG_TREND_STRING_Formula = 0,
1984  SG_TREND_STRING_Function,
1985  SG_TREND_STRING_Formula_Parameters,
1986  SG_TREND_STRING_Complete,
1987  SG_TREND_STRING_Compact
1988 };
1989 
1990 //---------------------------------------------------------
1991 class SAGA_API_DLL_EXPORT CSG_Trend
1992 {
1993 public:
1994  CSG_Trend(void);
1995 
1996  bool Set_Formula (const CSG_String &Formula);
1997  CSG_String Get_Formula (int Type = SG_TREND_STRING_Complete);
1998 
1999  int Get_Parameter_Count (void) const { return( m_Params .Get_Count() ); }
2000  double * Get_Parameters (void) const { return( m_Params.m_A.Get_Data() ); }
2001  bool Init_Parameter (const SG_Char &Variable, double Value);
2002 
2003  void Clr_Data (void);
2004  bool Add_Data (double x, double y);
2005  void Set_Data (double *x, double *y, int n, bool bAdd = false);
2006  void Set_Data (const CSG_Points &Data , bool bAdd = false);
2007  int Get_Data_Count (void) const { return( (int)m_Data[0].Get_Count() ); }
2008  double Get_Data_X (int i) const { return( m_Data[0][i] ); }
2009  double Get_Data_XMin (void) { return( m_Data[0].Get_Minimum() ); }
2010  double Get_Data_XMax (void) { return( m_Data[0].Get_Maximum() ); }
2011  CSG_Simple_Statistics & Get_Data_XStats (void) { return( m_Data[0] ); }
2012  double Get_Data_Y (int i) const { return( m_Data[1][i] ); }
2013  double Get_Data_YMin (void) { return( m_Data[1].Get_Minimum() ); }
2014  double Get_Data_YMax (void) { return( m_Data[1].Get_Maximum() ); }
2015  CSG_Simple_Statistics & Get_Data_YStats (void) { return( m_Data[1] ); }
2016 
2017  bool Set_Max_Iterations (int Iterations);
2018  int Get_Max_Iterations (void) const { return( m_Iter_Max); }
2019  bool Set_Max_Lambda (double Lambda);
2020  double Get_Max_Lambda (void) const { return( m_Lambda_Max); }
2021 
2022  bool Get_Trend (double *x, double *y, int n, const CSG_String &Formula);
2023  bool Get_Trend (const CSG_Points &Data , const CSG_String &Formula);
2024  bool Get_Trend (const CSG_String &Formula);
2025  bool Get_Trend (void);
2026 
2027  bool is_Okay (void) const { return( m_bOkay ); }
2028 
2029  CSG_String Get_Error (void);
2030 
2031  double Get_ChiSquare (void) const { return( m_bOkay ? m_ChiSqr : 0. ); }
2032  double Get_R2 (void) const { return( m_bOkay ? m_ChiSqr_o : 0. ); }
2033 
2034  double Get_Value (double x) const { return( m_bOkay ? m_Formula.Get_Value(x) : 0. ); }
2035 
2036 
2037 private:
2038 
2039  //-----------------------------------------------------
2040  class SAGA_API_DLL_EXPORT CParams
2041  {
2042  public:
2043  CParams(void) {}
2044 
2045  bool Create (const CSG_String &Variables);
2046  bool Destroy (void);
2047 
2048  int Get_Count (void) const { return( (int)m_Variables.Length() ); }
2049 
2050 
2051  CSG_String m_Variables;
2052 
2053  CSG_Vector m_A, m_Atry, m_dA, m_dA2, m_Beta;
2054 
2055  CSG_Matrix m_Alpha, m_Covar;
2056 
2057  };
2058 
2059 
2060  //-----------------------------------------------------
2061  bool m_bOkay;
2062 
2063  int m_Iter_Max;
2064 
2065  double m_ChiSqr, m_ChiSqr_o, m_Lambda, m_Lambda_Max;
2066 
2067  CParams m_Params;
2068 
2069  CSG_Simple_Statistics m_Data[2];
2070 
2071  CSG_Formula m_Formula;
2072 
2073 
2074  bool _Fit_Function (void);
2075  bool _Get_Gaussj (void);
2076  bool _Get_mrqcof (CSG_Vector &Parameters, CSG_Matrix &Alpha, CSG_Vector &Beta);
2077 
2078  void _Get_Function (double &y, double *dy_da, double x, const double *Parameters);
2079 
2080 };
2081 
2082 
2084 // //
2085 // //
2086 // //
2088 
2089 //---------------------------------------------------------
2090 class SAGA_API_DLL_EXPORT CSG_Trend_Polynom
2091 {
2092 public:
2093  CSG_Trend_Polynom(void);
2094 
2095  bool Destroy (void);
2096 
2097  bool Set_Order (int Order = 1);
2098 
2099  bool Clr_Data (void);
2100  bool Set_Data (double *x, double *y, int n, bool bAdd = false);
2101  bool Add_Data (double x, double y);
2102  int Get_Data_Count (void) const { return( m_x.Get_N() ); }
2103  double Get_Data_X (int i) const { return( m_x(i) ); }
2104  double Get_Data_Y (int i) const { return( m_y(i) ); }
2105 
2106  bool Get_Trend (void);
2107 
2108  int Get_Order (void) const { return( m_Order ); }
2109  int Get_nCoefficients (void) const { return( m_Order + 1 ); }
2110  double Get_Coefficient (int i) const { return( m_a(i) ); }
2111  double Get_R2 (void) const { return( m_r2 ); }
2112 
2113  double Get_Value (double x) const;
2114 
2115 
2116 private:
2117 
2118  double m_r2;
2119 
2120  int m_Order;
2121 
2122  CSG_Vector m_x, m_y, m_a;
2123 
2124 };
2125 
2126 
2128 // //
2129 // //
2130 // //
2132 
2133 //---------------------------------------------------------
2134 #endif // #ifndef HEADER_INCLUDED__SAGA_API__mat_tools_H
CSG_Index
Definition: mat_tools.h:200
SG_Get_Square
SAGA_API_DLL_EXPORT double SG_Get_Square(double Value)
Definition: mat_tools.cpp:70
CSG_Regression_Multiple::Get_StdError
double Get_StdError(int iVariable) const
Definition: mat_tools.h:1758
CSG_Category_Statistics::Get_Majority
bool Get_Majority(CSG_String &Value, int &Count)
Definition: mat_tools.h:987
CSG_Trend::Get_Max_Lambda
double Get_Max_Lambda(void) const
Definition: mat_tools.h:2020
CSG_Regression_Multiple::Get_RCoeff
double Get_RCoeff(int iVariable) const
Definition: mat_tools.h:1755
MLR_VAR_R2_ADJ
@ MLR_VAR_R2_ADJ
Definition: mat_tools.h:1700
CSG_Category_Statistics
Definition: mat_tools.h:926
REGRESSION_CORR_Pratt
@ REGRESSION_CORR_Pratt
Definition: mat_tools.h:1589
CSG_Index::is_Okay
bool is_Okay(void) const
Definition: mat_tools.h:240
CSG_Histogram::Get_Cumulative
size_t Get_Cumulative(int i) const
Definition: mat_tools.h:1057
CSG_Regression::Get_Type
TSG_Regression_Type Get_Type(void) const
Definition: mat_tools.h:1665
CSG_Cluster_Analysis::Get_Cluster
sLong Get_Cluster(sLong iElement) const
Definition: mat_tools.h:1177
SG_Compare_Char_Ptr
SAGA_API_DLL_EXPORT int SG_Compare_Char_Ptr(const void *a, const void *b)
Definition: mat_tools.cpp:211
CSG_Histogram::Get_Cumulative
size_t Get_Cumulative(size_t i) const
Definition: mat_tools.h:1058
CSG_Trend::Get_Parameter_Count
int Get_Parameter_Count(void) const
Definition: mat_tools.h:1999
CSG_Points_3D
Definition: geo_tools.h:322
CSG_Trend_Polynom::Get_Data_Y
double Get_Data_Y(int i) const
Definition: mat_tools.h:2104
SG_Matrix_LU_Solve
SAGA_API_DLL_EXPORT bool SG_Matrix_LU_Solve(int n, const int *Permutation, const double **Matrix, double *Vector, bool bSilent=true)
Definition: mat_matrix.cpp:2053
CSG_Formula::SSG_Function::Function
TSG_Formula_Function_1 Function
Definition: mat_tools.h:1913
CSG_Category_Statistics::Get_Minority
bool Get_Minority(int &Value)
Definition: mat_tools.h:990
CSG_Classifier_Supervised::Get_Class_Minimum
double Get_Class_Minimum(int iClass, int iFeature)
Definition: mat_tools.h:1264
ESG_Classify_Supervised
ESG_Classify_Supervised
Definition: mat_tools.h:1224
SG_Matrix_Get_Rotation
SAGA_API_DLL_EXPORT CSG_Matrix SG_Matrix_Get_Rotation(double R, bool bDegree=false)
Definition: mat_matrix.cpp:1866
CSG_Trend::Get_Data_YStats
CSG_Simple_Statistics & Get_Data_YStats(void)
Definition: mat_tools.h:2015
SG_DATATYPE_String
@ SG_DATATYPE_String
Definition: api_core.h:1009
CSG_Unique_Value_Statistics::Get_Majority
virtual bool Get_Majority(CSG_String &Value, int &Count) const
Definition: mat_tools.h:832
CSG_Unique_Number_Statistics::Get_Class
bool Get_Class(int Index, double &Value, int &Count) const
Definition: mat_tools.h:860
CSG_Regression_Weighted::Get_Predictor_Count
int Get_Predictor_Count(void) const
Definition: mat_tools.h:1817
CSG_Category_Statistics::Get_Category
bool Get_Category(int iCategory, CSG_String &Value, int &Count) const
Definition: mat_tools.h:973
CSG_Unique_Value_Statistics::~CSG_Unique_Value_Statistics
virtual ~CSG_Unique_Value_Statistics(void)
Definition: mat_tools.h:815
CSG_Regression_Multiple::m_Samples_Model
CSG_Matrix m_Samples_Model
Definition: mat_tools.h:1781
CSG_Vector::cend
const_iterator cend(void) const
Definition: mat_tools.h:451
SG_CLUSTERANALYSIS_Hill_Climbing
@ SG_CLUSTERANALYSIS_Hill_Climbing
Definition: mat_tools.h:1160
CSG_Unique_Value_Statistics::m_Count
CSG_Array_Int m_Count
Definition: mat_tools.h:841
CSG_Cluster_Analysis::Get_nMembers
int Get_nMembers(int iCluster) const
Definition: mat_tools.h:1189
SG_TREND_STRING_Formula_Parameters
@ SG_TREND_STRING_Formula_Parameters
Definition: mat_tools.h:1985
CSG_Vector::Get_Data
double * Get_Data(void) const
Definition: mat_tools.h:386
CSG_PriorityQueue::CSG_PriorityQueueItem::Compare
virtual int Compare(CSG_PriorityQueueItem *pItem)=0
CSG_Table::Get_Value
virtual bool Get_Value(sLong Index, int Field, CSG_String &Value) const
Definition: table.cpp:1185
SG_CLASSIFY_SUPERVISED_Mahalonobis
@ SG_CLASSIFY_SUPERVISED_Mahalonobis
Definition: mat_tools.h:1228
SG_Get_Rounded
SAGA_API_DLL_EXPORT double SG_Get_Rounded(double Value, int Decimals=0)
Definition: mat_tools.cpp:83
CSG_Grid_Radius::Get_Point
double Get_Point(int iRadius, int iPoint, int xOffset, int yOffset, int &x, int &y)
Definition: mat_tools.h:663
TESTDIST_TYPE_Right
@ TESTDIST_TYPE_Right
Definition: mat_tools.h:1527
CSG_Thin_Plate_Spline::Add_Point
bool Add_Point(const TSG_Point &p, double z)
Definition: mat_tools.h:1478
CSG_Regression_Multiple::Get_R2_Partial
double Get_R2_Partial(int iVariable) const
Definition: mat_tools.h:1756
REGRESSION_CORR_Olkin_Pratt
@ REGRESSION_CORR_Olkin_Pratt
Definition: mat_tools.h:1588
CSG_Grid_Radius
Definition: mat_tools.h:611
SG_Get_Digit_Count
SAGA_API_DLL_EXPORT int SG_Get_Digit_Count(int Number)
Definition: mat_tools.cpp:144
CSG_Simple_Statistics::Get_Sum_Of_Squares
double Get_Sum_Of_Squares(void)
Definition: mat_tools.h:752
CSG_Thin_Plate_Spline::Set_Point_Count
bool Set_Point_Count(int Count)
Definition: mat_tools.h:1472
CSG_Unique_String_Statistics::Get_Minority
virtual bool Get_Minority(CSG_String &Value, int &Count) const
Definition: mat_tools.h:908
CSG_Regression_Multiple::Get_Predictor
int Get_Predictor(int i) const
Definition: mat_tools.h:1750
CSG_Trend::Get_Data_X
double Get_Data_X(int i) const
Definition: mat_tools.h:2008
A
#define A
CSG_Matrix::Get_NRows
sLong Get_NRows(void) const
Definition: mat_tools.h:525
CSG_Spline::Get_y
double Get_y(int i) const
Definition: mat_tools.h:1446
CSG_Unique_Value_Statistics::Get_Minority
virtual bool Get_Minority(double &Value) const
Definition: mat_tools.h:828
CSG_Simple_Statistics::Get_Variance
double Get_Variance(void)
Definition: mat_tools.h:754
CSG_Histogram::Get_Break
double Get_Break(int i) const
Definition: mat_tools.h:1062
CSG_Regression_Weighted::Get_RCoeff
const CSG_Vector & Get_RCoeff(void) const
Definition: mat_tools.h:1823
CSG_Unique_String_Statistics::Get_Minority
virtual bool Get_Minority(CSG_String &Value) const
Definition: mat_tools.h:907
CSG_Unique_Value_Statistics::Get_Count
int Get_Count(int i) const
Definition: mat_tools.h:820
CSG_Regression::Get_Count
int Get_Count(void) const
Definition: mat_tools.h:1626
CSG_Trend::Get_Data_Y
double Get_Data_Y(int i) const
Definition: mat_tools.h:2012
operator*
SAGA_API_DLL_EXPORT CSG_Vector operator*(double Scalar, const CSG_Vector &Vector)
Definition: mat_matrix.cpp:579
CSG_Test_Distribution
Definition: mat_tools.h:1535
TESTDIST_TYPE_Middle
@ TESTDIST_TYPE_Middle
Definition: mat_tools.h:1528
CSG_Index::Get_Index
sLong Get_Index(sLong Position, bool Ascending=true) const
Definition: mat_tools.h:243
CSG_Unique_Number_Statistics
Definition: mat_tools.h:849
CSG_Index::CSG_Index_Compare
Definition: mat_tools.h:203
MLR_VAR_RCOEFF
@ MLR_VAR_RCOEFF
Definition: mat_tools.h:1697
CSG_PriorityQueue::Get_Item
CSG_PriorityQueueItem * Get_Item(size_t i) const
Definition: mat_tools.h:301
CSG_Regression::Get_xVariance
double Get_xVariance(void) const
Definition: mat_tools.h:1646
CSG_Unique_Value_Statistics::Get_Minority
virtual int Get_Minority(bool bWeighted=false) const
Definition: mat_tools.cpp:833
CSG_Regression::m_yVar
double m_yVar
Definition: mat_tools.h:1675
CSG_Histogram
Definition: mat_tools.h:1013
CSG_Trend
Definition: mat_tools.h:1992
CSG_Vector::Get_uSize
size_t Get_uSize(void) const
Definition: mat_tools.h:383
CSG_Histogram::Get_Elements
size_t Get_Elements(size_t i) const
Definition: mat_tools.h:1055
SG_Matrix_Solve
SAGA_API_DLL_EXPORT bool SG_Matrix_Solve(CSG_Matrix &Matrix, CSG_Vector &Vector, bool bSilent=true)
Definition: mat_matrix.cpp:1910
CSG_Regression_Weighted::Get_R2
double Get_R2(void) const
Definition: mat_tools.h:1822
CSG_Regression::m_xVar
double m_xVar
Definition: mat_tools.h:1674
CSG_Formula::SSG_Function
Definition: mat_tools.h:1910
SSG_Point_3D
Definition: geo_tools.h:265
CSG_Regression_Weighted::Get_Log_maxIter
int Get_Log_maxIter(void) const
Definition: mat_tools.h:1828
CSG_Classifier_Supervised::Get_Feature_Count
int Get_Feature_Count(void)
Definition: mat_tools.h:1258
MLR_VAR_R2
@ MLR_VAR_R2
Definition: mat_tools.h:1699
SG_Matrix_Eigen_Reduction
SAGA_API_DLL_EXPORT bool SG_Matrix_Eigen_Reduction(const CSG_Matrix &Matrix, CSG_Matrix &Eigen_Vectors, CSG_Vector &Eigen_Values, bool bSilent=true)
Definition: mat_matrix.cpp:1933
CSG_Index::CSG_Index_Compare::Compare
virtual int Compare(const sLong a, const sLong b)=0
CSG_Trend_Polynom
Definition: mat_tools.h:2091
CSG_Regression_Multiple::Get_R2_Partial_Adj
double Get_R2_Partial_Adj(int iVariable) const
Definition: mat_tools.h:1757
CSG_Simple_Statistics::Get_Sum
double Get_Sum(void)
Definition: mat_tools.h:751
CSG_Data_Object::Get_Name
const SG_Char * Get_Name(void) const
Definition: dataobject.cpp:349
CSG_Cluster_Analysis::Get_Iteration
int Get_Iteration(void) const
Definition: mat_tools.h:1185
CSG_Unique_Number_Statistics::Get_Majority
virtual bool Get_Majority(double &Value) const
Definition: mat_tools.h:870
CSG_Spline::Get_xMax
double Get_xMax(void) const
Definition: mat_tools.h:1444
REGRESSION_CORR_Wherry_1
@ REGRESSION_CORR_Wherry_1
Definition: mat_tools.h:1586
REGRESSION_Log
@ REGRESSION_Log
Definition: mat_tools.h:1610
CSG_Cluster_Analysis
Definition: mat_tools.h:1166
CSG_Regression::Get_R2
double Get_R2(void) const
Definition: mat_tools.h:1658
CSG_Regression::Get_yMin
double Get_yMin(void) const
Definition: mat_tools.h:1649
CSG_Regression::m_SE
double m_SE
Definition: mat_tools.h:1673
CSG_Unique_String_Statistics::Get_Majority
virtual bool Get_Majority(CSG_String &Value) const
Definition: mat_tools.h:905
CSG_Natural_Breaks
Definition: mat_tools.h:1111
CSG_Formula::Get_Formula
CSG_String Get_Formula(void) const
Definition: mat_tools.h:1895
CSG_Category_Statistics::Get_Minority
bool Get_Minority(double &Value, int &Count)
Definition: mat_tools.h:994
CSG_Natural_Breaks::Get_Break
double Get_Break(int i) const
Definition: mat_tools.h:1129
CSG_Regression_Multiple::Get_P
double Get_P(int iVariable) const
Definition: mat_tools.h:1760
CSG_Regression::Get_xMean
double Get_xMean(void) const
Definition: mat_tools.h:1645
SSG_Point
Definition: geo_tools.h:128
CSG_Regression::Get_yVariance
double Get_yVariance(void) const
Definition: mat_tools.h:1652
CSG_Unique_Value_Statistics::Get_Minority
virtual bool Get_Minority(CSG_String &Value, int &Count) const
Definition: mat_tools.h:834
CSG_Category_Statistics::Get_Minority
bool Get_Minority(int &Value, int &Count)
Definition: mat_tools.h:993
CSG_Simple_Statistics::Get_Kurtosis
double Get_Kurtosis(void)
Definition: mat_tools.h:757
CSG_Regression::Get_R2_Adj
double Get_R2_Adj(void) const
Definition: mat_tools.h:1659
SG_TREND_STRING_Compact
@ SG_TREND_STRING_Compact
Definition: mat_tools.h:1987
SG_TREND_STRING_Complete
@ SG_TREND_STRING_Complete
Definition: mat_tools.h:1986
CSG_Thin_Plate_Spline::Get_Point_Count
int Get_Point_Count(void)
Definition: mat_tools.h:1473
CSG_Category_Statistics::Get_Minority
bool Get_Minority(CSG_String &Value)
Definition: mat_tools.h:992
CSG_Trend::Get_R2
double Get_R2(void) const
Definition: mat_tools.h:2032
CSG_Matrix::Get_Data
double ** Get_Data(void) const
Definition: mat_tools.h:528
CSG_Histogram::Get_Element_Count
size_t Get_Element_Count(void) const
Definition: mat_tools.h:1051
CSG_Regression_Multiple::Get_ID
double Get_ID(int iVariable) const
Definition: mat_tools.h:1754
CSG_Histogram::Get_Center
double Get_Center(int i) const
Definition: mat_tools.h:1065
CSG_Trend::Get_Data_YMax
double Get_Data_YMax(void)
Definition: mat_tools.h:2014
CSG_Category_Statistics::Get_Minority
bool Get_Minority(CSG_String &Value, int &Count)
Definition: mat_tools.h:995
MLR_VAR_T
@ MLR_VAR_T
Definition: mat_tools.h:1702
CSG_Trend_Polynom::Get_R2
double Get_R2(void) const
Definition: mat_tools.h:2111
CSG_Trend_Polynom::Get_Coefficient
double Get_Coefficient(int i) const
Definition: mat_tools.h:2110
CSG_Matrix::Get_NCols
sLong Get_NCols(void) const
Definition: mat_tools.h:524
SG_Regression_Get_Adjusted_R2
SAGA_API_DLL_EXPORT double SG_Regression_Get_Adjusted_R2(double R2, int nSamples, int nPredictors, TSG_Regression_Correction Correction=REGRESSION_CORR_Wherry_1)
Definition: mat_regression.cpp:63
SG_Get_Rounded_To_SignificantFigures
SAGA_API_DLL_EXPORT double SG_Get_Rounded_To_SignificantFigures(double Value, int Decimals)
Definition: mat_tools.cpp:107
CSG_Grid_Radius::Get_Maximum
int Get_Maximum(void)
Definition: mat_tools.h:619
CSG_Category_Statistics::Get_Majority
bool Get_Majority(int &Value)
Definition: mat_tools.h:982
SG_CLASSIFY_SUPERVISED_SVM
@ SG_CLASSIFY_SUPERVISED_SVM
Definition: mat_tools.h:1233
CSG_Formula
Definition: mat_tools.h:1881
CSG_Spline::m_bCreated
bool m_bCreated
Definition: mat_tools.h:1454
REGRESSION_Linear
@ REGRESSION_Linear
Definition: mat_tools.h:1605
CSG_Simple_Statistics::Get_Maximum
double Get_Maximum(void)
Definition: mat_tools.h:749
SG_CLASSIFY_SUPERVISED_SID
@ SG_CLASSIFY_SUPERVISED_SID
Definition: mat_tools.h:1232
CSG_Unique_String_Statistics
Definition: mat_tools.h:884
SG_Get_Correlation_Matrix
SAGA_API_DLL_EXPORT CSG_Matrix SG_Get_Correlation_Matrix(const CSG_Matrix &Values, bool bCovariances=false)
Definition: mat_tools.cpp:3464
CSG_Spline::Get_x
double Get_x(int i) const
Definition: mat_tools.h:1445
REGRESSION_CORR_Claudy_3
@ REGRESSION_CORR_Claudy_3
Definition: mat_tools.h:1590
CSG_Regression_Multiple::Get_Info_Steps
class CSG_Table * Get_Info_Steps(void) const
Definition: mat_tools.h:1736
CSG_Histogram::Get_Center
double Get_Center(size_t i) const
Definition: mat_tools.h:1066
CSG_Unique_String_Statistics::~CSG_Unique_String_Statistics
virtual ~CSG_Unique_String_Statistics(void)
Definition: mat_tools.h:887
SG_CLASSIFY_SUPERVISED_WTA
@ SG_CLASSIFY_SUPERVISED_WTA
Definition: mat_tools.h:1231
CSG_Vector
Definition: mat_tools.h:362
REGRESSION_CORR_Wherry_2
@ REGRESSION_CORR_Wherry_2
Definition: mat_tools.h:1587
CSG_Parameter
Definition: parameters.h:208
TSG_Test_Distribution_Type
TSG_Test_Distribution_Type
Definition: mat_tools.h:1525
CSG_Trend::Get_Data_XMax
double Get_Data_XMax(void)
Definition: mat_tools.h:2010
CSG_Category_Statistics::Get_Majority
bool Get_Majority(int &Value, int &Count)
Definition: mat_tools.h:985
MLR_VAR_R
@ MLR_VAR_R
Definition: mat_tools.h:1698
SG_Get_Double_asString
SAGA_API_DLL_EXPORT CSG_String SG_Get_Double_asString(double Number, int Width=-1, int Precision=-1, bool bScientific=false)
Definition: mat_tools.cpp:159
CSG_Simple_Statistics::Get_Count
sLong Get_Count(void) const
Definition: mat_tools.h:745
CSG_Natural_Breaks::Get_Count
int Get_Count(void) const
Definition: mat_tools.h:1128
CSG_Cluster_Analysis::Get_nElements
sLong Get_nElements(void) const
Definition: mat_tools.h:1181
CSG_Trend_Polynom::Get_Data_X
double Get_Data_X(int i) const
Definition: mat_tools.h:2103
SG_Matrix_LU_Decomposition
SAGA_API_DLL_EXPORT bool SG_Matrix_LU_Decomposition(int n, int *Permutation, double **Matrix, bool bSilent=true, int *nRowChanges=NULL)
Definition: mat_matrix.cpp:1948
CSG_Unique_Value_Statistics::Get_Majority
virtual bool Get_Majority(double &Value) const
Definition: mat_tools.h:826
CSG_Classifier_Supervised::Get_Class_ID
const CSG_String & Get_Class_ID(int iClass)
Definition: mat_tools.h:1262
MLR_VAR_NAME
@ MLR_VAR_NAME
Definition: mat_tools.h:1696
CSG_Regression_Multiple::Get_T
double Get_T(int iVariable) const
Definition: mat_tools.h:1759
CSG_Simple_Statistics::Get_Minimum
double Get_Minimum(void)
Definition: mat_tools.h:748
TSG_PFNC_Compare
int(* TSG_PFNC_Compare)(const sLong a, const sLong b)
Definition: mat_tools.h:196
CSG_Unique_Value_Statistics::Get_Minority
virtual bool Get_Minority(double &Value, int &Count) const
Definition: mat_tools.h:829
CSG_Regression_Weighted::Get_RCoeff
double Get_RCoeff(int i) const
Definition: mat_tools.h:1824
CSG_Trend::Get_Parameters
double * Get_Parameters(void) const
Definition: mat_tools.h:2000
CSG_Regression_Multiple::m_Predictor
int * m_Predictor
Definition: mat_tools.h:1777
CSG_Simple_Statistics::Get_Weights
double Get_Weights(void) const
Definition: mat_tools.h:746
CSG_Regression_Weighted::Get_Log_Difference
double Get_Log_Difference(void) const
Definition: mat_tools.h:1830
CSG_Unique_Value_Statistics
Definition: mat_tools.h:812
CSG_Unique_Number_Statistics::CSG_Unique_Number_Statistics
CSG_Unique_Number_Statistics(bool bWeights=false)
Definition: mat_tools.h:851
CSG_Regression_Weighted::Get_CV_RMSE
double Get_CV_RMSE(void) const
Definition: mat_tools.h:1840
CSG_Regression::Get_xMax
double Get_xMax(void) const
Definition: mat_tools.h:1644
CSG_Histogram::is_Okay
bool is_Okay(void) const
Definition: mat_tools.h:1047
SG_Degree_To_Decimal
SAGA_API_DLL_EXPORT double SG_Degree_To_Decimal(double Deg, double Min, double Sec)
Definition: mat_tools.cpp:224
sLong
signed long long sLong
Definition: api_core.h:158
CSG_Category_Statistics::Get_Majority
bool Get_Majority(double &Value)
Definition: mat_tools.h:983
CSG_Regression_Multiple::m_bIntercept
bool m_bIntercept
Definition: mat_tools.h:1775
CSG_Regression_Weighted::Get_CV_R2
double Get_CV_R2(void) const
Definition: mat_tools.h:1842
CSG_Simple_Statistics::m_bEvaluated
int m_bEvaluated
Definition: mat_tools.h:790
CSG_Trend::is_Okay
bool is_Okay(void) const
Definition: mat_tools.h:2027
CSG_Simple_Statistics::Get_StdDev
double Get_StdDev(void)
Definition: mat_tools.h:755
ESG_Multiple_Regression_Info_Vars
ESG_Multiple_Regression_Info_Vars
Definition: mat_tools.h:1694
CSG_Histogram::Get_Break
double Get_Break(size_t i) const
Definition: mat_tools.h:1063
CSG_Regression::Get_Values
bool Get_Values(int i, double &x, double &y) const
Definition: mat_tools.h:1630
CSG_Classifier_Supervised::Get_Class_Count
int Get_Class_Count(void)
Definition: mat_tools.h:1260
CSG_PriorityQueue::Peek
CSG_PriorityQueueItem * Peek(void) const
Definition: mat_tools.h:305
TSG_Formula_Function_0
double(* TSG_Formula_Function_0)(void)
Definition: mat_tools.h:1874
CSG_Cluster_Analysis::Get_Variance
double Get_Variance(int iCluster) const
Definition: mat_tools.h:1190
CSG_Unique_Number_Statistics::Get_Minority
virtual bool Get_Minority(double &Value, int &Count) const
Definition: mat_tools.h:873
CSG_Regression::Get_yValue
double Get_yValue(int i) const
Definition: mat_tools.h:1629
SG_CLASSIFY_SUPERVISED_SAM
@ SG_CLASSIFY_SUPERVISED_SAM
Definition: mat_tools.h:1230
CSG_Regression::m_Type
TSG_Regression_Type m_Type
Definition: mat_tools.h:1679
CSG_Trend_Polynom::Get_nCoefficients
int Get_nCoefficients(void) const
Definition: mat_tools.h:2109
CSG_Array_Int
Definition: api_core.h:423
CSG_Trend::Get_Data_XMin
double Get_Data_XMin(void)
Definition: mat_tools.h:2009
CSG_Simple_Statistics::is_Evaluated
int is_Evaluated(void) const
Definition: mat_tools.h:741
CSG_Vector::Get_N
int Get_N(void) const
Definition: mat_tools.h:384
REGRESSION_Rez_X
@ REGRESSION_Rez_X
Definition: mat_tools.h:1606
SAGA_API_DLL_EXPORT
#define SAGA_API_DLL_EXPORT
Definition: api_core.h:94
CSG_Vector::cbegin
const_iterator cbegin(void) const
Definition: mat_tools.h:450
REGRESSION_Rez_Y
@ REGRESSION_Rez_Y
Definition: mat_tools.h:1607
CSG_Classifier_Supervised::Get_Class_Maximum
double Get_Class_Maximum(int iClass, int iFeature)
Definition: mat_tools.h:1265
CSG_Formula::SSG_Function::nParameters
int nParameters
Definition: mat_tools.h:1915
CSG_Unique_Value_Statistics::m_Weight
CSG_Vector m_Weight
Definition: mat_tools.h:843
SG_CLASSIFY_SUPERVISED_ParallelEpiped
@ SG_CLASSIFY_SUPERVISED_ParallelEpiped
Definition: mat_tools.h:1226
CSG_Regression::Get_Constant
double Get_Constant(void) const
Definition: mat_tools.h:1655
CSG_Vector::end
const_iterator end(void) const
Definition: mat_tools.h:449
CSG_Unique_Number_Statistics::~CSG_Unique_Number_Statistics
virtual ~CSG_Unique_Number_Statistics(void)
Definition: mat_tools.h:852
CSG_Grid_Radius::Get_nPoints
int Get_nPoints(int iRadius)
Definition: mat_tools.h:622
CSG_Simple_Statistics::Get_Mean
double Get_Mean(void)
Definition: mat_tools.h:753
CSG_Strings
Definition: api_core.h:701
CSG_Simple_Statistics::Get_Skewness
double Get_Skewness(void)
Definition: mat_tools.h:758
CSG_Regression_Weighted::Get_CV_NRMSE
double Get_CV_NRMSE(void) const
Definition: mat_tools.h:1841
REGRESSION_Pow
@ REGRESSION_Pow
Definition: mat_tools.h:1608
CSG_Unique_Value_Statistics::Get_Count
int Get_Count(void) const
Definition: mat_tools.h:819
CSG_Points
Definition: geo_tools.h:185
CSG_Category_Statistics::Get_Minority
bool Get_Minority(double &Value)
Definition: mat_tools.h:991
SG_CLASSIFY_SUPERVISED_MaximumLikelihood
@ SG_CLASSIFY_SUPERVISED_MaximumLikelihood
Definition: mat_tools.h:1229
CSG_Histogram::Get_Class_Count
size_t Get_Class_Count(void) const
Definition: mat_tools.h:1049
SG_Compare_Int
SAGA_API_DLL_EXPORT int SG_Compare_Int(const void *a, const void *b)
Definition: mat_tools.cpp:187
SG_CLUSTERANALYSIS_Combined
@ SG_CLUSTERANALYSIS_Combined
Definition: mat_tools.h:1161
CSG_Regression_Multiple::Get_With_Intercept
bool Get_With_Intercept(void) const
Definition: mat_tools.h:1719
CSG_Unique_Number_Statistics::Get_Value
double Get_Value(int Index) const
Definition: mat_tools.h:858
CSG_Vector::Get_Data
double Get_Data(sLong x) const
Definition: mat_tools.h:387
CSG_Regression_Multiple::Set_With_Intercept
void Set_With_Intercept(bool bOn=true)
Definition: mat_tools.h:1718
CSG_Cluster_Analysis::Get_SP
double Get_SP(void) const
Definition: mat_tools.h:1187
CSG_Table
Definition: table.h:285
CSG_Matrix::is_Square
bool is_Square(void) const
Definition: mat_tools.h:538
CSG_Cluster_Analysis::Get_nFeatures
int Get_nFeatures(void) const
Definition: mat_tools.h:1182
CSG_Vector::Get_Size
sLong Get_Size(void) const
Definition: mat_tools.h:382
ESG_Trend_String
ESG_Trend_String
Definition: mat_tools.h:1982
CSG_Unique_Value_Statistics::Get_Majority
virtual bool Get_Majority(double &Value, int &Count) const
Definition: mat_tools.h:827
TSG_Regression_Type
TSG_Regression_Type
Definition: mat_tools.h:1604
CSG_Unique_String_Statistics::Get_Majority
virtual bool Get_Majority(CSG_String &Value, int &Count) const
Definition: mat_tools.h:906
CSG_Spline::Get_xMin
double Get_xMin(void) const
Definition: mat_tools.h:1443
TSG_Regression_Correction
TSG_Regression_Correction
Definition: mat_tools.h:1583
CSG_Regression_Weighted::Get_CV_nSamples
int Get_CV_nSamples(void) const
Definition: mat_tools.h:1839
SG_TREND_STRING_Formula
@ SG_TREND_STRING_Formula
Definition: mat_tools.h:1983
CSG_PriorityQueue::Get_Size
size_t Get_Size(void) const
Definition: mat_tools.h:300
TSG_Formula_Function_2
double(* TSG_Formula_Function_2)(double, double)
Definition: mat_tools.h:1876
CSG_Regression_Weighted
Definition: mat_tools.h:1808
CSG_Simple_Statistics::m_nValues
sLong m_nValues
Definition: mat_tools.h:792
TESTDIST_TYPE_TwoTail
@ TESTDIST_TYPE_TwoTail
Definition: mat_tools.h:1529
SG_Char
#define SG_Char
Definition: api_core.h:536
CSG_Spline
Definition: mat_tools.h:1430
CSG_Thin_Plate_Spline::Get_Points
CSG_Points_3D & Get_Points(void)
Definition: mat_tools.h:1475
CSG_Regression::Get_xMin
double Get_xMin(void) const
Definition: mat_tools.h:1643
CSG_Array
Definition: api_core.h:308
CSG_Classifier_Supervised::Get_Class_Mean
double Get_Class_Mean(int iClass, int iFeature)
Definition: mat_tools.h:1263
B
#define B
CSG_PriorityQueue::Minimum
CSG_PriorityQueueItem * Minimum(void) const
Definition: mat_tools.h:309
CSG_String
Definition: api_core.h:563
CSG_Formula::SSG_Function::Name
const char * Name
Definition: mat_tools.h:1911
CSG_Unique_Value_Statistics::Get_Weight
double Get_Weight(int i) const
Definition: mat_tools.h:821
CSG_Simple_Statistics::Get_Values
double * Get_Values(void) const
Definition: mat_tools.h:776
CSG_Simple_Statistics::Get_Value
double Get_Value(sLong i) const
Definition: mat_tools.h:777
CSG_Regression_Multiple::m_pSteps
class CSG_Table * m_pSteps
Definition: mat_tools.h:1783
CSG_Regression::m_y
CSG_Vector m_y
Definition: mat_tools.h:1677
CSG_Regression::Get_Coefficient
double Get_Coefficient(void) const
Definition: mat_tools.h:1656
CSG_PriorityQueue::is_Empty
bool is_Empty(void) const
Definition: mat_tools.h:299
CSG_Regression::Get_R
double Get_R(void) const
Definition: mat_tools.h:1657
TSG_Formula_Function_1
double(* TSG_Formula_Function_1)(double)
Definition: mat_tools.h:1875
CSG_Category_Statistics::Get_Majority
bool Get_Majority(double &Value, int &Count)
Definition: mat_tools.h:986
CSG_Simple_Statistics::Get_Range
double Get_Range(void)
Definition: mat_tools.h:750
CSG_Unique_Number_Statistics::Get_Minority
virtual bool Get_Minority(double &Value) const
Definition: mat_tools.h:872
MLR_VAR_P
@ MLR_VAR_P
Definition: mat_tools.h:1704
CSG_Regression_Multiple::Get_Info_Model
class CSG_Table * Get_Info_Model(void) const
Definition: mat_tools.h:1735
CSG_Unique_Value_Statistics::Get_Majority
virtual int Get_Majority(bool bWeighted=false) const
Definition: mat_tools.cpp:805
CSG_Regression_Multiple::m_Names
CSG_Strings m_Names
Definition: mat_tools.h:1779
SG_CLASSIFY_SUPERVISED_BinaryEncoding
@ SG_CLASSIFY_SUPERVISED_BinaryEncoding
Definition: mat_tools.h:1225
SSG_Point::x
double x
Definition: geo_tools.h:129
SG_VectorR2_Rotate
SAGA_API_DLL_EXPORT bool SG_VectorR2_Rotate(double &x, double &y, double Angle)
Definition: mat_matrix.cpp:750
CSG_Cluster_Analysis::Get_nClusters
int Get_nClusters(void) const
Definition: mat_tools.h:1183
CSG_Category_Statistics::Get_Category
bool Get_Category(int iCategory, double &Value, int &Count) const
Definition: mat_tools.h:965
SG_TREND_STRING_Function
@ SG_TREND_STRING_Function
Definition: mat_tools.h:1984
CSG_Random
Definition: mat_tools.h:702
CSG_Cluster_Analysis::Get_Centroid
double Get_Centroid(int iCluster, int iFeature) const
Definition: mat_tools.h:1191
CSG_PriorityQueue
Definition: mat_tools.h:277
CSG_Formula::TSG_Function
struct CSG_Formula::SSG_Function TSG_Function
CSG_Formula::SSG_Function::bVarying
bool bVarying
Definition: mat_tools.h:1917
CSG_Unique_Value_Statistics::Create
virtual void Create(bool bWeights=false)
Definition: mat_tools.h:817
CSG_Grid_Radius::Get_Point
double Get_Point(int iPoint, int &x, int &y)
Definition: mat_tools.h:624
CSG_Trend_Polynom::Get_Data_Count
int Get_Data_Count(void) const
Definition: mat_tools.h:2102
CSG_Regression::Get_StdError
double Get_StdError(void) const
Definition: mat_tools.h:1661
SSG_Point::y
double y
Definition: geo_tools.h:129
CSG_Grid
Definition: grid.h:501
CSG_Unique_Value_Statistics::Get_Majority
virtual bool Get_Majority(CSG_String &Value) const
Definition: mat_tools.h:831
TSG_Formula_Function_3
double(* TSG_Formula_Function_3)(double, double, double)
Definition: mat_tools.h:1877
MLR_VAR_ID
@ MLR_VAR_ID
Definition: mat_tools.h:1695
CSG_Unique_Number_Statistics::Get_Majority
virtual bool Get_Majority(double &Value, int &Count) const
Definition: mat_tools.h:871
CSG_Unique_Value_Statistics::Get_Minority
virtual bool Get_Minority(CSG_String &Value) const
Definition: mat_tools.h:833
CSG_Trend::Get_Value
double Get_Value(double x) const
Definition: mat_tools.h:2034
MLR_VAR_SE
@ MLR_VAR_SE
Definition: mat_tools.h:1701
CSG_Trend::Get_Data_Count
int Get_Data_Count(void) const
Definition: mat_tools.h:2007
SG_CLASSIFY_SUPERVISED_MinimumDistance
@ SG_CLASSIFY_SUPERVISED_MinimumDistance
Definition: mat_tools.h:1227
SG_Compare_Double
SAGA_API_DLL_EXPORT int SG_Compare_Double(const void *a, const void *b)
Definition: mat_tools.cpp:199
CSG_PriorityQueue::CSG_PriorityQueueItem::CSG_PriorityQueueItem
CSG_PriorityQueueItem(void)
Definition: mat_tools.h:284
CSG_Trend::Get_Data_YMin
double Get_Data_YMin(void)
Definition: mat_tools.h:2013
CSG_Unique_String_Statistics::Get_Value
const SG_Char * Get_Value(int Index) const
Definition: mat_tools.h:893
CSG_Unique_Value_Statistics::CSG_Unique_Value_Statistics
CSG_Unique_Value_Statistics(void)
Definition: mat_tools.h:814
CSG_Grid_Radius::Get_Point
double Get_Point(int iPoint, int xOffset, int yOffset, int &x, int &y)
Definition: mat_tools.h:637
CSG_Thin_Plate_Spline
Definition: mat_tools.h:1465
CSG_Vector::begin
const_iterator begin(void) const
Definition: mat_tools.h:448
CSG_Parameters
Definition: parameters.h:1696
CSG_Grid_Radius::Get_nPoints
int Get_nPoints(void)
Definition: mat_tools.h:621
TSG_Data_Type
TSG_Data_Type
Definition: api_core.h:997
TESTDIST_TYPE_Left
@ TESTDIST_TYPE_Left
Definition: mat_tools.h:1526
CSG_Unique_String_Statistics::Get_Class
bool Get_Class(int Index, CSG_String &Value, int &Count) const
Definition: mat_tools.h:895
SG_CLUSTERANALYSIS_Minimum_Distance
@ SG_CLUSTERANALYSIS_Minimum_Distance
Definition: mat_tools.h:1159
CSG_Thin_Plate_Spline::Set_Point
bool Set_Point(int Index, double x, double y, double z)
Definition: mat_tools.h:1480
CSG_Category_Statistics::Get_Majority
bool Get_Majority(CSG_String &Value)
Definition: mat_tools.h:984
CSG_Grid_Radius::Get_Point
double Get_Point(int iRadius, int iPoint, int &x, int &y)
Definition: mat_tools.h:650
CSG_Regression::Get_P
double Get_P(void) const
Definition: mat_tools.h:1660
MLR_VAR_SIG
@ MLR_VAR_SIG
Definition: mat_tools.h:1703
CSG_PriorityQueue::CSG_PriorityQueueItem
Definition: mat_tools.h:282
CSG_PriorityQueue::Maximum
CSG_PriorityQueueItem * Maximum(void) const
Definition: mat_tools.h:324
CSG_Regression_Weighted::Get_Log_Epsilon
double Get_Log_Epsilon(void) const
Definition: mat_tools.h:1829
CSG_Regression
Definition: mat_tools.h:1616
CSG_Spline::Get_Count
int Get_Count(void) const
Definition: mat_tools.h:1442
CSG_Index::Get_Count
sLong Get_Count(void) const
Definition: mat_tools.h:241
SG_Decimal_To_Degree
SAGA_API_DLL_EXPORT void SG_Decimal_To_Degree(double Value, double &Deg, double &Min, double &Sec)
Definition: mat_tools.cpp:233
CSG_Trend::Get_Data_XStats
CSG_Simple_Statistics & Get_Data_XStats(void)
Definition: mat_tools.h:2011
CSG_Histogram::Get_Element_Maximum
size_t Get_Element_Maximum(void) const
Definition: mat_tools.h:1052
CSG_Matrix
Definition: mat_tools.h:480
CSG_Grids
Definition: grids.h:119
CSG_Thin_Plate_Spline::Set_Point
bool Set_Point(int Index, const TSG_Point &p, double z)
Definition: mat_tools.h:1494
CSG_Category_Statistics::Get_Category
bool Get_Category(int iCategory, int &Value, int &Count) const
Definition: mat_tools.h:957
CSG_Index::CSG_Index_Compare::~CSG_Index_Compare
virtual ~CSG_Index_Compare(void)
Definition: mat_tools.h:206
REGRESSION_Exp
@ REGRESSION_Exp
Definition: mat_tools.h:1609
CSG_Trend::Get_Max_Iterations
int Get_Max_Iterations(void) const
Definition: mat_tools.h:2018
REGRESSION_CORR_Smith
@ REGRESSION_CORR_Smith
Definition: mat_tools.h:1585
SG_VectorR3_Rotate
SAGA_API_DLL_EXPORT bool SG_VectorR3_Rotate(double Vector[3], size_t Axis, double Angle)
Definition: mat_matrix.cpp:776
CSG_Histogram::Get_Elements
size_t Get_Elements(int i) const
Definition: mat_tools.h:1054
CSG_Simple_Statistics
Definition: mat_tools.h:725
CSG_Simple_Statistics::m_Values
CSG_Array m_Values
Definition: mat_tools.h:796
CSG_Index::CSG_Index_Compare::CSG_Index_Compare
CSG_Index_Compare(void)
Definition: mat_tools.h:205
CSG_Trend::Get_ChiSquare
double Get_ChiSquare(void) const
Definition: mat_tools.h:2031
REGRESSION_CORR_None
@ REGRESSION_CORR_None
Definition: mat_tools.h:1584
CSG_Classifier_Supervised
Definition: mat_tools.h:1238
CSG_Histogram::Get_Value
double Get_Value(double i) const
Definition: mat_tools.h:1060
ESG_Cluster_Analysis_Method
ESG_Cluster_Analysis_Method
Definition: mat_tools.h:1158
CSG_Matrix::Get_NY
int Get_NY(void) const
Definition: mat_tools.h:523
CSG_Unique_String_Statistics::CSG_Unique_String_Statistics
CSG_Unique_String_Statistics(bool bWeights=false)
Definition: mat_tools.h:886
CSG_Regression_Multiple::Get_Info_Regression
class CSG_Table * Get_Info_Regression(void) const
Definition: mat_tools.h:1734
geo_tools.h
CSG_Regression::Get_yMax
double Get_yMax(void) const
Definition: mat_tools.h:1650
CSG_Vector::Get_Row_Count
sLong Get_Row_Count(void) const
Definition: mat_tools.h:381
CSG_Histogram::Get_Statistics
const CSG_Simple_Statistics & Get_Statistics(void) const
Definition: mat_tools.h:1082
CSG_Spline::m_z
CSG_Vector m_z
Definition: mat_tools.h:1456
CSG_Regression::Get_yMean
double Get_yMean(void) const
Definition: mat_tools.h:1651
CSG_Simple_Statistics::m_Weights
double m_Weights
Definition: mat_tools.h:794
CSG_Thin_Plate_Spline::Add_Point
bool Add_Point(double x, double y, double z)
Definition: mat_tools.h:1477
CSG_Matrix::Get_NX
int Get_NX(void) const
Definition: mat_tools.h:522
CSG_Thin_Plate_Spline::is_Okay
bool is_Okay(void)
Definition: mat_tools.h:1498
CSG_Simple_Statistics::m_bSorted
bool m_bSorted
Definition: mat_tools.h:788
CSG_Regression_Multiple
Definition: mat_tools.h:1709
CSG_Regression_Weighted::Get_Sample_Count
int Get_Sample_Count(void) const
Definition: mat_tools.h:1816
CSG_Vector::const_iterator
double const * const_iterator
Definition: mat_tools.h:446
CSG_Trend_Polynom::Get_Order
int Get_Order(void) const
Definition: mat_tools.h:2108
CSG_Regression::Get_xValue
double Get_xValue(int i) const
Definition: mat_tools.h:1628
operator+
SAGA_API_DLL_EXPORT CSG_String operator+(const char *A, const CSG_String &B)
Definition: api_string.cpp:473