Commit e130b9da authored by Paffenholz, Andreas's avatar Paffenholz, Andreas

programs ch 13

parent b0215851
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Fibonaccizahlen
*
* Uebersetzen mit
* gcc fibonacci.c -o fibonacci -l gmp
* Aufruf mit
* ./fibonacci 123456
**************************************/
#include <stdio.h>
#include <stdlib.h>
#include "gmp.h"
void fibonacci(mpz_t f, int n) {
mpz_init(f); // Initialisieren (zur Sicherheit)
mpz_set_ui(f,0); // --- '' ---
if ( n == 0 ) {
return;
}
if ( n == 1 ) {
mpz_set_ui(f,1);
return;
}
mpz_t g; // wir brauchen zwei vorangegangene Folgenglieder
mpz_init(g);
mpz_set_ui(g,1);
short even = 1; // wir speichern das neueste Folgenglied
// abwechselnd in f und g, je nachdem
// in welchem das vorletzte steht
// even=1: g, even=0: f
for ( int i = 2; i <= n; ++i, even = 1-even ) {
even ? mpz_add(f,f,g) : mpz_add(g,f,g); // Addition
}
if ( even ) // in dem Fall steht das letzte Folgenglied in g
mpz_set(f,g);
mpz_clear(g); // Speicher freigeben
}
int main(int argc, char** argv) {
int k = atoi(argv[1]); // ein Argument wird eingelesen
if ( k > 1000000 ) {
printf("number too large\n");
return 0;
}
mpz_t f; // Ein gmp-Integer fuer das Ergebnis
mpz_init(f); // Initialisieren
mpz_set_ui(f,0); // --- '' ---
fibonacci(f,k);
printf("Die %d-te Fibonaccizahl ist ",k);
mpz_out_str(stdout,10,f);
printf("\n");
mpz_clear(f); // Speicher freigeben
return 0;
}
4 4
1 3/4 3 5/2
3 3/7 4/5 2/13
1/2 4/3 2 17/4
3 4/5 7/2 2/7
\ No newline at end of file
4 4
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Matrixmultiplikation ueber Q mit gmp
* Ein-/Ausgabe
*
**************************************/
#include <stdio.h>
#include <stdlib.h>
#include "matrix_io.h"
void read_matrix(char* fname, mpq_t M[MAX_N][MAX_M], int* mx, int*my) {
FILE *file;
file = fopen(fname,"r");
if ( file == NULL ) {
printf("Datei nicht lesbar\n"); exit(1);
}
fscanf(file, "%d %d", mx, my);
char c[] = " %s";
char num[1000];
for ( int i = 0; i < *my; i++) {
for ( int j = 0; j < *my; j++) {
fscanf(file,c,&num);
mpq_init(M[i][j]);
mpq_set_str(M[i][j],num,10);
}
}
fclose(file);
}
void print_matrix ( mpq_t M[MAX_N][MAX_M], int mx, int my) {
for ( int i = 0; i < mx; i++) {
for ( int j = 0; j < my; j++) {
mpq_out_str(stdout,10,M[i][j]);
printf(" ");
}
printf("\n");
}
printf("\n");
}
void clear_matrix(mpq_t M[MAX_N][MAX_M], int mx, int my ) {
for ( int i = 0; i < mx; i++) {
for ( int j = 0; j < my; j++) {
mpq_clear(M[i][j]);
}
}
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Matrixmultiplikation ueber Q mit gmp
* Ein-/Ausgabe
*
**************************************/
#ifndef MATRIX_IO_H
#define MATRIX_IO_H
#include <gmp.h>
#define MAX_N 10
#define MAX_M 10
void read_matrix(char* fname, mpq_t M[MAX_N][MAX_M], int* mx, int*my);
void print_matrix ( mpq_t M[MAX_N][MAX_M], int mx, int my);
void clear_matrix(mpq_t M[MAX_N][MAX_M], int mx, int my );
#endif
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Matrixmultiplikation ueber Q mit gmp
*
* Uebersetzen mit
* gcc /matrix_multiplication.c matrix_io.c -o /matrix_multiplication
* Aufruf mit
* ./matrix_multiplication mat1.dat mat2.dat
**************************************/
#include <stdio.h>
#include <stdlib.h>
#include <gmp.h>
#include "matrix_io.h"
void multiply (mpq_t R[MAX_N][MAX_M], int* rx, int* ry, mpq_t M[MAX_N][MAX_M], mpq_t N[MAX_N][MAX_M], int mx, int my, int nx, int ny ) {
if ( my != nx ) {
printf("Matrix dimensions mismatch\n");
exit(1);
}
mpq_t q;
mpq_init(q);
for ( int i = 0; i < mx; ++i ) {
for ( int j = 0; j < ny; ++j ) {
mpq_init(R[i][j]);
mpq_set_str(R[i][j],"0",10);
for ( int a = 0; a < my; ++a ) {
mpq_mul(q, M[i][a], N[a][j]);
mpq_add(R[i][j], R[i][j], q);
}
}
}
mpq_clear(q);
*rx = mx;
*ry = ny;
}
int main(int argc, char** argv) {
int mx, my, nx, ny;
mpq_t M[MAX_N][MAX_M];
mpq_t N[MAX_N][MAX_M];
read_matrix(argv[1],M,&mx,&my);
read_matrix(argv[2],N,&nx,&ny);
print_matrix(M,mx,my);
print_matrix(N,nx,ny);
int rx, ry;
mpq_t R[MAX_N][MAX_M];
multiply(R,&rx,&ry,M,N,mx,my,nx,ny);
print_matrix(R,rx,ry);
clear_matrix(M,mx,my);
clear_matrix(N,nx,ny);
clear_matrix(R,rx,ry);
return 0;
}
/*************************************
* Beispielprogramm zur Vorlesung
* Einfuehrung in die Programmierung I
* Andreas Paffenholz
* TU Darmstadt, Wintersemester 2020/21
* (c) 2020-
*
* Beispiel fuer die Verwendung von sqlite3
*
* Uebersetzen mit
* gcc sqlite_example.c -o sqlite_example -l sqlite3
* Aufruf mit
* ./sqlite_example
**************************************/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <sqlite3.h>
int callback_listing(void *data, int n_cols, char **col_values, char **col_names) {
char* art = col_values[1];
art[0] = toupper(art[0]);
printf("%s %-10s hat %3d Ecken, %3d Kanten, and %3d Seiten\n",
art, col_values[0], atoi(col_values[2]), atoi(col_values[3]), atoi(col_values[4]) );
return 0;
}
int callback_euler(void *data, int n_cols, char **col_values, char **col_names) {
char* art = col_values[1];
art[0] = toupper(art[0]);
printf("%s %-10s hat Euler-Characteristik %2d\n",
art, col_values[0], atoi(col_values[2]));
return 0;
}
void cleanup( sqlite3 *db, char* sql_error, char* text ) {
fprintf(stderr, "%s\n", text);
fprintf(stderr, "SQL error: %s\n", sql_error);
sqlite3_free(sql_error);
sqlite3_close(db);
}
int main() {
char* names[5] = {"Tetraeder","Wuerfel","Oktaeder","Dodekaeder","Ikosaeder"};
char* art[5] = {"das","der","das","das","das"};
int fv[5][3] = {
{ 4, 6, 4},
{ 8, 12, 6},
{ 6, 12, 8},
{ 20, 30, 12},
{ 12, 30, 20}
};
sqlite3 *db;
char *error = 0;
// Datenbank oeffen oder erzeugen
int ret = sqlite3_open(":memory:", &db);
if (ret != SQLITE_OK) {
char msg[100];
sprintf(msg,"Datenbank konnte nicht geoeffnet werden: %s", sqlite3_errmsg(db));
cleanup(db, error, msg);
exit(1);
}
// Tabelle erzeugen
// hier mit sqlite3_exec
char *sql_table =
"CREATE TABLE regular(id INTEGER PRIMARY KEY, name TEXT, art TEXT, vertices INTEGER, edges INTEGER, facets INTEGER);";
ret = sqlite3_exec(db, sql_table, 0, 0, &error);
if (ret != SQLITE_OK ) {
cleanup(db, error, "Tabelle konnte nicht erzeugt werden" );
exit(1);
} else {
printf("Tabelle erzeugt\n");
}
// Einlesestatement der Daten vorbereiten
// Da wir mehr als eine Zeile auf die gleiche Weise einfuegen wollen
// arbeiten wir hier mit prepare, step, finalize
// dann muessen prepare und finalize nur einmal ausgefuehrt werden
// waehrend wir step dazwischen oefter aufrufen koennen
char *sql_insert =
"INSERT INTO regular(name,art,vertices,edges,facets) VALUES (?, ?, ?, ?, ?)";
ret = sqlite3_prepare_v2(db, sql_insert, -1, &statement, 0);
if ( ret != SQLITE_OK ) {
cleanup(db, error, "SQL prepare fehlgeschlagen" );
exit(1);
}
// Der Reihe nach mit unserer vorbereiteten Einleseanweisung die Daten
// in die Tabelle schreiben
// Dafuer muessen wir mit den bind-Anweisungen die Parameter unseres
// SQL-Statements mit den konkreten Daten belegen
// Zeiger auf eine Variable, die eine vorbereitete SQL-Anweisung aufnimmt
sqlite3_stmt *statement;
for ( int i = 0; i < 5; ++i ) {
sqlite3_bind_text(statement, 1, names[i], -1, NULL);
sqlite3_bind_text(statement, 2, art[i], -1, NULL);
sqlite3_bind_int(statement, 3, fv[i][0]);
sqlite3_bind_int(statement, 4, fv[i][1]);
sqlite3_bind_int(statement, 5, fv[i][2]);
// schreiben
sqlite3_step(statement);
int ret = sqlite3_reset(statement);
if ( ret != SQLITE_OK ) {
cleanup(db, error, "Daten konnten nicht eingefuegt werden" );
exit(1);
}
}
// Cache leeren, Anweisung loeschen
sqlite3_finalize(statement);
printf("Alle Daten eingefuegt\n");
// Daten wieder auslesen, zuerst die f-Vektoren
// Hier wieder mit sqlite3_exec, dem wir einen Zeiger auf callback_listing übergeben,
// was die Daten auf den Bildschirm schreibt
printf("f-Vektoren:\n");
char *sql_query =
"SELECT name, art, vertices, edges, facets FROM regular ORDER BY vertices";
ret = sqlite3_exec(db, sql_query, callback_listing, 0, &error);
if ( ret != SQLITE_OK ) {
cleanup(db, error, "Daten konnten nicht gelesen werden" );
exit(1);
}
printf("----\n");
// und dann die Euler-Charakteristik
printf("Euler-Characteristik:\n");
sql_query =
"SELECT name, art, vertices-edges+facets-1 as e FROM regular ORDER BY e";
ret = sqlite3_exec(db, sql_query, callback_euler, 0, &error);
if ( ret != SQLITE_OK ) {
cleanup(db, error, "Daten konnten nicht gelesen werden" );
exit(1);
}
// Datenbank schliessen
// Das ist insbesondere wichtig, wenn die Datenbank in eine Datei geschrieben wird
// und auch nach Programmende vorhanden sein soll
// ggf. werden hier noch bisher nur zwischengespeicherte Anweisungen ausgefuehrt!
sqlite3_close(db);
return 0;
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment