exp 10: init

Signed-off-by: Amneesh Singh <natto@weirdnatto.in>

10.c

@@ -0,0 +1,62 @@
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define EPSILON 0.0000001
+
+double *eigen(double **matrix, int order) {
+  double mxerr = 0;
+  double *prev = calloc(order, sizeof(double));
+  *prev = 1;
+
+  do {
+    double *eigen = calloc(order, sizeof(double));
+
+    for (int i = 0; i < order; i++)
+      for (int j = 0; j < order; j++)
+        eigen[i] += matrix[i][j] * prev[j];
+
+    double mx = fabs(eigen[0]);
+    for (int i = 1; i < order; i++)
+      mx = fabs(eigen[i]) > mx ? fabs(eigen[i]) : mx;
+
+    for (int i = 0; i < order; i++)
+      eigen[i] /= mx;
+
+    double error[order];
+
+    for (int i = 0; i < order; i++)
+      error[i] = fabs(eigen[i] - prev[i]);
+
+    mxerr = error[0];
+    for (int i = 1; i < order; i++)
+      mxerr = error[i] > mxerr ? error[i] : mxerr;
+
+    free(prev);
+    prev = eigen;
+
+  } while (mxerr > EPSILON);
+
+  return prev;
+}
+
+int main() {
+  const int ORDER = 3;
+
+  double **matrix = malloc(ORDER * sizeof(double *));
+  for (int i = 0; i < ORDER; i++)
+    matrix[i] = malloc(ORDER * sizeof(double));
+
+  matrix[0][0] = 21, matrix[0][1] = -99, matrix[0][2] = 0;
+  matrix[1][0] = -12, matrix[1][1] = 64, matrix[1][2] = 0;
+  matrix[2][0] = 9, matrix[2][1] = -0.5, matrix[2][2] = 4;
+
+  double *egn = eigen(matrix, ORDER);
+
+  for (int i = 0; i < ORDER; i++) {
+    printf("%lf ", egn[i]);
+    free(matrix[i]);
+  }
+  free(egn);
+  free(matrix);
+}

file.org

@@ -355,3 +355,131 @@ int main() {
   free(matrix);
 }
 #+end_src
+
+#+LATEX: \clearpage
+
+* Program for finding inverse of linear equations using Gauss Jordan method.
+#+ATTR_LATEX: :options frame=single,breaklines=true
+#+begin_src C  :tangle 9.c :results output :exports both :wrap src text
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+double **inverse(double **matrix, int order) {
+  double **inverse = calloc(order, sizeof(double *));
+  for (int i = 0; i < order; i++) {
+    inverse[i] = calloc(2 * order, sizeof(double));
+    inverse[i][order + i] = 1;
+    memcpy(inverse[i], matrix[i], order * sizeof(double));
+  }
+
+  for (int i = 0; i < order; i++) {
+    for (int j = 0; j < order; j++) {
+      if (i == j)
+        continue;
+      double r = inverse[j][i] / inverse[i][i];
+
+      for (int k = 0; k < order * 2; k++)
+        inverse[j][k] -= r * inverse[i][k];
+    }
+  }
+
+  for (int i = 0; i < order; i++) {
+    for (int j = 0; j < order; j++)
+      inverse[i][j + order] /= inverse[i][i];
+  }
+
+  return inverse;
+}
+
+int main() {
+  const int ORDER = 3;
+
+  double **matrix = malloc(ORDER * sizeof(double *));
+  for (int i = 0; i < ORDER; i++)
+    matrix[i] = malloc(ORDER * sizeof(double));
+
+  matrix[0][0] = 92, matrix[0][1] = 4.5, matrix[0][2] = 61; // 92x + 4.5y + 61z = 0
+  matrix[1][0] = -2, matrix[1][1] = 0, matrix[1][2] = 92387; // -2x + 92387z = 0
+  matrix[2][0] = -2, matrix[2][1] = 0, matrix[2][2] = -23; // -2x - 23z = 0
+
+  double **inv = inverse(matrix, ORDER);
+
+  for (int i = 0; i < ORDER; i++) {
+    for (int j = 0; j < ORDER; j++)
+      printf("%lf ", inv[i][j + ORDER]);
+    printf("\n");
+    free(inv[i]);
+    free(matrix[i]);
+  }
+  free(inv);
+  free(matrix);
+}
+#+end_src
+
+* Program for finding eigen values using power method.
+#+ATTR_LATEX: :options frame=single,breaklines=true
+#+begin_src C  :tangle 10.c :results output :exports both :wrap src text
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#define EPSILON 0.0000001
+
+double *eigen(double **matrix, int order) {
+  double mxerr = 0;
+  double *prev = calloc(order, sizeof(double));
+  *prev = 1;
+
+  do {
+    double *eigen = calloc(order, sizeof(double));
+
+    for (int i = 0; i < order; i++)
+      for (int j = 0; j < order; j++)
+        eigen[i] += matrix[i][j] * prev[j];
+
+    double mx = fabs(eigen[0]);
+    for (int i = 1; i < order; i++)
+      mx = fabs(eigen[i]) > mx ? fabs(eigen[i]) : mx;
+
+    for (int i = 0; i < order; i++)
+      eigen[i] /= mx;
+
+    double error[order];
+
+    for (int i = 0; i < order; i++)
+      error[i] = fabs(eigen[i] - prev[i]);
+
+    mxerr = error[0];
+    for (int i = 1; i < order; i++)
+      mxerr = error[i] > mxerr ? error[i] : mxerr;
+
+    free(prev);
+    prev = eigen;
+
+  } while (mxerr > EPSILON);
+
+  return prev;
+}
+
+int main() {
+  const int ORDER = 3;
+
+  double **matrix = malloc(ORDER * sizeof(double *));
+  for (int i = 0; i < ORDER; i++)
+    matrix[i] = malloc(ORDER * sizeof(double));
+
+  matrix[0][0] = 21, matrix[0][1] = -99, matrix[0][2] = 0;
+  matrix[1][0] = -12, matrix[1][1] = 64, matrix[1][2] = 0;
+  matrix[2][0] = 9, matrix[2][1] = -0.5, matrix[2][2] = 4;
+
+  double *egn = eigen(matrix, ORDER);
+
+  for (int i = 0; i < ORDER; i++) {
+    printf("%lf ", egn[i]);
+    free(matrix[i]);
+  }
+  free(egn);
+  free(matrix);
+}
+#+end_src