
1
2
3
4
5
6#include <stdio.h>

int main(){
    printf("Hello World\n");
    return 0;
}

Hello World


1
2
3
4
5
6#include <stdio.h>

int main(){     
    printf("Hello World!\n"); 
    return 0;
}

Hello World!


1
2
3
4
5#include <stdio.h>

main(){
    printf("Hello World!\n");
}

/tmp/tmpexq2n71l.c: In function ‘main’:
/tmp/tmpexq2n71l.c:6:7: error: expected ‘;’ before ‘{’ token
    6 | main(){
      |       ^
      |       ;
[C kernel] GCC exited with code 1, the executable will not be executed


1
2
3
4int main(){
    printf("Hello World!\n");
    return 0;
}

/tmp/tmpzwdt271q.c: In function ‘main’:
/tmp/tmpzwdt271q.c:2:5: warning: implicit declaration of function ‘printf’ [-Wimplicit-function-declaration]
    2 |     printf("Hello World!\n");
      |     ^~~~~~
/tmp/tmpzwdt271q.c:2:5: warning: incompatible implicit declaration of built-in function ‘printf’
/tmp/tmpzwdt271q.c:1:1: note: include ‘<stdio.h>’ or provide a declaration of ‘printf’
  +++ |+#include <stdio.h>
    1 | int main(){

Hello World!


1
2
3
4
5
6#include <stdio.h>

int main(){
    printf("Hello World!\n")
    return 0;
}

Hello World!


1
2    int x;
    double var;


1
2int x = 0;
double var=3.1415;


1
2
3
4
5
6
7
8
9#include <stdio.h>

int main() {
  int x = 0;

  printf("Input: x=");
  scanf("%d",&x);
  printf("Output: x=%d\n",x);
}

Input: x=4
Output: x=4, 12


1
2
3
4
5
6
7
8
9#include <stdio.h>

int main() {
  double x = 0;

  printf("Input: x=");
  scanf("%lf",&x);
  printf("Output: x=%f\n",x);
}

Input: x=3.1234
Output: x=3.123400


1
2
3
4
5
6
7
8
9#include <stdio.h>

int main() {
  int x = 0;

  printf("Input: x=");
  scanf("%d",x);
  printf("Output: x=%d\n",x);
}

Input: x=3

[C kernel] Executable exited with code -11


1
2
3
4
5
6
7
8
9#include <stdio.h>

int main() {
  double x = 0;

  printf("Input: x=");
  scanf("%f",&x);
  printf("Output: x=%f\n",x);
}

Input: x=3.1415
Output: x=3.141500


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16#include <stdio.h>

int main() {
  int x = 1;
  int y = 2;

  int tmp = 0;

  printf("a) x=%d, y=%d, tmp=%d\n",x,y,tmp);
  
  tmp = x;
  x = y;
  y = tmp;

  printf("b) x=%d, y=%d, tmp=%d\n",x,y,tmp);
}

a) x=1, y=2, tmp=0
b) x=2, y=1, tmp=1


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <stdio.h>

int main() {
  int x = 1;
  double y = 2.8;

  int sum_int = x+y;
  double sum_dbl = x+y;

  printf("sum_int = %d\n",sum_int);
  printf("sum_dbl = %f\n",sum_dbl);
}

sum_int = 3
sum_dbl = 3.800000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15#include <stdio.h>

int main() {
  double dbl1 = 2 / 3;
  double dbl2 = 2 / 3.;
  double dbl3 = 1E2;
  int int1 = 2;
  int int2 = 3;
 
  printf("a) %f\n",dbl1);
  printf("b) %f\n",dbl2);

  printf("c) %f\n",dbl3 * int1 / int2);
  printf("d) %f\n",dbl3 * (int1 / int2) );
}

a) 0.000000
b) 0.666667
c) 66.666667
d) 0.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15#include <stdio.h>

int main() {
  int a = 2;
  int b = 3;
  double dbl1 = a / b;
  double dbl2 = (double) (a / b);
  double dbl3 = (double) a / b;
  double dbl4 = a / (double) b;

  printf("a) %f\n",dbl1);
  printf("b) %f\n",dbl2);
  printf("c) %f\n",dbl3);
  printf("d) %f\n",dbl4);
}

a) 0.000000
b) 0.000000
c) 0.666667
d) 0.666667


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <stdio.h>

int main() {
  int a = 2;
  int b = 3;
  double dbl = (double) a / b;

  int i = dbl;

  printf("a) %f\n",dbl);
  printf("b) %f\n",dbl*b);
  printf("c) %d\n",i);
  printf("d) %d\n",i*b);
}

a) 0.666667
b) 2.000000
c) 0
d) 0


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15#include <stdio.h>

int main() {
  int result = 0;

  int a = 3;
  int b = 2;
  int c = 1;
  
  result = (a > b > c);
  printf("a) result=%d\n",result);

  result = (a > b) && (b > c);
  printf("b) result=%d\n",result);
}

/tmp/tmpl7rt034j.c: In function ‘main’:
/tmp/tmpl7rt034j.c:10:15: warning: comparisons like ‘X<=Y<=Z’ do not have their mathematical meaning [-Wparentheses]
   10 |   result = (a > b > c);
      |             ~~^~~

a) result=0
b) result=1


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15#include <stdio.h>

int main() {
  int x = 0;

  printf("Input x=");
  scanf("%d",&x);

  if (x < 0)
    printf("x=%d is negative\n",x);
  
  if (x > 0) {
    printf("x=%d is positive\n",x);
  }
}

Input x=3
x=3 is positive


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <stdio.h>

int main() {
  int var1 = -5;
  double var2 = 1e-32;
  int var3 = 5;

  if (var1 >= 0) {
    printf("var1 >= 0\n");
  }
  else {
    printf("var1 < 0\n");
  }

  if (var2) {
    printf("var2 != 0, i.e., cond. is true\n");
  }
  else {
    printf("var2 == 0, i.e., cond. is false\n");
  }
  
  if ( (var1 < var2) && (var2 < var3) ) {
    printf("var2 lies between the others\n");
  }
}

var1 < 0
var2 != 0, i.e., cond. is true
var2 lies between the others


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20#include <stdio.h>

int main() {
  int x = 0;

  printf("Input x=");
  scanf("%d",&x);

  if (x > 0) {
    if (x%2 != 0) {
      printf("x=%d is odd\n",x);
    }
    else {
      printf("x=%d is even\n",x);
    }
  }
  else {
    printf("Error: Input has to be positive!\n");
  }
}

Input x=3
x=3 is odd


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <stdio.h>

int main() {
  double x1 = 0;
  double x2 = 0;
  double tmp = 0;

  printf("Unsorted input:\n");
  printf(" x1=");
  scanf("%lf",&x1);
  printf(" x2=");
  scanf("%lf",&x2);
  
  if (x1 > x2) {
    tmp = x1;
    x1 = x2;
    x2 = tmp;
  }
  
  printf("Sorted output (ascending order):\n");
  printf(" x1=%f\n",x1);
  printf(" x2=%f\n",x2);
}

Unsorted input:
 x1=3
 x2=1
Sorted output (ascending order):
 x1=1.000000
 x2=3.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <stdio.h>

