nrutil.c File Reference

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include "NR.h"

Go to the source code of this file.

Macros
#define	NR_END   1
#define	FREE_ARG   char *

Functions
void	nrerror (const char error_text[])
float *	fvector (long nl, long nh)
int *	ivector (long nl, long nh)
unsigned char *	cvector (long nl, long nh)
unsigned long *	lvector (long nl, long nh)
double *	dvector (long nl, long nh)
float **	fmatrix (long nrl, long nrh, long ncl, long nch)
double **	dmatrix (long nrl, long nrh, long ncl, long nch)
int **	imatrix (long nrl, long nrh, long ncl, long nch)
float **	submatrix (float **a, long oldrl, long oldrh, long oldcl, long, long newrl, long newcl)
float **	convert_matrix (float *a, long nrl, long nrh, long ncl, long nch)
float ***	f3tensor (long nrl, long nrh, long ncl, long nch, long ndl, long ndh)
double ***	d3tensor (long nrl, long nrh, long ncl, long nch, long ndl, long ndh)
double ****	d4tensor (long nrl, long nrh, long ncl, long nch, long ndl, long ndh, long nwl, long nwh)
void	free_fvector (float *v, long nl, long)
void	free_ivector (int *v, long nl, long)
void	free_cvector (unsigned char *v, long nl, long)
void	free_lvector (unsigned long *v, long nl, long)
void	free_dvector (double *v, long nl, long)
void	free_fmatrix (float **m, long nrl, long, long ncl, long)
void	free_dmatrix (double **m, long nrl, long, long ncl, long)
void	free_imatrix (int **m, long nrl, long, long ncl, long)
void	free_submatrix (float **b, long nrl, long, long, long)
void	free_convert_matrix (float **b, long nrl, long, long, long)
void	free_f3tensor (float ***t, long nrl, long, long ncl, long, long ndl, long)
void	free_d3tensor (double ***t, long nrl, long, long ncl, long, long ndl, long)
void	free_d4tensor (double ****t, long nrl, long, long ncl, long, long ndl, long, long nwl, long)

Macro Definition Documentation

FREE_ARG

#define FREE_ARG   char *

Definition at line 8 of file nrutil.c.

Referenced by free_convert_matrix(), free_cvector(), free_d3tensor(), free_d4tensor(), free_dmatrix(), free_dvector(), free_f3tensor(), free_fmatrix(), free_fvector(), free_imatrix(), free_ivector(), free_lvector(), and free_submatrix().

NR_END

#define NR_END   1

Definition at line 7 of file nrutil.c.

Referenced by convert_matrix(), cvector(), d3tensor(), d4tensor(), dmatrix(), dvector(), f3tensor(), fmatrix(), free_convert_matrix(), free_cvector(), free_d3tensor(), free_d4tensor(), free_dmatrix(), free_dvector(), free_f3tensor(), free_fmatrix(), free_fvector(), free_imatrix(), free_ivector(), free_lvector(), free_submatrix(), fvector(), imatrix(), ivector(), lvector(), and submatrix().

Function Documentation

convert_matrix()

float ** convert_matrix	(	float *	a,
		long	nrl,
		long	nrh,
		long	ncl,
		long	nch )

Definition at line 166 of file nrutil.c.

{
  long i, j, nrow = nrh - nrl + 1, ncol = nch - ncl + 1;
  float **m;
 
  /* allocate pointers to rows */
  m = (float **)malloc((size_t)((nrow + NR_END) * sizeof(float *)));
  if (!m) nrerror(" allocation failure in convert_matrix()");
  m += NR_END;
  m -= nrl;
 
  /*set pointers to rows */
  m[nrl] = a - ncl;
  for (i = 1, j = nrl + 1; i < nrow; i++, j++) m[j] = m[j - 1] + ncol;
  /* return pointer to array of pointers to rows */
  return m;
}

cvector()

unsigned char * cvector	(	long	nl,
		long	nh )

Definition at line 43 of file nrutil.c.

{
  unsigned char *v;
 
  v = (unsigned char *)malloc(
      (size_t)((nh - nl + 1 + NR_END) * sizeof(unsigned char)));
  if (!v) nrerror("allocation failure in cvector()");
  return v - nl + NR_END;
}

