[WikiDyd] [TitleIndex] [WordIndex

Uwaga: starsze wykłady są niżej

WF 22.01.2013

Zaliczenie!

WE 15.01.2013

Słownik implementowany przez tablicę mieszającą

Wersja przechowująca pary (napis,napis)

Wersja universalna (void*,void*), bez allokacji pamięci na zawartość

Wersja universalna (void*,void*), z allokacją pamięci na zawartość

WD 8.01.2013

Słownik implementowany przez b-drzewo

Wszystkie programy spakowane zipem

WC 18.12.2012

Uruchamianie programu. Testy funkcjonalności, dane testowe, debugger

Wszystkie programy spakowane zipem

WB 11.12.2012

Macierze wielowymiarowe. Eliminacja Gaussa

Wszystkie programy spakowane zipem

Przypominam o pracy domowej: macie Państwo poprawić eliminację z częściowym wyborem elementu dominującego i dokończyć podstawienie wstecz.

WA 4.12.2012

Parsowanie napisów, drzewa binarne (wyrażenia arytmetyczne w postaci drzew)

Wszystkie programy spakowane zipem

A tutaj praca domowa - przypominam, że powinni Państwo poprawić funkcję słowotok tak, aby poprawnie reagowała na sekwencje separatorów.

   1 #include <string.h>
   2 
   3 char *slowotok( char *string, char *delim, char **saveptr ) {
   4         char *start= string != NULL ? string : *saveptr;
   5         char *cur = start;
   6 
   7         while( *start != '\0' && strchr( delim, *start ) != NULL ) {
   8                 start++;
   9         }
  10         if( *start == '\0' )
  11                 return NULL;
  12 
  13         while( *cur != '\0' && strchr( delim, *cur ) == NULL ) {
  14                 cur++;
  15         }
  16         if( *cur != '\0' ) {
  17                 *cur = '\0';
  18                 *saveptr = cur+1;
  19         } else {
  20                 *saveptr = cur;
  21         }
  22         
  23         return start;
  24 }
  25 
  26 #include <stdio.h>
  27 
  28 int main( int argc, char **argv ) {
  29         char delim[] = " ,.!?;:";
  30         char *save;
  31         char nap[] = "Ala ma kota. Ola ma psa, a Zosia dwa.";
  32         char *s= slowotok( nap, delim, &save );
  33 
  34         do {
  35                 printf( "%s\n", s );
  36                 s= slowotok( NULL, delim, &save );
  37         } while( s != NULL );
  38 
  39         return 0;
  40 }

Rozwiązanie pracy domowej Błędem poprzedniej wersji było inicjowanie zmiennej curr w niewłaściwym miejscu. Oto poprawka:

   1 #include <string.h>
   2 
   3 char *slowotok( char *string, char *delim, char **saveptr ) {
   4   char *start= string != NULL ? string : *saveptr;
   5   char *cur;
   6 
   7   while( *start != '\0' && strchr( delim, *start ) != NULL ) {
   8     start++;
   9   }
  10   if( *start == '\0' )
  11     return NULL;
  12 
  13   cur= start;
  14 
  15   while( *cur != '\0' && strchr( delim, *cur ) == NULL ) {
  16     cur++;
  17   }
  18   if( *cur != '\0' ) {
  19     *cur = '\0';
  20     *saveptr = cur+1;
  21   } else {
  22     *saveptr = cur;
  23   }
  24 
  25   return start;
  26 }

W9 27.11.2012

Parser ONP

Wszystkie programy spakowane zipem

W8 20.11.2012

Parsowanie napisów

Wszystkie programy spakowane zipem

   1 /** Funkcja zamieniająca wszystkie cyfry dziesiętne
   2     w argumencie na znak '*' 
   3     Przyklad:
   4     "Ala ma 2 koty a Ola 34 chomiki." -> "Ala ma * koty a Ola ** chomiki."
   5 */
   6 
   7 #include <ctype.h>
   8 
   9 void dig2star( char *string ) {
  10         while( *string ) {
  11                 if( isdigit( *string ) ) //if( *string >= '0' && *string <= '9' )
  12                         *string = '*';
  13                 string++;
  14         }
  15 }

   1 #include "parser_onp.h"
   2 
   3 double parser_onp( lexSym_t *wezSymbol( double *liczba, char *op ), int *err ) {
   4         lexSym_t ostsymb;
   5         double liczba, tmp;
   6   char op;
   7 
   8         while( (ostsymb= wezSymbol( &liczba, &op )) != KONIEC ) {
   9                 if( ostsymb == LICZBA ) 
  10                         push( liczba );
  11                 else if( ostsymb == OPERATOR ) {
  12                         if( size() < 2 ) {
  13                                 *err = -4; /* za mało argumentów */
  14                                 return 0.0;
  15                         }
  16                         switch( op ) {
  17                                 case '+' : push( pop()+pop() );
  18                                                                          break;
  19                                 case '*' : push( pop()*pop() );
  20                                                                          break;
  21                                 case '-' : tmp = pop();
  22                                                                          push( pop()-tmp );
  23                    break;
  24         case '/' : tmp = pop();
  25                                                                          if( tmp == 0 ) {
  26                                                                                  *err = -1; /* dzielenie przez zero */
  27                      return 0.0;
  28                    }
  29                    push( pop() / tmp );
  30                                                                          break;
  31                                 default:   *err = -2; /* nieznany operator */
  32                    return 0.0;
  33       }
  34                 } else {
  35                   *err = -3; /* nieznany symbol leksykalny */
  36                         return 0.0;
  37                 }
  38         }
  39         return pop();
  40 }

   1 #ifndef _STOS_H_
   2 #define _STOS_H_
   3 
   4 void push( double );
   5 double pop( void );
   6 int size( void );
   7 
   8 #endif
   9 

   1 #include "stos.h"
   2 
   3 #define MAX 4096
   4 
   5 static double moj_stos[MAX];
   6 static int wsk_mojego_stosu = 0;
   7 
   8 void push( double liczba ) {
   9         moj_stos[wsk_mojego_stosu++] = liczba;
  10 }
  11 
  12 double pop( void ) {
  13         if( wsk_mojego_stosu > 0 )
  14                 return moj_stos[--wsk_mojego_stosu];
  15         else
  16                 return -9999.9999;
  17 }
  18 
  19 int size( void ) {
  20         return wsk_mojego_stosu;
  21 }

   1 #include <stdio.h>
   2 #include "stos.h"
   3 
   4 int main( int argc, char **argv ) {
   5         double t[] = { 9.9, 8.8, 7.7, 6.6, 5.5, 5 };
   6         
   7         int i;
   8 
   9         for( i= 0; i < sizeof t / sizeof t[0]; i++ )
  10                 push( t[i] );
  11 
  12         printf( "Na stosie jest %d liczb.\n", size() );
  13 
  14         while( size() > 0 )
  15                 printf( "Zdejmujemy %g\n", pop() );
  16 
  17         printf( "Stos %sjest pusty\n", size() > 0 ? "NIE " : "" );
  18 
  19         return 0;
  20 }

   1 #ifndef _ALEKS_H_
   2 #define _ALEKS_H_
   3 
   4 typedef int lexSym_t;
   5 
   6 #define NIEZNANY_ZNAK 0
   7 #define LICZBA 1
   8 #define OPERATOR 2
   9 #define KONIEC 3
  10 
  11 void initAleks( char *s );
  12 
  13 lexSym_t wezSymbol( double *l, char *op );
  14 
  15 #endif
  16 

   1 #include "aleks.h"
   2 #include <stdlib.h>
   3 #include <ctype.h>
   4 
   5 static char *string;
   6 
   7 void initAleks( char *s ) {
   8         string = s;
   9 }
  10 
  11 lexSym_t wezSymbol( double *l, char *op ) {
  12 
  13         while( *string != '\0' && isspace(*string) )
  14                 string++;
  15 
  16         if( *string == '\0' )
  17                 return KONIEC;
  18 
  19         if( *string == '+' || *string == '*' || *string == '/' || (*string == '-' && *(string+1)) ) {
  20                 *op = *string;
  21                 string++;
  22                 return OPERATOR;
  23         }
  24 
  25         if( isdigit(*string) || *string == '.' ) {
  26                 *l = atof( string );
  27                 while( isdigit(*string) || *string == '.' )
  28                         string++;
  29                 return LICZBA;
  30         }
  31 
  32         *op = *string;
  33   ++string;     
  34   return NIEZNANY_ZNAK;
  35 }

   1 #include "aleks.h"
   2 #include <stdio.h>
   3 
   4 int main( int argc, char **argv ) {
   5         char *test = "2 4 + 5 6 * / 2 - 3.55 9.21 + - =";
   6         char op;
   7   double l;
   8         lexSym_t s;
   9 
  10         initAleks( test );
  11 
  12         printf( "Testowy napis: \"%s\"\n", test );
  13 
  14         while( (s= wezSymbol( &l, &op )) != KONIEC ) {
  15                 switch( s ) {
  16                         case LICZBA: printf( "LICZBA %g\n", l );
  17                                 break;
  18                         case OPERATOR: printf( "OPERATOR %c\n", op );
  19                                 break;
  20                         case NIEZNANY_ZNAK: printf( "NIEZNANY_ZNAK: '%c'\n", op );
  21                                 break;
  22                 }
  23         }
  24         printf( "KONIEC\n" );
  25 
  26         return 0;
  27 }

W7 13.11.2012

Listy liniowe i drzewa binarne

   1 /* Lista liniowa jednokierunkowa, zawierająca liczby *
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 
   5 typedef struct n {
   6         double d;
   7         struct n *nxt;
   8 } elem_t, *list_t;
   9 
  10 list_t add( list_t l, double x ) {
  11 /** Wstawianie na koniec listy (rekurencyjnie) */
  12         if( l == NULL ) {
  13                 list_t nowy= malloc( sizeof *nowy );
  14                 nowy->d = x;
  15                 nowy->nxt = NULL;
  16                 return nowy;
  17         } else {
  18                 l->nxt = add( l->nxt, x );
  19                 return l;
  20         }
  21 }
  22 
  23 list_t add_nr( list_t l, double x ) {
  24 /** Wstawianie na koniec listy (bez rekurencji) */
  25         if( l == NULL ) {
  26     list_t nowy= malloc( sizeof *nowy );
  27     nowy->d = x;
  28     nowy->nxt = NULL;
  29     return nowy;
  30   } else {
  31                 list_t it = l;
  32                 while( it->nxt != NULL )
  33                         it= it->nxt;
  34                 it->nxt = malloc( sizeof *it->nxt );
  35                 it->nxt->d = x;
  36                 it->nxt->nxt = NULL;
  37                 return l;
  38         }
  39 }
  40 
  41 list_t ordr( list_t l, double x ) {
  42 /** Wstawianie w kolejnosci niemalejacej (bez rekurencji) */
  43   list_t nowy= malloc( sizeof *nowy );
  44   nowy->d = x;
  45   nowy->nxt = l;
  46         if( l == NULL || l->d > x ) {
  47     return nowy;
  48   } else {
  49                 list_t it = l;
  50                 while( it->nxt != NULL && it->nxt->d <= x  )
  51                         it= it->nxt;
  52                 nowy->nxt = it->nxt;
  53                 it->nxt = nowy;
  54                 return l;
  55         }
  56 }
  57 
  58 list_t ins( list_t l, double x ) {
  59 /** Wstawianie na początek listy */
  60         list_t nowy= malloc( sizeof *nowy );
  61         nowy->d = x;
  62         nowy->nxt = l;
  63         return nowy;
  64 }
  65 
  66 void print_l( list_t l, FILE *out ) {
  67         while( l != NULL ) {
  68                 fprintf( out, "%g -> ", l->d );
  69                 l = l->nxt;
  70         }
  71         fprintf( out, "NULL\n" );
  72 }
  73 
  74 int
  75 main( int argc, char **argv ) {
  76         list_t l= NULL;
  77 
  78         while( --argc ) {
  79                 l = ordr( l, atof( *(++argv) ) );
  80         }
  81 
  82         print_l( l, stdout );
  83 
  84         return EXIT_SUCCESS;
  85 }

   1 /* Lista liniowa jednokierunkowa zawierająca struktury *
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 
   6 typedef struct n {
   7   char *imie;
   8         char *nazwisko;
   9         int lp;
  10         struct n *nxt;
  11 } elem_t, *list_t;
  12 
  13 list_t ordr( list_t l, char *im, char *nz, int lp ) {
  14 /** Wstawianie w kolejnosci niemalejacej (bez rekurencji) */
  15   list_t nowy= malloc( sizeof *nowy );
  16   nowy->imie= im;
  17   nowy->nazwisko = nz;  
  18   nowy->lp= lp;
  19         if( l == NULL || l->lp > lp ) {
  20     return nowy;
  21   } else {
  22                 list_t it = l;
  23                 while( it->nxt != NULL && it->nxt->lp <= lp  )
  24                         it= it->nxt;
  25                 nowy->nxt = it->nxt;
  26                 it->nxt = nowy;
  27                 return l;
  28         }
  29 }
  30 
  31 void print_l( list_t l, FILE *out ) {
  32         while( l != NULL ) {
  33                 fprintf( out, "%s %s %d\n", l->imie, l->nazwisko, l->lp );
  34                 l = l->nxt;
  35         }
  36 }
  37 
  38 #define MAXBUF 1024
  39 
  40 int parsebuf( char *buf, char **im, char **naz, int *lp ) {
  41 /** Parsuje buf -> (string,string,int),
  42     kopiuje pierwszy string do im, drugi do naz, a int do lp 
  43                 Zwraca liczbe sparsowanych pól
  44 */
  45   char imie[MAXBUF], nazwisko[MAXBUF];
  46         int nr= sscanf( buf, "%s %s %d", imie, nazwisko, lp );
  47         if( nr == 3 ) {
  48                 *im= malloc( strlen(imie)+1 );
  49                 strcpy( *im, imie );
  50                 *naz= malloc( strlen(nazwisko)+1 );
  51                 strcpy( *naz, nazwisko );
  52         }       
  53         return nr;
  54 }
  55 
  56 int
  57 main( int argc, char **argv ) {
  58         FILE *in = argc > 1 ? fopen( argv[1], "r" ) : stdin;
  59         char buf[MAXBUF];
  60         char *im, *naz;
  61         int lp;
  62         list_t l= NULL;
  63 
  64         while( fgets( buf, MAXBUF, in ) != NULL ) {
  65                 if( parsebuf( buf, &im, &naz, &lp ) == 3 )
  66                   l = ordr( l, im, naz, lp );
  67         }
  68 
  69         print_l( l, stdout );
  70 
  71         return EXIT_SUCCESS;
  72 }

   1 /* Drzewo posukiwań binarnych (BST) zawierające liczby */
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 
   5 typedef struct n {
   6         double d;
   7         struct n *l, *p;
   8 } node_t, * tree_t;
   9 
  10 tree_t add( tree_t t, double x ) {
  11         if( t == NULL ) {
  12                 tree_t nowy= malloc( sizeof *nowy );
  13                 nowy->d = x;
  14                 nowy->l = nowy->p = NULL;
  15                 return nowy;
  16         } else if( t->d > x ) {
  17                 t->l = add( t->l, x );
  18                 return t;
  19         } else {
  20                 t->p = add( t->p, x );
  21                 return t;
  22         }
  23 }
  24 
  25 void print_tree( tree_t t, FILE *out, int g ) {
  26         if( t != NULL ) {
  27                 int i;
  28                 print_tree( t->p, out, g+1 );
  29                 for( i= 0; i < g; i++ )
  30                         fprintf( out, "   " );
  31                 fprintf( out, "%g\n", t->d );
  32                 print_tree( t->l, out, g+1 );
  33         }
  34 }
  35 
  36 int
  37 main( int argc, char **argv ) {
  38   tree_t t= NULL;
  39 
  40   while( --argc ) {
  41     t = add( t, atof( *(++argv) ) );
  42   }
  43 
  44   print_tree( t, stdout, 0 );
  45 
  46   return EXIT_SUCCESS;
  47 }

