cwp.h

来自「该程序是用vc开发的对动态数组进行管理的DLL」· C头文件 代码 · 共 605 行 · 第 1/2 页

/* Copyright (c) Colorado School of Mines, 2003.*/
/* All rights reserved.                       */

/* cwp.h - include file for general purpose CWP stuff */

#ifndef CWP_H
#define CWP_H

#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <limits.h>
#include <float.h>
#include "xstruct.h"

/*-----------#include <fcntl.h>------------*/    /* non-ANSI */
/*-----------#include <unistd.h>-----------*/    /* non-ANSI */
/*-----------#include <sys/types.h>--------*/    /* non-ANSI */

#ifdef CADDR_T_NOT_DEFINED
typedef char *          caddr_t;
#endif
typedef struct _complexStruct { /* fcomplex number */
	float r,i;
}  fcomplex;
typedef struct _dcomplexStruct { /* double-precision fcomplex number */
	double r,i;
}  dcomplex;

 
/* CWP ENDIAN */

#ifdef CWP_BIG_ENDIAN
#define CWPENDIAN 1
#endif
#ifdef CWP_LITTLE_ENDIAN
#define CWPENDIAN 0
#endif

#ifndef NULL
#define NULL	((void *)0)
#endif
#ifndef EXIT_FAILURE
#define EXIT_FAILURE (1)
#endif
#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS (0)
#endif
#ifndef SEEK_SET
#define SEEK_SET (0)
#endif
#ifndef SEEK_CUR
#define SEEK_CUR (1)
#endif
#ifndef SEEK_END
#define SEEK_END (2)
#endif
#ifndef PI
#define PI (3.141592653589793f)
#endif
#ifndef D_PI 
#define D_PI (double) (3.1415926535897932385)
#endif
#ifndef GOLDEN_RATIO 
#define GOLDEN_RATIO (1.618034)   /* the golden ratio */
#endif
#ifndef TRUE
#define TRUE (1)
#endif
#ifndef FALSE
#define FALSE (0)
#endif
#ifndef YES
#define YES (1)
#endif
#ifndef NO
#define NO (0)
#endif
#ifndef SGN
#define SGN(x) ((x) < 0 ? -1.0 : 1.0)
#endif
#ifndef ABS
#define ABS(x) ((x) < 0 ? -(x) : (x))
#endif
#ifndef MAX
#define	MAX(x,y) ((x) > (y) ? (x) : (y))
#endif
#ifndef MIN
#define	MIN(x,y) ((x) < (y) ? (x) : (y))
#endif
#define NINT(x) ((int)((x)>0.0?(x)+0.5:(x)-0.5))
#define CLOSETO(x, y) ((ABS((x) - (y)) <= FLT_EPSILON*ABS(y))?cwp_true:cwp_false)
#define ISODD(n) ((n) & 01)
#define ISIZE sizeof(int)
#define FSIZE sizeof(float)
#define DSIZE sizeof(double)
#define	STREQ(s,t) (strcmp(s,t) == 0)
#define	STRLT(s,t) (strcmp(s,t) < 0)
#define	STRGT(s,t) (strcmp(s,t) > 0)
#define	DIM(a) (sizeof(a)/sizeof(a[0]))


/* FUNCTION PROTOTYPES */

