epilectrik
/
pyNgSpice
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

type long --> int

h_vogt 15 years ago
parent
026a471d51
commit
4cbfbad8b5
7 changed files with 172 additions and 160 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      ChangeLog
  2. 18
      src/include/ngspice/fftext.h
  3. 31
      src/maths/fft/fftext.c
  4. 252
      src/maths/fft/fftlib.c
  5. 16
      src/maths/fft/fftlib.h
  6. 5
      src/spicelib/devices/isrc/isrcacct.c
  7. 5
      src/spicelib/devices/vsrc/vsrcacct.c

5
ChangeLog
View File

@ -1,3 +1,8 @@
2011-08-21 Holger Vogt
* fftext.h, fftext.c, fftlib.c, fftlib.h: type long to int
(patch by Robert)
isracct.c, vsrcacct.c: suppress info on freeing fft tables
2011-08-21 Robert Larice
* src/main.c ,
* src/frontend/runcoms.c ,

18
src/include/ngspice/fftext.h
View File

@ -9,7 +9,7 @@
#define FFT(a,n) if(!fftInit(roundtol(LOG2(n)))) ffts(a,roundtol(LOG2(n)),1);else printf("fft error\n");
*******************************************************************/
int fftInit(long M);
int fftInit(int M);
// malloc and init cosine and bit reversed tables for a given size fft, ifft, rfft, rifft
/* INPUTS */
/* M = log2 of fft size (ex M=10 for 1024 point fft) */
@ -19,7 +19,7 @@ int fftInit(long M);
void fftFree(void);
// release storage for all private cosine and bit reversed tables
void ffts(double *data, long M, long Rows);
void ffts(double *data, int M, int Rows);
/* Compute in-place complex fft on the rows of the input array */
/* INPUTS */
/* *ioptr = input data array */
@ -28,7 +28,7 @@ void ffts(double *data, long M, long Rows);
/* OUTPUTS */
/* *ioptr = output data array */
void iffts(double *data, long M, long Rows);
void iffts(double *data, int M, int Rows);
/* Compute in-place inverse complex fft on the rows of the input array */
/* INPUTS */
/* *ioptr = input data array */
@ -37,7 +37,7 @@ void iffts(double *data, long M, long Rows);
/* OUTPUTS */
/* *ioptr = output data array */
void rffts(double *data, long M, long Rows);
void rffts(double *data, int M, int Rows);
/* Compute in-place real fft on the rows of the input array */
/* The result is the complex spectra of the positive frequencies */
/* except the location for the first complex number contains the real */
@ -51,7 +51,7 @@ void rffts(double *data, long M, long Rows);
/* *ioptr = output data array in the following order */
/* Re(x[0]), Re(x[N/2]), Re(x[1]), Im(x[1]), Re(x[2]), Im(x[2]), ... Re(x[N/2-1]), Im(x[N/2-1]). */
void riffts(double *data, long M, long Rows);
void riffts(double *data, int M, int Rows);
/* Compute in-place real ifft on the rows of the input array */
/* data order as from rffts */
/* INPUTS */
@ -62,7 +62,7 @@ void riffts(double *data, long M, long Rows);
/* OUTPUTS */
/* *ioptr = real output data array */
void rspectprod(double *data1, double *data2, double *outdata, long N);
void rspectprod(double *data1, double *data2, double *outdata, int N);
// When multiplying a pair of spectra from rfft care must be taken to multiply the
// two real values seperately from the complex ones. This routine does it correctly.
// the result can be stored in-place over one of the inputs
@ -81,9 +81,9 @@ void rspectprod(double *data1, double *data2, double *outdata, long N);
//This is how I like to define a real matrix:
//struct matrix { // real matrix
// double *d; // pointer to data
// long Nrows; // number of rows in the matrix
// long Ncols; // number of columns in the matrix (can be less than Rsiz)
// long Rsiz; // number of doubles from one row to the next
// int Nrows; // number of rows in the matrix
// int Ncols; // number of columns in the matrix (can be less than Rsiz)
// int Rsiz; // number of doubles from one row to the next
//};
//typedef struct matrix matrix;

31
src/maths/fft/fftext.c
View File

