home *** CD-ROM | disk | FTP | other *** search
/ Boston 2 / boston-2.iso / DOS / PROGRAM / C / CUG / PROGS.C < prev    next >
Text File  |  1993-12-01  |  6KB  |  335 lines
  1. /* EXAMPLE OF I/O STATEMENTS */
  2. #include "bc.h"
  3. main() {
  4. char *S = "STRING", *FLNAME = "TDAT.G";
  5. int A = 234, B = 678;
  6. if((fp1=fopen( "DATA.TST", "w"))==0){puts("can't open #1");exit(1);}
  7. fprintf(fp1, "%s %d %d", S, A, B);
  8. fclose(fp1);
  9. if((fp1=fopen( "DATA.TST", "r"))==0){puts("can't open #1");exit(1);}
  10. IEOF = fscanf(fp1, "%s %d %d", S, &A, &B);
  11. fclose(fp1);
  12. printf("%s %d %d \n", S, A, B);
  13. LIST(FLNAME);
  14. }/* IOEX*/
  15.  
  16. LIST(FILENAME)
  17. char *FILENAME;
  18. {
  19. char C;
  20. if((fp4=fopen( FILENAME, "r"))==0){puts("can't open #4");exit(1);}
  21. while((C = getc(fp4)) != EOF) {
  22.   putchar(C);
  23. }/*WH*/
  24. fclose(fp4);
  25. }/* LIST*/
  26.  
  27. /* ERATOSTHENES SIEVE */
  28. #include "bc.h"
  29. #define SIZE 8190
  30. main() {
  31. int ITER, COUNT, I, K;
  32. int PRIME, FLAG[8191];
  33. printf("10 ITERATIONS \n");
  34. for(ITER = 1; ITER <= 10; ITER++) {
  35.   COUNT = 0;
  36.   for(I = 0; I <= SIZE; I++) {
  37.     FLAG[I] = 1;
  38.   }/*I*/
  39.   for(I = 0; I <= SIZE; I++) {
  40.     if(FLAG[I] != 0) {
  41.       PRIME = I+I+3;
  42.       K = I + PRIME;
  43.       while(K <= SIZE) {
  44.         FLAG[K] = 0;
  45.         K = K + PRIME;
  46.       }/*WH*/
  47.       COUNT++;
  48.     }/*IF*/
  49.   }/*I*/
  50. }/*ITER*/
  51. printf(" %d PRIMES \n", COUNT);
  52. }/* SIEVE*/
  53.  
  54. /* EIGHT QUEENS CHESS PROBLEM */
  55. #include "bc.h"
  56. int COLFREE[8], X[8];
  57. int UPFREE[15], DOWNFREE[15];
  58. int R, K;
  59. main() {
  60. /* INITIALIZE EMPTY BOARD */
  61. for(K = 0; K <= 7; K++) {
  62.   COLFREE[K] = TRUE;
  63. }/*K*/
  64. for(K = 0; K <= 14; K++) {
  65.   UPFREE[K] = DOWNFREE[K] = TRUE;
  66. }/*K*/
  67. R = -1;
  68. ADDQUEEN();
  69. }/* QUEEN8*/
  70.  
  71. ADDQUEEN()
  72. {
  73. int C;
  74. R++;
  75. for(C = 0; C <= 7; C++) {
  76.   /* IS SQUARE[R,C] FREE? */
  77.   if(COLFREE[C] && UPFREE[R-C+7] && DOWNFREE[R+C]) {
  78.     /* SET QUEEN ON SQUARE[R,C] */
  79.     X[R] = C;
  80.     COLFREE[C] = UPFREE[R-C+7] = DOWNFREE[R+C] = FALSE;
  81.     if(R == 7) {
  82.       printf("\n CONFIGURATION \n");
  83.       for(K = 0; K <= 7; K++) {
  84.         printf(" %d", X[K]);
  85.       }/*K*/
  86.       exit(1);
  87.     ELSE ADDQUEEN();
  88.     }/*IF*/
  89.     /* REMOVE QUEEN FROM SQUARE[R,C)] */
  90.     COLFREE[C] = UPFREE[R-C+7] = DOWNFREE[R+C] = TRUE;
  91.   }/*IF*/
  92. }/*C*/
  93. R--;
  94. }/* ADDQUEEN*/
  95.  
  96. /* PRODUCT OF TWO MATRICES OF VARIABLE DIMENSIONS */
  97. #include "bc.h"
  98. #define DLIM 21
  99. main() {
  100. double A[DLIM][DLIM], B[DLIM][DLIM], C[DLIM][DLIM];
  101. int I,J,K, N1,N2,N3;
  102. printf("DIMENSIONS = ");
  103. IEOF = scanf("%d %d %d", &N1, &N2, &N3);
  104. /* GENERATE MATRICES */
  105. for(J = 1; J <= N2; J++) {
  106.   for(I = 1; I <= N1; I++) {
  107.     A[I][J] = (double)(J-I);
  108.   }/*I*/
  109.   for(K = 1; K <= N3; K++) {
  110.     B[J][K] = (double)(J+K);
  111.   }/*K*/
  112. }/*J*/
  113. MATPRI(A,N1,N2);
  114. MATPRI(B,N2,N3);
  115. MULT(A,B,C,N1,N2,N3);
  116. MATPRI(C,N1,N3);
  117. }/* MAIN*/
  118.  
  119. MULT(E,F,G, L1,L2,L3)
  120. double E[DLIM][DLIM], F[DLIM][DLIM], G[DLIM][DLIM];
  121. int L1, L2, L3;
  122. {
  123. int I,J,K;
  124. for(I = 1; I <= L1; I++) {
  125.   for(K = 1; K <= L3; K++) {
  126.     G[I][K] = 0;
  127.     for(J = 1; J <= L2; J++) {
  128.       G[I][K] = G[I][K]+E[I][J]*F[J][K];
  129.     }/*J*/
  130.   }/*K*/
  131. }/*I*/
  132. }/* MULT*/
  133.  
  134. MATPRI(A, L1,L2)
  135. double A[DLIM][DLIM]; int L1, L2;
  136. {
  137. int I,J;
  138. printf("\n");
  139. for(I = 1; I <= L1; I++) {
  140.   for(J = 1; J <= L2; J++) {
  141.     printf("%8.3f", A[I][J]);
  142.   }/*J*/
  143.   printf("\n");
  144. }/*I*/
  145. }/* MATPRI*/
  146.  
  147. /* EXAMPLE USING CONDITIONAL STATEMENTS */
  148. #include "bc.h"
  149. main() {
  150. char  *S = "@$^&*+";
  151. int I;
  152. for(I = 1; I <= 5; I++) {
  153.   if(S[I] == '@') {
  154.     printf("@");
  155.   } else if {
  156.     printf("$");
  157.   } else if {
  158.     printf("^");
  159.   } else {
  160.     printf("NO MATCH");
  161.   }/*IF*/
  162. }/*I*/
  163. }/* CONDIT*/
  164.  
  165. /* TOWERS OF HANOI */
  166. #include "bc.h"
  167. #define NDISK 64
  168. main() {
  169. MOVE(NDISK, 1, 3, 2);
  170. }/* HANOI*/
  171.  
  172. MOVE(N, A, B, C)
  173. int N, A, B, C;
  174. {
  175. if(N > 0) {
  176.   MOVE(N-1, A, C, B);
  177.   printf("MOVE A DISK FROM %d TO %d \n", A, B);
  178.   MOVE(N-1, C, B, A);
  179. }/*IF*/
  180. }/* MOVE*/
  181.  
  182. /* INVERSE AND DETERMINANT OF SYMMETRIC MATRIX */
  183. #include "bc.h"
  184. #define DLIM 31
  185. main() {
  186. double A[DLIM][DLIM],R[DLIM][DLIM],DET,SINV();
  187. int I,J,ND;
  188. printf("ND = ");
  189. IEOF = scanf("%d", &ND);
  190. /* GENERATE ND X ND MATRIX */
  191. for(I = 1; I <= ND; I++) {
  192.   for(J = 1; J <= ND; J++) {
  193.     A[I][J]=1.;
  194.   }/*J*/
  195.   A[I][I]=2.;
  196. }/*I*/
  197. MATPRI(A,ND,ND);
  198. DET=SINV(A,R,ND);
  199. MATPRI(R,ND,ND);
  200. printf("%10.3f\n", DET);
  201. }/*MAIN*/
  202.  
  203. double SINV(A,R,NN)
  204. double A[DLIM][DLIM], R[DLIM][DLIM];
  205. int NN;
  206. {
  207. double VEC[DLIM],DET,RL;
  208. int I,J,K,L;
  209. DET=A[1][1];
  210. R[1][1]=1./A[1][1];
  211. for(L = 2; L <= NN; L++) {
  212.   K=L-1;
  213.   RL=A[L][L];
  214.   for(I = 1; I <= K; I++) {
  215.     VEC[I]=0.;
  216.     for(J = 1; J <= K; J++) {
  217.       VEC[I]=VEC[I]+R[I][J]*A[L][J];
  218.     }/*J*/
  219.     RL=RL-A[L][I]*VEC[I];
  220.   }/*I*/
  221.   DET=DET*RL;
  222.   for(I = 1; I <= K; I++) {
  223.     R[L][I]=-VEC[I]/RL;
  224.     R[I][L]=R[L][I];
  225.   }/*I*/
  226.   for(I = 1; I <= K; I++) {
  227.     for(J = I; J <= K; J++) {
  228.       R[I][J]=R[I][J]-VEC[I]*R[L][J];
  229.       R[J][I]=R[I][J];
  230.     }/*J*/
  231.   }/*I*/
  232.   R[L][L]=1./RL;
  233. }/*L*/
  234. return(DET);
  235. }/* SINV*/
  236.  
  237. /* SHELL-METZNER SORT */
  238. #include "bc.h"
  239. #define DLIM 101
  240. #define NN 20
  241. main() {
  242. int X[DLIM];
  243. /* GENERATE VECTOR */
  244. for(I = 1; I <= N; I++) {
  245.   X[I] = N-I+1;
  246. }/*I*/
  247. PRVEC(X,L);
  248. SZSORT(X,L);
  249. PRVEC(X,L);
  250. }/* SORT*/
  251.  
  252. SZSORT(X,N)
  253. int X,N;
  254. {
  255. int KT,TP,I,J, K = 1;
  256. while(K < N) {
  257.   K = 2*K;
  258. }/*WH*/
  259. K = K/2 - 1;
  260. while(K >= 1) {
  261.   KT=1;
  262.   while(KT > 0) {
  263.     J = K;
  264.     KT = 0;
  265.     for(I = 1; I <= N; I++) {
  266.       J++;
  267.       if(J <= N && X[I] > X[J]) {
  268.         TP=X[I];X[I]=X[J];X[J]=TP;
  269.         KT++;
  270.       }/*IF*/
  271.     }/*I*/
  272.   }/*WH*/
  273.   K = K/2;
  274. }/*WH*/
  275. }/* SZSORT*/
  276.  
  277. PRVEC(A,LL)
  278. int A[], LL;
  279. {
  280. int I;
  281. printf("\n");
  282. for(I = 1; I <= LL; I++) {
  283.   printf(" %d ", A[I]);
  284. }/*I*/
  285. printf("\n");
  286. return;
  287. }/* PRVEC*/
  288.  
  289. /* FIBONACCI NUMBERS */
  290. #include "bc.h"
  291. main() {
  292. int  N;
  293. printf("N = ");
  294. IEOF = scanf("%d", &N);
  295. printf("FIBON = %d\n", FIB(N));
  296. }/* FIBNUM*/
  297.  
  298. int FIB(K)
  299. int K;
  300. {
  301. if(K <= 2) {
  302.   return(1);
  303. } else {
  304.   return(FIB(K-1) + FIB(K-2));
  305. }/*IF*/
  306. }/* FIB*/
  307.  
  308. /* ZERO OF FUNCTION BY NEWTON'S METHOD */
  309. #include "bc.h"
  310. main() {
  311. int NMAX=20;
  312. double TOL=1.0E-6, X0, X, NEWT();
  313. X0 = 2;
  314. X = NEWT(X0,TOL,NMAX);
  315. printf("%f \n", X);
  316. }/* NEWTON*/
  317.  
  318. double NEWT(X0,TOL,NMAX)
  319. double X0,TOL; int NMAX;
  320. {
  321. double FN(), DFN(), fabs(), X, INC;
  322. int I, N;
  323. X = X0;
  324. for(I = 1; I <= NMAX; I++) {
  325.   INC = -FN(X)/DFN(X);
  326.   X = X + INC;
  327.   if(fabs(INC) < TOL) {
  328.     return(X);
  329.   }/*IF*/
  330. }/*I*/
  331. printf("NO CONVERGENCE");
  332. exit(1);
  333. }/* NEWT*/
  334.  
  335.