W6 06.11.2012

Wskaźniki do funkcji, tablice struktur, qsort, operacje na napisach

   1 /** Tablicuje zadaną funkcję dla punktów zapisanych w pliku
   2     z danymi - wylicza w każdym punkcie wartość funkcji
   3     i aproksymację jej pochodnej ilorazem różnicowym w przód.
   4 */
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <math.h>
   8 #include <string.h>
   9 #include "tdyn.h"  /* tdyn.c i tdyn.h pisaliśmy na W5 */
  10 
  11 typedef double (*fd_p)( double );  /* wskaźnik do funkcji */
  12 
  13 double moja( double x ) {  /* przykł. funkcja zgodna z typem fd_p */
  14         return sin(x)*exp(-.2*x);
  15 }
  16 
  17 void calc_f_df( td_t *x, td_t *y, td_t *yp, double eps, fd_p f )
  18 /** Funkcja tablicująca f */
  19 {
  20         int i;
  21         y->n = yp->n = 0;
  22         while( y->size < x->n )
  23                 double_size_td( y );
  24         while( yp->size < x->n )
  25                 double_size_td( yp );
  26         for( i= 0; i < x->n; i++ ) {
  27                 y->t[i] = f( x->t[i] );
  28     yp->t[i] = ( f(x->t[i]+eps) - f(x->t[i]) ) / eps;
  29         }
  30         y->n= yp->n= x->n;
  31 }
  32 
  33 typedef struct {  /* struktura mapująca nazwę na wskaźnik do f */
  34         fd_p f;
  35         char *naz;
  36 } fun_t;
  37 
  38 int
  39 main( int argc, char **argv ) {
  40         FILE *in = argc > 1 ? fopen( argv[1], "r" ) : stdin;
  41         FILE *ou = argc > 2 ? fopen( argv[2], "w" ) : stdout;
  42         double eps = argc > 3 ? atof( argv[3] ) : 1e-6;
  43         int i;
  44         fun_t funkcje[] = {
  45     { moja, "moja" },
  46     { sin, "sin" },
  47     { cos, "cos" }
  48   };
  49 
  50         td_t *x = init_td( 100 );
  51         td_t *fx = init_td( 100 );
  52         td_t *dfx = init_td( 100 );
  53 
  54         read_td( x, in );
  55 
  56         if( x->n > 0 ) {
  57                 fd_p f = log;
  58           if( argc > 4 ) {
  59                         for( i= 0; i < sizeof funkcje / sizeof funkcje[0]; i++ )
  60                                 if( strcmp( argv[4], funkcje[i].naz ) == 0 )
  61                                         f = funkcje[i].f;
  62                 }       
  63                 calc_f_df( x, fx, dfx, eps, f );
  64                 for( i= 0; i < x->n; i++ )
  65                         fprintf( ou, "%g %g %g\n", x->t[i], fx->t[i], dfx->t[i] );
  66                 return EXIT_SUCCESS;
  67         }
  68 
  69         return EXIT_FAILURE;
  70 }

   1 /** Prosty generator liczb losowych <0,1>
   2 */
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <time.h>
   6 
   7 int main( int argc, char **argv ) {
   8         int n= argc > 1 ? atoi( argv[1] ) : 10;
   9 
  10         srand( time( NULL ) );
  11 
  12         int i;
  13 
  14         for( i= 0; i < n; i++ )
  15                 printf( "%g\n", (double)rand() / RAND_MAX );
  16 
  17         return 0;
  18 }

   1 /** Sortowanie tablicy dynamicznej: porównanie sortowania przez wstawianie i sortowania szybkiego
   2 */
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include "tdyn.h"
   6 
   7 int fcmp( const void *a, const void *b ) {
   8         double *da = (double*) a;
   9         double *db = (double*) b;
  10 
  11         if( *da > *db )
  12                 return 1;
  13         else if( *da == *db )
  14                 return 0;
  15         else
  16                 return -1;
  17 }
  18 
  19 int main( int argc, char **argv ) {
  20         FILE *in = argc > 1 ? fopen( argv[1], "r" ) : stdin;
  21         td_t *x = init_td( 100 );
  22         int i;
  23 
  24         read_td( x, in );
  25 
  26 #ifdef INSORT
  27         sort_td( x );
  28 #else
  29         qsort( x->t, x->n, sizeof x->t[0], fcmp );
  30 #endif
  31 
  32         for( i= 1; i < x->n; i++ )
  33                 if( x->t[i] < x->t[i-1] )
  34                         fprintf( stderr, "O JENYLKU! nie sortuje dobrze\n" );
  35 
  36         for( i= 0; i < x->n; i++ )
  37                 printf( "%g\n", x->t[i] );
  38 
  39         return 0;
  40 }

   1 /** Sortowanie alfabetyczne
   2 */
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 
   7 #define MAXLINE 4096 
   8 
   9 /* własna wersja strcmp */
  10 int xstrcmp( char *a, char *b ) {
  11         while( *a == *b && *a != '\0' ) {
  12                 a++;
  13                 b++;
  14         }
  15         return *a - *b;
  16 }
  17 
  18 int fcmp( const void *a, const void *b ) {
  19         char *pa = * (char**)a;
  20         char *pb = * (char**)b;
  21         return xstrcmp( pa, pb ); /* po skasowaniu litery x mamy standardowy strcmp */
  22 }
  23 
  24 int main( int argc, char **argv ) {
  25         char buf[MAXLINE];
  26         char **file= NULL;
  27         int n= 0;
  28         int file_size = 100;
  29         int i;
  30         
  31         file= malloc( file_size * sizeof *file );
  32 
  33         while( fgets( buf, MAXLINE, stdin ) != NULL ) {
  34                 char *line = malloc( (strlen( buf )+1) * sizeof *line );
  35                 strcpy( line, buf );
  36                 if( n == file_size ) {
  37                         char **tmp = realloc( file, 2*file_size*sizeof *tmp );
  38                         if( tmp == NULL ) {
  39                                 fprintf( stderr, "KASZANKA!\n" );
  40                                 return EXIT_FAILURE;
  41                         }
  42                         file= tmp;
  43                         file_size *= 2;
  44                 }
  45                 file[n++] = line;
  46         }
  47 
  48         qsort( file, n, sizeof *file, fcmp );
  49 
  50         for( i= 0; i < n; i++ )
  51                 printf( "%s", file[i] );
  52 
  53         return EXIT_SUCCESS;
  54 }

