nrutil.c
上传用户:szb0815
上传日期:2007-06-13
资源大小:338k
文件大小:8k
源码类别:

生物技术

开发平台:

C++ Builder

  1. /* CAUTION: This is the ANSI C (only) version of the Numerical Recipes
  2.    utility file nrutil.c.  Do not confuse this file with the same-named
  3.    file nrutil.c that is supplied in the 'misc' subdirectory.
  4.    *That* file is the one from the book, and contains both ANSI and
  5.    traditional K&R versions, along with #ifdef macros to select the
  6.    correct version.  *This* file contains only ANSI C.               */
  7. #include <stdio.h>
  8. #include <stddef.h>
  9. #include <stdlib.h>
  10. #define NR_END 1
  11. #define FREE_ARG char*
  12. void nrerror(char error_text[])
  13. /* Numerical Recipes standard error handler */
  14. {
  15. fprintf(stderr,"Numerical Recipes run-time error...n");
  16. fprintf(stderr,"%sn",error_text);
  17. fprintf(stderr,"...now exiting to system...n");
  18. exit(1);
  19. }
  20. float *vector(long nl, long nh)
  21. /* allocate a float vector with subscript range v[nl..nh] */
  22. {
  23. float *v;
  24. v=(float *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(float)));
  25. if (!v) nrerror("allocation failure in vector()");
  26. return v-nl+NR_END;
  27. }
  28. int *ivector(long nl, long nh)
  29. /* allocate an int vector with subscript range v[nl..nh] */
  30. {
  31. int *v;
  32. v=(int *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(int)));
  33. if (!v) nrerror("allocation failure in ivector()");
  34. return v-nl+NR_END;
  35. }
  36. unsigned char *cvector(long nl, long nh)
  37. /* allocate an unsigned char vector with subscript range v[nl..nh] */
  38. {
  39. unsigned char *v;
  40. v=(unsigned char *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(unsigned char)));
  41. if (!v) nrerror("allocation failure in cvector()");
  42. return v-nl+NR_END;
  43. }
  44. unsigned long *lvector(long nl, long nh)
  45. /* allocate an unsigned long vector with subscript range v[nl..nh] */
  46. {
  47. unsigned long *v;
  48. v=(unsigned long *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(long)));
  49. if (!v) nrerror("allocation failure in lvector()");
  50. return v-nl+NR_END;
  51. }
  52. float *dvector(long nl, long nh)
  53. /* allocate a float vector with subscript range v[nl..nh] */
  54. {
  55. float *v;
  56. v=(float *)malloc((size_t) ((nh-nl+1+NR_END)*sizeof(float)));
  57. if (!v) nrerror("allocation failure in dvector()");
  58. return v-nl+NR_END;
  59. }
  60. float **matrix(long nrl, long nrh, long ncl, long nch)
  61. /* allocate a float matrix with subscript range m[nrl..nrh][ncl..nch] */
  62. {
  63. long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
  64. float **m;
  65. /* allocate pointers to rows */
  66. m=(float **) malloc((size_t)((nrow+NR_END)*sizeof(float*)));
  67. if (!m) nrerror("allocation failure 1 in matrix()");
  68. m += NR_END;
  69. m -= nrl;
  70. /* allocate rows and set pointers to them */
  71. m[nrl]=(float *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(float)));
  72. if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
  73. m[nrl] += NR_END;
  74. m[nrl] -= ncl;
  75. for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
  76. /* return pointer to array of pointers to rows */
  77. return m;
  78. }
  79. float **dmatrix(long nrl, long nrh, long ncl, long nch)
  80. /* allocate a float matrix with subscript range m[nrl..nrh][ncl..nch] */
  81. {
  82. long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
  83. float **m;
  84. /* allocate pointers to rows */
  85. m=(float **) malloc((size_t)((nrow+NR_END)*sizeof(float*)));
  86. if (!m) nrerror("allocation failure 1 in matrix()");
  87. m += NR_END;
  88. m -= nrl;
  89. /* allocate rows and set pointers to them */
  90. m[nrl]=(float *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(float)));
  91. if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
  92. m[nrl] += NR_END;
  93. m[nrl] -= ncl;
  94. for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
  95. /* return pointer to array of pointers to rows */
  96. return m;
  97. }
  98. int **imatrix(long nrl, long nrh, long ncl, long nch)
  99. /* allocate a int matrix with subscript range m[nrl..nrh][ncl..nch] */
  100. {
  101. long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
  102. int **m;
  103. /* allocate pointers to rows */
  104. m=(int **) malloc((size_t)((nrow+NR_END)*sizeof(int*)));
  105. if (!m) nrerror("allocation failure 1 in matrix()");
  106. m += NR_END;
  107. m -= nrl;
  108. /* allocate rows and set pointers to them */
  109. m[nrl]=(int *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(int)));
  110. if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
  111. m[nrl] += NR_END;
  112. m[nrl] -= ncl;
  113. for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
  114. /* return pointer to array of pointers to rows */
  115. return m;
  116. }
  117. float **submatrix(float **a, long oldrl, long oldrh, long oldcl, long oldch,
  118. long newrl, long newcl)
  119. /* point a submatrix [newrl..][newcl..] to a[oldrl..oldrh][oldcl..oldch] */
  120. {
  121. long i,j,nrow=oldrh-oldrl+1,ncol=oldcl-newcl;
  122. float **m;
  123. /* allocate array of pointers to rows */
  124. m=(float **) malloc((size_t) ((nrow+NR_END)*sizeof(float*)));
  125. if (!m) nrerror("allocation failure in submatrix()");
  126. m += NR_END;
  127. m -= newrl;
  128. /* set pointers to rows */
  129. for(i=oldrl,j=newrl;i<=oldrh;i++,j++) m[j]=a[i]+ncol;
  130. /* return pointer to array of pointers to rows */
  131. return m;
  132. }
  133. float **convert_matrix(float *a, long nrl, long nrh, long ncl, long nch)
  134. /* allocate a float matrix m[nrl..nrh][ncl..nch] that points to the matrix
  135. declared in the standard C manner as a[nrow][ncol], where nrow=nrh-nrl+1
  136. and ncol=nch-ncl+1. The routine should be called with the address
  137. &a[0][0] as the first argument. */
  138. {
  139. long i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1;
  140. float **m;
  141. /* allocate pointers to rows */
  142. m=(float **) malloc((size_t) ((nrow+NR_END)*sizeof(float*)));
  143. if (!m) nrerror("allocation failure in convert_matrix()");
  144. m += NR_END;
  145. m -= nrl;
  146. /* set pointers to rows */
  147. m[nrl]=a-ncl;
  148. for(i=1,j=nrl+1;i<nrow;i++,j++) m[j]=m[j-1]+ncol;
  149. /* return pointer to array of pointers to rows */
  150. return m;
  151. }
  152. float ***f3tensor(long nrl, long nrh, long ncl, long nch, long ndl, long ndh)
  153. /* allocate a float 3tensor with range t[nrl..nrh][ncl..nch][ndl..ndh] */
  154. {
  155. long i,j,nrow=nrh-nrl+1,ncol=nch-ncl+1,ndep=ndh-ndl+1;
  156. float ***t;
  157. /* allocate pointers to pointers to rows */
  158. t=(float ***) malloc((size_t)((nrow+NR_END)*sizeof(float**)));
  159. if (!t) nrerror("allocation failure 1 in f3tensor()");
  160. t += NR_END;
  161. t -= nrl;
  162. /* allocate pointers to rows and set pointers to them */
  163. t[nrl]=(float **) malloc((size_t)((nrow*ncol+NR_END)*sizeof(float*)));
  164. if (!t[nrl]) nrerror("allocation failure 2 in f3tensor()");
  165. t[nrl] += NR_END;
  166. t[nrl] -= ncl;
  167. /* allocate rows and set pointers to them */
  168. t[nrl][ncl]=(float *) malloc((size_t)((nrow*ncol*ndep+NR_END)*sizeof(float)));
  169. if (!t[nrl][ncl]) nrerror("allocation failure 3 in f3tensor()");
  170. t[nrl][ncl] += NR_END;
  171. t[nrl][ncl] -= ndl;
  172. for(j=ncl+1;j<=nch;j++) t[nrl][j]=t[nrl][j-1]+ndep;
  173. for(i=nrl+1;i<=nrh;i++) {
  174. t[i]=t[i-1]+ncol;
  175. t[i][ncl]=t[i-1][ncl]+ncol*ndep;
  176. for(j=ncl+1;j<=nch;j++) t[i][j]=t[i][j-1]+ndep;
  177. }
  178. /* return pointer to array of pointers to rows */
  179. return t;
  180. }
  181. void free_vector(float *v, long nl, long nh)
  182. /* free a float vector allocated with vector() */
  183. {
  184. free((FREE_ARG) (v+nl-NR_END));
  185. }
  186. void free_ivector(int *v, long nl, long nh)
  187. /* free an int vector allocated with ivector() */
  188. {
  189. free((FREE_ARG) (v+nl-NR_END));
  190. }
  191. void free_cvector(unsigned char *v, long nl, long nh)
  192. /* free an unsigned char vector allocated with cvector() */
  193. {
  194. free((FREE_ARG) (v+nl-NR_END));
  195. }
  196. void free_lvector(unsigned long *v, long nl, long nh)
  197. /* free an unsigned long vector allocated with lvector() */
  198. {
  199. free((FREE_ARG) (v+nl-NR_END));
  200. }
  201. void free_dvector(float *v, long nl, long nh)
  202. /* free a float vector allocated with dvector() */
  203. {
  204. free((FREE_ARG) (v+nl-NR_END));
  205. }
  206. void free_matrix(float **m, long nrl, long nrh, long ncl, long nch)
  207. /* free a float matrix allocated by matrix() */
  208. {
  209. free((FREE_ARG) (m[nrl]+ncl-NR_END));
  210. free((FREE_ARG) (m+nrl-NR_END));
  211. }
  212. void free_dmatrix(float **m, long nrl, long nrh, long ncl, long nch)
  213. /* free a float matrix allocated by dmatrix() */
  214. {
  215. free((FREE_ARG) (m[nrl]+ncl-NR_END));
  216. free((FREE_ARG) (m+nrl-NR_END));
  217. }
  218. void free_imatrix(int **m, long nrl, long nrh, long ncl, long nch)
  219. /* free an int matrix allocated by imatrix() */
  220. {
  221. free((FREE_ARG) (m[nrl]+ncl-NR_END));
  222. free((FREE_ARG) (m+nrl-NR_END));
  223. }
  224. void free_submatrix(float **b, long nrl, long nrh, long ncl, long nch)
  225. /* free a submatrix allocated by submatrix() */
  226. {
  227. free((FREE_ARG) (b+nrl-NR_END));
  228. }
  229. void free_convert_matrix(float **b, long nrl, long nrh, long ncl, long nch)
  230. /* free a matrix allocated by convert_matrix() */
  231. {
  232. free((FREE_ARG) (b+nrl-NR_END));
  233. }
  234. void free_f3tensor(float ***t, long nrl, long nrh, long ncl, long nch,
  235. long ndl, long ndh)
  236. /* free a float f3tensor allocated by f3tensor() */
  237. {
  238. free((FREE_ARG) (t[nrl][ncl]+ndl-NR_END));
  239. free((FREE_ARG) (t[nrl]+ncl-NR_END));
  240. free((FREE_ARG) (t+nrl-NR_END));
  241. }