int main() {
  double r = 0;
  double x1 = 0;
  double x2 = 0;
  double z1 = 0;
  double z2 = 0;
  double dist2 = 0;

  printf("Radius of the circle: r=");
  scanf("%lf",&r);
  printf("Center of the circle: x = (x1,x2)\n");
  printf(" x1=");
  scanf("%lf",&x1);
  printf(" x2=");
  scanf("%lf",&x2);
  printf("Point in the plane: z = (z1,z2)\n");
  printf(" z1=");
  scanf("%lf",&z1);
  printf(" z2=");
  scanf("%lf",&z2);

  dist2 = (x1-z1)*(x1-z1) + (x2-z2)*(x2-z2);
  if ( dist2 < r*r ) {
      printf("z is inside the circle\n");
  }
  else { 
    if ( dist2 > r*r ) {
      printf("z is outside of the circle\n");
    }
    else {
      printf("z lies on the boundary of the circle\n");
    }
  }
}

Radius of the circle: r=3
Center of the circle: x = (x1,x2)
 x1=0
 x2=0
Point in the plane: z = (z1,z2)
 z1=1
 z2=2
z is inside the circle


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13#include <stdio.h>

int main() {
  int x = 7;
  printf("a) %d\n", x);
  x = 9;
  printf("b) %d\n", x);
  {
    int x = 17;
    printf("c) %d\n", x);
  }
  printf("d) %d\n", x);
}

a) 7
b) 9
c) 17
d) 9


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <stdio.h>

int var0 = 5;

int main() {
  int var1 = 7;
  int var2 = 9;

  printf("a) %d, %d, %d\n", var0, var1, var2);
  {
    int var1 = 17;

    printf("b) %d, %d, %d\n", var0, var1, var2);
    var0 = 15;
    var2 = 19;
    printf("c) %d, %d, %d\n", var0, var1, var2);
    {
      int var0 = 25;
      printf("d) %d, %d, %d\n", var0, var1, var2);
    }
  }
  printf("e) %d, %d, %d\n", var0, var1, var2);
}

a) 5, 7, 9
b) 5, 17, 9
c) 15, 17, 19
d) 25, 17, 19
e) 15, 7, 19


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <stdio.h>

double square(double x) {
  return x*x;
}

int main() {
  double x = 0;
  printf("Input x = ");
  scanf("%lf",&x);
  printf("%f^2 = %f\n",x,square(x));
}

Input x = 3
3.000000^2 = 9.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21#include <stdio.h>

double min(double x, double y) {
  if (x > y) {
    return y;
  }
  else {
    return x;
  }
}

int main() {
  double x = 0;
  double y = 0;
  
  printf("Input x = ");
  scanf("%lf",&x);
  printf("Input y = ");
  scanf("%lf",&y);
  printf("min(x,y) = %f\n",min(x,y));
}

Input x = 3
Input y = 4
min(x,y) = 3.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <stdio.h>

double min(double, double);

int main() {
  double x = 0;
  double y = 0;
  
  printf("Input x = ");
  scanf("%lf",&x);
  printf("Input y = ");
  scanf("%lf",&y);
  printf("min(x,y) = %f\n",min(x,y));
}

double min(double x, double y) {
  if (x > y) {
    return y;
  }
  else {
    return x;
  }
}

Input x = 3
Input y = 4
min(x,y) = 3.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <stdio.h>

void test(int x) {
  printf("a) x=%d\n", x);
  x = 43;
  printf("b) x=%d\n", x);
}

int main() {
  int x = 12;
  printf("c) x=%d\n", x);
  test(x);
  printf("d) x=%d\n", x);
}

c) x=12
a) x=12
b) x=43
d) x=12


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15#include <stdio.h>

double divide(double, double);

int main() {
  int int1 = 2;
  int int2 = 3;
 
  printf("a) %f\n", int1 / int2 );
  printf("b) %f\n", divide(int1,int2));
}

double divide(double dbl1, double dbl2) {
  return(dbl1 / dbl2);
}

a) 0.000000
b) 0.666667


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <stdio.h>

int isEqual(int, int);

int main() {
  double x = 4.1;
  double y = 4.9;
  
  if (isEqual(x,y)) {
      printf("x == y\n");
  }
  else {
      printf("x != y\n");
  }
}

int isEqual(int x, int y) {
  if (x == y) {
    return 1;
  }
  else {
    return 0;
  }
}

x == y


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12#include <stdio.h>

int main() {
  // printf("1 ");
  printf("2 ");
  /*
    printf("3");
    printf("4");
  */
  printf("5");
  printf("\n");
}

2 5


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37// Exercise 0.1 -- how to comment a program
// author: Michael Feischl
// last modified: 11.03.2020

#include <stdio.h>

double min(double, double);

int main() {
  double x = 0;
  double y = 0;

  // read input x
  printf("Input x = ");
  scanf("%lf",&x);
  
  // read input y
  printf("Input y = ");
  scanf("%lf",&y);
  
  // determine and print minimum
  printf("min(x,y) = %f\n",min(x,y));
}

// The function min determines the mininum of two
// double values x and y

double min(double x, double y) {
  if (x > y) {
    // if x > y, then min(x,y) = y
    return y;
  }
  else {
    // otherwise, x <= y and min(x,y) = x
    return x;
  }
}

Input x = 3
Input y = 4
min(x,y) = 3.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31// author: Dirk Praetorius
// last modified: 15.03.2020

#include <stdio.h>

// The Euclidean algorithm to compute the greatest
// common divisor (gcd) is based on gcd(a,b) = gcd(a-b,b)
// for a>b and gcd(a,b) = gcd(b,a).

int euclid(int a, int b) {
  int tmp = 0;

  // iteration gcd(a,b) = gcd(a-b,b), realized
  // using division with remainder, until b = 0.
  // Then, since it was a==b, it holds gcd = a.

  while (b != 0) {
    tmp = a%b;
    a = b;
    b = tmp;
  }

  return a;
}

int main(){
  int a = 200;
  int b = 110;

  printf("gcd(%d,%d)=%d\n",a,b,euclid(a,b));
}

gcd(200,110)=10


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35#include <stdio.h>

// The function factorial computes the factorial
// of a nonnegative integer n recursively

int factorial(int n) {
  if (n <= -1) {
    // factorial not defined for n <= -1
    return -1;
  } 
  else {
    if (n > 1) {
      // recursive step n! = n*(n-1)!
      return n*factorial(n-1);
    }
    else {
      // stopping criterion 0! = 1 = 1!
      return 1;
    }
  }
}

int main() {
  int n = 0;
  int nfac = 0;
  printf("n=");
  scanf("%d",&n);
  nfac = factorial(n);
  if (nfac <= 0) {
    printf("Wrong input!\n");
  }
  else {
    printf("%d!=%d\n",n,nfac);
  }
}

n=5
5!=120


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <stdio.h>

double f(double x) {
  return x*x + 1/(2 + x) - 2;
}

double bisection(double a, double b, double tol){
  double m = 0.5*(a+b);
  if ( b - a <= 2*tol ) {
    return m;
  }
  else {
    if ( f(a)*f(m) <= 0 ) {
      return bisection(a,m,tol);
    }
    else {
      return bisection(m,b,tol);
    }
  }
}

int main() {
  double a = 0;
  double b = 10;
  double tol = 1e-12;
  double x = bisection(a,b,tol);
  
  printf("Approximate zero of the function x=%g\n",x);
  printf("Function value f(x)=%g\n",f(x));  // %g chooses good floating point output
}

Approximate zero of the function x=1.30278
Function value f(x)=-5.64659e-13


1
2
3
4
5
6
7
8#include <stdio.h>
#include <math.h>

int main() {
  double x = 2.;
  double y = sqrt(x);
  printf("sqrt(%f)=%f\n",x,y);
}

sqrt(2.000000)=1.414214


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11#include <stdio.h>

