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

生物技术

开发平台:

C/C++

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