@ -12,14 +12,15 @@
#include "fftlib.h"
#include "matlib.h"
#include <ngspice/fftext.h>
#include <ngspice/memory.h>
// pointers to storage of Utbl's and BRLow's
static double *UtblArray[8*sizeof(long)] =
static double *UtblArray[8*sizeof(int)] =
{0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
static short *BRLowArray[8*sizeof(long)/2] = {0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
static short *BRLowArray[8*sizeof(int)/2] = {0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0};
int fftInit(long M)
int fftInit(int M)
{
// malloc and init cosine and bit reversed tables for a given size fft, ifft, rfft, rifft
/* INPUTS */
@ -29,11 +30,11 @@ int fftInit(long M)
int theError = 1;
/*** I did NOT test cases with M>27 ***/
if ((M >= 0) && (M < 8*sizeof(long))) {
if ((M >= 0) && ((size_t) M < 8*sizeof(int))) {
theError = 0;
if (UtblArray[M] == 0) { // have we not inited this size fft yet?
// init cos table
UtblArray[M] = (double *) malloc( (POW2(M)/4+1)*sizeof(double) );
UtblArray[M] = TMALLOC(double, POW2(M)/4+1);
if (UtblArray[M] == 0)
theError = 2;
else {
@ -41,7 +42,7 @@ int fftInit(long M)
}
if (M > 1) {
if (BRLowArray[M/2] == 0) { // init bit reversed table for cmplx fft
BRLowArray[M/2] = (short *) malloc( POW2(M/2-1)*sizeof(short) );
BRLowArray[M/2] = TMALLOC(short, POW2(M/2-1));
if (BRLowArray[M/2] == 0)
theError = 2;
else {
@ -51,7 +52,7 @@ int fftInit(long M)
}
if (M > 2) {
if (BRLowArray[(M-1)/2] == 0) { // init bit reversed table for real fft
BRLowArray[(M-1)/2] = (short *) malloc( POW2((M-1)/2-1)*sizeof(short) );
BRLowArray[(M-1)/2] = TMALLOC(short, POW2((M-1)/2-1));
if (BRLowArray[(M-1)/2] == 0)
theError = 2;
else {
@ -67,14 +68,14 @@ int fftInit(long M)
void fftFree(void)
{
// release storage for all private cosine and bit reversed tables
long i1;
for (i1=8*sizeof(long)/2-1; i1>=0; i1--) {
int i1;
for (i1=8*sizeof(int)/2-1; i1>=0; i1--) {
if (BRLowArray[i1] != 0) {
free(BRLowArray[i1]);
BRLowArray[i1] = 0;
};
};
for (i1=8*sizeof(long)-1; i1>=0; i1--) {
for (i1=8*sizeof(int)-1; i1>=0; i1--) {
if (UtblArray[i1] != 0) {
free(UtblArray[i1]);
UtblArray[i1] = 0;
@ -87,7 +88,7 @@ void fftFree(void)
Just make sure fftlib has been called for each M first.
**************************************************/
void ffts(double *data, long M, long Rows)
void ffts(double *data, int M, int Rows)
{
/* Compute in-place complex fft on the rows of the input array */
/* INPUTS */
@ -99,7 +100,7 @@ void ffts(double *data, long M, long Rows)
ffts1(data, M, Rows, UtblArray[M], BRLowArray[M/2]);
}
void iffts(double *data, long M, long Rows)
void iffts(double *data, int M, int Rows)
{
/* Compute in-place inverse complex fft on the rows of the input array */
/* INPUTS */
@ -111,7 +112,7 @@ void iffts(double *data, long M, long Rows)
iffts1(data, M, Rows, UtblArray[M], BRLowArray[M/2]);
}
void rffts(double *data, long M, long Rows)
void rffts(double *data, int M, int Rows)
{
/* Compute in-place real fft on the rows of the input array */
/* The result is the complex spectra of the positive frequencies */
@ -128,7 +129,7 @@ void rffts(double *data, long M, long Rows)
rffts1(data, M, Rows, UtblArray[M], BRLowArray[(M-1)/2]);
}
void riffts(double *data, long M, long Rows)
void riffts(double *data, int M, int Rows)
{
/* Compute in-place real ifft on the rows of the input array */
/* data order as from rffts */
@ -142,7 +143,7 @@ void riffts(double *data, long M, long Rows)
riffts1(data, M, Rows, UtblArray[M], BRLowArray[(M-1)/2]);
}
void rspectprod(double *data1, double *data2, double *outdata, long N)
void rspectprod(double *data1, double *data2, double *outdata, int N)
{
// When multiplying a pair of spectra from rfft care must be taken to multiply the
// two real values seperately from the complex ones. This routine does it correctly.

252
src/maths/fft/fftlib.c
View File

@ -3,7 +3,7 @@ lower level fft stuff including routines called in fftext.c and fft2d.c
*******************************************************************/
#include "fftlib.h"
#include <math.h>
#define MCACHE (11-(sizeof(double)/8)) // fft's with M bigger than this bust primary cache
#define MCACHE (11-(int)(sizeof(double)/8)) // fft's with M bigger than this bust primary cache
// some math constants to 40 decimal places
#define MYPI 3.141592653589793238462643383279502884197 // pi
@ -20,7 +20,7 @@ lower level fft stuff including routines called in fftext.c and fft2d.c
routines to initialize tables used by fft routines
**************************************************/
void fftCosInit(long M, double *Utbl)
void fftCosInit(int M, double *Utbl)
{
/* Compute Utbl, the cosine table for ffts */
/* of size (pow(2,M)/4 +1) */
@ -28,15 +28,15 @@ void fftCosInit(long M, double *Utbl)
/* M = log2 of fft size */
/* OUTPUTS */
/* *Utbl = cosine table */
unsigned long fftN = POW2(M);
unsigned long i1;
int fftN = POW2(M);
int i1;
Utbl[0] = 1.0;
for (i1 = 1; i1 < fftN/4; i1++)
Utbl[i1] = cos( (2.0 * MYPI * i1) / fftN );
Utbl[fftN/4] = 0.0;
}
void fftBRInit(long M, short *BRLow)
void fftBRInit(int M, short *BRLow)
{
/* Compute BRLow, the bit reversed table for ffts */
/* of size pow(2,M/2 -1) */
@ -44,19 +44,19 @@ void fftBRInit(long M, short *BRLow)
/* M = log2 of fft size */
/* OUTPUTS */
/* *BRLow = bit reversed counter table */
long Mroot_1 = M / 2 - 1;
long Nroot_1 = POW2(Mroot_1);
long i1;
long bitsum;
long bitmask;
long bit;
int Mroot_1 = M / 2 - 1;
int Nroot_1 = POW2(Mroot_1);
int i1;
int bitsum;
int bitmask;
int bit;
for (i1 = 0; i1 < Nroot_1; i1++) {
bitsum = 0;
bitmask = 1;
for (bit=1; bit <= Mroot_1; bitmask<<=1, bit++)
if (i1 & bitmask)
bitsum = bitsum + (Nroot_1 >> bit);
BRLow[i1] = bitsum;
BRLow[i1] = (short) bitsum;
};
}
@ -64,8 +64,8 @@ void fftBRInit(long M, short *BRLow)
parts of ffts1
*************************************************/
static inline void bitrevR2(double *ioptr, long M, short *BRLow);
static inline void bitrevR2(double *ioptr, long M, short *BRLow)
static inline void bitrevR2(double *ioptr, int M, short *BRLow);
static inline void bitrevR2(double *ioptr, int M, short *BRLow)
{
/*** bit reverse and first radix 2 stage of forward or inverse fft ***/
double f0r;
@ -92,17 +92,17 @@ static inline void bitrevR2(double *ioptr, long M, short *BRLow)
double *p1r;
double *IOP;
double *iolimit;
long Colstart;
long iCol;
unsigned long posA;
unsigned long posAi;
unsigned long posB;
unsigned long posBi;
const unsigned long Nrems2 = POW2((M+3)/2);
const unsigned long Nroot_1_ColInc = POW2(M)-Nrems2;
const unsigned long Nroot_1 = POW2(M/2-1)-1;
const unsigned long ColstartShift = (M+1)/2 +1;
int Colstart;
int iCol;
int posA;
int posAi;
int posB;
int posBi;
const int Nrems2 = POW2((M+3)/2);
const int Nroot_1_ColInc = POW2(M)-Nrems2;
const int Nroot_1 = POW2(M/2-1)-1;
const int ColstartShift = (M+1)/2 +1;
posA = POW2(M); // 1/2 of POW2(M) complexes
posAi = posA + 1;
posB = posA + 2;
@ -410,16 +410,16 @@ static inline void fft8pt(double *ioptr)
ioptr[15] = f6i;
}
static inline void bfR2(double *ioptr, long M, long NDiffU);
static inline void bfR2(double *ioptr, long M, long NDiffU)
static inline void bfR2(double *ioptr, int M, int NDiffU);
static inline void bfR2(double *ioptr, int M, int NDiffU)
{
/*** 2nd radix 2 stage ***/
unsigned long pos;
unsigned long posi;
unsigned long pinc;
unsigned long pnext;
unsigned long NSameU;
unsigned long SameUCnt;
int pos;
int posi;
int pinc;
int pnext;
int NSameU;
int SameUCnt;
double *pstrt;
double *p0r, *p1r, *p2r, *p3r;
@ -520,17 +520,17 @@ static inline void bfR2(double *ioptr, long M, long NDiffU)
}
}
static inline void bfR4(double *ioptr, long M, long NDiffU);
static inline void bfR4(double *ioptr, long M, long NDiffU)
static inline void bfR4(double *ioptr, int M, int NDiffU);
static inline void bfR4(double *ioptr, int M, int NDiffU)
{
/*** 1 radix 4 stage ***/
unsigned long pos;
unsigned long posi;
unsigned long pinc;
unsigned long pnext;
unsigned long pnexti;
unsigned long NSameU;
unsigned long SameUCnt;
int pos;
int posi;
int pinc;
int pnext;
int pnexti;
int NSameU;
int SameUCnt;
double *pstrt;
double *p0r, *p1r, *p2r, *p3r;
@ -730,21 +730,21 @@ static inline void bfR4(double *ioptr, long M, long NDiffU)
}
static inline void bfstages(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, long StageCnt);
static inline void bfstages(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, long StageCnt)
static inline void bfstages(double *ioptr, int M, double *Utbl, int Ustride, int NDiffU, int StageCnt);
static inline void bfstages(double *ioptr, int M, double *Utbl, int Ustride, int NDiffU, int StageCnt)
{
/*** RADIX 8 Stages ***/
unsigned long pos;
unsigned long posi;
unsigned long pinc;
unsigned long pnext;
unsigned long NSameU;
unsigned long Uinc;
unsigned long Uinc2;
unsigned long Uinc4;
unsigned long DiffUCnt;
unsigned long SameUCnt;
unsigned long U2toU3;
int pos;
int posi;
int pinc;
int pnext;
int NSameU;
int Uinc;
int Uinc2;
int Uinc4;
int DiffUCnt;
int SameUCnt;
int U2toU3;
double *pstrt;
double *p0r, *p1r, *p2r, *p3r;
@ -1052,11 +1052,11 @@ static inline void bfstages(double *ioptr, long M, double *Utbl, long Ustride, l
}
}
void fftrecurs(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, long StageCnt);
void fftrecurs(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, long StageCnt)
void fftrecurs(double *ioptr, int M, double *Utbl, int Ustride, int NDiffU, int StageCnt);
void fftrecurs(double *ioptr, int M, double *Utbl, int Ustride, int NDiffU, int StageCnt)
{
/* recursive bfstages calls to maximize on chip cache efficiency */
long i1;
int i1;
if (M <= MCACHE) // fits on chip ?
bfstages(ioptr, M, Utbl, Ustride, NDiffU, StageCnt); /* RADIX 8 Stages */
else {
@ -1067,7 +1067,7 @@ void fftrecurs(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, l
}
}
void ffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
void ffts1(double *ioptr, int M, int Rows, double *Utbl, short *BRLow)
{
/* Compute in-place complex fft on the rows of the input array */
/* INPUTS */
@ -1079,8 +1079,8 @@ void ffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
/* OUTPUTS */
/* *ioptr = output data array */
long StageCnt;
long NDiffU;
int StageCnt;
int NDiffU;
switch (M) {
case 0:
@ -1137,8 +1137,8 @@ void ffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
parts of iffts1
*************************************************/
static inline void scbitrevR2(double *ioptr, long M, short *BRLow, double scale);
static inline void scbitrevR2(double *ioptr, long M, short *BRLow, double scale)
static inline void scbitrevR2(double *ioptr, int M, short *BRLow, double scale);
static inline void scbitrevR2(double *ioptr, int M, short *BRLow, double scale)
{
/*** scaled bit reverse and first radix 2 stage forward or inverse fft ***/
double f0r;
@ -1165,17 +1165,17 @@ static inline void scbitrevR2(double *ioptr, long M, short *BRLow, double scale)
double *p1r;
double *IOP;
double *iolimit;
long Colstart;
long iCol;
unsigned long posA;
unsigned long posAi;
unsigned long posB;
unsigned long posBi;
const unsigned long Nrems2 = POW2((M+3)/2);
const unsigned long Nroot_1_ColInc = POW2(M)-Nrems2;
const unsigned long Nroot_1 = POW2(M/2-1)-1;
const unsigned long ColstartShift = (M+1)/2 +1;
int Colstart;
int iCol;
int posA;
int posAi;
int posB;
int posBi;
const int Nrems2 = POW2((M+3)/2);
const int Nroot_1_ColInc = POW2(M)-Nrems2;
const int Nroot_1 = POW2(M/2-1)-1;
const int ColstartShift = (M+1)/2 +1;
posA = POW2(M); // 1/2 of POW2(M) complexes
posAi = posA + 1;
posB = posA + 2;
@ -1483,16 +1483,16 @@ static inline void ifft8pt(double *ioptr, double scale)
ioptr[15] = scale*f6i;
}
static inline void ibfR2(double *ioptr, long M, long NDiffU);
static inline void ibfR2(double *ioptr, long M, long NDiffU)
static inline void ibfR2(double *ioptr, int M, int NDiffU);
static inline void ibfR2(double *ioptr, int M, int NDiffU)
{
/*** 2nd radix 2 stage ***/
unsigned long pos;
unsigned long posi;
unsigned long pinc;
unsigned long pnext;
unsigned long NSameU;
unsigned long SameUCnt;
int pos;
int posi;
int pinc;
int pnext;
int NSameU;
int SameUCnt;
double *pstrt;
double *p0r, *p1r, *p2r, *p3r;
@ -1593,17 +1593,17 @@ static inline void ibfR2(double *ioptr, long M, long NDiffU)
}
}
static inline void ibfR4(double *ioptr, long M, long NDiffU);
static inline void ibfR4(double *ioptr, long M, long NDiffU)
static inline void ibfR4(double *ioptr, int M, int NDiffU);
static inline void ibfR4(double *ioptr, int M, int NDiffU)
{
/*** 1 radix 4 stage ***/
unsigned long pos;
unsigned long posi;
unsigned long pinc;
unsigned long pnext;
unsigned long pnexti;
unsigned long NSameU;
unsigned long SameUCnt;
int pos;
int posi;
int pinc;
int pnext;
int pnexti;
int NSameU;
int SameUCnt;
double *pstrt;
double *p0r, *p1r, *p2r, *p3r;
@ -1803,21 +1803,21 @@ static inline void ibfR4(double *ioptr, long M, long NDiffU)
}
static inline void ibfstages(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, long StageCnt);
static inline void ibfstages(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, long StageCnt)
static inline void ibfstages(double *ioptr, int M, double *Utbl, int Ustride, int NDiffU, int StageCnt);
static inline void ibfstages(double *ioptr, int M, double *Utbl, int Ustride, int NDiffU, int StageCnt)
{
/*** RADIX 8 Stages ***/
unsigned long pos;
unsigned long posi;
unsigned long pinc;
unsigned long pnext;
unsigned long NSameU;
unsigned long Uinc;
unsigned long Uinc2;
unsigned long Uinc4;
unsigned long DiffUCnt;
unsigned long SameUCnt;
unsigned long U2toU3;
int pos;
int posi;
int pinc;
int pnext;
int NSameU;
int Uinc;
int Uinc2;
int Uinc4;
int DiffUCnt;
int SameUCnt;
int U2toU3;
double *pstrt;
double *p0r, *p1r, *p2r, *p3r;
@ -2128,11 +2128,11 @@ static inline void ibfstages(double *ioptr, long M, double *Utbl, long Ustride,
}
}
void ifftrecurs(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, long StageCnt);
void ifftrecurs(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU, long StageCnt)
void ifftrecurs(double *ioptr, int M, double *Utbl, int Ustride, int NDiffU, int StageCnt);
void ifftrecurs(double *ioptr, int M, double *Utbl, int Ustride, int NDiffU, int StageCnt)
{
/* recursive bfstages calls to maximize on chip cache efficiency */
long i1;
int i1;
if (M <= MCACHE)
ibfstages(ioptr, M, Utbl, Ustride, NDiffU, StageCnt); /* RADIX 8 Stages */
else {
@ -2143,7 +2143,7 @@ void ifftrecurs(double *ioptr, long M, double *Utbl, long Ustride, long NDiffU,
}
}
void iffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
void iffts1(double *ioptr, int M, int Rows, double *Utbl, short *BRLow)
{
/* Compute in-place inverse complex fft on the rows of the input array */
/* INPUTS */
@ -2155,8 +2155,8 @@ void iffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
/* OUTPUTS */
/* *ioptr = output data array */
long StageCnt;
long NDiffU;
int StageCnt;
int NDiffU;
const double scale = 1.0/POW2(M);
switch (M) {
@ -2502,14 +2502,14 @@ static inline void rfft8pt(double *ioptr)
ioptr[15] = scale*f6i;
}
static inline void frstage(double *ioptr, long M, double *Utbl);
static inline void frstage(double *ioptr, long M, double *Utbl)
static inline void frstage(double *ioptr, int M, double *Utbl);
static inline void frstage(double *ioptr, int M, double *Utbl)
{
/* Finish RFFT */
unsigned long pos;
unsigned long posi;
unsigned long diffUcnt;
int pos;
int posi;
int diffUcnt;
double *p0r, *p1r;
double *u0r, *u0i;
@ -2629,7 +2629,7 @@ static inline void frstage(double *ioptr, long M, double *Utbl)
};
}
void rffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
void rffts1(double *ioptr, int M, int Rows, double *Utbl, short *BRLow)
{
/* Compute in-place real fft on the rows of the input array */
/* The result is the complex spectra of the positive frequencies */
@ -2646,8 +2646,8 @@ void rffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
/* Re(x[0]), Re(x[N/2]), Re(x[1]), Im(x[1]), Re(x[2]), Im(x[2]), ... Re(x[N/2-1]), Im(x[N/2-1]). */
double scale;
long StageCnt;
long NDiffU;
int StageCnt;
int NDiffU;
M=M-1;
switch (M) {
@ -2999,14 +2999,14 @@ static inline void rifft8pt(double *ioptr, double scale)
ioptr[15] = scale*f6i;
}
static inline void ifrstage(double *ioptr, long M, double *Utbl);
static inline void ifrstage(double *ioptr, long M, double *Utbl)
static inline void ifrstage(double *ioptr, int M, double *Utbl);
static inline void ifrstage(double *ioptr, int M, double *Utbl)
{
/* Start RIFFT */
unsigned long pos;
unsigned long posi;
unsigned long diffUcnt;
int pos;
int posi;
int diffUcnt;
double *p0r, *p1r;
double *u0r, *u0i;
@ -3126,7 +3126,7 @@ static inline void ifrstage(double *ioptr, long M, double *Utbl)
};
}
void riffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
void riffts1(double *ioptr, int M, int Rows, double *Utbl, short *BRLow)
{
/* Compute in-place real ifft on the rows of the input array */
/* data order as from rffts1 */
@ -3141,8 +3141,8 @@ void riffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow)
/* *ioptr = real output data array */
double scale;
long StageCnt;
long NDiffU;
int StageCnt;
int NDiffU;
scale = 1.0/POW2(M);
M=M-1;

16
src/maths/fft/fftlib.h
View File

@ -1,14 +1,14 @@
#define MYRECIPLN2 1.442695040888963407359924681001892137426 // 1.0/log(2)
/* some useful conversions between a number and its power of 2 */
#define LOG2(a) (MYRECIPLN2*log(a)) // doubleing point logarithm base 2
#define POW2(m) ((unsigned long) 1 << (m)) // integer power of 2 for m<32
#define LOG2(a) (MYRECIPLN2*log(a)) // floating point logarithm base 2
#define POW2(m) (1 << (m)) // integer power of 2 for m<32
/*******************************************************************
lower level fft stuff called by routines in fftext.c and fft2d.c
*******************************************************************/
void fftCosInit(long M, double *Utbl);
void fftCosInit(int M, double *Utbl);
/* Compute Utbl, the cosine table for ffts */
/* of size (pow(2,M)/4 +1) */
/* INPUTS */
@ -16,7 +16,7 @@ void fftCosInit(long M, double *Utbl);
/* OUTPUTS */
/* *Utbl = cosine table */
void fftBRInit(long M, short *BRLow);
void fftBRInit(int M, short *BRLow);
/* Compute BRLow, the bit reversed table for ffts */
/* of size pow(2,M/2 -1) */
/* INPUTS */
@ -24,7 +24,7 @@ void fftBRInit(long M, short *BRLow);
/* OUTPUTS */
/* *BRLow = bit reversed counter table */
void ffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow);
void ffts1(double *ioptr, int M, int Rows, double *Utbl, short *BRLow);
/* Compute in-place complex fft on the rows of the input array */
/* INPUTS */
/* *ioptr = input data array */
@ -35,7 +35,7 @@ void ffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow);
/* OUTPUTS */
/* *ioptr = output data array */
void iffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow);
void iffts1(double *ioptr, int M, int Rows, double *Utbl, short *BRLow);
/* Compute in-place inverse complex fft on the rows of the input array */
/* INPUTS */
/* *ioptr = input data array */
@ -46,7 +46,7 @@ void iffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow);
/* OUTPUTS */
/* *ioptr = output data array */
void rffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow);
void rffts1(double *ioptr, int M, int Rows, double *Utbl, short *BRLow);
/* Compute in-place real fft on the rows of the input array */
/* The result is the complex spectra of the positive frequencies */
/* except the location for the first complex number contains the real */
@ -62,7 +62,7 @@ void rffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow);
/* Re(x[0]), Re(x[N/2]), Re(x[1]), Im(x[1]), Re(x[2]), Im(x[2]), ... Re(x[N/2-1]), Im(x[N/2-1]). */
void riffts1(double *ioptr, long M, long Rows, double *Utbl, short *BRLow);
void riffts1(double *ioptr, int M, int Rows, double *Utbl, short *BRLow);
/* Compute in-place real ifft on the rows of the input array */
/* data order as from rffts1 */
/* INPUTS */

5
src/spicelib/devices/isrc/isrcacct.c
View File

@ -16,6 +16,8 @@ extern int fftInit(long M);
extern void fftFree(void);
extern void rffts(float *data, long M, long Rows);
extern bool ft_ngdebug; /* some additional debug info printed */
#define SAMETIME(a,b) (fabs((a)-(b))<= TIMETOL * PW)
#define TIMETOL 1e-7
@ -197,7 +199,8 @@ ISRCaccept(CKTcircuit *ckt, GENmodel *inModel)
/* FIXME, dont' want this here, over to aof_get or somesuch */
if (ckt->CKTtime == 0.0) {
printf("VSRC: free fft tables\n");
if (ft_ngdebug)
printf("VSRC: free fft tables\n");
fftFree();
}

5
src/spicelib/devices/vsrc/vsrcacct.c
View File

@ -16,6 +16,8 @@ extern int fftInit(long M);
extern void fftFree(void);
extern void rffts(float *data, long M, long Rows);
extern bool ft_ngdebug; /* some additional debug info printed */
#define SAMETIME(a,b) (fabs((a)-(b))<= TIMETOL * PW)
#define TIMETOL 1e-7
@ -197,7 +199,8 @@ VSRCaccept(CKTcircuit *ckt, GENmodel *inModel)
/* FIXME, dont' want this here, over to aof_get or somesuch */
if (ckt->CKTtime == 0.0) {
printf("VSRC: free fft tables\n");
if(ft_ngdebug)
printf("VSRC: free fft tables\n");
fftFree();
}

Write Preview
Loading…
Cancel
Save