int main() {
  int counter = 9;

  while (counter > 0) {
    printf("%d ",counter);
    counter = counter-1;
  }
  printf("\n");
}

9 8 7 6 5 4 3 2 1


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <stdio.h>

int main() {
  int a = 0;
  int b = 43;

  printf("1) a=%d, b=%d\n",a,b);

  b = a++;
  printf("2) a=%d, b=%d\n",a,b);

  b = ++a;
  printf("3) a=%d, b=%d\n",a,b);
}

1) a=0, b=43
2) a=1, b=0
3) a=2, b=2


 1
 2
 3
 4
 5
 6
 7
 8
 9
10#include <stdio.h>

int main() {
  int counter = 5;

  while (--counter > 0) {
    printf("%d ",counter);
  }
  printf("\n");
}

4 3 2 1


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35#include <stdio.h>
#include <math.h>

double f(double x) {
  return x*x + 1/(2 + x) - 2;
}

double bisection(double a, double b, double tol){
  double fa = f(a);
  double m = 0.5*(a+b);
  double fm = 0;

  while ( b - a > 2*tol ) {
    m = 0.5*(a+b);
    fm = f(m);
    if ( fa*fm <= 0 ) {
      b = m;
    }
    else {
      a = m;
      fa = fm;
    }
  }
  return m;
}

int main() {
  double a = 0;
  double b = 10;
  double tol = 1e-12;
  double x = bisection(a,b,tol);
  
  printf("Approximate zero of the function x=%g\n",x);
  printf("Function value f(x)=%g\n",f(x));
}

Approximate zero of the function x=1.30278
Function value f(x)=-1.99352e-12


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20#include <stdio.h>

int main() {
  int a = 200;
  int b = 110;
  int tmp = 0;

  printf("gcd(%d,%d)=",a,b);
  
  while (a != b) {
    if (a < b) {
      tmp = a;
      a = b;
      b = tmp;
    }
    a = a-b;
  }
  
  printf("%d\n",a);
}

gcd(200,110)=10


1
2
3
4
5
6
7
8while (a != b) {
    if (a < b) {
      tmp = a;
      a = b;
      b = tmp;
    }
    a = a-b;
  }


1
2
3
4
5
6
7
8while (a != 0) {
    if (a < b) {
      tmp = a;
      a = b;
      b = tmp;
    }
    a = a%b;
  }


1
2
3
4
5  while (b != 0) {
    tmp = a%b;
    a = b;
    b = tmp;
  }


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17#include <stdio.h>

int main() {
  int a = 200;
  int b = 110;
  int tmp = 0;

  printf("ggT(%d,%d)=",a,b);

  while (b != 0) {
    tmp = a%b;
    a = b;
    b = tmp;
  }
  
  printf("%d\n",a);
}

ggT(200,110)=10


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11#include <stdio.h>

int main() {
  int counter = 5;

  do {
    printf("%d ",counter);
  }
  while (--counter>0);
  printf("\n");
}

5 4 3 2 1


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <stdio.h>

int main() {
  int x0 = 0;
  int x1 = 1;
  int tmp = 0;
  int c = 0;
  
  printf("c=");
  scanf("%d",&c);
  
  printf("%d %d ",x0,x1);

  do {
    tmp = x0 + x1;
    x0 = x1;
    x1 = tmp;
    printf("%d ",x1);
  }
  while(x1 <= c);

  printf("\n");
}

c=5
0 1 1 2 3 5 8


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <stdio.h>

int main() {
  int a = 200;
  int b = 110;
  int tmp = 0;
  
  printf("gcd(%d,%d)=",a,b);
  
  // Euclidean algorithm with infinite loop + break
  while (1) {
    if (b == 0) {
      break;
    }
    else {
      tmp = a%b;
      a = b;
      b = tmp;
    }
  }
  
  printf("%d\n",a);
}

gcd(200,110)=10


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20#include <stdio.h>
#include <assert.h>

void test(int x, int y) {
  assert(x<y);
  printf("It holds x < y\n");
}

int main() {
  int x = 0;
  int y = 0;
  
  printf("x = ");
  scanf("%d",&x);
  
  printf("y = ");
  scanf("%d",&y);
  
  test(x,y);
}

x = 6
y = 3