d3tensor()

double *** d3tensor	(	long	nrl,
		long	nrh,
		long	ncl,
		long	nch,
		long	ndl,
		long	ndh )

Definition at line 223 of file nrutil.c.

{
  long i, j, nrow = nrh - nrl + 1, ncol = nch - ncl + 1, ndep = ndh - ndl + 1;
  double ***t;
 
  /* allocate pointers to pointers to rows */
  t = (double ***)malloc((size_t)((nrow + NR_END) * sizeof(double **)));
  if (!t) nrerror("allocation failure 1 in d3tensor()");
  t += NR_END;
  t -= nrl;
 
  /* allocate pointers to rows and set pointers to them */
  t[nrl] =
      (double **)malloc((size_t)((nrow * ncol + NR_END) * sizeof(double *)));
  if (!t[nrl]) nrerror("allocation failure 2 in d3tensor()");
  t[nrl] += NR_END;
  t[nrl] -= ncl;
 
  /* allocate rows and set pointers to them */
  t[nrl][ncl] = (double *)malloc(
      (size_t)((nrow * ncol * ndep + NR_END) * sizeof(double)));
  if (!t[nrl][ncl]) nrerror("allocation failure 3 in d3tensor()");
  t[nrl][ncl] += NR_END;
  t[nrl][ncl] -= ndl;
 
  for (j = ncl + 1; j <= nch; j++) t[nrl][j] = t[nrl][j - 1] + ndep;
  for (i = nrl + 1; i <= nrh; i++) {
    t[i] = t[i - 1] + ncol;
    t[i][ncl] = t[i - 1][ncl] + ncol * ndep;
    for (j = ncl + 1; j <= nch; j++) t[i][j] = t[i][j - 1] + ndep;
  }
  /* return pointer to array of pointers to rows */
  return t;
}

d4tensor()

double **** d4tensor	(	long	nrl,
		long	nrh,
		long	ncl,
		long	nch,
		long	ndl,
		long	ndh,
		long	nwl,
		long	nwh )

Definition at line 261 of file nrutil.c.

{
  long i, j, k, nrow = nrh - nrl + 1, ncol = nch - ncl + 1,
                ndep = ndh - ndl + 1, nwid = nwh - nwl + 1;
  double ****t;
 
  // allocate pointers to pointers to pointers to rows
  t = (double ****)malloc((size_t)((nrow + NR_END) * sizeof(double ***)));
  if (!t) nrerror("allocation failure 1 in d4tensor()");
  t += NR_END;
  t -= nrl;
 
  // allocate pointers to pointers to rows and set pointers to them
  t[nrl] =
      (double ***)malloc((size_t)((nrow * ncol + NR_END) * sizeof(double **)));
  if (!t[nrl]) nrerror("allocation failure 2 in d4tensor()");
  t[nrl] += NR_END;
  t[nrl] -= ncl;
 
  // allocate pointers to rows and set pointers to them
  t[nrl][ncl] = (double **)malloc(
      (size_t)((nrow * ncol * ndep + NR_END) * sizeof(double *)));
  if (!t[nrl][ncl]) nrerror("allocation failure 3 in d4tensor()");
  t[nrl][ncl] += NR_END;
  t[nrl][ncl] -= ndl;
 
  // allocate rows and set pointers to them
  t[nrl][ncl][ndl] = (double *)malloc(
      (size_t)((nrow * ncol * ndep * nwid + NR_END) * sizeof(double)));
  if (!t[nrl][ncl][ndl]) nrerror("allocation failure 4 in d4tensor()");
  t[nrl][ncl][ndl] += NR_END;
  t[nrl][ncl][ndl] -= nwl;
 
  for (i = nrl; i <= nrh; i++) {
    if (i > nrl) {
      t[i] = t[i - 1] + ncol;
      t[i][ncl] = t[i - 1][ncl] + ncol * ndep;
      t[i][ncl][ndl] = t[i - 1][ncl][ndl] + ncol * ndep * nwid;
    }
    for (j = ncl; j <= nch; j++) {
      if (j > ncl) {
        t[i][j] = t[i][j - 1] + ndep;
        t[i][j][ndl] = t[i][j - 1][ndl] + ndep * nwid;
      }
 
      for (k = ndl; k <= ndh; k++) {
        if (k > ndl) t[i][j][k] = t[i][j][k - 1] + nwid;
      }
    }
  }
 
  // return pointer to pointer to array of pointers to rows
  return t;
}