W5 30.10.2012

Struktury, oparacje na wskaźnikach, dynamiczne tablice

   1 // Zwinne Czytanie - czytamy wektor o niewiadomo jakiej
   2 // długości
   3 
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include "vutl.h"
   7 
   8 int main( int argc, char **argv ) {
   9         FILE *in= argc > 1 ? fopen(argv[1],"r") : stdin;
  10 
  11         int i= 0;  // ile liczb przeczytaliśmy
  12         
  13         double *w= malloc( 10 * sizeof(double) ); // tu przechowujemy
  14         int size = 10; // tyle mamy miejsca w w
  15 
  16         double x; // tymczasowa zmienna uzywana przy czytaniu
  17 
  18         if( in == NULL || w == NULL )
  19                 return EXIT_FAILURE;
  20 
  21         while( fscanf( in, "%lf", &x ) == 1 ) {
  22                 if( i == size ) {
  23                         double *tmp= realloc( w, 2*size*sizeof(double) );
  24                         if( tmp == NULL ) {
  25                                 fprintf( stderr, "Blad przy probie powiekszenia w do wielkosci %d\n", 2*size );
  26                                 return EXIT_FAILURE;
  27                         }
  28                         w= tmp;
  29                         size *= 2;
  30                 }
  31                 w[i++]= x;
  32         }
  33 
  34         printf( "Przeczytano %d liczb, wektor w ma dlugosc = %d\n", i, size );
  35 
  36         // sortowanie i wypisywanie
  37         sortvct( w, i-2 );
  38         pvct( w, i );
  39 
  40         return EXIT_SUCCESS;
  41 }

   1 #ifndef VUTL_H
   2 #define VUTL_H
   3 
   4 void sortvct( double w[], int n );
   5 
   6 void pvct( double w[], int n );
   7 
   8 #endif
   9 

   1 #include "vutl.h"
   2 #include <stdio.h>
   3 
   4 void sortvct( double w[], int n ) {
   5         int i, j;
   6         for( i= 1; i < n; i++ ) {
   7                 double tmp= w[i];
   8                 for( j= i; j > 0 && w[j-1] > tmp; j-- )
   9                    w[j]= w[j-1];
  10                 w[j]= tmp;      
  11         }
  12 }
  13 
  14 void pvct( double w[], int n )
  15 {
  16   int i;
  17   printf( "[" );
  18   for( i= 0; i < n; i ++ )
  19     printf( " %g", w[i] );
  20   printf( " ]\n" );
  21 }

   1 #ifndef TDYN_H
   2 #define TDYN_H
   3 
   4 #include <stdio.h>
   5 
   6 typedef struct td {
   7         double *t;  // miejsce w pamięci
   8   int size;   // ile zaalokowano
   9         int n;      // ile aktualnie jest w użyciu
  10 } td_t;
  11 
  12 td_t * init_td( int start_size ); // inicjalizacja struktury o pocz. wielk. start_size
  13 
  14 td_t * double_size_td( td_t *s );
  15 
  16 int read_td( td_t *s, FILE *in ); // czyta z pliku in zawartość s
  17                                   // zwraca liczbę przeczytanych liczb
  18 
  19 void sort_td( td_t *s ); // sortuje s rosnąco
  20 
  21 #endif
  22 

   1 #include <stdlib.h>
   2 #include "tdyn.h"
   3 
   4 td_t * init_td( int start_size ) {
   5 // inicjalizacja struktury o pocz. wielk. start_size
   6         td_t *n = malloc( sizeof *n );
   7         if( n == NULL )
   8                 return NULL;
   9 
  10         if( (n->t= malloc( start_size * sizeof * n->t )) == NULL ) {
  11                 free( n );
  12                 return NULL;
  13         }
  14 
  15         n->size= start_size;
  16         n->n = 0;
  17 
  18         return n;
  19 }
  20 
  21 td_t * double_size_td( td_t *s ) {
  22 // dwukrotne powiększenie s->t
  23         double *tmp = realloc( s->t, 2*s->size*sizeof * s->t );
  24         if( tmp == NULL )
  25                 return NULL;
  26         else {
  27         s->t = tmp;
  28                 s->size *= 2;
  29                 return s;
  30         }
  31 }
  32 
  33 int read_td( td_t *s, FILE *in ) {
  34 // czyta z pliku in zawartość s
  35 // zwraca liczbę przeczytanych liczb
  36    int i= 0;
  37    double x;
  38    while( fscanf( in, "%lf", &x ) == 1 ) {
  39       if( s->n == s->size && double_size_td( s ) == NULL ) {
  40         return i;
  41       }
  42       s->t[s->n++]= x;
  43       i++;
  44    }
  45    return i;
  46 }
  47 
  48 void sort_td( td_t *s ) {
  49         int i, j;
  50         for( i= 1; i < s->n; i++ ) {
  51                 double tmp= s->t[i];
  52                 for( j= i; j > 0 && s->t[j-1] > tmp; j-- )
  53                    s->t[j]= s->t[j-1];
  54                 s->t[j]= tmp;   
  55         }
  56 }

   1 // Zwinne Czytanie - czytamy wektor o niewiadomo jakiej
   2 // długości
   3 // wykorzystujemy tablicę dynamiczną
   4 
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include "vutl.h"
   8 
   9 #include "tdyn.h"
  10 
  11 int main( int argc, char **argv ) {
  12         FILE *in= argc > 1 ? fopen(argv[1],"r") : stdin;
  13 
  14         if( in == NULL )
  15                 return EXIT_FAILURE;
  16 
  17 #ifdef STATIC
  18         td_t w;
  19 
  20         w.n= 0;
  21         if( (w.t= malloc( 4* sizeof *w.t )) == NULL )
  22                 return EXIT_FAILURE;
  23         w.size= 4;
  24 
  25         int i= read_td( &w, in );
  26 
  27         printf( "Przeczytano %d liczb, wektor w ma dlugosc = %d\n", i, w.size );
  28 
  29         sortvct( w.t, w.n );
  30         pvct( w.t, w.n );
  31   
  32 #else
  33 
  34         td_t *pw;
  35         if( (pw= init_td( 4 )) == NULL )
  36                 return EXIT_FAILURE;
  37         int i= read_td( pw, in );
  38 
  39         printf( "Przeczytano %d liczb, wektor ma dlugość = %d\n", i, pw->size );
  40 
  41         sortvct( pw->t, pw->n );
  42         pvct( pw->t, pw-> n );
  43         
  44 #endif
  45 
  46         return EXIT_SUCCESS;
  47 }