#ifdef __cplusplus /* if C++, specify external linkage to C functions */
extern "C" {
#endif

/* allocate and free multi-dimensional arrays */
void		*alloc1 (size_t n1, size_t size);
void		*realloc1 (void *v, size_t n1, size_t size);
void		**alloc2 (size_t n1, size_t n2, size_t size);
void		***alloc3 (size_t n1, size_t n2, size_t n3, size_t size);
void		****alloc4 (size_t n1, size_t n2, size_t n3, size_t n4, size_t size);
void		*****alloc5 (size_t n1, size_t n2, size_t n3, size_t n4, size_t n5, size_t size);
void		******alloc6 (size_t n1, size_t n2, size_t n3, size_t n4, size_t n5, size_t n6, 
                   size_t size);

void		free1 (void *p);
void		free2 (void **p);
void		free3 (void ***p);
void		free4 (void ****p);
void		free5 (void *****p);
void		free6 (void ******p);
int			*alloc1int (size_t n1);
int			*realloc1int (int *v, size_t n1);
int			**alloc2int (size_t n1, size_t n2);
int			***alloc3int (size_t n1, size_t n2, size_t n3);
float		*alloc1float (size_t n1);
float		*realloc1float (float *v, size_t n1);
float		**alloc2float (size_t n1, size_t n2);
float		***alloc3float (size_t n1, size_t n2, size_t n3);

float		****alloc4float (size_t n1, size_t n2, size_t n3, size_t n4);
void		free4float (float ****p);
float		*****alloc5float (size_t n1, size_t n2, size_t n3, size_t n4, size_t n5);
void		free5float (float *****p);
float		******alloc6float (size_t n1, size_t n2, size_t n3, size_t n4, size_t n5, size_t n6);
void		free6float (float ******p);
int			****alloc4int (size_t n1, size_t n2, size_t n3, size_t n4);
void		free4int (int ****p);
int			*****alloc5int (size_t n1, size_t n2, size_t n3, size_t n4, size_t n5);
void		free5int (int *****p);
unsigned short ******alloc6ushort(size_t n1,size_t n2,size_t n3,size_t n4,
        size_t n5, size_t n6);
unsigned char *****alloc5uchar(size_t n1,size_t n2,size_t n3,size_t n4,
        size_t n5);
void		free5uchar(unsigned char *****p);
unsigned short *****alloc5ushort(size_t n1,size_t n2,size_t n3,size_t n4,
        size_t n5);
void		free5ushort(unsigned short *****p);
unsigned char ******alloc6uchar(size_t n1,size_t n2,size_t n3,size_t n4,
        size_t n5, size_t n6);
void		free6uchar(unsigned char ******p);
unsigned short ******alloc6ushort(size_t n1,size_t n2,size_t n3,size_t n4,
        size_t n5, size_t n6);
void		free6ushort(unsigned short ******p);

double		*alloc1double (size_t n1);
double		*realloc1double (double *v, size_t n1);
double		**alloc2double (size_t n1, size_t n2);
double		***alloc3double (size_t n1, size_t n2, size_t n3);
fcomplex	*alloc1complex (size_t n1);
fcomplex	*realloc1complex (fcomplex *v, size_t n1);
fcomplex	**alloc2complex (size_t n1, size_t n2);
fcomplex	***alloc3complex (size_t n1, size_t n2, size_t n3);

dcomplex	*alloc1dcomplex (size_t n1);
dcomplex	*realloc1dcomplex (dcomplex *v, size_t n1);
dcomplex	**alloc2dcomplex (size_t n1, size_t n2);
dcomplex	***alloc3dcomplex (size_t n1, size_t n2, size_t n3);

void		free1int (int *p);
void		free2int (int **p);
void		free3int (int ***p);
void		free1float (float *p);
void		free2float (float **p);
void		free3float (float ***p);

void		free1double (double *p);
void		free2double (double **p);
void		free3double (double ***p);
void		free1complex (fcomplex *p);
void		free2complex (fcomplex **p);
void		free3complex (fcomplex ***p);

void		free1dcomplex (dcomplex *p);
void		free2dcomplex (dcomplex **p);
void		free3dcomplex (dcomplex ***p);

/* fcomplex number manipulation */
fcomplex	cadd (fcomplex a, fcomplex b);
fcomplex	csub (fcomplex a, fcomplex b);
fcomplex	cmul (fcomplex a, fcomplex b);
fcomplex	cdiv (fcomplex a, fcomplex b);
float		rcabs (fcomplex z);
fcomplex	cmplx (float re, float im);
fcomplex	conjg (fcomplex z);
fcomplex	cneg (fcomplex z);
fcomplex	cinv (fcomplex z);
fcomplex	csqrt (fcomplex z);
fcomplex	cexp (fcomplex z);
fcomplex	crmul (fcomplex a, float x);

/* fcomplex functions */

fcomplex	cipow(fcomplex a, int p);
fcomplex	crpow(fcomplex a, float p);
fcomplex	rcpow(float a, fcomplex p);
fcomplex	ccpow (fcomplex a, fcomplex p);
fcomplex	ccos(fcomplex a);
fcomplex	csin(fcomplex a);
fcomplex	ccosh(fcomplex a);
fcomplex	csinh(fcomplex a);
fcomplex	cexp1(fcomplex a);
fcomplex	clog(fcomplex a);

/* double fcomplex */
dcomplex	dcadd (dcomplex a, dcomplex b);
dcomplex	dcsub (dcomplex a, dcomplex b);
dcomplex	dcmul (dcomplex a, dcomplex b);
dcomplex	dcdiv (dcomplex a, dcomplex b);
double		drcabs (dcomplex z);
dcomplex	dcmplx (double re, double im);
dcomplex	dconjg (dcomplex z);
dcomplex	dcneg (dcomplex z);
dcomplex	dcinv (dcomplex z);
dcomplex	dcsqrt (dcomplex z);
dcomplex	dcexp (dcomplex z);
dcomplex	dcrmul (dcomplex a, double x);

/* double fcomplex functions */
dcomplex	dcipow(dcomplex a, int p);
dcomplex	dcrpow(dcomplex a, float p);
dcomplex	rdcpow(float a, dcomplex p);
dcomplex	dcdcpow(dcomplex a, dcomplex p);
dcomplex	dccos(dcomplex a);
dcomplex	dcsin(dcomplex a);
dcomplex	dccosh(dcomplex a);
dcomplex	dcsinh(dcomplex a);
dcomplex	dcexp1(dcomplex a);
dcomplex	dclog(dcomplex a);



/* big matrix handler */
void		*bmalloc (int nbpe, int n1, int n2);
void		bmfree (void *bm);
void		bmread (void *bm, int dir, int k1, int k2, int n, void *v);
void		bmwrite (void *bm, int dir, int k1, int k2, int n, void *v);

/* interpolation */
float		fsinc (float x);
double		dsinc (double x);
void		mksinc (float d, int lsinc, float sinc[]);
void		ints8r (int nxin, float dxin, float fxin, float yin[], 
				float yinl, float yinr, int nxout, float xout[], float yout[]);
void		ints8c (int nxin, float dxin, float fxin, fcomplex yin[], 
				fcomplex yinl, fcomplex yinr, int nxout, float xout[], fcomplex yout[]);
void		intt8r (int ntable, float table[][8],
				int nxin, float dxin, float fxin, float yin[], 
				float yinl, float yinr, int nxout, float xout[], float yout[]);
void		intt8c (int ntable, float table[][8],
				int nxin, float dxin, float fxin, fcomplex yin[], 
				fcomplex yinl, fcomplex yinr, int nxout, float xout[], fcomplex yout[]);
void		ress8r (int nxin, float dxin, float fxin, float yin[], 
				float yinl, float yinr, 
				int nxout, float dxout, float fxout, float yout[]);
void		ress8c (int nxin, float dxin, float fxin, fcomplex yin[], 
				fcomplex yinl, fcomplex yinr, 
				int nxout, float dxout, float fxout, fcomplex yout[]);
void		shfs8r (float dx, int nxin, float fxin, float yin[], 
				float yinl, float yinr, int nxout, float fxout, float yout[]);
void		xindex (int nx, float ax[], float x, int *index);
void		intl2b (int nxin, float dxin, float fxin,
				int nyin, float dyin, float fyin, unsigned char *zin,
				int nxout, float dxout, float fxout,
				int nyout, float dyout, float fyout, unsigned char *zout);
void		intlin (int nin, float xin[], float yin[], float yinl, float yinr,
				int nout, float xout[], float yout[]);
void		intcub (int ideriv, int nin, float xin[], float ydin[][4],
				int nout, float xout[], float yout[]);
void		cakima (int n, float x[], float y[], float yd[][4]);
void		cmonot (int n, float x[], float y[], float yd[][4]);
void		csplin (int n, float x[], float y[], float yd[][4]);
void		yxtoxy (int nx, float dx, float fx, float y[], 
				int ny, float dy, float fy, float xylo, float xyhi, float x[]);
void		intlinc (int nin, float xin[], fcomplex yin[], fcomplex yinl, fcomplex yinr,
				int nout, float xout[], fcomplex yout[]);
void		linear_regression(float *y, float *x, int n, float coeff[4]);

/* Butterworth filters */
void		bfhighpass (int npoles, float f3db, int n, float p[], float q[]);
void		bflowpass (int npoles, float f3db, int n, float p[], float q[]);
void		bfdesign (float fpass, float apass, float fstop, float astop,	int *npoles, float *f3db);

/* differentiator approximations */
void		mkdiff (int n, float a, float h, int l, int m, float d[]);
void		mkhdiff (float h, int l, float d[]);
void		holbergd1 (float e, int n, float d[]);