Referenced by neBEMPrepareWeightingField(), and neBEMSolve().

dmatrix()

double ** dmatrix	(	long	nrl,
		long	nrh,
		long	ncl,
		long	nch )

Definition at line 98 of file nrutil.c.

{
  long i, nrow = nrh - nrl + 1, ncol = nch - ncl + 1;
  double **m;
 
  /* allocate pointer to row */
  m = (double **)malloc((size_t)((nrow + NR_END) * sizeof(double *)));
  if (!m) nrerror("allocation faliore 1 in matrix()");
  m += NR_END;
  m -= nrl;
 
  /* allocate row and set pointer to them */
  m[nrl] = (double *)malloc((size_t)((nrow * ncol + NR_END) * sizeof(double)));
  if (!m[nrl]) nrerror("allocation faliore 2 in matrix()");
  m[nrl] += NR_END;
  m[nrl] -= ncl;
 
  for (i = nrl + 1; i <= nrh; i++) m[i] = m[i - 1] + ncol;
 
  /* return pointer to array of pointer to rows */
  return m;
}

Referenced by InvertMatrix(), LHMatrix(), neBEMReadGeometry(), ReadInvertedMatrix(), ReadPrimitives(), and Solve().

dvector()

double * dvector	(	long	nl,
		long	nh )

Definition at line 64 of file nrutil.c.

{
  double *v;
 
  v = (double *)malloc((size_t)((nh - nl + 1 + NR_END) * sizeof(double)));
  if (!v) nrerror("allocation failure in dvector()");
  return v - nl + NR_END;
}

Referenced by ElePFAtPoint(), InvertMatrix(), ludcmp(), MapFPR(), neBEMInitialize(), neBEMPrepareWeightingField(), neBEMReadGeometry(), ReadPrimitives(), RHVector(), Solve(), svdcmp(), VoxelFPR(), and WtFldPFAtPoint().

f3tensor()

float *** f3tensor	(	long	nrl,
		long	nrh,
		long	ncl,
		long	nch,
		long	ndl,
		long	ndh )

Definition at line 188 of file nrutil.c.

{
  long i, j, nrow = nrh - nrl + 1, ncol = nch - ncl + 1, ndep = ndh - ndl + 1;
  float ***t;
 
  /* allocate pointers to pointers to rows */
  t = (float ***)malloc((size_t)((nrow + NR_END) * sizeof(float **)));
  if (!t) nrerror("allocation failure 1 in f3tensor()");
  t += NR_END;
  t -= nrl;
 
  /* allocate pointers to rows and set pointers to them */
  t[nrl] = (float **)malloc((size_t)((nrow * ncol + NR_END) * sizeof(float *)));
  if (!t[nrl]) nrerror("allocation failure 2 in f3tensor()");
  t[nrl] += NR_END;
  t[nrl] -= ncl;
 
  /* allocate rows and set pointers to them */
  t[nrl][ncl] =
      (float *)malloc((size_t)((nrow * ncol * ndep + NR_END) * sizeof(float)));
  if (!t[nrl][ncl]) nrerror("allocation failure 3 in f3tensor()");
  t[nrl][ncl] += NR_END;
  t[nrl][ncl] -= ndl;
 
  for (j = ncl + 1; j <= nch; j++) t[nrl][j] = t[nrl][j - 1] + ndep;
  for (i = nrl + 1; i <= nrh; i++) {
    t[i] = t[i - 1] + ncol;
    t[i][ncl] = t[i - 1][ncl] + ncol * ndep;
    for (j = ncl + 1; j <= nch; j++) t[i][j] = t[i][j - 1] + ndep;
  }
  /* return pointer to array of pointers to rows */
  return t;
}

fmatrix()

float ** fmatrix	(	long	nrl,
		long	nrh,
		long	ncl,
		long	nch )

Definition at line 74 of file nrutil.c.