tmp0re3hp7h.out: /tmp/tmpdnqxpqyp.c:5: test: Assertion `x<y' failed.
[C kernel] Executable exited with code -6


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#include <stdio.h>
#include <assert.h>
// The Euclidean algorithm to compute the greatest
// common divisor (gcd) is based on gcd(a,b) = gcd(a-b,b)
// for a>b and gcd(a,b) = gcd(b,a).

int euclid(int a, int b) {
  assert(a > 0);
  assert(b > 0);
  int tmp = 0;

  // iteration gcd(a,b) = gcd(a-b,b), realized
  // using division with remainder, until b = 0.
  // Then, since it was a==b, it holds gcd = a.

  while (b != 0) {
    tmp = a%b;
    a = b;
    b = tmp;
  }

  return a;
}

int main(){
    int a=0,b=0;
    printf("Input:\na=");
    scanf("%d",&a);
    printf("b=");
    scanf("%d",&b);
    printf("gcc(%d,%d) = %d\n",a,b,euclid(a,b));
}

Input:
a=7
b=5
gcc(7,5) = 1


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <stdio.h>

int main() {
  double x[3] = {0,0,0};
  
  printf("Read a vector x in R^3 from keyboard:\n");
  
  // read x0
  printf("x_0 = ");
  scanf("%lf",&x[0]);

  // read x1
  printf("x_1 = ");
  scanf("%lf",&x[1]);

  // read x2
  printf("x_2 = ");
  scanf("%lf",&x[2]);

  // print vector (componentwise)
  printf("x = (%f, %f, %f)\n",x[0],x[1],x[2]);
}

Read a vector x in R^3 from keyboard:
x_0 = 3
x_1 = 4
x_2 = 5
x = (3.000000, 4.000000, 5.000000)


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19#include <stdio.h>

void callByReference(double y[3]) {
  printf("a) y = (%f, %f, %f)\n",y[0],y[1],y[2]);
  y[0] = 1;
  y[1] = 2;
  y[2] = 3;
  printf("b) y = (%f, %f, %f)\n",y[0],y[1],y[2]);
}

int main() {
  double x[3] = {0,0,0};
  
  printf("c) x = (%f, %f, %f)\n",x[0],x[1],x[2]);
  
  // function call modifies the coefficients!
  callByReference(x);
  printf("d) x = (%f, %f, %f)\n",x[0],x[1],x[2]);
}

c) x = (0.000000, 0.000000, 0.000000)
a) y = (0.000000, 0.000000, 0.000000)
b) y = (1.000000, 2.000000, 3.000000)
d) x = (1.000000, 2.000000, 3.000000)


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11#include <stdio.h>

int main() {
  int x[3] = {0,1,2};
  
  // this coefficient has no reserved memory!
  x[100] = 43;

  // nevertheless, writing and reading is possible!
  printf("x = (%d, %d, %d), x[%d] = %d\n", x[0],x[1],x[2],100,x[100]);
}

x = (0, 1, 2), x[100] = 43


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11#include <stdio.h>

int main() {
  int j = 0;

  for (j=5; j>0 ; j--) {
    printf("%d ",j);
  }

  printf("\n");
}

5 4 3 2 1


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <stdio.h>

// Read from the keyboard a double vector
// of length dim

void scanVector(double input[], int dim) {
  int j = 0;
  // iterate over all indices of the vector
  for (j=0; j<dim; j++) {
    // initialize j-th coefficient
    input[j] = 0;
    // read j-th coefficient
    printf("%d: ",j);
    scanf("%lf",&input[j]);
  }
}

// Print to the screen a double vector
// of length dim

void printVector(double output[], int dim) {
  int j = 0;
  // iterate over all indices of the vector
  for (j=0; j<dim; j++) {
    // print j-th coefficient
    printf("%f ",output[j]);
  }
  printf("\n");
}

int main() {
  double x[5];
  // recall: call by reference for arrays
  scanVector(x,5);
  printVector(x,5);
}

0: 8
1: 6
2: 5
3: 4
4: 5
8.000000 6.000000 5.000000 4.000000 5.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34#include <stdio.h>
#define DIM 5

void scanVector(double input[], int dim) {
  int j = 0;
  for (j=0; j<dim; j++) {
    input[j] = 0;
    printf("%d: ",j);
    scanf("%lf",&input[j]);
  }
}

// The function returns the minimum of a double vector
// of length dim

double min(double input[], int dim) {
  int j = 0;
  // initial guess: the minimum is located at input[0]
  double minval = input[0];
  // iterate over all entries of the vector
  for (j=1; j<dim; j++) {
    // if a smaller value is found, update minimum
    if (input[j] < minval) {
      minval = input[j];
    }
  }
  return minval;
}

int main() {
  double x[DIM];
  scanVector(x,DIM);
  printf("The minimum of the vector is %f\n", min(x,DIM));
}

0: 3
1: 4
2: 5
3: 6
4: 7
The minimum of the vector is 3.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <stdio.h>

int main() {
  int j = 0;
  int n = 100;

  int sum = 0;

  for (j=1; j<=n; j++) {
    sum = sum+j;
  }

  printf("sum_{j=1}^{%d} j = %d\n",n,sum);
}

sum_{j=1}^{100} j = 5050


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <stdio.h>

int main() {
  int j = 0;
  int n = 5;

  int factorial = 1;

  for (j=1; j<=n; j++) {
    factorial = factorial*j;
  }

  printf("%d! = %d\n",n,factorial);
}

5! = 120


1
2
3
4
5
6 for (j=0; j<M; j++) {
    b[j] = 0;
    for (k=0; k<N; k++) {
      b[j] = b[j] + A[j][k]*x[k];
    }
  }


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14// 2D-Array Speicherung
for (j=0; j<M; j++) {
    b[j] = 0;
    for (k=0; k<N; k++) {
      b[j] = b[j] + A[j][k]*x[k];
    }
  }
// 1D-Array spaltenweise Speicherung
for (j=0; j<M; j++) {
    b[j] = 0;
    for (k=0; k<N; k++) {
      b[j] = b[j] + A[j+k*M]*x[k];
    }
  }


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61#include <stdio.h>
#define DIM 5

// read a double vector of length dim from the keyboard
void scanVector(double input[], int dim);

// print a double vector of length dim to the screen
void printVector(double output[], int dim);

// sort a double vector of length dim in ascending order
void minsort(double vector[], int dim);

int main() {
  double x[DIM];
  scanVector(x,DIM);
  minsort(x,DIM);
  printVector(x,DIM);
}

void scanVector(double input[], int dim) {
  int j = 0;
  for (j=0; j<dim; j++) {
    input[j] = 0;
    printf("%d: ",j);
    scanf("%lf",&input[j]);
  }
}

void printVector(double output[], int dim) {
  int j = 0;
  for (j=0; j<dim; j++) {
    printf("%f ",output[j]);
  }
  printf("\n");
}

void minsort(double vector[], int dim) {
  int j = 0;
  int k = 0;
  int argmin = 0;
  double tmp = 0;
  
  // iterate over all indices of the vector
  for (j=0; j<dim-1; j++) {
    // determine minimum in (vector[j],...,vector[dim-1])
    // initial guess: minimum is located at vector[j]
    argmin = j;
    for (k=j+1; k<dim; k++) {
      if (vector[argmin] > vector[k]) {
        argmin = k;
      }
    }
    // now vector[argmin] is minimum in the remainder
    // if needed, swap with j so that vector[j] is mininum
    if (argmin > j) {
      tmp = vector[argmin];
      vector[argmin] = vector[j];
      vector[j] = tmp;
    }
  }
}

0: 3
1: 4
2: 5
3: 6
4: 7
3.000000 4.000000 5.000000 6.000000 7.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20#include <stdio.h>

int main() {
  int j = 0;
  int k = 0;
  
  for (j=0; j<4; ++j) {
    if (j%2 == 0) {
      continue;
    }
    for (k=0; k < 10; ++k) {
      printf("j=%d, k=%d\n",j,k);
      if (k > 1) {
        break;
      }
    }
  }
  printf("End: j=%d, k=%d\n",j,k);

}

j=1, k=0
j=1, k=1
j=1, k=2
j=3, k=0
j=3, k=1
j=3, k=2
End: j=4, k=2


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13double maximum(double vector[], int n) {
  int i = 0;
  double max = 0;
  
  max = vector[0];
  for (i=1; i<n; i++) {
    if (vector[i] > max) {
      max = vector[i];
    }
  }
  
  return max;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12void MVM(double A[], double x[], double b[],
         int m, int n) {
  int i = 0;
  int j = 0;

  for (j=0; j<m; j++) {
    b[j] = 0;
    for (k=0; k<n; k++) {
      b[j] = b[j] + A[j+k*m]*x[k];
    }
  }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12int search(int vector[], int value, int n) {

  int j = 0;
  
  for (j=0; j<n; j++) {
    if (vector[j] == value) {
      return j;
    }
  }

  return -1;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21int binsearch(int vector[], int value, int n) {

  int j = 0;
  int start = 0;
  int end = n-1;

  while (start <= end) {
    j = 0.5*(end + start);
    if (vector[j] == value) {
      return j;
    }
    else if (vector[j] > value) {
      end = j-1;
    }
    else {
      start = j+1;
    }
  }

  return -1;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20void minsort(int vector[], int n) {
  int j = 0;
  int k = 0;
  int argmin = 0;
  double tmp = 0;

  for (j=0; j<n-1; j++) {
    argmin = j;
    for (k=j+1; k<n; k++) {
      if (vector[argmin] > vector[k]) {
        argmin = k;
      }
    }
    if (argmin > j) {
      tmp = vector[argmin];
      vector[argmin] = vector[j];
      vector[j] = tmp;
    }
  }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73//%cflags:-I data/
//ACHTUNG: Zeile 1 ist nur fuer die korrekte Funktion des interaktiven Skriptums noetig
// include some libraries
#include <stdio.h>
#include <math.h>
#include <time.h>

// include library for dynamic storage allocation
// see line 27-29 below
#include <stdlib.h>

// define minimal and maximal problem size
#define NMIN (int)1e3
#define NMAX (int)1e6

// declaration of codes from previous slides
#include "aufwand_search.c"
#include "aufwand_binsearch.c"
#include "aufwand_minsort.c"

int main() {
  int n = NMIN;
  int j = 0;
  int tmp=0;
  clock_t start = 0;
  clock_t runtime = 0;
  clock_t previous_runtime = 0;

 // allocate dynamic vector ==> int vector[NMAX];
  printf("*** allocate integer vector, length=%d\n",NMAX);
  int* vector = malloc(NMAX*sizeof(int));
 
  // initialize vector with deterministic data
  printf("*** initialize vector\n");
  for (j=0; j<NMAX; ++j) {
    vector[j] = j;
  }
  
  /*
    // alternative: initialize vector with random numbers
    srand(time(NULL));
    // fill the vector with non-negative random numbers
    printf("*** generate random numbers\n");
    for (j=0; j<NMAX; ++j) {
      vector[j] = rand();
    }
  */
  
  // print the runtime for various vector lengths
  printf("*** determine computing times\n");
  for (n = NMIN; n <= NMAX; n = 2*n) {
    // save start time, call function, determine runtime
    start = clock();
    
     tmp = search(vector,-1,n); // linear complexity
    //tmp = binsearch(vector,-1,n); // logarithmic compl.
    //minsort(vector,n); // quadratic complexity
    
    runtime = clock() - start;
    
    // print runtime (and relative increase of runtime)
    if (n == NMIN) {
      printf("n=%d, runtime=%1.2f\n",n,
             (double) runtime/CLOCKS_PER_SEC);
    }
    else {
      printf("n=%d, runtime=%1.2f, factor=%1.2f\n",
             n, (double) runtime/CLOCKS_PER_SEC,
             (double) runtime/previous_runtime);
    }
    previous_runtime = runtime;
  }
}

/tmp/tmpr2qorgxe.c: In function ‘main’:
/tmp/tmpr2qorgxe.c:24:7: warning: variable ‘tmp’ set but not used [-Wunused-but-set-variable]
   24 |   int tmp=0;
      |       ^~~

*** allocate integer vector, length=1000000
*** initialize vector
*** determine computing times
n=1000, runtime=0.00
n=2000, runtime=0.00, factor=1.20
n=4000, runtime=0.00, factor=1.83
n=8000, runtime=0.00, factor=1.91
n=16000, runtime=0.00, factor=1.90
n=32000, runtime=0.00, factor=2.10
n=64000, runtime=0.00, factor=1.99
n=128000, runtime=0.00, factor=2.02
n=256000, runtime=0.00, factor=2.04
n=512000, runtime=0.00, factor=2.00


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20#include <stdio.h>

int main() {
  int var = 1;
  int* ptr = &var;

  printf("a) var = %d, *ptr = %d\n",var,*ptr);

  var = 2;
  printf("b) var = %d, *ptr = %d\n",var,*ptr);

  *ptr = 3;
  printf("c) var = %d, *ptr = %d\n",var,*ptr);

  var = 47;
  printf("d) *(&var) = %d,",*(&var));
  printf("*&var = %d\n",*&var);
    
  printf("e) &var = %p\n", &var);
}

a) var = 1, *ptr = 1
b) var = 2, *ptr = 2
c) var = 3, *ptr = 3
d) *(&var) = 47,*&var = 47
e) &var = 0x7fffc438a6ec


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <stdio.h>

void test(int* y) {
  printf("a) *y=%d\n", *y);
  *y = 43;
  printf("b) *y=%d\n", *y);
}

int main() {
  int x = 12;
  printf("c) x=%d\n", x);
  test(&x);
  printf("d) x=%d\n", x);
}

c) x=12
a) *y=12
b) *y=43
d) x=43


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58#include <stdio.h>
#include <assert.h>
#define DIM 5

// The function scanVector reads the coefficients
// of a double vector of length dim from the keyboard
void scanVector(double input[], int dim);

// The function determineMinMax returns the minimum
// and maximum of a double vector of length dim. We
// use Call-by-Reference because of 2 return values.

void determineMinMax(double vector[],int dim,
                     double* min, double* max);

int main() {
  double x[DIM];
  double max = 0;
  double min = 0;
  scanVector(x,DIM);
  determineMinMax(x,DIM, &min, &max);
  printf("min(x) = %f\n",min);
  printf("max(x) = %f\n",max);
}

void scanVector(double input[], int dim) {
  assert(dim > 0);
  int j = 0;
  for (j=0; j<dim; ++j) {
    input[j] = 0;
    printf("%d: ",j);
    scanf("%lf",&input[j]);
  }
}

void determineMinMax(double vector[],int dim,
                     double* min, double* max) {
  int j = 0;
  assert(dim > 0);

  // First guess for minimum as well as maximum is the
  // first vector coefficient.
  // Recall that, e.g., max is double* so that *max is
  // a double variable.
  *max = vector[0];
  *min = vector[0];
  
  // iterate through vector and search for smaller resp.
  // larger elements to determine minimum and maximum.
  for (j=1; j<dim; ++j) {
    if (vector[j] < *min) {
      *min = vector[j];
    }
    else if (vector[j] > *max) {
      *max = vector[j];
    }
  }
}

0: 4
1: 3
2: 5
3: 6
4: 7
min(x) = 3.000000
max(x) = 7.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <stdio.h>
#include <assert.h>

double* scanVector(int length) {
  assert(length > 0);
  double vector[length];
  int j = 0;
  for (j=0; j<length; ++j) {
    vector[j] = 0;
    printf("vector[%d] = ",j);
    scanf("%lf",&vector[j]);
  }
  return vector;
}

int main() {
  double* x;
  int j = 0;
  int dim = 0;
  
  printf("dim = ");
  scanf("%d",&dim);
  
  x = scanVector(dim);

  for (j=0; j<dim; ++j) {
    printf("x[%d] = %f\n",j,x[j]);
  }
}

/tmp/tmpw5npq09t.c: In function ‘scanVector’:
/tmp/tmpw5npq09t.c:13:10: warning: function returns address of local variable [-Wreturn-local-addr]
   13 |   return vector;
      |          ^~~~~~

dim = 4
vector[0] = 3
vector[1] = 4
vector[2] = 5
vector[3] = 6

[C kernel] Executable exited with code -11


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17#include <stdio.h>

void printSizeOf(double vector[]) {
  printf("sizeof(vector) = %d\n",sizeof(vector));  
}

int main() {
  int var = 43;
  double array[12];
  double* ptr = array;

  printf("sizeof(var) = %d\n",sizeof(var));
  printf("sizeof(double) = %d\n",sizeof(double));
  printf("sizeof(array) = %d\n",sizeof(array));
  printf("sizeof(ptr) = %d\n",sizeof(ptr));
  printSizeOf(array);
}

/tmp/tmp644_iya1.c: In function ‘printSizeOf’:
/tmp/tmp644_iya1.c:4:40: warning: ‘sizeof’ on array function parameter ‘vector’ will return size of ‘double *’ [-Wsizeof-array-argument]
    4 |   printf("sizeof(vector) = %d\n",sizeof(vector));
      |                                        ^
/tmp/tmp644_iya1.c:3:25: note: declared here
    3 | void printSizeOf(double vector[]) {
      |                  ~~~~~~~^~~~~~~~

sizeof(var) = 4
sizeof(double) = 8
sizeof(array) = 96
sizeof(ptr) = 8
sizeof(vector) = 8


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

// scanVector allocates a double vector of prescribed
// length and reads the coefficients from the keyboard
double* scanVector(int length) {
  int j = 0;
  double* vector = NULL;
  // ensure that given length is admissible
  assert(length > 0);
 
  // allocate memory and ensure that this was successful
  vector = malloc(length*sizeof(double));
  assert(vector != NULL);
  
  // read coefficients from keyboard
  for (j=0; j<length; ++j) {
    vector[j] = 0;
    printf("vector[%d] = ",j);
    scanf("%lf",&vector[j]);
  }
  // return base pointer of dynamic vector
  return vector;
}

// printVector prints vector of given length in the shell
void printVector(double* vector, int length) {
  int j = 0;
  // ensure that vector and length are admissible
  assert(vector != NULL);
  assert(length > 0);

  // print coefficients to shell
  for (j=0; j<length; ++j) {
    printf("vector[%d] = %f\n",j,vector[j]);
  }
}

int main() {
  // always set pointers to NULL, if not bound to memory
  double* x = NULL;
  int dim = 0;

  // read vector length from keyboard
  printf("dim = ");
  scanf("%d",&dim);
  
  // allocate vector, read coefficients, and print vector
  x = scanVector(dim);
  printVector(x,dim);

  // do not forget to free memory
  free(x);
  // set pointer x to NULL, since not bound to memory
  x = NULL;
}

dim = 4
vector[0] = 1
vector[1] = 2
vector[2] = 3
vector[3] = 4
vector[0] = 1.000000
vector[1] = 2.000000
vector[2] = 3.000000
vector[3] = 4.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int main() {
  int N = 5;
  int Nnew = 10;
  int j = 0;
  
  int* array = malloc(N*sizeof(int));
  assert(array != NULL);
  for (j=0; j<N; ++j){
    array[j] = j;
  }
  
  array = realloc(array,Nnew*sizeof(int));
  assert(array != NULL);
  for (j=N; j<Nnew; ++j){
    array[j] = 10*j;
  }

  for (j=0; j<Nnew; ++j){
    printf("%d ",array[j]);
  }
  printf("\n");
  free(array);
  array = NULL;
}

0 1 2 3 4 50 60 70 80 90


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#ifndef INCLUDE_DYNAMICVECTORS__
#define INCLUDE_DYNAMICVECTORS__

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

// allocate + initialize dynamic double vector of length n
double* mallocVector(int n);

// free a dynamic vector and set the pointer to NULL
double* freeVector(double* vector);

// extend dynamic double vector and initialize new entries
double* reallocVector(double* vector, int n, int nnew);

// allocate dynamic double vector of length n and read
// entries from keyboard
double* scanVector(int n);

// print dynamic double vector of length n to shell
void printVector(double* vector, int n);

#endif


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59#include "dynamicvectors.h"

double* mallocVector(int n) {
  int j = 0;
  double* vector = NULL;
  assert(n > 0);

  vector = malloc(n*sizeof(double));
  assert(vector != NULL);
 
  for (j=0; j<n; ++j) {
    vector[j] = 0;
  }
  return vector;
}

double* freeVector(double* vector) {
  free(vector);
  return NULL;
}

double* reallocVector(double* vector, int n, int nnew) {
  int j = 0;
  assert(vector != NULL);
  assert(n > 0);
  assert(nnew > 0);
  
  vector = realloc(vector,nnew*sizeof(double));
  assert(vector != NULL);
  for (j=n; j<nnew; ++j) {
    vector[j] = 0;
  }
  return vector;
}

double* scanVector(int n) {
  int j = 0;
  double* vector = NULL;
  assert(n > 0);

  vector = mallocVector(n);
  assert(vector != NULL);
  
  for (j=0; j<n; ++j) {
    printf("vector[%d] = ",j);
    scanf("%lf",&vector[j]);
  }
  return vector;
}

void printVector(double* vector, int n) {
  int j = 0;
  assert(vector != NULL);
  assert(n > 0);

  for (j=0; j<n; ++j) {
    printf("%d: %f\n",j,vector[j]);
  }
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23//%cflags:data/dynamicvectors.o -I data/
//ACHTUNG: Zeile 1 ist nur fuer die korrekte Funktion des interaktiven 
//         Skriptums noetig (ersetzt gcc ... dynamicvectors.o)
#include "dynamicvectors.h"

int main() {
  double* x = NULL;
  int n = 10;
  int j = 0;
  
  x = mallocVector(n);
  for (j=0; j<n; ++j) {
    x[j] = j;
  }
  
  x = reallocVector(x,n,2*n);
  for (j=n; j<2*n; ++j) {
    x[j] = 10*j;
  }
  
  printVector(x,2*n);
  x = freeVector(x);
}

0: 0.000000
1: 1.000000
2: 2.000000
3: 3.000000
4: 4.000000
5: 5.000000
6: 6.000000
7: 7.000000
8: 8.000000
9: 9.000000
10: 100.000000
11: 110.000000
12: 120.000000
13: 130.000000
14: 140.000000
15: 150.000000
16: 160.000000
17: 170.000000
18: 180.000000
19: 190.000000


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

char* stringCopy(char* source) {
  int length = 0;
  char* result = NULL;
  // ensure that source string exists
  assert(source != NULL);
  
  // determine length and allocate memory
  length = strlen(source);
  result = malloc((length+1)*sizeof(char));
  // copy source string and return copy
  strcpy(result,source);
  return result;
}

int main() {
  char* string1 = "Hello World?";
  char* string2 = stringCopy(string1);
  string2[11] = '!';
  printf("%s %s\n",string1,string2);
  free(string2);
  string2=NULL;
}

Hello World? Hello World!


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <stdio.h>

void output1(char* string) {
  printf("*%s*\n",string);
}

void output2(char* string) {
  printf("#%s#\n",string);
}

int main() {
  char string[] = "Hello World";
  void (*output)(char* string) = NULL;

  // call function output1 via function pointer
  output = output1;
  output(string);
 
  // call function output2 via function pointer
  output = output2;
  output(string);
}

*Hello World*
#Hello World#


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60#include <stdio.h>
#include <assert.h>
#include <math.h>

// bisection returns an approximate root x0 of a
// continuous real-valued scalar function fct with
// fct(a) * fct(b) <= 0, for which the intermediate
// value theorem yields the existence of a root.
//
// bisection takes the function pointer of the function
// fct: [a,b] -> R and a tolerance tol and returns x0
// in (a,b) such that |x0 - x| <= tol, where fct(x) = 0.

double bisection(double (*fct)(double x),
                 double a, double b, double tol);

// demo function f
double f(double x) {
  return x*x + exp(x) - 2;
}

int main() {
  double a = 0;
  double b = 10;
  double tol = 1e-12;
   
  double x = bisection(f,a,b,tol);
  printf("Approximate zero of the function x=%1.15e\n",x);
}

double bisection(double (*fct)(double x),
                 double a, double b, double tol) {
  double m = 0;
  double fa = 0;
  double fm = 0;
  
  // ensure that input is admissible
  assert(a < b);
  fa = fct(a);
  assert(fa*fct(b) <= 0);
  
  // iterate by interval bisection
  while ( b-a > 2*tol) {
    // compute interval mitpoint and evaluate fct
    m = (a+b)/2;
    fm = fct(m);
    if ( fa*fm <= 0 ) {
      // theorem guarantees root in [a,m]
      b = m;
    }
    else {
      // theorem guarantees root in [m,b]
      a = m;
      fa = fm;
    }
  }
  // as loop terminates, x in [a,b] and |b-a| <= 2*tol
  // so that |x-m| <= tol for the midpoint m.
  return m;
}

Approximate zero of the function x=5.372744491739923e-01


 1
 2
 3
 4
 5
 6
 7
 8
 9
10// declaration of structure and corresponding data type
typedef struct _Student_ {
  char* firstname;
  char* lastname;
  int studentID;
  int studiesID;
  double final_test;
  double kreuzerl;
  double exercise;
} Student;


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26// declaration of structure
struct _Student_ {
  char* firstname;   // first name
  char* lastname;    // last name
  int studentID;     // student ID
  int studiesID;     // studies ID
  double final_test; // points in final test
  double kreuzerl; // percentage of Kreuzerl
  double exercise;   // points in exercises
};

// declaration of corresponding data type
typedef struct _Student_ Student;

main() {
  // declaration of variable var of type Student
  Student var;
  // assign values to members of struct variable
  var.firstname = "Dirk";
  var.lastname = "Praetorius";
  var.studentID = 0;
  var.studiesID = 680;
  var.final_test = 25.;
  var.kreuzerl = 0.7;
  var.exercise = 35.;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23// declaration of structure and corresponding data type
typedef struct _Student_ {
  char* firstname;
  char* lastname;
  int studentID;
  int studiesID;
  double final_test;
  double kreuzerl;
  double exercise;
} Student;

main() {
  // declaration of variable var of type Student
  Student var;
  // assign values to members of struct variable
  var.firstname = "Dirk";
  var.lastname = "Praetorius";
  var.studentID = 0;
  var.studiesID = 680;
  var.final_test = 25.;
  var.kreuzerl = 0.7;
  var.exercise = 35.;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21Student* newStudent() {
  
  // allocate memory for struct variable as before.
  // Do not forget to use sizeof within malloc!
  
  Student* pointer = malloc(sizeof(Student));
  assert( pointer != NULL);

  // dereferencing of the pointer yields a struct variable
  // of type Student. The use of brackets is mandatory!
  
  (*pointer).firstname = NULL;
  (*pointer).lastname = NULL;
  (*pointer).studentID = 0;
  (*pointer).studiesID = 0;
  (*pointer).final_test = 0.;
  (*pointer).kreuzerl = 0.;
  (*pointer).exercise = 0.;

  return pointer;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26// declaration of structure and corresponding data type
typedef struct _Student_ {
  char* firstname;
  char* lastname;
  int studentID;
  int studiesID;
  double final_test;
  double kreuzerl;
  double exercise;
} Student;

// allocate and initialize new student
Student* newStudent() {
  Student* student = malloc(sizeof(Student));
  assert(student != NULL);
  
  student->firstname = NULL;
  student->lastname = NULL;
  student->studentID = 0;
  student->studiesID = 0;
  student->final_test = 0.;
  student->kreuzerl = 0.;
  student->exercise = 0.;
  
  return student;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18// free memory allocation
Student* delStudent(Student* student) {
  assert(student != NULL);
  
  // delete firstname, if memory has been allocated
  if (student->firstname != NULL) {
    free(student->firstname);
  }
    
  // delete lastname, if memory has been allocated
  if (student->lastname != NULL) {
    free(student->lastname);
  }
  
  // delete memory of struct variable and return NULL
  free(student);
  return NULL;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18// shallow copy of student
Student* copyStudent(Student* student) {
  Student* copy = newStudent();
  assert(student != NULL);
  
  // note: for pointes, only adresses are copied
  copy->firstname = student->firstname;
  copy->lastname = student->lastname;
  
  // copy of elementary data
  copy->studentID = student->studentID;
  copy->studiesID = student->studiesID;
  copy->final_test = student->final_test;
  copy->kreuzerl = student->kreuzerl;
  copy->exercise = student->exercise;
  
  return copy;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31// deep copy of student
Student* cloneStudent(Student* student) {
  Student* copy = newStudent();
  int length = 0;
  assert( student != NULL);
  
  // full copy of firstname
  if (student->firstname != NULL) {
    length = strlen(student->firstname);
    copy->firstname = malloc((length+1)*sizeof(char));
    assert(copy->firstname != NULL);
    strcpy(copy->firstname, student->firstname);
  }
  
  // full copy of lastname
  if (student->lastname != NULL) {
    length = strlen(student->lastname);
    copy->lastname = malloc((length+1)*sizeof(char));
    assert(copy->lastname != NULL);
    strcpy(copy->lastname, student->lastname);
  }
  
  // copy of elementary data
  copy->studentID = student->studentID;
  copy->studiesID = student->studiesID;
  copy->final_test = student->final_test;
  copy->kreuzerl = student->kreuzerl;
  copy->exercise = student->exercise;

  return copy;
}


1
2
3
4
5
6
7// declare array
Student** participant = malloc(N*sizeof(Student*));

// allocate memory for participants
for (j=0; j<N; ++j){
  participant[j] = newStudent();
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14typedef struct _Address_ {
  char* street;
  char* number;
  char* city;
  char* zip;
} Address;

typedef struct _Employee_ {
  char* firstname;
  char* lastname;
  char* title;
  Address* home;
  Address* office;
} Employee;


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <math.h>

typedef struct _Vector3_ {
  double x;
  double y;
  double z;
} Vector3;

Vector3* newVector3(double x, double y, double z) {
  Vector3* v = malloc(sizeof(Vector3));
  assert(v != NULL); // ensure proper memory allocation
  v->x = x;
  v->y = y;
  v->z = z;
  return v;
}

Vector3* delVector3(Vector3* v) {
  assert(v != NULL); // ensure that vector v exists
  free(v);
  return NULL;
}

double dist(Vector3* v, Vector3* w) {
  assert(v != NULL); // ensure that vector v exists
  assert(w != NULL); // ensure that vector w exists
  return sqrt( (v->x - w->x)*(v->x - w->x)
               + (v->y - w->y)*(v->y - w->y)
               + (v->z - w->z)*(v->z - w->z) );
}

int main() {
  Vector3* v = newVector3(1,1,1);
  Vector3* w = newVector3(1,2,3);
  printf("dist(x,y) = %f\n", dist(v,w));
  v = delVector3(v);
  w = delVector3(w);
}

dist(x,y) = 2.236068


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35#ifndef INCLUDE_VECTOR__
#define INCLUDE_VECTOR__

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>

// declaration of new data type Vector
typedef struct _Vector_ {
  int n;          // Dimension
  double* entry;  // Vector coefficients
} Vector;

// allocate and initialize new vector of length n
Vector* newVector(int n);

// free storage of allocated vector and return NULL
Vector* delVector(Vector* X);

// return length of a vector
int getVectorN(Vector* X);

// return coefficient Xi of vector X
double getVectorEntry(Vector* X, int i);

// assign new value to coefficient Xi of vector X
void setVectorEntry(Vector* X, int i, double Xi);

// some example functions...
Vector* inputVector();
double normVector(Vector* X);
double productVector(Vector* X, Vector* Y);

#endif


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18Vector* newVector(int n) {
  int i = 0;
  Vector* X = NULL;
  
  assert(n > 0);
  
  X = malloc(sizeof(Vector));
  assert(X != NULL);
  
  X->n = n;
  X->entry = malloc(n*sizeof(double));
  assert(X->entry != NULL);
  
  for (i=0; i<n; ++i) {
    X->entry[i] = 0;
  }
  return X;
}


1
2
3
4
5
6
7Vector* delVector(Vector* X) {
  assert(X != NULL);
  free(X->entry);
  free(X);
  
  return NULL;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16int getVectorN(Vector* X) {
  assert(X != NULL);
  return X->n;
}

double getVectorEntry(Vector* X, int i) {
  assert(X != NULL);
  assert((i >= 0) && (i < X->n));
  return X->entry[i];
}

void setVectorEntry(Vector* X, int i, double Xi){
  assert(X != NULL);
  assert((i >= 0) && (i < X->n));
  X->entry[i] = Xi;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23Vector* inputVector() {
  
  Vector* X = NULL;
  int i = 0;
  int n = 0;
  double input = 0;
  
  printf("Length of the vector n=");
  scanf("%d",&n);
  assert(n > 0);
  
  X = newVector(n);
  assert(X != NULL);
  
  for (i=0; i<n; ++i) {
    input = 0;
    printf("x[%d]=",i);
    scanf("%lf",&input);
    setVectorEntry(X,i,input);
  }
  
  return X;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19double normVector(Vector* X) {
  
  double Xi = 0;
  double norm = 0;
  int n = 0;
  int i = 0;
  
  assert(X != NULL);
 
  n = getVectorN(X);

  for (i=0; i<n; ++i) {
    Xi = getVectorEntry(X,i);
    norm = norm + Xi*Xi;
  }
  norm = sqrt(norm);
  
  return norm;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22double productVector(Vector* X, Vector* Y) {
  
  double Xi = 0;
  double Yi = 0;
  double product = 0;
  int n = 0;
  int i = 0;

  assert(X != NULL);
  assert(Y != NULL);
  
  n = getVectorN(X);
  assert(n == getVectorN(Y));
  
  for (i=0; i<n; ++i) {
    Xi = getVectorEntry(X,i);
    Yi = getVectorEntry(Y,i);
    product = product + Xi*Yi;
  }
  
  return product;
}


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13#include <stdio.h>

int main() {
  int j = 0;
  int n = 8*sizeof(int); // number bits per int
  int min = 1;

  // compute 2^(n-1)
  for (j=1; j<n; ++j) {
    min = 2*min;
  }
  printf("n=%d, min=%d, max=%d\n",n,min,min-1);
}

n=32, min=-2147483648, max=2147483647


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14#include <stdio.h>

int main() {
  int n = 1;
  int factorial = 1;

  do {
    ++n;
    factorial = n*factorial;
    printf("n=%d, n!=%d\n",n,factorial);
  } while (factorial < n*factorial);

  printf("n=%d, n!>%d\n",n+1,n*factorial);
}

n=2, n!=2
n=3, n!=6
n=4, n!=24
n=5, n!=120
n=6, n!=720
n=7, n!=5040
n=8, n!=40320
n=9, n!=362880
n=10, n!=3628800
n=11, n!=39916800
n=12, n!=479001600
n=13, n!=1932053504
n=14, n!>-653108224


1
2
3
4
5
6
7
8#include <stdio.h>

int main() {
  char var = 'A';

  printf("sizeof(var) = %d\n", sizeof(var));
  printf("%c %d\n",var,var);
}

sizeof(var) = 1
A 65


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16#include <stdio.h>
#include <math.h>

int main() {
  double x = (116./100.)*100.;

  printf("x=%f\n",x);
  printf("floor(x)=%f\n",floor(x));

  if (x==116.) {
    printf("There holds x==116\n");
  }
  else {
    printf("x = %.15f\n",x);
  }
}

x=116.000000
floor(x)=115.000000
x = 115.999999999999986


1
2
3
4
5
6
7#include <stdio.h>
int main() {
  double x = 2./3.;
  float y = 2./3.;
  printf("%17.6f, %e\n", x, x);
  printf("%16.15f, %.15e\n",y, y);
}

         0.666667, 6.666667e-01
0.666666686534882, 6.666666865348816e-01

Datentyp	Platzhalter `printf`	Platzhalter `scanf`
`int`	`%d`	`%d`
`double`	`%f`	`%lf`
`char`	`%c`	`%c`

Symbol	Bedeutung
`==`	Gleichheit (ACHTUNG mit Zuweisung!)
`!=`	Ungleichheit
`>`	echt größer
`<`	echt kleiner
`>=`	größer oder gleich
`<=`	kleiner oder gleich

Symbol	Bedeutung
`!`	Nicht
`&&`	und
`\|\|`	oder

	linear	quadratisch	fastlinear
$n$	search	minsort	binsearch
1.000	0.00	0.00	0.00
2.000	0.00	0.00	0.00
4.000	0.00	0.01	0.00
8.000	0.00	0.06	0.00
16.000	0.00	0.25	0.00
32.000	0.00	1.03	0.00
64.000	0.00	4.12	0.00
128.000	0.00	16.55	0.00
256.000	0.00	64.31	0.00
512.000	0.00	257.25	0.00
1.024.000	0.00	>18min	0.00
2.048.000	0.01	>72min	0.00
4.096.000	0.01	>4,5h	0.00
8.192.000	0.02	>18h	0.00
16.384.000	0.04	>3d	0.00
32.768.000	0.08	>12d	0.00
65.536.000	0.15	>1,5m	0.00
131.072.000	0.29	>6m	0.00
262.144.000	0.60	>2y	0.00
524.288.000	1.18	>8y	0.00
1.048.576.000	2.53	>32y	0.00

Einführung in das Programmieren für Technische Mathematik¶

C & C++¶

Programmieren für Mathematiker¶

Wichtige Infos zu EPROG¶

Literatur¶

Programm¶

Algorithmus¶

Programmiersprachen¶

Achtung¶

Wie erstellt man ein C-Programm?¶

Das erste C-Programm¶

Das erste C-Programm¶

Das erste C-Programm¶

Achtung¶

Fehler¶

Syntaxfehler¶

Laufzeitfehler¶

Beispiel für Syntaxfehler¶

Beispiel für Syntaxfehler¶

Die ersten Sprachelemente¶

Variablen¶

Variablen-Namen¶

Datentypen¶

Deklaration¶

Initialisierung¶

Zuweisungsoperator =¶

Arithmetische Operatoren¶

Arithmetische Operatoren¶

Type Casting¶

Implizites Typecasting¶

Explizites Type Casting¶

Fehlerquelle beim Type Casting¶

Einfache Verzweigung¶

Logische Operatoren¶

Logische Verkettung¶

if-else¶

Beispiel zu if¶

Beispiel zu if-else¶

Gerade oder Ungerade?¶

Zwei Zahlen aufsteigend sortieren¶

Innen oder Außen?¶

Gleichheit vs. Zuweisung¶

Strukturierung mit Blöcken¶

Lifetime & Scope¶

Globale & Lokale Variablen¶

Blöcke¶

Einfaches Beispiel¶

Komplizierteres Beispiel¶

Funktionen¶

Beispiel: Quadrieren¶

Funktionen¶

Namenskonvention¶

Funktionen in C¶

Funktionen in C¶

Variablen¶

Call by Value¶

Beispiel: Minimum zweier Zahlen¶

Deklaration von Funktionen¶

Beispiel zu Call by Value¶

Type Casting & Call by Value¶

Type Casting (Negativbeispiel!)¶

Kommentare im Code¶

Kommentarzeilen¶

Kommentarzeilen in C¶

Beispiel zu vernünftigem Kommentieren von Code¶

Rekursionen¶

Rekursive Funktion¶

Beispiel: Faktorielle¶

Reihenfolge der Selbstaufrufe am Beispiel Faktorielle¶

Nullstellensuche mit dem Bisektionsverfahren¶

Illustration des Bisektionsverfahrens¶

Beispiel: Bisektionsverfahren¶

Mathematische Funktionen¶

Preprocessor, Compiler & Linker¶

Bibliotheken & Header-Files¶

Elementares Beispiel¶

Code mehrfach ausführen mit Schleifen¶

Schleifen¶

Die while-Schleife¶

Operator ++¶

Die `for`-Schleife¶

Beispiel: Summensymbol $\displaystyle\sum$ ¶

Beispiel: Summensymbol $\displaystyle\sum$ ¶

Beispiel: Produktsymbol $\displaystyle\prod$ ¶

`break` und `continue`¶

Landau-Symbol $\mathcal{O}$ (= groß-O)¶