W4 23.10.2012

Czytanie z plików, regresja liniowa, dynamiczna allokacja pamięci, make

   1 // regresja liniowa: czyta plik zawierający pary x_i, y_i
   2 // wyznacza współczynniki a i b takie, aby zminimalizować
   3 // błąd średniokwadratowy sum_i (ax_i+b - y_i)^2
   4 // UWAGA! TO JEST WERSJĄ Z BŁĘDEM !!!
   5 
   6 #include <stdio.h>
   7 
   8 //czytanie danych
   9 int czytajxy( FILE *in, double *x, double *y, int max ) {
  10         int n= 0;
  11         int bfs= 0;
  12         double t1, t2;
  13 
  14         while( (bfs= fscanf( in, "%lf %lf", &t1, &t2 )) == 2 )
  15                 if( n == max )
  16                         return -max;
  17                 else {
  18                         x[n]= t1;
  19                         y[n]= t2;
  20                         n++;
  21                 }
  22 
  23         if( bfs == EOF )
  24                 return n;
  25         else
  26                 return -n;
  27 }
  28 
  29 void reg_lin( double *x, double *y, int n, double *a, double *b ) {
  30         int i;
  31         double sx2=  0.0;
  32   double sx4=  0.0;
  33   double syx2= 0.0;
  34   double sy=   0.0;
  35         double w;
  36         for( i= 0; i < n; i++ ) {
  37                 double x2= x[i]*x[i];
  38                 sy += y[i];
  39                 syx2 += y[i]*x2;
  40                 sx2 += x2;
  41                 sx4 += x2*x2;
  42         }
  43         w = sx4*n - sx2*sx2;
  44         *a = ( syx2*n - sx2*sy ) / w;
  45         *b = ( sx4*sy - syx2*sx2 ) / w;
  46 }
  47 
  48 #define MAX 10
  49 
  50 int main( int argc, char **argv ) {
  51         double x[MAX];
  52         double y[MAX];
  53         int n;
  54         double a, b;
  55 
  56         FILE *in= argc > 1 ? fopen( argv[1], "r" ) : stdin;
  57 
  58         if( (n= czytajxy( in, x, y, MAX ))  <= 0 ) {
  59                 fprintf( stderr, "%s: błędne dane - przeczytano %d par liczb i napotkano błąd.\n", argv[0], -n );
  60                 return -1;
  61         }
  62 
  63         reg_lin( x, y, n, &a, &b );
  64 
  65         printf( "Regresja liniowa danych: y = %g x + %g\n", a, b );
  66 
  67         return 0;
  68 }

