ssantisi
/
simulacion-permeabilidad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Linter to c files

Browse Source
milestone_5_without_improvements
chortas 4 years ago
parent 3210b268aa
commit 83d7d29273
43 changed files with 1416 additions and 1496 deletions
Show Stats Download Patch File Download Diff File

152
fftma_module/gen/lib_src/Py_getvalues.c
Unescape Escape View File

@ -1,62 +1,62 @@
#include <Python.h>
#include <numpy/arrayobject.h>
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include "Py_py-api.h"
#include "genlib.h"
#include "simpio.h"
#include "geostat.h"
#include "pressure.h"
#include "simpio.h"
#include "toolsIO.h"
#include <Python.h>
#include <numpy/arrayobject.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#if PY_MAJOR_VERSION >= 3
#define PyIntObject PyLongObject
#define PyInt_Type PyLong_Type
#define PyInt_Check(op) PyLong_Check(op)
#define PyInt_CheckExact(op) PyLong_CheckExact(op)
#define PyInt_FromString PyLong_FromString
#define PyInt_FromUnicode PyLong_FromUnicode
#define PyInt_FromLong PyLong_FromLong
#define PyInt_FromSize_t PyLong_FromSize_t
#define PyInt_FromSsize_t PyLong_FromSsize_t
#define PyInt_AsLong PyLong_AsLong
#define PyInt_AS_LONG PyLong_AS_LONG
#define PyInt_AsSsize_t PyLong_AsSsize_t
#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
#define PyNumber_Int PyNumber_Long
#define PyIntObject PyLongObject
#define PyInt_Type PyLong_Type
#define PyInt_Check(op) PyLong_Check(op)
#define PyInt_CheckExact(op) PyLong_CheckExact(op)
#define PyInt_FromString PyLong_FromString
#define PyInt_FromUnicode PyLong_FromUnicode
#define PyInt_FromLong PyLong_FromLong
#define PyInt_FromSize_t PyLong_FromSize_t
#define PyInt_FromSsize_t PyLong_FromSsize_t
#define PyInt_AsLong PyLong_AsLong
#define PyInt_AS_LONG PyLong_AS_LONG
#define PyInt_AsSsize_t PyLong_AsSsize_t
#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
#define PyNumber_Int PyNumber_Long
#endif
#if PY_MAJOR_VERSION >= 3
#define PyBoolObject PyLongObject
#define PyBoolObject PyLongObject
#endif
#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
#ifndef PyUnicode_InternFromString
#define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
#endif
#ifndef PyUnicode_InternFromString
#define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
#endif
#endif
int Py_getvalues(PyObject* args, long* seed,struct grid_mod* grid,struct vario_mod* variogram,struct statistic_mod* stat)
int Py_getvalues(PyObject* args, long* seed, struct grid_mod* grid, struct vario_mod* variogram, struct statistic_mod* stat)
{
int i, varioNargs=12, j=0;
int i, varioNargs = 12, j = 0;
PyObject* listvario;
PyObject* vgr;
//char* gwnfilename;
stat->nblock_mean=1;
stat->nblock_var=1;
stat->mean=(double*)malloc(stat->nblock_mean * sizeof(double));
if (stat->mean == NULL) return 0;
stat->variance=(double*)malloc(stat->nblock_var * sizeof(double));
if (stat->variance == NULL) return 0;
stat->nblock_mean = 1;
stat->nblock_var = 1;
stat->mean = (double*)malloc(stat->nblock_mean * sizeof(double));
if (stat->mean == NULL)
return 0;
stat->variance = (double*)malloc(stat->nblock_var * sizeof(double));
if (stat->variance == NULL)
return 0;
if(!PyArg_ParseTuple(args, "iiidddlO!ddi", /*"iiidddslO!ddi",*/
if (!PyArg_ParseTuple(args, "iiidddlO!ddi", /*"iiidddslO!ddi",*/
&(grid->NX),
&(grid->NY),
&(grid->NZ),
@ -66,45 +66,45 @@ int Py_getvalues(PyObject* args, long* seed,struct grid_mod* grid,struct vario_m
/*gwnfilename,*/
seed,
&PyList_Type, &listvario,
stat->mean+0,
stat->variance+0,
&(stat->type))) return 0;
variogram->Nvario=PyList_Size(listvario);
variogram->var=(double*)malloc(variogram->Nvario*sizeof(double));
if(variogram->var==NULL) return 0;
variogram->vario=(int*)malloc(variogram->Nvario*sizeof(int));
if(variogram->vario==NULL) return 0;
variogram->alpha=(double*)malloc(variogram->Nvario*sizeof(double));
if(variogram->alpha==NULL) return 0;
variogram->scf=(double*)malloc(3*variogram->Nvario*sizeof(double));
if(variogram->var==NULL) return 0;
variogram->ap=(double*)malloc(9*variogram->Nvario*sizeof(double));
if(variogram->var==NULL) return 0;
for(i=0;i<variogram->Nvario;i++)
{
vgr=PyList_GetItem(listvario,i);
if(PyTuple_Size(vgr)!=12) return 0;
(variogram->var)[i]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->vario)[i]=(int)PyInt_AsLong(PyTuple_GetItem(vgr,j++));
(variogram->alpha)[i]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->scf)[i*3+0]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->scf)[i*3+1]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->scf)[i*3+2]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->ap)[i*9+0]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->ap)[i*9+1]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->ap)[i*9+2]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->ap)[i*9+3]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->ap)[i*9+4]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
(variogram->ap)[i*9+5]=PyFloat_AsDouble(PyTuple_GetItem(vgr,j++));
stat->mean + 0,
stat->variance + 0,
&(stat->type)))
return 0;
variogram->Nvario = PyList_Size(listvario);
variogram->var = (double*)malloc(variogram->Nvario * sizeof(double));
if (variogram->var == NULL)
return 0;
variogram->vario = (int*)malloc(variogram->Nvario * sizeof(int));
if (variogram->vario == NULL)
return 0;
variogram->alpha = (double*)malloc(variogram->Nvario * sizeof(double));
if (variogram->alpha == NULL)
return 0;
variogram->scf = (double*)malloc(3 * variogram->Nvario * sizeof(double));
if (variogram->var == NULL)
return 0;
variogram->ap = (double*)malloc(9 * variogram->Nvario * sizeof(double));
if (variogram->var == NULL)
return 0;
for (i = 0; i < variogram->Nvario; i++) {
vgr = PyList_GetItem(listvario, i);
if (PyTuple_Size(vgr) != 12)
return 0;
(variogram->var)[i] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->vario)[i] = (int)PyInt_AsLong(PyTuple_GetItem(vgr, j++));
(variogram->alpha)[i] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->scf)[i * 3 + 0] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->scf)[i * 3 + 1] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->scf)[i * 3 + 2] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->ap)[i * 9 + 0] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->ap)[i * 9 + 1] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->ap)[i * 9 + 2] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->ap)[i * 9 + 3] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->ap)[i * 9 + 4] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
(variogram->ap)[i * 9 + 5] = PyFloat_AsDouble(PyTuple_GetItem(vgr, j++));
}
return 1;
}

43
fftma_module/gen/lib_src/Py_kgeneration.c
Unescape Escape View File