{
  long i, nrow = nrh - nrl + 1, ncol = nch - ncl + 1;
  float **m;
 
  /* allocate pointers to rows */
  m = (float **)malloc((size_t)((nrow + NR_END) * sizeof(float *)));
  if (!m) nrerror("allocation failure 1 in matrix()");
  m += NR_END;
  m -= nrl;
 
  /* allocate rows and set pointers to them */
  m[nrl] = (float *)malloc((size_t)((nrow * ncol + NR_END) * sizeof(float)));
  if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
  m[nrl] += NR_END;
  m[nrl] -= ncl;
 
  for (i = nrl + 1; i <= nrh; i++) m[i] = m[i - 1] + ncol;
 
  /* return pointer to array of pointer to rows */
  return m;
}

free_convert_matrix()

void free_convert_matrix	(	float **	b,
		long	nrl,
		long	,
		long	,
		long	)

Definition at line 500 of file nrutil.c.

                                 {
  free((FREE_ARG)(b + nrl - NR_END));
}

free_cvector()

void free_cvector	(	unsigned char *	v,
		long	nl,
		long	)

Definition at line 461 of file nrutil.c.

                                                     {
  free((FREE_ARG)(v + nl - NR_END));
}

free_d3tensor()

void free_d3tensor	(	double ***	t,
		long	nrl,
		long	,
		long	ncl,
		long	,
		long	ndl,
		long	)

Definition at line 514 of file nrutil.c.

                                     {
  free((FREE_ARG)(t[nrl][ncl] + ndl - NR_END));
  free((FREE_ARG)(t[nrl] + ncl - NR_END));
  free((FREE_ARG)(t + nrl - NR_END));
}

free_d4tensor()

void free_d4tensor	(	double ****	t,
		long	nrl,
		long	,
		long	ncl,
		long	,
		long	ndl,
		long	,
		long	nwl,
		long	)

Definition at line 523 of file nrutil.c.

                                                       {
  free((FREE_ARG)(t[nrl][ncl][ndl] + nwl - NR_END));
  free((FREE_ARG)(t[nrl][ncl] + ndl - NR_END));
  free((FREE_ARG)(t[nrl] + ncl - NR_END));
  free((FREE_ARG)(t + nrl - NR_END));
}

free_dmatrix()

void free_dmatrix	(	double **	m,
		long	nrl,
		long	,
		long	ncl,
		long	)

Definition at line 482 of file nrutil.c.

                                                                  {
  free((FREE_ARG)(m[nrl] + ncl - NR_END));
  free((FREE_ARG)(m + nrl - NR_END));
}

Referenced by ComputeSolution(), InvertMatrix(), and Solve().

free_dvector()

void free_dvector	(	double *	v,
		long	nl,
		long	)

Definition at line 471 of file nrutil.c.

                                              {
  free((FREE_ARG)(v + nl - NR_END));
}

Referenced by ElePFAtPoint(), InvertMatrix(), ludcmp(), MapFPR(), Solve(), svdcmp(), VoxelFPR(), and WtFldPFAtPoint().

free_f3tensor()

void free_f3tensor	(	float ***	t,
		long	nrl,
		long	,
		long	ncl,
		long	,
		long	ndl,
		long	)

Definition at line 506 of file nrutil.c.

                                     {
  free((FREE_ARG)(t[nrl][ncl] + ndl - NR_END));
  free((FREE_ARG)(t[nrl] + ncl - NR_END));
  free((FREE_ARG)(t + nrl - NR_END));
}

free_fmatrix()

void free_fmatrix	(	float **	m,
		long	nrl,
		long	,
		long	ncl,
		long	)

Definition at line 476 of file nrutil.c.

                                                                 {
  free((FREE_ARG)(m[nrl] + ncl - NR_END));
  free((FREE_ARG)(m + nrl - NR_END));
}

free_fvector()

void free_fvector	(	float *	v,
		long	nl,
		long	)

Definition at line 451 of file nrutil.c.

                                             {
  free((FREE_ARG)(v + nl - NR_END));
}

free_imatrix()

void free_imatrix	(	int **	m,
		long	nrl,
		long	,
		long	ncl,
		long	)

Definition at line 488 of file nrutil.c.

                                                               {
  free((FREE_ARG)(m[nrl] + ncl - NR_END));
  free((FREE_ARG)(m + nrl - NR_END));
}

free_ivector()

void free_ivector	(	int *	v,
		long	nl,
		long	)

Definition at line 456 of file nrutil.c.

                                           {
  free((FREE_ARG)(v + nl - NR_END));
}

Referenced by InvertMatrix().

free_lvector()

void free_lvector	(	unsigned long *	v,
		long	nl,
		long	)

Definition at line 466 of file nrutil.c.

                                                     {
  free((FREE_ARG)(v + nl - NR_END));
}

free_submatrix()

void free_submatrix	(	float **	b,
		long	nrl,
		long	,
		long	,
		long	)

Definition at line 494 of file nrutil.c.

                            {
  free((FREE_ARG)(b + nrl - NR_END));
}

fvector()

float * fvector	(	long	nl,
		long	nh )

Definition at line 23 of file nrutil.c.

{
  float *v;
 
  v = (float *)malloc((size_t)((nh - nl + 1 + NR_END) * sizeof(float)));
  if (!v) nrerror("allocation failure in vector()");
  return v - nl + NR_END;
}

imatrix()

int ** imatrix	(	long	nrl,
		long	nrh,
		long	ncl,
		long	nch )

Definition at line 122 of file nrutil.c.

{
  long i, nrow = nrh - nrl + 1, ncol = nch - ncl + 1;
  int **m;
 
  /* allocate pointer to row */
  m = (int **)malloc((size_t)((nrow + NR_END) * sizeof(int *)));
  if (!m) nrerror("allocation faliore 1 in matrix()");
  m += NR_END;
  m -= nrl;
 
  /* allocate row and set pointer to them */
  m[nrl] = (int *)malloc((size_t)((nrow * ncol + NR_END) * sizeof(int)));
  if (!m[nrl]) nrerror("allocation falior 2 in matrix()");
  m[nrl] += NR_END;
  m[nrl] -= ncl;
 
  for (i = nrl + 1; i <= nrh; i++) m[i] = m[i - 1] + ncol;
 
  /* return pointer to array of pointer to rows */
  return m;
}

Referenced by neBEMReadGeometry().

ivector()

int * ivector	(	long	nl,
		long	nh )

Definition at line 33 of file nrutil.c.

{
  int *v;
 
  v = (int *)malloc((size_t)((nh - nl + 1 + NR_END) * sizeof(int)));
  if (!v) nrerror("allocation failure in ivector()");
  return v - nl + NR_END;
}

Referenced by InvertMatrix(), neBEMInitialize(), neBEMPrepareWeightingField(), neBEMReadGeometry(), and ReadPrimitives().

lvector()

unsigned long * lvector	(	long	nl,
		long	nh )

Definition at line 54 of file nrutil.c.

{
  unsigned long *v;
 
  v = (unsigned long *)malloc((size_t)((nh - nl + 1 + NR_END) * sizeof(long)));
  if (!v) nrerror("allocation failure in lvector()");
  return v - nl + NR_END;
}

nrerror()

void nrerror

(

const char

error_text[]

)

Definition at line 14 of file nrutil.c.

{
  fprintf(stderr, " run_time error......\n");
  fprintf(stderr, "%s\n", error_text);
  fprintf(stderr, ".....now exiting to system.....\n");
  exit(1);
}

submatrix()

float ** submatrix	(	float **	a,
		long	oldrl,
		long	oldrh,
		long	oldcl,
		long	,
		long	newrl,
		long	newcl )

Definition at line 146 of file nrutil.c.

{
  long i, j, nrow = oldrh - oldrl + 1, ncol = oldcl - newcl;
  float **m;
 
  /* allocate array of pointers to rows */
  m = (float **)malloc((size_t)((nrow + NR_END) * sizeof(float *)));
  if (!m) nrerror(" allocation failure in submatrix()");
  m += NR_END;
  m -= newrl;
 
  /*set pointers to rows */
  for (i = oldrl, j = newrl; i <= oldrh; i++, j++) m[j] = a[i] + ncol;
 
  /* return pointer to array of pointers to rows */
  return m;
}