Poprawiona wersja regresji liniowej, z plikiem Makefile (archiwum zip)

   1 // Zwinne Czytanie - czytamy wektor o niewiadomo jakiej
   2 // długości
   3 
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 
   7 int main( int argc, char **argv ) {
   8         FILE *in= argc > 1 ? fopen(argv[1],"r") : stdin;
   9 
  10         int i= 0;  // ile liczb przeczytaliśmy
  11         
  12         double *w= malloc( 10 * sizeof(double) ); // tu przechowujemy
  13         int size = 10; // tyle mamy miejsca w w
  14 
  15         double x; // tymczasowa zmienna uzywana przy czytaniu
  16 
  17         if( in == NULL || w == NULL )
  18                 return EXIT_FAILURE;
  19 
  20         while( fscanf( in, "%lf", &x ) == 1 ) {
  21                 if( i == size ) {
  22                         double *tmp= realloc( w, 2*size*sizeof(double) );
  23       if( tmp == NULL ) {
  24                                 fprintf( stderr, "Blad przy probie powiekszenia w do wielkosci %d\n", 2*size );
  25                                 return EXIT_FAILURE;
  26                         }
  27                         w= tmp;
  28                         size *= 2;
  29                 }
  30                 w[i++]= x;
  31         }
  32 
  33         printf( "Przeczytano %d liczb, wektor w ma dlugosc = %d\n", i, size );
  34         return EXIT_SUCCESS;
  35 }

W3 16.10.2012

Czytanie plików zawierających liczby

   1 // czyta z pliku pary liczb (u,i)
   2 // i wypisuje na stdout
   3 // trójki liczb (u,i, u/i)
   4 
   5 #include <stdio.h>
   6 
   7 int main( int argc, char *argv[] ) {
   8         double u,i;
   9 
  10         if( argc != 2 ) {
  11                 fprintf( stderr, "Błąd: oczekiwany argument - nazwa pliku z danymi\n" );
  12                 return 1;
  13         }
  14 
  15         FILE *in = fopen( argv[1], "r" );
  16 
  17         if( in == NULL ) {
  18                 fprintf( stderr, "Błąd: nie mogę otworzyć %s do czytania\n", argv[1] );
  19                 return 2;
  20         }
  21 
  22         while( fscanf( in, "%lf %lf", &u, &i ) == 2 )
  23                 printf( "%g\t%g\t%g\n", u, i, u/i );
  24 
  25         if( !feof(in) ) {
  26                 fprintf( stderr, "Błąd: jakieś śmieci w pliku %s\n", argv[1] );
  27                 return 3;
  28         }
  29 
  30         fclose( in );
  31 
  32         return 0;
  33 }

   1 // czyta z pliku (albo z stdin gdy nie podano nazwy) pary liczb (u,i)
   2 // i wypisuje do pliku (albo na stdout gdy nie podano nazwy)
   3 // trójki liczb (u,i, u/i)
   4 
   5 #include <stdio.h>
   6 
   7 int main( int argc, char *argv[] ) {
   8         double u,i;
   9         FILE *in = argc > 1 ? fopen( argv[1], "r" ) : stdin;
  10         FILE *ou = argc > 2 ? fopen( argv[2], "w" ) : stdout;
  11         char *progname= argv[0];
  12 
  13         if( in == NULL ) {
  14                 fprintf( stderr, "%s: Błąd: nie mogę otworzyć \"%s\" do czytania\n", progname, argv[1] );
  15                 return 1;
  16         }
  17 
  18         if( ou == NULL ) {
  19                 fprintf( stderr, "%s: Błąd: nie mogę otworzyć \"%s\" do pisania\n", progname, argv[2] );
  20                 return 2;
  21         }
  22 
  23         while( fscanf( in, "%lf %lf", &u, &i ) == 2 )
  24                 fprintf( ou, "%g\t%g\t%g\n", u, i, u/i );
  25 
  26         if( !feof(in) ) {
  27                 fprintf( stderr, "Błąd: jakieś śmieci w pliku %s\n", argv[1] );
  28                 return 3;
  29         }
  30 
  31         fclose( in );
  32         fclose( ou );
  33 
  34         return 0;
  35 }

   1 // regresja liniowa: czyta plik zawierający pary x_i, y_i
   2 // wyznacza współczynniki a i b takie, aby zminimalizować
   3 // błąd średniokwadratowy sum_i (ax_i+b - y_i)^2
   4 // TYLKO TEST FUNKCJI WCZYTUJĄCEJ !!!
   5 
   6 #include <stdio.h>
   7 
   8 //czytanie danych
   9 int czytajxy( FILE *in, double *x, double *y, int max ) {
  10         int n= 0;
  11         int bfs= 0;
  12 
  13         while( n < max && (bfs= fscanf( in, "%lf %lf", &x[n], &y[n] )) == 2 )
  14                 n++;
  15 
  16         if( bfs == EOF || feof(in) )
  17                 return n;
  18         else
  19                 return -n;
  20 }
  21 
  22 #define MAX 10
  23 
  24 int main( int argc, char **argv ) {
  25         double x[MAX];
  26         double y[MAX];
  27 
  28         FILE *in= argc > 1 ? fopen( argv[1], "r" ) : stdin;
  29 
  30         printf( "czytajxy zwróciła %d\n", czytajxy( in, x, y, MAX ) );
  31 
  32         return 0;
  33 }

W2 9.10.2012

Argumenty wywołania - komunikacja z programem

   1 #include <stdio.h>
   2 #include <math.h>
   3 
   4 int
   5 main ()
   6 {
   7   int d;                        // kąt w stopniach
   8   double r;                     // kąt w radianach
   9 
  10   for (d = 5; d <= 360; d += 5) {
  11     r = (double) d / 180 * M_PI;
  12     printf ("%05d\t%10.5g\n", d, r);
  13   }
  14 
  15   return 0;
  16 }

   1 #include <stdio.h>
   2 #include <math.h>
   3 #include <stdlib.h>
   4 
   5 int
   6 main ( int argc, char *argv[] )
   7 {
   8         int start, stop, krok;
   9   int d;                        // kąt w stopniach
  10   double r;                     // kąt w radianach
  11 
  12         start= argc > 1 ? atoi( argv[1] ) : 0;
  13         stop=  argc > 2 ? atoi( argv[2] ) : 360;
  14         krok=  argc > 3 ? atoi( argv[3] ) : 10;
  15 
  16   for (d = start; d <= stop; d += krok) {
  17     r = (double) d / 180 * M_PI;
  18     printf ("%05d\t%10.5g\n", d, r);
  19   }
  20 
  21   return 0;
  22 }

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 
   4 int
   5 main ( int argc, char *argv[] )
   6 {
   7         double start, stop, krok;
   8   double u;                     // rzędna
   9         int i,n;
  10         double min_i, max_i;
  11 
  12         start= argc > 1 ? atof( argv[1] ) : 0;
  13         stop=  argc > 2 ? atof( argv[2] ) : 1;
  14         krok=  argc > 3 ? atof( argv[3] ) : .01;
  15         min_i = argc > 4 ? atof( argv[4] ) : -1;
  16         max_i = argc > 5 ? atof( argv[5] ) : 1;
  17 
  18         srand( argc > 6 ? atoi( argv[6] ) : 0 );
  19 
  20         n= (stop-start)/krok+1;
  21 
  22   for (i= 0; i <= n; i++) {
  23                 u= start + i * krok;
  24     printf ("%g\t%g\n", u, min_i+((double)rand()/RAND_MAX*(max_i-min_i)) );
  25   }
  26 
  27   return 0;
  28 }

   1 #include <stdio.h>
   2 
   3 int main() {
   4         double u,i;
   5 
   6         while( scanf( "%lf %lf", &u, &i ) == 2 )
   7                 printf( "%g\t%g\t%g\n", u, i, u/i );
   8 
   9         return 0;
  10 }

W1 2.10.2012

Wprowadzenie

   1 #include <stdio.h>
   2 
   3 int main( int argc, char *argv[] )
   4 {
   5         if( argc > 1 ) {
   6                 printf( "Cześć %s\n", argv[1] );
   7                 return 0;
   8         } else {
   9                 printf( "Cześć\n" );
  10                 return 1;
  11         }
  12 }

   1 /* Sumator: dodaje liczby podane jako argumenty wywołania */
   2 
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 
   6 double sum( double v[], int n )
   7 {
   8         double s = 0.0;
   9         int i;
  10         for( i= 0; i < n; i++ )
  11                 s += v[i];
  12 
  13         return s;
  14 }
  15 
  16 void pvct( double w[], int n ) 
  17 {
  18         int i;
  19         printf( "[" );
  20         for( i= 0; i < n; i ++ )
  21                 printf( " %g", w[i] );
  22         printf( " ]\n" );
  23 }
  24 
  25 void sortvct( double w[], int n ) {
  26         int i, j;
  27         for( i= 1; i < n; i++ ) {
  28                 double tmp= w[i];
  29                 for( j= i; j > 0 && w[j-1] > tmp; j-- )
  30                    w[j]= w[j-1];
  31                 w[j]= tmp;      
  32         }
  33 }
  34 
  35 int main( int argc, char *argv[] ) {
  36         double w[1000];
  37         int m= 0;
  38 
  39         int i;
  40 
  41         for( i= 1; i < argc; i++ )
  42                 w[m++]= atof( argv[i] );
  43 
  44         pvct( w, m );
  45 
  46         sortvct( w, m );
  47 
  48         pvct( w, m );
  49 
  50         printf( "suma=%g\n", sum( w, m ) );
  51 
  52         return 0;
  53 }

2015-09-23 06:44