@ -1,54 +1,49 @@
#include <Python.h>
#include <numpy/arrayobject.h>
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include "Py_py-api.h"
#include "genlib.h"
#include "simpio.h"
#include "geostat.h"
#include "toolsIO.h"
#include "simpio.h"
#include "toolsFFTMA.h"
#include "toolsIO.h"
#include <Python.h>
#include <numpy/arrayobject.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* kgeneration */
/* Z is the GWN with 0-mean and 1-variance */
/* Y1 is the realization with 0-mean and variance wanted */
/* Y is the realization with mean and variance wanted */
void Py_kgeneration(long seed,struct grid_mod grid,struct statistic_mod stat,struct vario_mod variogram,struct realization_mod *Z,struct realization_mod *Y,struct realization_mod *Y1, int n[3])
{
int i,N;
void Py_kgeneration(long seed, struct grid_mod grid, struct statistic_mod stat, struct vario_mod variogram, struct realization_mod* Z, struct realization_mod* Y, struct realization_mod* Y1, int n[3])
{
int i, N;
int typelog;
/*generate Gaussian white noise*/
N = grid.NX*grid.NY*grid.NZ;
N = grid.NX * grid.NY * grid.NZ;
n[0] = 0;
n[1] = 0;
n[2] = 0;
generate(&seed,N,Z);
generate(&seed, N, Z);
/*FFTMA*/
FFTMA2(variogram,grid,n,Z,Y);
FFTMA2(variogram, grid, n, Z, Y);
/*add the statistics*/
//if (stat.mean[0] != 0 || stat.variance[0]!= 1)
//addstat2(Y,stat,Y1,Y);
/* make a log normal realization */
if (stat.type==1 || stat.type==2){
if (stat.type == 1 || stat.type == 2) {
typelog=stat.type+2;
typelog = stat.type + 2;
/* nor2log(Y1,typelog,Y1); */
nor2log(Y,typelog,Y);
nor2log(Y, typelog, Y);
}
return;
}
}

41
fftma_module/gen/lib_src/axes.c
Unescape Escape View File

@ -2,40 +2,37 @@
#include <stdlib.h>
/*normalizes anisotropy axes*/
void axes(double *ap,double *scf,int N)
void axes(double* ap, double* scf, int N)
{
double sclpdt, r, eps = 1.E-6;
int i,j,k;
int i, j, k;
for (k = 0; k < N; k++) {
r = sqrt(ap[9*k]*ap[9*k]+ap[9*k+1]*ap[9*k+1]+ap[9*k+2]*ap[9*k+2]);
ap[9*k] /= r;
ap[9*k+1] /= r;
ap[9*k+2] /= r;
sclpdt = ap[9*k]*ap[9*k+3]+ap[9*k+1]*ap[9*k+4]+ap[9*k+2]*ap[9*k+5];
r = sqrt(ap[9 * k] * ap[9 * k] + ap[9 * k + 1] * ap[9 * k + 1] + ap[9 * k + 2] * ap[9 * k + 2]);
ap[9 * k] /= r;
ap[9 * k + 1] /= r;
ap[9 * k + 2] /= r;
sclpdt = ap[9 * k] * ap[9 * k + 3] + ap[9 * k + 1] * ap[9 * k + 4] + ap[9 * k + 2] * ap[9 * k + 5];
if (sclpdt > eps) {
printf("Non orthogonal axes");
exit;
} else {
r = sqrt(ap[9*k+3]*ap[9*k+3]+ap[9*k+4]*ap[9*k+4]+ap[9*k+5]*ap[9*k+5]);
ap[9*k+3] /= r;
ap[9*k+4] /= r;
ap[9*k+5] /= r;
ap[9*k+6] = ap[9*k+1]*ap[9*k+5]-ap[9*k+2]*ap[9*k+4];
ap[9*k+7] = ap[9*k+2]*ap[9*k+3]-ap[9*k]*ap[9*k+5];
ap[9*k+8] = ap[9*k]*ap[9*k+4]-ap[9*k+1]*ap[9*k+3];
for (i=0; i<3; i++) {
for (j=0; j<3; j++) {
if (scf[3*k+j] == 0.)
scf[3*k+j] = 1.;
ap[9*k+3*j+i] /= scf[3*k+j];
r = sqrt(ap[9 * k + 3] * ap[9 * k + 3] + ap[9 * k + 4] * ap[9 * k + 4] + ap[9 * k + 5] * ap[9 * k + 5]);
ap[9 * k + 3] /= r;
ap[9 * k + 4] /= r;
ap[9 * k + 5] /= r;
ap[9 * k + 6] = ap[9 * k + 1] * ap[9 * k + 5] - ap[9 * k + 2] * ap[9 * k + 4];
ap[9 * k + 7] = ap[9 * k + 2] * ap[9 * k + 3] - ap[9 * k] * ap[9 * k + 5];
ap[9 * k + 8] = ap[9 * k] * ap[9 * k + 4] - ap[9 * k + 1] * ap[9 * k + 3];
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
if (scf[3 * k + j] == 0.)
scf[3 * k + j] = 1.;
ap[9 * k + 3 * j + i] /= scf[3 * k + j];
}
}
}
}
return;
}

22
fftma_module/gen/lib_src/build_real.c
Unescape Escape View File

@ -1,10 +1,10 @@
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include "geostat.h"
#include <math.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "geostat.h"
#include <string.h>
/* build_real */
/* build a realization in the spectral domain */
@ -18,21 +18,21 @@
/*realization: vector defining the real part */
/*ireal: vector defining the i-part */
void build_real(int n[3],int NTOT,double *covar,double *realization,double *ireal)
void build_real(int n[3], int NTOT, double* covar, double* realization, double* ireal)
{
int i,j,k,maille1;
int i, j, k, maille1;
double temp;
/*decomposition and multiplication in the spectral domain*/
for ( k = 1; k <= n[2]; k++) {
for (k = 1; k <= n[2]; k++) {
for (j = 1; j <= n[1]; j++) {
for (i = 1; i <= n[0]; i++) {
maille1 = i+(j-1+(k-1)*n[1])*n[0];
maille1 = i + (j - 1 + (k - 1) * n[1]) * n[0];
temp = covar[maille1];
if (temp > 0.) {
temp = sqrt(temp)/(double) NTOT;
temp = sqrt(temp) / (double)NTOT;
} else if (temp < 0.) {
temp = sqrt(-temp)/(double) NTOT;
temp = sqrt(-temp) / (double)NTOT;
}
realization[maille1] *= temp;
ireal[maille1] *= temp;

10
fftma_module/gen/lib_src/cardsin.c
Unescape Escape View File

@ -1,6 +1,6 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*cardsin covariance function*/
double cardsin(double h)
@ -9,10 +9,10 @@ double cardsin(double h)
double z;
if (h != 0) {
z = (double)(h*delta);
z = sin(z)/z;
z = (double)(h * delta);
z = sin(z) / z;
} else {
z = 1.;
}
return(z);
return (z);
}

11
fftma_module/gen/lib_src/cgrid.c
Unescape Escape View File

@ -1,6 +1,5 @@
#include <stdlib.h>
#include "geostat.h"
#include <stdlib.h>
/*computes the size of the grid for FFTs*/
/*input: */
@ -12,11 +11,11 @@
/* i = [0 1 2] */
void cgrid(struct vario_mod variogram, struct grid_mod grid, int n[3])
{
int i,N;
int i, N;
double D;
if (n == NULL || n[0] == 0 || n[1] == 0 || n[2] == 0) {
for (i = 0; i<3; i++) {
for (i = 0; i < 3; i++) {
switch (i) {
case 0:
N = grid.NX;
@ -31,10 +30,10 @@ void cgrid(struct vario_mod variogram, struct grid_mod grid, int n[3])
D = grid.DZ;
break;
}
n[i] = length(N,i,variogram.scf,variogram.ap,D,variogram.Nvario);
n[i] = length(N, i, variogram.scf, variogram.ap, D, variogram.Nvario);
}
} else {
if ((n[0]<grid.NX) || (n[1]<grid.NY) || (n[2]<grid.NZ)) {
if ((n[0] < grid.NX) || (n[1] < grid.NY) || (n[2] < grid.NZ)) {
printf("Indicated dimensions are inappropriate in cgrid");
exit;
}

30
fftma_module/gen/lib_src/clean_real.c
Unescape Escape View File

@ -1,25 +1,23 @@
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include "geostat.h"
#include <math.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "geostat.h"
#include <string.h>
void clean_real(struct realization_mod *realin,int n[3],struct grid_mod grid,double *vectorresult,struct realization_mod *realout)
void clean_real(struct realization_mod* realin, int n[3], struct grid_mod grid, double* vectorresult, struct realization_mod* realout)
{
int i,j,k,maille0,maille1;
int i, j, k, maille0, maille1;
double NTOT;
NTOT=n[0]*n[1]*n[2];
NTOT = n[0] * n[1] * n[2];
/*is the output realization already allocated?*/
/*if not, memory allocation*/
if ((*realout).vector == NULL || (*realout).n != (*realin).n)
{
(*realout).vector = (double *) malloc((*realin).n * sizeof(double));
if ((*realout).vector == NULL)
{
if ((*realout).vector == NULL || (*realout).n != (*realin).n) {
(*realout).vector = (double*)malloc((*realin).n * sizeof(double));
if ((*realout).vector == NULL) {
printf("Clean_real.c: No memory available\n");
exit;
}
@ -27,11 +25,11 @@ void clean_real(struct realization_mod *realin,int n[3],struct grid_mod grid,dou
(*realout).n = (*realin).n;
(*realout).code = 1;
for ( k = 1; k <= grid.NZ; k++) {
for (k = 1; k <= grid.NZ; k++) {
for (j = 1; j <= grid.NY; j++) {
for (i = 1; i <= grid.NX; i++) {
maille1 = i+(j-1+(k-1)*n[1])*n[0];
maille0 = i-1+(j-1+(k-1)*grid.NY)*grid.NX;
maille1 = i + (j - 1 + (k - 1) * n[1]) * n[0];
maille0 = i - 1 + (j - 1 + (k - 1) * grid.NY) * grid.NX;
/* Modif du 18 juin 2003 */
/*(*realout).vector[maille0] = vectorresult[maille1]/(double) NTOT;*/
(*realout).vector[maille0] = vectorresult[maille1];

35
fftma_module/gen/lib_src/cov_value.c
Unescape Escape View File

@ -1,11 +1,11 @@
#include <math.h>
#include "geostat.h"
#include "genlib.h"
#include "geostat.h"
#include <math.h>
/*selection of model covariance*/
double cov_value(struct vario_mod variogram,double di,double dj,double dk)
double cov_value(struct vario_mod variogram, double di, double dj, double dk)
{
double hx,hy,hz,h;
double hx, hy, hz, h;
double cov;
int k;
@ -13,39 +13,38 @@ double cov_value(struct vario_mod variogram,double di,double dj,double dk)
for (k = 0; k < variogram.Nvario; k++) {
hx = di*variogram.ap[9*k]+dj*variogram.ap[9*k+1]+dk*variogram.ap[9*k+2];
hy = di*variogram.ap[9*k+3]+dj*variogram.ap[9*k+4]+dk*variogram.ap[9*k+5];
hz = di*variogram.ap[9*k+6]+dj*variogram.ap[9*k+7]+dk*variogram.ap[9*k+8];
h = sqrt(hx*hx+hy*hy+hz*hz);
hx = di * variogram.ap[9 * k] + dj * variogram.ap[9 * k + 1] + dk * variogram.ap[9 * k + 2];
hy = di * variogram.ap[9 * k + 3] + dj * variogram.ap[9 * k + 4] + dk * variogram.ap[9 * k + 5];
hz = di * variogram.ap[9 * k + 6] + dj * variogram.ap[9 * k + 7] + dk * variogram.ap[9 * k + 8];
h = sqrt(hx * hx + hy * hy + hz * hz);
switch (variogram.vario[k]) {
case 1:
cov += variogram.var[k]*exponential(h);
cov += variogram.var[k] * exponential(h);
break;
case 2:
cov += variogram.var[k]*gaussian(h);
cov += variogram.var[k] * gaussian(h);
break;
case 3:
cov += variogram.var[k]*spherical(h);
cov += variogram.var[k] * spherical(h);
break;
case 4:
cov += variogram.var[k]*cardsin(h);
cov += variogram.var[k] * cardsin(h);
break;
case 5:
cov += variogram.var[k]*stable(h,variogram.alpha[k]);
cov += variogram.var[k] * stable(h, variogram.alpha[k]);
break;
case 6:
cov += variogram.var[k]*gammf(h,variogram.alpha[k]);
cov += variogram.var[k] * gammf(h, variogram.alpha[k]);
break;
case 7:
cov += variogram.var[k]*cubic(h);
cov += variogram.var[k] * cubic(h);
break;
case 8:
cov += variogram.var[k]*nugget(h);
cov += variogram.var[k] * nugget(h);
break;
case 9:
cov += variogram.var[k]*power(h,variogram.alpha[k]);
cov += variogram.var[k] * power(h, variogram.alpha[k]);
break;
}
}

85
fftma_module/gen/lib_src/covariance.c
Unescape Escape View File

@ -2,85 +2,76 @@
/*builds the sampled covariance function*/
/*dimensions are even*/
void covariance(double *covar, struct vario_mod variogram, struct grid_mod mesh, int n[3])
void covariance(double* covar, struct vario_mod variogram, struct grid_mod mesh, int n[3])
{
int i,j,k,maille,n2[3],symmetric;
double di,dj,dk;
int i, j, k, maille, n2[3], symmetric;
double di, dj, dk;
for (i=0;i<3;i++)
n2[i] = n[i]/2;
for (i=0; i<= n2[0]; i++) {
for (j=0; j<= n2[1]; j++) {
for (k=0; k<= n2[2]; k++) {
for (i = 0; i < 3; i++)
n2[i] = n[i] / 2;
for (i = 0; i <= n2[0]; i++) {
for (j = 0; j <= n2[1]; j++) {
for (k = 0; k <= n2[2]; k++) {
/*area 1*/
maille = 1+i+n[0]*(j+n[1]*k);
di = (double)i*mesh.DX;
dj = (double)j*mesh.DY;
dk = (double)k*mesh.DZ;
covar[maille] = (double)cov_value(variogram,di,dj,dk);
maille = 1 + i + n[0] * (j + n[1] * k);
di = (double)i * mesh.DX;
dj = (double)j * mesh.DY;
dk = (double)k * mesh.DZ;
covar[maille] = (double)cov_value(variogram, di, dj, dk);
if (k > 0 && k <n2[2] && j > 0 && j <n2[1] && i > 0 && i <n2[0]) {
if (k > 0 && k < n2[2] && j > 0 && j < n2[1] && i > 0 && i < n2[0]) {
/*area 2*/
symmetric = 1+n[0]-i+n[0]*(n[1]-j+n[1]*(n[2]-k));
symmetric = 1 + n[0] - i + n[0] * (n[1] - j + n[1] * (n[2] - k));
covar[symmetric] = covar[maille];
}
if (i > 0 && i <n2[0]) {
if (i > 0 && i < n2[0]) {
/*area 4*/
di = -(double)i*mesh.DX;
dj = (double)j*mesh.DY;
dk = (double)k*mesh.DZ;
maille = 1+(n[0]-i)+n[0]*(j+n[1]*k);
covar[maille] = (double)cov_value(variogram,di,dj,dk);
di = -(double)i * mesh.DX;
dj = (double)j * mesh.DY;
dk = (double)k * mesh.DZ;
maille = 1 + (n[0] - i) + n[0] * (j + n[1] * k);
covar[maille] = (double)cov_value(variogram, di, dj, dk);
}
if (k > 0 && k <n2[2] && j > 0 && j <n2[1]) {
if (k > 0 && k < n2[2] && j > 0 && j < n2[1]) {
/*area 8*/
symmetric = 1+i+n[0]*(n[1]-j+n[1]*(n[2]-k));
symmetric = 1 + i + n[0] * (n[1] - j + n[1] * (n[2] - k));
covar[symmetric] = covar[maille];
}
if (i > 0 && i <n2[0] && j > 0 && j < n2[1]) {
if (i > 0 && i < n2[0] && j > 0 && j < n2[1]) {
/*area 5*/
di = -(double)i*mesh.DX;
dj = -(double)j*mesh.DY;
dk = (double)k*mesh.DZ;
maille = 1+(n[0]-i)+n[0]*(n[1]-j+n[1]*k);
covar[maille] = (double)cov_value(variogram,di,dj,dk);
di = -(double)i * mesh.DX;
dj = -(double)j * mesh.DY;
dk = (double)k * mesh.DZ;
maille = 1 + (n[0] - i) + n[0] * (n[1] - j + n[1] * k);
covar[maille] = (double)cov_value(variogram, di, dj, dk);
}
if (k > 0 && k <n2[2]) {
if (k > 0 && k < n2[2]) {
/*area 6*/
symmetric = 1+i+n[0]*(j+n[1]*(n[2]-k));
symmetric = 1 + i + n[0] * (j + n[1] * (n[2] - k));
covar[symmetric] = covar[maille];
}
if (j > 0 && j < n2[1]) {
/*area 3*/
di = (double)i*mesh.DX;
dj = -(double)j*mesh.DY;
dk = (double)k*mesh.DZ;
maille = 1+i+n[0]*(n[1]-j+n[1]*k);
covar[maille] = (double)cov_value(variogram,di,dj,dk);
di = (double)i * mesh.DX;
dj = -(double)j * mesh.DY;
dk = (double)k * mesh.DZ;
maille = 1 + i + n[0] * (n[1] - j + n[1] * k);
covar[maille] = (double)cov_value(variogram, di, dj, dk);
}
if (k > 0 && k <n2[2] && i > 0 && i <n2[0]) {
if (k > 0 && k < n2[2] && i > 0 && i < n2[0]) {
/*area 7*/
symmetric = 1+n[0]-i+n[0]*(j+n[1]*(n[2]-k));
symmetric = 1 + n[0] - i + n[0] * (j + n[1] * (n[2] - k));
covar[symmetric] = covar[maille];
}
}
}
}

7
fftma_module/gen/lib_src/cubic.c
Unescape Escape View File

@ -1,7 +1,6 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*cubic covariance function*/
double cubic(double h)
@ -11,7 +10,7 @@ double cubic(double h)
if (h >= 1.) {
z = 0.;
} else {
z = 1.-7.*(double)(h*h)+(35./4.)*(double)(h*h*h)-3.5*(double)(h*h*h*h*h)+.75*(double)(h*h*h*h*h*h*h);
z = 1. - 7. * (double)(h * h) + (35. / 4.) * (double)(h * h * h) - 3.5 * (double)(h * h * h * h * h) + .75 * (double)(h * h * h * h * h * h * h);
}
return (z);
}

6
fftma_module/gen/lib_src/exponential.c
Unescape Escape View File

@ -1,9 +1,9 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*exponential covariance function*/
double exponential(double h)
{
return (exp(-3.*(double)h));
return (exp(-3. * (double)h));
}

58
fftma_module/gen/lib_src/fftma2.c
Unescape Escape View File

@ -1,8 +1,7 @@
#include "geostat.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "geostat.h"
/*FAST FOURIER TRANSFORM MOVING AVERAGE METHOD */
/*Turns a Gaussian white noise vector into a */
@ -22,84 +21,79 @@
/*output: */
/*realout: structure defining a realization - */
void FFTMA2(struct vario_mod variogram,struct grid_mod grid,int n[3],struct realization_mod *realin,struct realization_mod *realout)
void FFTMA2(struct vario_mod variogram, struct grid_mod grid, int n[3], struct realization_mod* realin, struct realization_mod* realout)
{
int NTOT,i,j,k,NMAX,NDIM,ntot,nmax,NXYZ,nxyz,maille0,maille1;
int NTOT, i, j, k, NMAX, NDIM, ntot, nmax, NXYZ, nxyz, maille0, maille1;
int solver;
double temp;
double *ireal,*covar,*workr,*worki,*realization;
double *ireal, *covar, *workr, *worki, *realization;
/*covariance axis normalization*/
axes(variogram.ap,variogram.scf,variogram.Nvario);
axes(variogram.ap, variogram.scf, variogram.Nvario);
/*pseudo-grid definition*/
cgrid(variogram,grid,n);
cgrid(variogram, grid, n);
/*constant definition*/
NTOT = n[0]*n[1]*n[2];
ntot = NTOT+1;
NTOT = n[0] * n[1] * n[2];
ntot = NTOT + 1;
NMAX = n[0];
NDIM = 3;
for (i=1;i<3;i++) {
for (i = 1; i < 3; i++) {
if (n[i] > NMAX)
NMAX = n[i];
if (n[i] == 1)
NDIM--;
}
nmax = NMAX+1;
NXYZ = grid.NX*grid.NY*grid.NZ;
nxyz = NXYZ+1;
nmax = NMAX + 1;
NXYZ = grid.NX * grid.NY * grid.NZ;
nxyz = NXYZ + 1;
/*array initialization*/
covar = (double *) malloc(ntot * sizeof(double));
covar = (double*)malloc(ntot * sizeof(double));
testmemory(covar);
ireal = (double *) malloc(ntot * sizeof(double));
ireal = (double*)malloc(ntot * sizeof(double));
testmemory(ireal);
realization = (double *) malloc(ntot * sizeof(double));
realization = (double*)malloc(ntot * sizeof(double));
testmemory(realization);
workr = (double *) malloc(nmax * sizeof(double));
workr = (double*)malloc(nmax * sizeof(double));
testmemory(workr);
worki = (double *) malloc(nmax * sizeof(double));
worki = (double*)malloc(nmax * sizeof(double));
testmemory(worki);
/*covariance function creation*/
covariance(covar,variogram,grid,n);
covariance(covar, variogram, grid, n);
/*power spectrum*/
fourt(covar,ireal,n,NDIM,1,0,workr,worki);
fourt(covar, ireal, n, NDIM, 1, 0, workr, worki);
/*organization of the input Gaussian white noise*/
solver=0;
prebuild_gwn(grid,n,realin,realization,solver);
solver = 0;
prebuild_gwn(grid, n, realin, realization, solver);
/*forward fourier transform of the GWN*/
fourt(realization,ireal,n,NDIM,1,0,workr,worki);
fourt(realization, ireal, n, NDIM, 1, 0, workr, worki);
/* build realization in spectral domain */
build_real(n,NTOT,covar,realization,ireal);
build_real(n, NTOT, covar, realization, ireal);
free(covar);
/*backward fourier transform*/
fourt(realization,ireal,n,NDIM,0,1,workr,worki);
fourt(realization, ireal, n, NDIM, 0, 1, workr, worki);
free(ireal);
free(workr);
free(worki);
/*output realization*/
clean_real(realin,n,grid,realization,realout);
clean_real(realin, n, grid, realization, realout);
free(realization);
return;
}

188
fftma_module/gen/lib_src/fourt.c
Unescape Escape View File

@ -1,5 +1,5 @@
#include <stdio.h>
#include <math.h>
#include <stdio.h>
/*fast fourier transform */
/* THE COOLEY-TUKEY FAST FOURIER TRANSFORM */
@ -89,11 +89,10 @@
/* PROGRAM MODIFIED FROM A SUBROUTINE OF BRENNER */
/* 10-06-2000, MLR */
void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icplx, double *workr,double *worki)
void fourt(double* datar, double* datai, int nn[3], int ndim, int ifrwd, int icplx, double* workr, double* worki)
{
int ifact[21],ntot,idim,np1,n,np2,m,ntwo,iff,idiv,iquot,irem,inon2,non2p,np0,nprev,icase,ifmin,i,j,jmax,np2hf,i2,i1max,i3,j3,i1,ifp1,ifp2,i2max,i1rng,istep,imin,imax,mmax,mmin,mstep,j1,j2max,j2,jmin,j3max,nhalf;
double theta,wstpr,wstpi,wminr,wmini,wr,wi,wtemp,thetm,wmstr,wmsti,twowr,sr,si,oldsr,oldsi,stmpr,stmpi,tempr,tempi,difi,difr,sumr,sumi,TWOPI = 6.283185307179586476925286766559;
int ifact[21], ntot, idim, np1, n, np2, m, ntwo, iff, idiv, iquot, irem, inon2, non2p, np0, nprev, icase, ifmin, i, j, jmax, np2hf, i2, i1max, i3, j3, i1, ifp1, ifp2, i2max, i1rng, istep, imin, imax, mmax, mmin, mstep, j1, j2max, j2, jmin, j3max, nhalf;
double theta, wstpr, wstpi, wminr, wmini, wr, wi, wtemp, thetm, wmstr, wmsti, twowr, sr, si, oldsr, oldsi, stmpr, stmpi, tempr, tempi, difi, difr, sumr, sumi, TWOPI = 6.283185307179586476925286766559;
ntot = 1;
for (idim = 0; idim < ndim; idim++) {
@ -103,8 +102,8 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
/*main loop for each dimension*/
np1 = 1;
for (idim = 1; idim <= ndim; idim++) {
n = nn[idim-1];
np2 = np1*n;
n = nn[idim - 1];
np2 = np1 * n;
if (n < 1) {
goto L920;
@ -119,23 +118,23 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
idiv = 2;
L10:
iquot = m/idiv;
irem = m-idiv*iquot;
iquot = m / idiv;
irem = m - idiv * iquot;
if (iquot < idiv)
goto L50;
if (irem == 0) {
ntwo *= 2;
ifact[iff] = idiv;
iff++;
m= iquot;
m = iquot;
goto L10;
}
idiv = 3;
inon2 = iff;
L30:
iquot = m/idiv;
irem = m-idiv*iquot;
iquot = m / idiv;
irem = m - idiv * iquot;
if (iquot < idiv)
goto L60;
if (irem == 0) {
@ -159,8 +158,7 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
ifact[iff] = m;
L70:
non2p = np2/ntwo;
non2p = np2 / ntwo;
/*SEPARATE FOUR CASES--
1. COMPLEX TRANSFORM
@ -187,7 +185,7 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
i = 1;
for (j = 1; j <= ntot; j++) {
datar[j] = datar[i];
datai[j] = datar[i+1];
datai[j] = datar[i + 1];
i += 2;
}
@ -195,15 +193,15 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
L100:
if (non2p > 1)
goto L200;
np2hf = np2/2;
np2hf = np2 / 2;
j = 1;
for (i2 = 1; i2 <= np2; i2 += np1) {
if (j >= i2)
goto L130;
i1max = i2+np1-1;
i1max = i2 + np1 - 1;
for (i1 = i2; i1 <= i1max; i1++) {
for (i3 = i1; i3 <= ntot; i3 += np2) {
j3 = j+i3-i2;
j3 = j + i3 - i2;
tempr = datar[i3];
tempi = datai[i3];
datar[i3] = datar[j3];
@ -225,7 +223,6 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
if (m >= np1)
goto L140;
}
}
goto L300;
@ -245,9 +242,9 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
ifp2 = np2;
iff = ifmin;
L250:
ifp1 = ifp2/ifact[iff];
ifp1 = ifp2 / ifact[iff];
j += ifp1;
if (j >= i3+ifp2) {
if (j >= i3 + ifp2) {
j -= ifp2;
ifp2 = ifp1;
iff += 1;
@ -255,14 +252,13 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
goto L250;
}
}
i2max = i3+np2-np1;
i2max = i3 + np2 - np1;
i = 1;
for (i2 = i3; i2 <= i2max; i2 += np1) {
datar[i2] = workr[i];
datai[i2] = worki[i];
i++;
}
}
}
@ -270,12 +266,12 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
L300:
i1rng = np1;
if (icase == 2)
i1rng = np0*(1+nprev/2);
i1rng = np0 * (1 + nprev / 2);
if (ntwo <= np1)
goto L600;
for (i1 = 1; i1 <= i1rng; i1++) {
imin = np1+i1;
istep = 2*np1;
imin = np1 + i1;
istep = 2 * np1;
goto L330;
L310:
@ -283,13 +279,13 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
for (i = imin; i <= ntot; i += istep) {
tempr = datar[i];
tempi = datai[i];
datar[i] = datar[j]-tempr;
datai[i] = datai[j]-tempi;
datar[j] = datar[j]+tempr;
datai[j] = datai[j]+tempi;
datar[i] = datar[j] - tempr;
datai[i] = datai[j] - tempi;
datar[j] = datar[j] + tempr;
datai[j] = datai[j] + tempi;
j += istep;
}
imin = 2*imin-i1;
imin = 2 * imin - i1;
istep *= 2;
L330:
@ -297,12 +293,12 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
goto L310;
/*special case-- W = -sqrt(-1)*/
imin = 3*np1+i1;
istep = 4*np1;
imin = 3 * np1 + i1;
istep = 4 * np1;
goto L420;
L400:
j = imin-istep/2;
j = imin - istep / 2;
for (i = imin; i <= ntot; i += istep) {
if (ifrwd != 0) {
tempr = datai[i];
@ -311,14 +307,14 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
tempr = -datai[i];
tempi = datar[i];
}
datar[i] = datar[j]-tempr;
datai[i] = datai[j]-tempi;
datar[i] = datar[j] - tempr;
datai[i] = datai[j] - tempi;
datar[j] += tempr;
datai[j] += tempi;
j += istep;
}
imin = 2*imin-i1;
imin = 2 * imin - i1;
istep *= 2;
L420:
@ -327,14 +323,14 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
}
/*main loop for factors of 2. W=EXP(-2*PI*SQRT(-1)*m/mmax) */
theta = -TWOPI/8.;
theta = -TWOPI / 8.;
wstpr = 0.;
wstpi = -1.;
if (ifrwd == 0) {
theta = -theta;
wstpi = 1.;
}
mmax = 8*np1;
mmax = 8 * np1;
goto L540;
L500:
@ -342,31 +338,31 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
wmini = sin(theta);
wr = wminr;
wi = wmini;
mmin = mmax/2+np1;
mstep = np1*2;
mmin = mmax / 2 + np1;
mstep = np1 * 2;
for (m = mmin; m <= mmax; m += mstep) {
for (i1 = 1; i1 <= i1rng; i1++) {
istep = mmax;
imin = m+i1;
imin = m + i1;
L510:
j = imin-istep/2;
j = imin - istep / 2;
for (i = imin; i <= ntot; i += istep) {
tempr = datar[i]*wr-datai[i]*wi;
tempi = datar[i]*wi+datai[i]*wr;
datar[i] = datar[j]-tempr;
datai[i] = datai[j]-tempi;
tempr = datar[i] * wr - datai[i] * wi;
tempi = datar[i] * wi + datai[i] * wr;
datar[i] = datar[j] - tempr;
datai[i] = datai[j] - tempi;
datar[j] += tempr;
datai[j] += tempi;
j += istep;
}
imin = 2*imin-i1;
imin = 2 * imin - i1;
istep *= 2;
if (istep <= ntwo)
goto L510;
}
wtemp = wr*wstpi;
wr = wr*wstpr-wi*wstpi;
wi = wi*wstpr+wtemp;
wtemp = wr * wstpi;
wr = wr * wstpr - wi * wstpi;
wi = wi * wstpr + wtemp;
}
wstpr = wminr;
wstpi = wmini;
@ -383,11 +379,11 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
ifp1 = ntwo;
iff = inon2;
L610:
ifp2 = ifact[iff]*ifp1;
theta = -TWOPI/ (double)ifact[iff];
ifp2 = ifact[iff] * ifp1;
theta = -TWOPI / (double)ifact[iff];
if (ifrwd == 0)
theta = -theta;
thetm = theta/ (double)(ifp1/np1);
thetm = theta / (double)(ifp1 / np1);
wstpr = cos(theta);
wstpi = sin(theta);
wmstr = cos(thetm);
@ -396,19 +392,19 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
wmini = 0.;
for (j1 = 1; j1 <= ifp1; j1 += np1) {
i1max = j1+i1rng-1;
i1max = j1 + i1rng - 1;
for (i1 = j1; i1 <= i1max; i1++) {
for (i3 = i1; i3 <= ntot; i3 += np2) {
i = 1;
wr = wminr;
wi = wmini;
j2max = i3+ifp2-ifp1;
j2max = i3 + ifp2 - ifp1;
for (j2 = i3; j2 <= j2max; j2 += ifp1) {
twowr = 2.*wr;
twowr = 2. * wr;
jmin = i3;
j3max = j2+np2-ifp2;
for (j3 = j2 ; j3 <= j3max; j3 += ifp2) {
j = jmin+ifp2-ifp1;
j3max = j2 + np2 - ifp2;
for (j3 = j2; j3 <= j3max; j3 += ifp2) {
j = jmin + ifp2 - ifp1;
sr = datar[j];
si = datai[j];
oldsr = 0.;
@ -417,25 +413,25 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
L620:
stmpr = sr;
stmpi = si;
sr = twowr*sr-oldsr+datar[j];
si = twowr*si-oldsi+datai[j];
sr = twowr * sr - oldsr + datar[j];
si = twowr * si - oldsi + datai[j];
oldsr = stmpr;
oldsi = stmpi;
j -= ifp1;
if (j > jmin)
goto L620;
workr[i] = wr*sr-wi*si-oldsr+datar[j];
worki[i] = wi*sr+wr*si-oldsi+datai[j];
workr[i] = wr * sr - wi * si - oldsr + datar[j];
worki[i] = wi * sr + wr * si - oldsi + datai[j];
jmin += ifp2;
i++;
}
wtemp = wr*wstpi;
wr = wr*wstpr-wi*wstpi;
wi = wi*wstpr+wtemp;
wtemp = wr * wstpi;
wr = wr * wstpr - wi * wstpi;
wi = wi * wstpr + wtemp;
}
i = 1;
for (j2 = i3; j2 <= j2max; j2 += ifp1) {
j3max = j2+np2-ifp2;
j3max = j2 + np2 - ifp2;
for (j3 = j2; j3 <= j3max; j3 += ifp2) {
datar[j3] = workr[i];
datai[j3] = worki[i];
@ -444,9 +440,9 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
}
}
}
wtemp = wminr*wmsti;
wminr = wminr*wmstr-wmini*wmsti;
wmini = wmini*wmstr+wtemp;
wtemp = wminr * wmsti;
wminr = wminr * wmstr - wmini * wmsti;
wmini = wmini * wmstr + wtemp;
}
iff++;
ifp1 = ifp2;
@ -469,7 +465,7 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
nhalf = n;
n += n;
theta = -TWOPI/ (double) n;
theta = -TWOPI / (double)n;
if (ifrwd == 0)
theta = -theta;
wstpr = cos(theta);
@ -482,23 +478,23 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
L710:
j = jmin;
for (i = imin; i <= ntot; i += np2) {
sumr = (datar[i]+datar[j])/2.;
sumi = (datai[i]+datai[j])/2.;
difr = (datar[i]-datar[j])/2.;
difi = (datai[i]-datai[j])/2.;
tempr = wr*sumi+wi*difr;
tempi = wi*sumi-wr*difr;
datar[i] = sumr+tempr;
datai[i] = difi+tempi;
datar[j] = sumr-tempr;
datai[j] = tempi-difi;
sumr = (datar[i] + datar[j]) / 2.;
sumi = (datai[i] + datai[j]) / 2.;
difr = (datar[i] - datar[j]) / 2.;
difi = (datai[i] - datai[j]) / 2.;
tempr = wr * sumi + wi * difr;
tempi = wi * sumi - wr * difr;
datar[i] = sumr + tempr;
datai[i] = difi + tempi;
datar[j] = sumr - tempr;
datai[j] = tempi - difi;
j += np2;
}
imin++;
jmin--;
wtemp = wr*wstpi;
wr = wr*wstpr-wi*wstpi;
wi = wi*wstpr+wtemp;
wtemp = wr * wstpi;
wr = wr * wstpr - wi * wstpi;
wi = wi * wstpr + wtemp;
L725:
if (imin < jmin) {
goto L710;
@ -513,10 +509,10 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
L740:
np2 *= 2;
ntot *= 2;
j = ntot+1;
imax = ntot/2+1;
j = ntot + 1;
imax = ntot / 2 + 1;
L745:
imin = imax-nhalf;
imin = imax - nhalf;
i = imin;
goto L755;
L750:
@ -527,7 +523,7 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
j--;
if (i < imax)
goto L750;
datar[j] = datar[imin]-datai[imin];
datar[j] = datar[imin] - datai[imin];
datai[j] = 0.;
if (i >= j) {
goto L780;
@ -542,7 +538,7 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
j--;
if (i > imin)
goto L765;
datar[j] = datar[imin]+datai[imin];
datar[j] = datar[imin] + datai[imin];
datai[j] = 0.;
imax = imin;
goto L745;
@ -556,15 +552,15 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
if (nprev <= 2)
goto L900;
for (i3 = 1; i3 <= ntot; i3 += np2) {
i2max = i3+np2-np1;
i2max = i3 + np2 - np1;
for (i2 = i3; i2 <= i2max; i2 += np1) {
imax = i2+np1-1;
imin = i2+i1rng;
jmax = 2*i3+np1-imin;
imax = i2 + np1 - 1;
imin = i2 + i1rng;
jmax = 2 * i3 + np1 - imin;
if (i2 > i3)
jmax += np2;
if (idim > 2) {
j = jmax+np0;
j = jmax + np0;
for (i = imin; i <= imax; i++) {
datar[i] = datar[j];
datai[i] = -datai[j];
@ -586,6 +582,6 @@ void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icpl
np1 = np2;
nprev = n;
}
L920:
L920:
return;
}

12
fftma_module/gen/lib_src/gammf.c
Unescape Escape View File

@ -1,7 +1,6 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*gamma covariance function*/
double gammf(double h, double alpha)
@ -9,8 +8,7 @@ double gammf(double h, double alpha)
float delta;
double z;
delta = pow(20.,1./alpha)-1.;
z = 1./(double)(pow(1.+h*delta,alpha));
return(z);
delta = pow(20., 1. / alpha) - 1.;
z = 1. / (double)(pow(1. + h * delta, alpha));
return (z);
}

20
fftma_module/gen/lib_src/gasdev.c
Unescape Escape View File

@ -1,29 +1,29 @@
#include <math.h>
#include "genlib.h"
#include <math.h>
#define NTAB 32
double gasdev(long *idum,long *idum2, long *iy, long iv[NTAB])
double gasdev(long* idum, long* idum2, long* iy, long iv[NTAB])
/*returns a normally distributed deviate with 0 mean*/
/*and unit variance, using ran2(idum) as the source */
/*of uniform deviates */
{
double ran2(long *idum,long *idum2, long *iy, long iv[NTAB]);
double ran2(long* idum, long* idum2, long* iy, long iv[NTAB]);
static int iset = 0;
static double gset;
double fac,rsq,v1,v2;
double fac, rsq, v1, v2;
if (iset == 0) {
do {
v1 = 2.0*ran2(idum,idum2,iy,iv)-1.0;
v2 = 2.0*ran2(idum,idum2,iy,iv)-1.0;
rsq = v1*v1+v2*v2;
v1 = 2.0 * ran2(idum, idum2, iy, iv) - 1.0;
v2 = 2.0 * ran2(idum, idum2, iy, iv) - 1.0;
rsq = v1 * v1 + v2 * v2;
} while (rsq >= 1.0 || rsq == 0.0);
fac = sqrt(-2.0*log(rsq)/rsq);
gset = v1*fac;
fac = sqrt(-2.0 * log(rsq) / rsq);
gset = v1 * fac;
iset = 1;
return (v2*fac);
return (v2 * fac);
} else {
iset = 0;
return (gset);

7
fftma_module/gen/lib_src/gaussian.c
Unescape Escape View File

@ -1,10 +1,9 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*gaussian covariance function*/
double gaussian(double h)
{
return (exp(-3.*(double)(h*h)));
return (exp(-3. * (double)(h * h)));
}

24
fftma_module/gen/lib_src/generate.c
Unescape Escape View File

@ -1,7 +1,6 @@
#include <stdlib.h>
#include <math.h>
#include "geostat.h"
#include <math.h>
#include <stdlib.h>
/* GENERATION OF A GAUSSIAN WHITE NOISE VECTOR */
/*input: */
@ -10,14 +9,14 @@
/*output: */
/* realization: structure defining the realization*/
void generate(long *seed, int n, struct realization_mod *realization)
void generate(long* seed, int n, struct realization_mod* realization)
{
int i;
long idum2 = 123456789,iy = 0;
long *iv;
int iset =0;
long idum2 = 123456789, iy = 0;
long* iv;
int iset = 0;
iv = (long *) malloc(NTAB * sizeof(long));
iv = (long*)malloc(NTAB * sizeof(long));
/*negative seed*/
if (*seed > 0.0)
@ -26,18 +25,15 @@ void generate(long *seed, int n, struct realization_mod *realization)
/*realization definition*/
(*realization).n = n;
(*realization).code = 0;
(*realization).vector = (double *) malloc(n * sizeof(double));
(*realization).vector = (double*)malloc(n * sizeof(double));
if ((*realization).vector == NULL) {
printf("No memory available in generate");
exit;
}
/*Gaussian white noise generation*/
for (i=0; i < n; i++)
(*realization).vector[i] = gasdev(seed,&idum2,&iy,iv,&iset);
for (i = 0; i < n; i++)
(*realization).vector[i] = gasdev(seed, &idum2, &iy, iv, &iset);
return;
}

13
fftma_module/gen/lib_src/genlib.c
Unescape Escape View File

@ -7,10 +7,10 @@
* interface description in genlib.h for details.
*/
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "genlib.h"
@ -34,16 +34,17 @@ char undefined_object[] = "UNDEFINED";
/* Section 2 -- Memory allocation */
void *GetBlock(size_t nbytes)
void* GetBlock(size_t nbytes)
{
void *result;
void* result;
result = malloc(nbytes);
if (result == NULL) Error("No memory available");
if (result == NULL)
Error("No memory available");
return (result);
}
void FreeBlock(void *ptr)
void FreeBlock(void* ptr)
{
free(ptr);
}

41
fftma_module/gen/lib_src/genlib.h
Unescape Escape View File

@ -25,9 +25,9 @@
#ifndef _genlib_h
#define _genlib_h
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
/* Section 1 -- Define new "primitive" types */
@ -45,20 +45,21 @@
*/
#ifdef THINK_C
typedef int bool;
typedef int bool;
#else
#ifdef TRUE
#ifndef bool
#define bool int
#endif
#else
# ifdef TRUE
# ifndef bool
# define bool int
# endif
# else
# ifdef bool
# define FALSE 0
# define TRUE 1
# else
typedef enum {FALSE, TRUE} bool;
# endif
# endif
#ifdef bool
#define FALSE 0
#define TRUE 1
#else
typedef enum { FALSE,
TRUE } bool;
#endif
#endif
#endif
/*
@ -72,7 +73,7 @@
* Declaring it as a string emphasizes this atomicity.
*/
typedef char *string;
typedef char* string;
/*
* Constant: UNDEFINED
@ -84,7 +85,7 @@ typedef char *string;
* therefore inappropriate as a sentinel.
*/
#define UNDEFINED ((void *) undefined_object)
#define UNDEFINED ((void*)undefined_object)
extern char undefined_object[];
@ -111,7 +112,7 @@ extern char undefined_object[];
* no memory is available, GetBlock generates an error.
*/
void *GetBlock(size_t nbytes);
void* GetBlock(size_t nbytes);
/*
* Function: FreeBlock
@ -121,7 +122,7 @@ void *GetBlock(size_t nbytes);
* have been allocated using GetBlock, New, or NewArray.
*/
void FreeBlock(void *ptr);
void FreeBlock(void* ptr);
/*
* Macro: New
@ -135,7 +136,7 @@ void FreeBlock(void *ptr);
* target type.
*/
#define New(type) ((type) GetBlock(sizeof *((type) NULL)))
#define New(type) ((type)GetBlock(sizeof *((type)NULL)))
/*
* Macro: NewArray
@ -145,7 +146,7 @@ void FreeBlock(void *ptr);
* values of the specified element type.
*/
#define NewArray(n, type) ((type *) GetBlock((n) * sizeof(type)))
#define NewArray(n, type) ((type*)GetBlock((n) * sizeof(type)))
/* Section 3 -- Basic error handling */

192
fftma_module/gen/lib_src/geostat.h
Unescape Escape View File

@ -1,8 +1,7 @@
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#ifndef _GEOSTAT_H
#define _GEOSTAT_H
@ -27,7 +26,6 @@
/* cdf_mod */
/* realization_mod */
/* List of functions: */
/* ------------------ */
@ -44,9 +42,6 @@
/* test_fract, trun1, trungasdev,vec_vec, */
/* vf2gthres,polint */
/*STRUCTURES*/
/*----------*/
/*variogram */
@ -68,15 +63,13 @@
/*var: normalized variance per variogram model(sum = 1)*/
struct vario_mod {
int Nvario;
int *vario;
double *alpha;
double *ap;
double *scf;
double *var;
int* vario;
double* alpha;
double* ap;
double* scf;
double* var;
};
/*variogram table */
/*Nvario: number of combined variogram models */
/*vario: model of variogram per variogram model */
@ -96,17 +89,14 @@ struct vario_mod {
/*var: normalized variance per variogram model(sum = 1)*/
struct variotable_mod {
int number_of_variograms;
int *Nvario;
int *vario;
float *alpha;
float *ap;
float *scf;
float *var;
int* Nvario;
int* vario;
float* alpha;
float* ap;
float* scf;
float* var;
};
/*grid */
/*NX: number of gridblocks along the X axis*/
/*NY: number of gridblocks along the Y axis*/
@ -119,11 +109,10 @@ struct variotable_mod {
/*Zo: Z-cell number of the origin cell */
struct grid_mod {
int NX, NY, NZ;
double DX,DY,DZ;
double Xo,Yo,Zo;
double DX, DY, DZ;
double Xo, Yo, Zo;
};
/*well data */
/*nwell: number of wells */
/*n: number of measurement points per well */
@ -154,17 +143,15 @@ struct grid_mod {
struct welldata_mod {
int nwell;
int *n;
int* n;
int ntype;
int *code;
float *x;
float *y;
float *z;
float *measure;
int* code;
float* x;
float* y;
float* z;
float* measure;
};
/*volume fractions for facies */
/*ncat: number of facies */
/*nblock: number of gridblocks with different */
@ -176,10 +163,9 @@ struct welldata_mod {
struct statfacies_mod {
int ncat;
int nblock;
float *vf;
float* vf;
};
/*inequalities for truncated plurigaussian realizations*/
/*only two basic realizations Y1 and Y2 are considered */
/*Y1 and Y2 are independent */
@ -204,12 +190,11 @@ struct statfacies_mod {
struct inequalities_mod {
int nsY1;
int nsY2;
float *thresholds;
int *address_sY1;
int *address_sY2;
float* thresholds;
int* address_sY1;
int* address_sY2;
};
/*statistical data */
/*type --> 0 : normal */
/* --> 1 : natural log */
@ -229,12 +214,11 @@ struct inequalities_mod {
struct statistic_mod {
int type;
int nblock_mean;
double *mean;
double* mean;
int nblock_var;
double *variance;
double* variance;
};
/*gradual deformation parameters */
/*Nadded: number of complementary realizations */
/*NZONES: number of subregions */
@ -246,11 +230,10 @@ struct statistic_mod {
/*for subregions along axes X,Y,Z */
struct grad_mod {
int Nadded, NZONES;
float *rho;
float* rho;
int *cellini, *cellfin;
};
/*gradient structures */
/*Nparam : number of parameters for which gradients are */
/* required */
@ -263,12 +246,10 @@ struct grad_mod {
/* Ncells....2*Ncells-1 for the second parameter */
/* and so on */
struct gradients_mod {
int Nparam,Ncells;
float *grad;
int Nparam, Ncells;
float* grad;
};
/*description of discretized cumulative distributions */
/*n: number of points */
/*x: values along the x axis i = [0...n-1] */
@ -276,11 +257,10 @@ struct gradients_mod {
/* distribution i = [0...n-1] */
struct cdf_mod {
int n;
float *x;
float *fx;
float* x;
float* fx;
};
/*realization */
/*n: number of components */
/*code: status of the realization */
@ -303,7 +283,7 @@ struct cdf_mod {
struct realization_mod {
int n;
int code;
double *vector;
double* vector;
};
/*=====================================================*/
@ -311,18 +291,15 @@ struct realization_mod {
/*FUNCTIONS*/
/*---------*/
/*normalization of the anostropy axes */
/*ap: anisotropy axes */
/*scf: correlation lengths */
/* The returned normalized axes are in ap */
void axes(double *ap, double *scf, int N);
void axes(double* ap, double* scf, int N);
/*cardsin covariance value for lag h*/
double cardsin(double h);
/*Cholesky decomposition of matrix C */
/* C : symetric positive-definite matrix recorded */
/* (per raws) as a vector with only components */
@ -330,8 +307,7 @@ double cardsin(double h);
/* n : dimension of matrix Cij */
/* */
/* C is turned into the lower triangular cholesky matrix*/
void choldc(double *C, int n);
void choldc(double* C, int n);
/*computes the coordinates of a given cell */
/*as numbers of cells along the X,Y and Z axes*/
@ -341,8 +317,7 @@ void choldc(double *C, int n);
/*grid: structure defining the grid */
/*output: */
/*i: vector with the coordinates */
void coordinates(int maille, int i[3],struct grid_mod grid);
void coordinates(int maille, int i[3], struct grid_mod grid);
/*builds the sampled covariance function */
/*dimensions are even */
@ -351,7 +326,7 @@ void coordinates(int maille, int i[3],struct grid_mod grid);
/*variogram: structure defined above */
/*grid: structure defined above */
/*n: number of gridblocks along X,Y and Z*/
void covariance(double *covar,struct vario_mod variogram, struct grid_mod grid, int n[3]);
void covariance(double* covar, struct vario_mod variogram, struct grid_mod grid, int n[3]);
/*computation of the covariance matrix for the well data*/
/*well coordinates are given as a number of cells */
@ -362,8 +337,7 @@ void covariance(double *covar,struct vario_mod variogram, struct grid_mod grid,
/*variogram: structure defined above */
/*well: structure defined above */
/*grid: structure defined above */
void cov_matrix(double *C, struct vario_mod variogram, struct welldata_mod well, struct grid_mod grid);
void cov_matrix(double* C, struct vario_mod variogram, struct welldata_mod well, struct grid_mod grid);
/*calculation of the covariance value for a distance h */
/*defined by i,j,k */
@ -382,12 +356,11 @@ void cov_matrix(double *C, struct vario_mod variogram, struct welldata_mod well,
/*dj: distance along the Y axis */
/*dk: distance along the Z axis */
/* The returned value is the computed covariance value */
double cov_value(struct vario_mod variogram,double di,double dj,double dk);
double cov_value(struct vario_mod variogram, double di, double dj, double dk);
/*cubic covariance value for lag h*/
double cubic(double h);
/*truncation of the power spectrum to remove */
/*high frequencies - isotropic case */
/*covar: power spectrum */
@ -395,8 +368,7 @@ double cubic(double h);
/*ky: number of cells to save along the y-axis */
/*kz: number of cells to save along the z-axis */
/*n[3]: number of cells along the X, Y and Z axes*/
void cutspectr(float *covar, int kx, int ky, int kz, int n[3]);
void cutspectr(float* covar, int kx, int ky, int kz, int n[3]);
/*defines the threshold interval for a facies x*/
/*lim_inf: lower bound */
@ -405,8 +377,7 @@ void cutspectr(float *covar, int kx, int ky, int kz, int n[3]);
/*thresholds: Gaussian threshold vector */
/*facies: structure defined above */
/*nblock: gridcell number of point x */
void deflimit(double *plim_inf, double *plim_sup, float x, float *thresholds, struct statfacies_mod facies,int nblock);
void deflimit(double* plim_inf, double* plim_sup, float x, float* thresholds, struct statfacies_mod facies, int nblock);
/*kriges the realization considering weights */
/*realin: input realization */
@ -416,14 +387,11 @@ void deflimit(double *plim_inf, double *plim_sup, float x, float *thresholds, st
/*grid: structure defined above */
/*D: weight vector of length Ndata, Di, i = 0...Ndata-1*/
/*The kriged realization is stored in realout */
void dual_kri(struct realization_mod *realin, struct vario_mod variogram,struct welldata_mod well, struct grid_mod grid, double *D,struct realization_mod *realout);
void dual_kri(struct realization_mod* realin, struct vario_mod variogram, struct welldata_mod well, struct grid_mod grid, double* D, struct realization_mod* realout);
/*exponential covariance value for lag h*/
double exponential(double h);
/*Fast Fourier Transform - Cooley-Tukey algorithm */
/*datar: real part vector - to be transformed */
/*datai: imaginary part vector - to be transformed */
@ -434,44 +402,36 @@ double exponential(double h);
/*workr: utility real part vector for storage */
/*worki: utility imaginary part vector for storage */
/*The transformed data are returned in datar and datai*/
void fourt(double *datar,double *datai, int nn[3], int ndim, int ifrwd, int icplx,double *workr,double *worki);
void fourt(double* datar, double* datai, int nn[3], int ndim, int ifrwd, int icplx, double* workr, double* worki);
/*calculates F(x) = (1/a)*exp(-x*x/2)*/
double funtrun1(double x);
/*cumulative standard normal value*/
float G(float x);
/*gamma covariance value for lag h and exponent alpha*/
double gammf(double h, double alpha);
/*returns the value ln(G(x))*/
float gammln(float xx);
/*incomplete gamma fnction*/
float gammp(float a, float x);
/*returns a normally distributed deviate with 0 mean*/
/*and unit variance, using ran1(idum) as the source */
/*of uniform deviates */
/*idum: seed */
double gasdev(long *idum, long *idum2, long *iy, long *iv, int *iset);
double gasdev(long* idum, long* idum2, long* iy, long* iv, int* iset);
/*gaussian covariance value for lag h*/
double gaussian(double h);
/*incomplete gamma function evaluated by its continued */
/*fraction represented as gammcf, also returns ln(G(a))*/
/*as gln */
void gcf(float *gammcf, float a, float x, float *gln);
void gcf(float* gammcf, float a, float x, float* gln);
/*computation of the covariance matrix for the well data*/
/*well coordinates have no specific unit */
@ -482,8 +442,7 @@ void gcf(float *gammcf, float a, float x, float *gln);
/*and k = j+i(i+1)/2 */
/*variogram: structure defined above */
/*well: structure defined above */
void gen_cov_matrix(double *C, struct vario_mod variogram, struct welldata_mod well, int n);
void gen_cov_matrix(double* C, struct vario_mod variogram, struct welldata_mod well, int n);
/*Ginv */
/*Computes the inverse of the standard normal cumulative*/
@ -494,7 +453,6 @@ void gen_cov_matrix(double *C, struct vario_mod variogram, struct welldata_mod w
/*p: cumulative probability value */
float Ginv(float p);
/*gradual combination of 1 realization + Nadded */
/*complementary realizations */
/*rho: gradual deformation parameters */
@ -510,8 +468,7 @@ float Ginv(float p);
/*n: number of components per realization */
/*NZONES: number of subregions */
/*grid: grid definition */
void gradual(struct grad_mod grad,float *Zo,float *Z,float *Zfinal,int n,struct grid_mod grid);
void gradual(struct grad_mod grad, float* Zo, float* Z, float* Zfinal, int n, struct grid_mod grid);
/*computes the size of the underlying grid for FFTs*/
/*input: */
@ -526,8 +483,7 @@ void cgrid(struct vario_mod variogram, struct grid_mod grid, int n[3]);
/*incomplete gamma function evaluated by its series*/
/*representation as gamser, also returns ln(G(a)) */
/*as gln */
void gser(float *gamser, float a, float x, float *gln);
void gser(float* gamser, float a, float x, float* gln);
/*calculates x so that x = invF(u) */
/*F is the cumulative density function for the */
@ -538,18 +494,16 @@ void gser(float *gamser, float a, float x, float *gln);
/*C: normalizing constant */
double invtrun1(double u, double lim_inf, double lim_sup, double C);
/*computes the kriging mean and variance*/
/*for the vector bi, i = [0...n-1] */
void krig_stat(float *b, int n, struct vario_mod variogram, struct welldata_mod well, float *mean, float *var);
void krig_stat(float* b, int n, struct vario_mod variogram, struct welldata_mod well, float* mean, float* var);
/* computes the number of gridblocks for one dimension*/
/*N: initial number of gridblocks */
/*i: considered direction */
/*scf: correlation length */
/*ap: normalized anisotropy axes */
int length(int N, int i, double *scf, double *ap, double D, int Nvari);
int length(int N, int i, double* scf, double* ap, double D, int Nvari);
/*calculates L.Z/
/* L : lower triangular matrix recorded */
@ -560,7 +514,7 @@ int length(int N, int i, double *scf, double *ap, double D, int Nvari);
/* n : dimension of matrix Lij */
/* */
/* The solution vector is returned in b */
void LtimeZ(double *L, float *Z, float *b, int n);
void LtimeZ(double* L, float* Z, float* b, int n);
/*determines the greatest prime factor of an integer*/
int maxfactor(int n);
@ -570,40 +524,32 @@ int maxfactor(int n);
/*defined by the probability ratio "ratio". */
/*If ratio >= 1, metrop = 1(true), while if ratio < 1, */
/*metrop is only true with probability "ratio" */
int metrop(double ratio,long *idum,long *idum2, long *iy, long *iv);
int metrop(double ratio, long* idum, long* idum2, long* iy, long* iv);
/*2-norm of vector b */
/* b : vector */
/* n : length of b, bi, i = [0...n-1]*/
/*returns the norm of b */
double norm(double *b,int n);
double norm(double* b, int n);
/*value of g(x) where g is the normal function*/
double normal(double x);
/*nugget covariance value for lag h*/
double nugget(double h);
/*power covariance value for lag h and exponent alpha*/
double power(double h,double alpha);
double power(double h, double alpha);
/*generates uniform deviates between 0 and 1*/
/*idum: seed */
double ran2(long *idum, long *idum2, long *iy, long *iv);
double ran2(long* idum, long* idum2, long* iy, long* iv);
/*calculates bt.b */
/* b : vector, bi, i = [0...n-1] */
/* n : length of b */
/*returns the scalar product of b*/
double scal_vec(double *b,int n);
double scal_vec(double* b, int n);
/*solves the set of n linear equations Cx = D */
/* C : symmetric positive-definite matrix recorded */
@ -614,32 +560,26 @@ double scal_vec(double *b,int n);
/* */
/* The solution vector is returned in D */
/* CONJUGATE GRADIENT method */
void solve3(double *C, double *D, int n);
void solve3(double* C, double* D, int n);
/*sorts an array [0...n-1] into ascending order using */
/*shell */
void sort(float n, float *arr);
void sort(float n, float* arr);
/*spherical covariance value for lag h*/
double spherical(double h);
/*stable covariance value for lag h and exponent alpha*/
double stable(double h, double alpha);
/*conversion of log mean and variance to nor*/
void statlog2nor(struct statistic_mod *pstat);
void statlog2nor(struct statistic_mod* pstat);
/*tries factor */
/*pnum: number to be decomposed */
/*fact: suggested factor */
/*pmaxfac: memory to keep the greatest factor*/
int test_fact(int *pnum, int fact, int *pmaxfac);
int test_fact(int* pnum, int fact, int* pmaxfac);
/*calculates the integrale of an approximate function*/
/*for the Gaussian function over an interval defined */
@ -648,29 +588,25 @@ int test_fact(int *pnum, int fact, int *pmaxfac);
/*lim_sup: upper bound of the considered interval */
double trun1(double lim_inf, double lim_sup);
/*draws a truncated gaussian variable between lim_inf*/
/*and lim_sup */
/*idum: seed */
double trungasdev(long *idum,double lim_inf,double lim_sup,long *idum2, long *iy, long iv[NTAB]);
double trungasdev(long* idum, double lim_inf, double lim_sup, long* idum2, long* iy, long iv[NTAB]);
/* tb1.b2 */
/* b1 : vector */
/* b2 : vector */
/* n : length of b1 and b2, bi, i = [0...n-1]*/
/*returns the norm the product tb1.b2 */
double vec_vec(double *b1, double *b2,int n);
double vec_vec(double* b1, double* b2, int n);
/*turns the volume fractions into Gaussian thresholds */
/*facies: structure defined above */
/*thresholds: output threshold vector fot i = [0...n-1]*/
/*where n is the number of facies-1 */
/*USES normal*/
void vf2gthres(struct statfacies_mod facies,float *thresholds);
void polint(float xa[],float ya[],int n,float x, float *y,float *dy);
void vf2gthres(struct statfacies_mod facies, float* thresholds);
void polint(float xa[], float ya[], int n, float x, float* y, float* dy);
#endif

16
fftma_module/gen/lib_src/length.c
Unescape Escape View File

@ -1,7 +1,7 @@
#include <math.h>
/* compute the length for one dimension*/
int length(int N, int i, double *scf, double *ap, double D, int Nvari)
int length(int N, int i, double* scf, double* ap, double D, int Nvari)
{
int maxfactor(int n);
double temp1, temp2;
@ -13,22 +13,22 @@ int length(int N, int i, double *scf, double *ap, double D, int Nvari)
} else {
for (k = 0; k < Nvari; k++) {
temp1 = fabs(ap[9*k+i])*scf[3*k]*scf[3*k];
for (j = 1; j <3; j++) {
temp2 = fabs(ap[9*k+3*j+i])*scf[3*k+j]*scf[3*k+j];
temp1 = fabs(ap[9 * k + i]) * scf[3 * k] * scf[3 * k];
for (j = 1; j < 3; j++) {
temp2 = fabs(ap[9 * k + 3 * j + i]) * scf[3 * k + j] * scf[3 * k + j];
if (temp2 > temp1)
temp1 = temp2;
}
}
temp1 = sqrt(temp1);
temp1 /= (double)D;
if ((double)N/temp1 < 2.) {
n = N+(int)(2*temp1);
if ((double)N / temp1 < 2.) {
n = N + (int)(2 * temp1);
} else {
n = N+(int)temp1;
n = N + (int)temp1;
}
if ((n % 2) != 0)
n = n+1;
n = n + 1;
nmax = maxfactor(n);
while (nmax > nlimit) {
n += 2;

14
fftma_module/gen/lib_src/maxfactor.c
Unescape Escape View File

@ -3,30 +3,30 @@
/*determines the greatest prime factor of an integer*/
int maxfactor(int n)
{
int test_fact(int *pnum, int fact, int *pmaxfac);
int test_fact(int* pnum, int fact, int* pmaxfac);
int lnum, fact;
int maxfac;
maxfac = 1;
lnum = n;
if ( lnum != 0 && lnum != 1 ) {
if (lnum != 0 && lnum != 1) {
fact = 2;
if ( test_fact( &lnum, fact,&maxfac)) {
if (test_fact(&lnum, fact, &maxfac)) {
fact = 3;
if ( test_fact( &lnum, fact,&maxfac)) {
if (test_fact(&lnum, fact, &maxfac)) {
fact = 5;
for (;;) {
if (!test_fact( &lnum, fact,&maxfac))
if (!test_fact(&lnum, fact, &maxfac))
break;
fact += 2;
if (!test_fact( &lnum, fact,&maxfac))
if (!test_fact(&lnum, fact, &maxfac))
break;
fact += 4;
}
}
}
if ( lnum != 1 ) {
if (lnum != 1) {
if (lnum > maxfac)
maxfac = lnum;
}

15
fftma_module/gen/lib_src/nor2log.c
Unescape Escape View File

@ -1,7 +1,6 @@
#include <stdlib.h>
#include <math.h>
#include "geostat.h"
#include <math.h>
#include <stdlib.h>
/*TURNS NORMAL NUMBERS INTO LOGNORMAL NUMBERS */
/*input: */
@ -13,20 +12,18 @@
/*realout: structure defining a realization - */
/* lognormal numbers */
void nor2log(struct realization_mod *realin, int typelog, struct realization_mod *realout)
void nor2log(struct realization_mod* realin, int typelog, struct realization_mod* realout)
{
int i;
double coeff;
coeff = log(10.0);
/*Is the output realization allocated ?*/
/*is its length equal to realin.n?*/
if ((*realout).vector == NULL || (*realout).n != (*realin).n) {
(*realout).vector = (double *) malloc((*realin).n * sizeof(double));
(*realout).vector = (double*)malloc((*realin).n * sizeof(double));
if ((*realout).vector == NULL) {
printf("No memory available");
return;
@ -34,7 +31,6 @@ void nor2log(struct realization_mod *realin, int typelog, struct realization_mod
}
(*realout).n = (*realin).n;
switch ((*realin).code) {
case 0:
case 1:
@ -55,7 +51,6 @@ void nor2log(struct realization_mod *realin, int typelog, struct realization_mod
break;
}
/*anamorphose*/
for (i = 0; i < (*realin).n; i++) {
switch (typelog) {
@ -65,7 +60,7 @@ void nor2log(struct realization_mod *realin, int typelog, struct realization_mod
break;
case 4:
/*log10*/
(*realout).vector[i] = exp((*realin).vector[i]*coeff);
(*realout).vector[i] = exp((*realin).vector[i] * coeff);
break;
default:
printf("Unexpected case in nor2log");

7
fftma_module/gen/lib_src/nugget.c
Unescape Escape View File

@ -1,7 +1,6 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*nugget covariance function*/
double nugget(double h)
@ -9,6 +8,6 @@ double nugget(double h)
if (h == 0) {
return (1.);
} else {
return(0.);
return (0.);
}
}

7
fftma_module/gen/lib_src/power.c
Unescape Escape View File

@ -1,10 +1,9 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*power covariance function*/
double power(double h, double alpha)
{
return(pow(h,alpha));
return (pow(h, alpha));
}

40
fftma_module/gen/lib_src/prebuild_gwn.c
Unescape Escape View File

@ -1,10 +1,10 @@
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include "geostat.h"
#include <math.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "geostat.h"
#include <string.h>
/* prebuild_gwn */
/* Produce a first construction in real space of the Gaussian white noise */
@ -19,29 +19,25 @@
/* must be a Gaussian white noise */
/*realization: structure defining a realization*/
void prebuild_gwn(struct grid_mod grid,int n[3],struct realization_mod *realin,double *realization,int solver)
void prebuild_gwn(struct grid_mod grid, int n[3], struct realization_mod* realin, double* realization, int solver)
{
int i,j,k,maille0,maille1;
{
int i, j, k, maille0, maille1;
int ntot;
ntot=n[0]*n[1]*n[2];
realization[0]=0.;
if (solver==1)
{
for (i=0;i<ntot;i++)
{
realization[i+1]=(*realin).vector[i];
ntot = n[0] * n[1] * n[2];
realization[0] = 0.;
if (solver == 1) {
for (i = 0; i < ntot; i++) {
realization[i + 1] = (*realin).vector[i];
}
}
else
{
for ( k = 1; k <= n[2]; k++) {
} else {
for (k = 1; k <= n[2]; k++) {
for (j = 1; j <= n[1]; j++) {
for (i = 1; i <= n[0]; i++) {
maille1 = i+(j-1+(k-1)*n[1])*n[0];
maille1 = i + (j - 1 + (k - 1) * n[1]) * n[0];
if (i <= grid.NX && j <= grid.NY && k <= grid.NZ) {
maille0 = i-1+(j-1+(k-1)*grid.NY)*grid.NX;
maille0 = i - 1 + (j - 1 + (k - 1) * grid.NY) * grid.NX;
realization[maille1] = (*realin).vector[maille0];
} else {
realization[maille1] = 0.;
@ -51,4 +47,4 @@ void prebuild_gwn(struct grid_mod grid,int n[3],struct realization_mod *realin,d
}
}
return;
}
}

7
fftma_module/gen/lib_src/pressure.h
Unescape Escape View File

@ -1,7 +1,7 @@
#include <stdlib.h>
#include <string.h>
#include "genlib.h"
#include "geostat.h"
#include <stdlib.h>
#include <string.h>
#ifndef _PRESSURE_H
#define _PRESSURE_H
@ -14,8 +14,7 @@
/* y: macroscopic gradient value in x direction */
/* z: macroscopic gradient value in x direction */
struct pressure_mod {
double x,y,z;
double x, y, z;
};
#endif // define _PRESSURE_H

55
fftma_module/gen/lib_src/ran2.c
Unescape Escape View File

@ -2,8 +2,8 @@
#define IM1 2147483563
#define IM2 2147483399
#define AM (1.0/IM1)
#define IMM1 (IM1-1)
#define AM (1.0 / IM1)
#define IMM1 (IM1 - 1)
#define IA1 40014
#define IA2 40692
#define IQ1 53668
@ -11,11 +11,11 @@
#define IR1 12211
#define IR2 3791
#define NTAB 32
#define NDIV (1+IMM1/NTAB)
#define NDIV (1 + IMM1 / NTAB)
#define EPS 1.2e-7
#define RNMX (1.0-EPS)
#define RNMX (1.0 - EPS)
double ran2(long *idum, long *idum2, long *iy, long iv[NTAB])
double ran2(long* idum, long* idum2, long* iy, long iv[NTAB])
{
int j;
@ -23,28 +23,37 @@ double ran2(long *idum, long *idum2, long *iy, long iv[NTAB])
double temp;
if (*idum <= 0) {
if (-(*idum) < 1) *idum = 1;
else *idum = -(*idum);
if (-(*idum) < 1)
*idum = 1;
else
*idum = -(*idum);
*idum2 = (*idum);
for (j = NTAB+7; j >= 0; j--) {
k = (*idum)/IQ1;
*idum = IA1*(*idum-k*IQ1)-k*IR1;
if (*idum < 0) *idum += IM1;
if (j < NTAB) iv[j] = *idum;
for (j = NTAB + 7; j >= 0; j--) {
k = (*idum) / IQ1;
*idum = IA1 * (*idum - k * IQ1) - k * IR1;
if (*idum < 0)
*idum += IM1;
if (j < NTAB)
iv[j] = *idum;
}
*iy = iv[0];
}
k = (*idum)/IQ1;
*idum = IA1*(*idum-k*IQ1)-k*IR1;
if (*idum < 0) *idum += IM1;
k = *idum2/IQ2;
*idum2 = IA2*(*idum2-k*IQ2)-k*IR2;
if (*idum2 < 0) *idum2 += IM2;
j = (*iy)/NDIV;
*iy = iv[j]-(*idum2);
k = (*idum) / IQ1;
*idum = IA1 * (*idum - k * IQ1) - k * IR1;
if (*idum < 0)
*idum += IM1;
k = *idum2 / IQ2;
*idum2 = IA2 * (*idum2 - k * IQ2) - k * IR2;
if (*idum2 < 0)
*idum2 += IM2;
j = (*iy) / NDIV;
*iy = iv[j] - (*idum2);
iv[j] = *idum;
if (*iy < 1) (*iy) += IMM1;
if ((temp = AM*(*iy)) > RNMX) return (RNMX);
else return (temp);
if (*iy < 1)
(*iy) += IMM1;
if ((temp = AM * (*iy)) > RNMX)
return (RNMX);
else
return (temp);
}

8
fftma_module/gen/lib_src/random.c
Unescape Escape View File

@ -25,7 +25,7 @@
void Randomize(void)
{
srand((int) time(NULL));
srand((int)time(NULL));
}
/*
@ -44,8 +44,8 @@ int RandomInteger(int low, int high)
int k;
double d;
d = (double) rand() / ((double) RAND_MAX + 1);
k = (int) (d * (high - low + 1));
d = (double)rand() / ((double)RAND_MAX + 1);
k = (int)(d * (high - low + 1));
return (low + k);
}
@ -60,7 +60,7 @@ double RandomReal(double low, double high)
{
double d;
d = (double) rand() / ((double) RAND_MAX + 1);
d = (double)rand() / ((double)RAND_MAX + 1);
return (low + d * (high - low));
}

2
fftma_module/gen/lib_src/random.h
Unescape Escape View File

@ -23,7 +23,7 @@
*/
#ifndef RAND_MAX
# define RAND_MAX ((int) ((unsigned) ~0 >> 1))
#define RAND_MAX ((int)((unsigned)~0 >> 1))
#endif
/*

21
fftma_module/gen/lib_src/scanadt.c
Unescape Escape View File

@ -4,11 +4,11 @@
* This file implements the scanadt.h interface.
*/
#include <stdio.h>
#include <ctype.h>
#include "scanadt.h"
#include "genlib.h"
#include "strlib.h"
#include "scanadt.h"
#include <ctype.h>
#include <stdio.h>
/*
* Type: scannerCDT
@ -53,13 +53,15 @@ scannerADT NewScanner(void)
void FreeScanner(scannerADT scanner)
{
if (scanner->str != NULL) FreeBlock(scanner->str);
if (scanner->str != NULL)
FreeBlock(scanner->str);
FreeBlock(scanner);
}
void SetScannerString(scannerADT scanner, string str)
{
if (scanner->str != NULL) FreeBlock(scanner->str);
if (scanner->str != NULL)
FreeBlock(scanner->str);
scanner->str = CopyString(str);
scanner->len = StringLength(str);
scanner->cp = 0;
@ -80,9 +82,11 @@ string ReadToken(scannerADT scanner)
scanner->savedToken = NULL;
return (token);
}
if (scanner->spaceOption == IgnoreSpaces) SkipSpaces(scanner);
if (scanner->spaceOption == IgnoreSpaces)
SkipSpaces(scanner);
start = finish = scanner->cp;
if (start >= scanner->len) return (CopyString(""));
if (start >= scanner->len)
return (CopyString(""));
ch = scanner->str[scanner->cp];
if (isalnum(ch)) {
finish = ScanToEndOfIdentifier(scanner);
@ -100,7 +104,8 @@ bool MoreTokensExist(scannerADT scanner)
if (scanner->savedToken != NULL) {
return (!StringEqual(scanner->savedToken, ""));
}
if (scanner->spaceOption == IgnoreSpaces) SkipSpaces(scanner);
if (scanner->spaceOption == IgnoreSpaces)
SkipSpaces(scanner);
return (scanner->cp < scanner->len);
}

5
fftma_module/gen/lib_src/scanadt.h
Unescape Escape View File

@ -60,7 +60,7 @@
* internal representation are hidden from the client.
*/
typedef struct scannerCDT *scannerADT;
typedef struct scannerCDT* scannerADT;
/*
* Function: NewScanner
@ -151,7 +151,8 @@ void SaveToken(scannerADT scanner, string token);
* of this option.
*/
typedef enum { PreserveSpaces, IgnoreSpaces } spaceOptionT;
typedef enum { PreserveSpaces,
IgnoreSpaces } spaceOptionT;
void SetScannerSpaceOption(scannerADT scanner, spaceOptionT option);
spaceOptionT GetScannerSpaceOption(scannerADT scanner);

8
fftma_module/gen/lib_src/simpio.c
Unescape Escape View File

@ -10,8 +10,8 @@
#include <string.h>
#include "genlib.h"
#include "strlib.h"
#include "simpio.h"
#include "strlib.h"
/*
* Constants:
@ -131,7 +131,7 @@ string GetLine(void)
* twice the size of the previous one is allocated.
*/
string ReadLine(FILE *infile)
string ReadLine(FILE* infile)
{
string line, nline;
int n, ch, size;
@ -142,7 +142,7 @@ string ReadLine(FILE *infile)
while ((ch = getc(infile)) != '\n' && ch != EOF) {
if (n == size) {
size *= 2;
nline = (string) GetBlock(size + 1);
nline = (string)GetBlock(size + 1);
strncpy(nline, line, n);
FreeBlock(line);
line = nline;
@ -154,7 +154,7 @@ string ReadLine(FILE *infile)
return (NULL);
}
line[n] = '\0';
nline = (string) GetBlock(n + 1);
nline = (string)GetBlock(n + 1);
strcpy(nline, line);
FreeBlock(line);
return (nline);

2
fftma_module/gen/lib_src/simpio.h
Unescape Escape View File

@ -70,6 +70,6 @@ string GetLine(void);
* is at the end-of-file position.
*/
string ReadLine(FILE *infile);
string ReadLine(FILE* infile);
#endif

7
fftma_module/gen/lib_src/spherical.c
Unescape Escape View File

@ -1,7 +1,6 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*spherical covariance function*/
double spherical(double h)
@ -11,7 +10,7 @@ double spherical(double h)
if (h >= 1.) {
z = 0.;
} else {
z = 1.-1.5*(double)h+0.5*(double)(h*h*h);
z = 1. - 1.5 * (double)h + 0.5 * (double)(h * h * h);
}
return (z);
}

7
fftma_module/gen/lib_src/stable.c
Unescape Escape View File

@ -1,10 +1,9 @@
#include <stdio.h>
#include <math.h>
#include "genlib.h"
#include <math.h>
#include <stdio.h>
/*stable covariance function*/
double stable(double h, double alpha)
{
return(exp(-3.*(double)pow(h,alpha)));
return (exp(-3. * (double)pow(h, alpha)));
}

14
fftma_module/gen/lib_src/stack.c
Unescape Escape View File

@ -7,9 +7,9 @@
* the type name stackElementT.
*/
#include <stdio.h>
#include "genlib.h"
#include "stack.h"
#include "genlib.h"
#include <stdio.h>
/*
* Constant: InitialStackSize
@ -33,7 +33,7 @@
*/
struct stackCDT {
stackElementT *elements;
stackElementT* elements;
int count;
int size;
};
@ -63,13 +63,15 @@ void FreeStack(stackADT stack)
void Push(stackADT stack, stackElementT element)
{
if (stack->count == stack->size) ExpandStack(stack);
if (stack->count == stack->size)
ExpandStack(stack);
stack->elements[stack->count++] = element;
}
stackElementT Pop(stackADT stack)
{
if (StackIsEmpty(stack)) Error("Pop of an empty stack");
if (StackIsEmpty(stack))
Error("Pop of an empty stack");
return (stack->elements[--stack->count]);
}
@ -108,7 +110,7 @@ stackElementT GetStackElement(stackADT stack, int index)
static void ExpandStack(stackADT stack)
{
stackElementT *array;
stackElementT* array;
int i, newSize;
newSize = stack->size * 2;

4
fftma_module/gen/lib_src/stack.h
Unescape Escape View File

@ -22,7 +22,7 @@
* be changed by editing this definition line.
*/
typedef void *stackElementT;
typedef void* stackElementT;
/*
* Type: stackADT
@ -34,7 +34,7 @@ typedef void *stackElementT;
* the underlying fields.
*/
typedef struct stackCDT *stackADT;
typedef struct stackCDT* stackADT;
/*
* Function: NewStack

73
fftma_module/gen/lib_src/strlib.c
Unescape Escape View File

@ -17,9 +17,9 @@
* interface.
*/
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "genlib.h"
#include "strlib.h"
@ -59,7 +59,8 @@ char IthChar(string s, int i)
{
int len;
if (s == NULL) Error("NULL string passed to IthChar");
if (s == NULL)
Error("NULL string passed to IthChar");
len = strlen(s);
if (i < 0 || i > len) {
Error("Index outside of string range in IthChar");
@ -72,12 +73,16 @@ string SubString(string s, int p1, int p2)
int len;
string result;
if (s == NULL) Error("NULL string passed to SubString");
if (s == NULL)
Error("NULL string passed to SubString");
len = strlen(s);
if (p1 < 0) p1 = 0;
if (p2 >= len) p2 = len - 1;
if (p1 < 0)
p1 = 0;
if (p2 >= len)
p2 = len - 1;
len = p2 - p1 + 1;
if (len < 0) len = 0;
if (len < 0)
len = 0;
result = CreateString(len);
strncpy(result, s + p1, len);
result[len] = '\0';
@ -96,7 +101,8 @@ string CharToString(char ch)
int StringLength(string s)
{
if (s == NULL) Error("NULL string passed to StringLength");
if (s == NULL)
Error("NULL string passed to StringLength");
return (strlen(s));
}
@ -104,7 +110,8 @@ string CopyString(string s)
{
string newstr;
if (s == NULL) Error("NULL string passed to CopyString");
if (s == NULL)
Error("NULL string passed to CopyString");
newstr = CreateString(strlen(s));
strcpy(newstr, s);
return (newstr);
@ -132,27 +139,36 @@ int StringCompare(string s1, string s2)
int FindChar(char ch, string text, int start)
{
char *cptr;
if (text == NULL) Error("NULL string passed to FindChar");
if (start < 0) start = 0;
if (start > strlen(text)) return (-1);
char* cptr;
if (text == NULL)
Error("NULL string passed to FindChar");
if (start < 0)
start = 0;
if (start > strlen(text))
return (-1);
cptr = strchr(text + start, ch);
if (cptr == NULL) return (-1);
return ((int) (cptr - text));
if (cptr == NULL)
return (-1);
return ((int)(cptr - text));
}
int FindString(string str, string text, int start)
{
char *cptr;
if (str == NULL) Error("NULL pattern string in FindString");
if (text == NULL) Error("NULL text string in FindString");
if (start < 0) start = 0;
if (start > strlen(text)) return (-1);
char* cptr;
if (str == NULL)
Error("NULL pattern string in FindString");
if (text == NULL)
Error("NULL text string in FindString");
if (start < 0)
start = 0;
if (start > strlen(text))
return (-1);
cptr = strstr(text + start, str);
if (cptr == NULL) return (-1);
return ((int) (cptr - text));
if (cptr == NULL)
return (-1);
return ((int)(cptr - text));
}
/* Section 4 -- Case-conversion functions */
@ -166,7 +182,8 @@ string ConvertToLowerCase(string s)
Error("NULL string passed to ConvertToLowerCase");
}
result = CreateString(strlen(s));
for (i = 0; s[i] != '\0'; i++) result[i] = tolower(s[i]);
for (i = 0; s[i] != '\0'; i++)
result[i] = tolower(s[i]);
result[i] = '\0';
return (result);
}
@ -180,7 +197,8 @@ string ConvertToUpperCase(string s)
Error("NULL string passed to ConvertToUpperCase");
}
result = CreateString(strlen(s));
for (i = 0; s[i] != '\0'; i++) result[i] = toupper(s[i]);
for (i = 0; s[i] != '\0'; i++)
result[i] = toupper(s[i]);
result[i] = '\0';
return (result);
}
@ -222,7 +240,8 @@ double StringToReal(string s)
double result;
char dummy;
if (s == NULL) Error("NULL string passed to StringToReal");
if (s == NULL)
Error("NULL string passed to StringToReal");
if (sscanf(s, " %lg %c", &result, &dummy) != 1) {
Error("StringToReal called on illegal number %s", s);
}
@ -242,5 +261,5 @@ double StringToReal(string s)
static string CreateString(int len)
{
return ((string) GetBlock(len + 1));
return ((string)GetBlock(len + 1));
}

37
fftma_module/gen/lib_src/symtab.c
Unescape Escape View File

@ -4,10 +4,10 @@
* This file implements the symbol table abstraction.
*/
#include <stdio.h>
#include "symtab.h"
#include "genlib.h"
#include "strlib.h"
#include "symtab.h"
#include <stdio.h>
/*
* Constants
@ -25,8 +25,8 @@
typedef struct cellT {
string key;
void *value;
struct cellT *link;
void* value;
struct cellT* link;
} cellT;
/*
@ -41,13 +41,13 @@ typedef struct cellT {
*/
struct symtabCDT {
cellT *buckets[NBuckets];
cellT* buckets[NBuckets];
};
/* Private function declarations */
static void FreeBucketChain(cellT *cp);
static cellT *FindCell(cellT *cp, string s);
static void FreeBucketChain(cellT* cp);
static cellT* FindCell(cellT* cp, string s);
static int Hash(string s, int nBuckets);
/* Public entries */
@ -74,15 +74,15 @@ void FreeSymbolTable(symtabADT table)
FreeBlock(table);
}
void Enter(symtabADT table, string key, void *value)
void Enter(symtabADT table, string key, void* value)
{
int bucket;
cellT *cp;
cellT* cp;
bucket = Hash(key, NBuckets);
cp = FindCell(table->buckets[bucket], key);
if (cp == NULL) {
cp = New(cellT *);
cp = New(cellT*);
cp->key = CopyString(key);
cp->link = table->buckets[bucket];
table->buckets[bucket] = cp;
@ -90,22 +90,23 @@ void Enter(symtabADT table, string key, void *value)
cp->value = value;
}
void *Lookup(symtabADT table, string key)
void* Lookup(symtabADT table, string key)
{
int bucket;
cellT *cp;
cellT* cp;
bucket = Hash(key, NBuckets);
cp = FindCell(table->buckets[bucket], key);
if (cp == NULL) return(UNDEFINED);
if (cp == NULL)
return (UNDEFINED);
return (cp->value);
}
void MapSymbolTable(symtabFnT fn, symtabADT table,
void *clientData)
void* clientData)
{
int i;
cellT *cp;
cellT* cp;
for (i = 0; i < NBuckets; i++) {
for (cp = table->buckets[i]; cp != NULL; cp = cp->link) {
@ -125,9 +126,9 @@ void MapSymbolTable(symtabFnT fn, symtabADT table,
* this function must free the string storage as well.
*/
static void FreeBucketChain(cellT *cp)
static void FreeBucketChain(cellT* cp)
{
cellT *next;
cellT* next;
while (cp != NULL) {
next = cp->link;
@ -146,7 +147,7 @@ static void FreeBucketChain(cellT *cp)
* returned. If no match is found, the function returns NULL.
*/
static cellT *FindCell(cellT *cp, string key)
static cellT* FindCell(cellT* cp, string key)
{
while (cp != NULL && !StringEqual(cp->key, key)) {
cp = cp->link;

12
fftma_module/gen/lib_src/symtab.h
Unescape Escape View File

@ -15,7 +15,7 @@
* This type is the ADT used to represent a symbol table.
*/
typedef struct symtabCDT *symtabADT;
typedef struct symtabCDT* symtabADT;
/*
* Type: symtabFnT
@ -24,8 +24,8 @@ typedef struct symtabCDT *symtabADT;
* map over the entries in a symbol table.
*/
typedef void (*symtabFnT)(string key, void *value,
void *clientData);
typedef void (*symtabFnT)(string key, void* value,
void* clientData);
/* Exported entries */
@ -55,7 +55,7 @@ void FreeSymbolTable(symtabADT table);
* Each call to Enter supersedes any previous definition for key.
*/
void Enter(symtabADT table, string key, void *value);
void Enter(symtabADT table, string key, void* value);
/*
* Function: Lookup
@ -65,7 +65,7 @@ void Enter(symtabADT table, string key, void *value);
* table, or UNDEFINED, if no such value exists.
*/
void *Lookup(symtabADT table, string key);
void* Lookup(symtabADT table, string key);
/*
* Function: MapSymbolTable
@ -80,6 +80,6 @@ void *Lookup(symtabADT table, string key);
*/
void MapSymbolTable(symtabFnT fn, symtabADT table,
void *clientData);
void* clientData);
#endif

10
fftma_module/gen/lib_src/test_fact.c
Unescape Escape View File

@ -1,26 +1,24 @@
#include "genlib.h"
/*tries factor*/
int test_fact(int *pnum, int fact, int *pmaxfac)
int test_fact(int* pnum, int fact, int* pmaxfac)
{
int power, t;
power = 0;
while ( ( t = *pnum / fact ) * fact == *pnum ) {
while ((t = *pnum / fact) * fact == *pnum) {
++power;
*pnum = t;
}
if ( power != 0 ) {
if (power != 0) {
if (fact > *pmaxfac)
*pmaxfac = fact;
}
if ( t > fact ) {
if (t > fact) {
return (1);
}
return (0);
}

10
fftma_module/gen/lib_src/testmemory.c
Unescape Escape View File

@ -1,11 +1,11 @@
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <math.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
void testmemory(double *realint)
void testmemory(double* realint)
{
if (realint == NULL) {
printf("Testmemory.c: No memory available \n");

Write Preview
Loading…
Cancel
Save