liblip-dev 2.0.0-1.2 / usr / include / lip / liblip.h

This file is indexed.

/usr/include/lip/liblip.h is in liblip-dev 2.0.0-1.2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
/**************************************************************************

  Procedural intervace to the methods of Lipschitz interpolant classes
 ***************************************************************************/


#ifdef __cplusplus
extern "C" {
#endif


//#define NULL 0

/* interface to the members of SLipInt class ===================== */
double	LipIntValue(int* Dim, int* Ndata, double* x, double* Xd,double* y,  double* Lipconst, int* Index);

double	LipIntValueAuto(int* Dim, int* Ndata, double* x,double* Xd, double* y, int* Index);

double	LipIntValueCons(int* Dim, int* Ndata, int* Cons, double* x, double* Xd,double* y,  double* Lipconst, int* Index);

double	LipIntValueConsLeftRegion(int* Dim, int* Ndata, int* Cons, double* x, double* Xd,double* y,  double* Lipconst, 
								  double* Region, int* Index);

double	LipIntValueConsRightRegion(int* Dim, int* Ndata, int* Cons, double* x, double* Xd,double* y,  double* Lipconst, 
								   double* Region, int* Index);


double	LipIntValueLocal(int *Dim, int *Ndata, double* x, double* Xd,double* y);

double	LipIntValueLocalCons(int *Dim, int *Ndata,int* Cons, double* x, double* Xd,double* y);

double	LipIntValueLocalConsLeftRegion(int *Dim, int *Ndata,int* Cons, double* x, double* Xd,double* y, double* Region);

double	LipIntValueLocalConsRightRegion(int *Dim, int *Ndata,int* Cons, double* x, double* Xd,double* y, double* Region);


void	LipIntComputeLipschitz(int *Dim, int *Ndata, double* x, double* y);

void	LipIntComputeLocalLipschitz(int *Dim, int *Ndata, double* x, double* y);

void	LipIntComputeLipschitzCV(int *Dim, int *Ndata, double* Xd, double* y, double* T,
			int* type, int* Cons, double* Region, double *W);

void	LipIntComputeLipschitzSplit(int *Dim, int *Ndata, double* Xd, double* y, double* T, double* ratio,
			int* type, int* Cons, double* Region, double *W);


void	LipIntSmoothLipschitz(int *Dim, int *Ndata,  double* Xd, double* y, double* T,  double* LC, 
							  int* fW, int* fC, int* fR, double* W, int* Cons, double* Region);
 // fR is 0, 1-left, 2-right

void	LipIntSetGamma(double* g);
double	LipIntGetLipConst() ;
void	LipIntGetScaling(double *S) ;
int		LipIntComputeScaling(int *Dim, int *Ndata, double* XData, double* YData);
void	ConvertXData(int *Dim, int* npts,  double* XData);
void	ConvertXDataAux(int *Dim, int* npts,  double* XData, double *auxdata);

int		LipIntVerifyMonotonicity(int *Dim, int* npts, int* Cons,  double* XData, double* YData, double* LC, double* eps);
int		LipIntVerifyMonotonicityLeftRegion(int *Dim, int* npts, int* Cons,  double* XData, double* YData, double* Region, 
										   double* LC, double* eps);
int		LipIntVerifyMonotonicityRightRegion(int *Dim, int* npts, int* Cons,  double* XData, double* YData, double* Region, 
											double* LC, double* eps);


/* interface to the members of SLipIntInf class ====================================== */

double	LipIntInfValue(int *Dim, int *Ndata, double* x, double* Xd,double* y,  double* Lipconst, int* Index);

double	LipIntInfValueAuto(int *Dim, int *Ndata, double* x,double* Xd, double* y, int* Index);

double	LipIntInfValueCons(int *Dim, int *Ndata, int* Cons, double* x, double* Xd,double* y,  double Lipconst, int* Index);

double	LipIntInfValueConsLeftRegion(int *Dim, int *Ndata, int* Cons, double* x, double* Xd,double* y,  double* Lipconst, 
								  double* Region, int* Index);

double	LipIntInfValueConsRightRegion(int *Dim, int *Ndata, int* Cons, double* x, double* Xd,double* y,  double* Lipconst, 
								   double* Region, int* Index);


double	LipIntInfValueLocal(int *Dim, int *Ndata, double* x, double* Xd,double* y);

double	LipIntInfValueLocalCons(int *Dim, int *Ndata,int* Cons, double* x, double* Xd,double* y);

double	LipIntInfValueLocalConsLeftRegion(int *Dim, int *Ndata,int* Cons, double* x, double* Xd,double* y, double* Region);

double	LipIntInfValueLocalConsRightRegion(int *Dim, int *Ndata,int* Cons, double* x, double* Xd,double* y, double* Region);


void	LipIntInfComputeLipschitz(int *Dim, int *Ndata, double* x, double* y);

void	LipIntInfComputeLocalLipschitz(int *Dim, int *Ndata, double* x, double* y);

void	LipIntInfComputeLipschitzCV(int *Dim, int *Ndata, double* Xd, double* y, double* T,
			int* type, int* Cons, double* Region, double *W);

void	LipIntInfComputeLipschitzSplit(int *Dim, int *Ndata, double* Xd, double* y, double* T, double* ratio,
			int* type, int* Cons, double* Region, double *W);


void	LipIntInfSmoothLipschitz(int *Dim, int *Ndata,  double* Xd, double* y, double* T,  double* LC, 
							  int* fW, int* fC, int* fR, double* W, int* Cons, double* Region);
 // fR is 0, 1-left, 2-right

double	LipIntInfGetLipConst() ;
void	LipIntInfGetScaling(double *S) ;
int		LipIntInfComputeScaling(int *Dim, int *Ndata, double* XData, double* YData);

int		LipIntInfVerifyMonotonicity(int *Dim, int* npts, int* Cons,  double* XData, double* YData, double LC, double ep);
int		LipIntInfVerifyMonotonicityLeftRegion(int *Dim, int npts, int* Cons,  double* XData, double* YData, double* Region, 
										   double* LC, double* eps);
int		LipIntInfVerifyMonotonicityRightRegion(int *Dim, int npts, int* Cons,  double* XData, double* YData, double* Region, 
											double* LC, double* eps);


void	LipIntInfSmoothLipschitzSimp(int *Dim, int* npts,  double* XData, double* YData, double* TData,  double* LC);
void	LipIntInfSmoothLipschitzSimpW(int *Dim, int* npts,  double* XData, double* YData, double* TData,  double* LC, double* W);




/* interface to the members of STCInterpolant class ====================================== */

// supplies the data to Interpolant and constructs the interpolant
// assuming a given Lipschitz constant, supplied by SetLipschitz
// if LipConstant was not supplied, tries to find it from the data
// assumes that all data are different. 

 int	STCBuildLipInterpolant(int *Dim, int *Ndata, double* x, double* y);

// as above, but for explicit evaluation, needs no preprocessing, but may be slower
 int	STCBuildLipInterpolantExplicit(int *Dim, int *Ndata, double* x, double* y);

// in the methods above, the coordinates of the data points in x are stored in rows

// the following methods store data in columns (like in fortran or Matlab)
// they use the transposed of the matrix x 
 int	STCBuildLipInterpolantColumn(int *Dim, int *Ndata, double* x, double* y);

// as above, but for explicit evaluation, needs no preprocessing, but may be slower
 int	STCBuildLipInterpolantExplicitColumn(int *Dim, int *Ndata, double* x, double* y);


// specify the Lipschitz constant for your function
 void	STCSetLipschitz(double* x);

// computes the value of the interpolant at any given point x
 double	STCValue( double* x );

// same but using explicit evaluation with no preprocessing
 double	STCValueExplicit( double* x );

 void	STCFreeMemory();






#ifdef __cplusplus
}
#endif

APT Browse - Built by Thomas Orozco.