- Stahuj zápisky z přednášek a ostatní studijní materiály
- Zapisuj si jen kvalitní vyučující (obsáhlá databáze referencí)
- Nastav si své předměty a buď stále v obraze
- Zapoj se svojí aktivitou do soutěže o ceny
- Založ si svůj profil, aby tě tví spolužáci mohli najít
- Najdi své přátele podle místa kde bydlíš nebo školy kterou studuješ
- Diskutuj ve skupinách o tématech, které tě zajímají
Studijní materiály
Vše v jednom
KTE/ZPE - Základy programování pro elektrotechniku
Zjednodušená ukázka:
Stáhnout celý tento materiál!3 = 0
!1 = 0
!(a < 5)
~3D = 252
~00000011B = 11111100B
~1D = 254
~00000001B = 11111110B
signed short int i;
1. Dekadická čísla
a) rozložený tvar
12345
5 4 3 2 1
00000101 00000100 00000011 00000010 00000001
b) stažený tvar Binary Coded Decimal
12345
45 23 01
0100 0101 0010 0011 0000 0001
Převody číselných soustav
11111111B = FFH = 255D
5D = 101B
76543210 – pořadí bitů
00000101B = 20*1 + 21*0 +22*1 + 23*0 + 24*0 +25*0 + 26*0 + 27*0 = 1 + 0 + 4 + 0 + 0 + 0 + 0 + 0 = 5D
10D = 1010B
40D = 28H 54D = 36H 31D = 1(15) = 1FH
2 3
0
Číslice 16ové soustavy:
0 1 2 3 4 5 6 7 8 9 (10) (11) (12) (13) (14) (15)
0 1 2 3 4 5 6 7 8 9 A B C D E F
1Fh = 1FH
2) Celá čísla v pevné řádové čárce (pevná délka slova)
a) jednoduchá délka – Word = 2 Byte
0 – 65535
b) dvojnásobná délka – DWord = 4 Byte
0 – 4294967295
Na 8 bitech:
MSB
LSB
n-1 0
Most Significant Bit – nejvýznamnější bit
Least Significant Bit – nejméně významný bit
Zobrazení kladných i záp. celých čísel v paměti počítače
a) přímý kód (příklady na 8mi bitech, obdobně pro více bitů)
5D = 00000101B
kl. čísla 0 – 127
záp. čísla –127 – 0
0/1
+/-
00000000B = 0D
10000000B = -0D
b) invezní kód
5D = 00000101B
-5D = 11111010B
00000000B = 0D
11111111B = -0D
c) doplňkový kód
5D = 00000101B
11111010 – inverzní kód
+ 00000001
-5D = 11111011B
Když chci získat dec. číslo:
-5D = 11111011B
00000100 – inverzní kód
+ 00000001
00000101B = 5D
5D = 00000101B
-5D = 11111011B
00000000B
00000000B = 0D
11111111B
00000001B
00000000B
d) kód s posunutou nulou – někde uprostřed rozsahu si stanovím nulu, např. 127
3) Reálná čísla – pevná řádová čárka
,00100000B = 0,125D
76543210
1
1* ––––- + atd.
28-5
IEEE formát
32 bitů 00000000000000000000000000000000
znaménko mantisy
exponent - kód sposunutou nulou
mantisa – přímý kód – desetinné č.
14.3.2005
j = j || (i / 2)
int i = 1, j = 1;
j = !j && (i = i + 1) – spíše odstrašující
0 (nepravda) 2 (pravda)
Celkově: 0 (nepravda)
int i = 5;
/* nejaky vypocet */
if (i == 1)
/* prikaz */
1
if (i = 1) /* asi chyba – i bude 1 místo 5 a podmínka
je pravdiva */
/* prikaz */
int c;
if (c = getchar() == 'A') { /* chyba - v c bude 0 nebo 1 */
/* nejake operace vyuzivajici prom. c */
if ((c = getchar()) == 'A') { /* chyba - v c bude 0 nebo 1 */
/* nejake operace vyuzivajici prom. c */
podmínka ? je-li pravdivá : je-li nepravdivá;
(a < 5) ? a++ : a--;
b = (a < 5) ? a : a - 5;
int c;
c = getchar();
c = ((c >= 'a') && (c unsigned long => float => double => long double
int c; /* vetsinou znaky */
c++;
c = 'A' + 3;
Explicitní
int i;
double d = 3.14;
i = (int) d; /* i bude 3, d bude stále 3.14 */
c = (char) i;
(double), (float) atd.
- má vysokou prioritu
i = (int) d * 5 /* napřed se provede (int) d a potom nás.*/
double d;
double PI = 3.14159;
d = 4 / 3 * PI;
- d bude PI, tj. 3.14159
Správně např. s explicitní typovou konverzí:
double d;
double PI = 3.14159;
d = (double) 4 / (double) 3 * PI;
- d bude PI, tj. 5,1887866666666666666666666666667
Spec. - přetyp. na void
prázdný typ
(void) sin(PI); /* poněkud málo užitečné použití ;-) */
- potlačení návratové hodnoty funkce
18.4.2005
Explicitní přetypování - dokončení
double d;
d = 13.628346;
d = (double)((long) d); /* d bude 13.0 */
(int) f = 3; /* nelze, přetypování NENÍ l-hodnota
Preprocesor jazyka C
- direktivy začínají #
- zpracují před vlastním překladem do stroj. kódu
- např. #include
Konstanty
#define PI 3.14
#define PIPI (PI + PI)
main()
{
double d;
d = 2 * PIPI;
/* bez závorek u PIPI by počítal 2*3.14 + 3.14 */
printf("\nd = %f\n", d);
system("PAUSE");
}
zrušení definice:
#undef PI
Lze i:
#define WOKNA
main()
{
double d;
d = 2 * PIPI;
printf("\nd = %f\n", d);
#ifdef WOKNA
printf("\nJsem pod Woknama... UAAAA!!!\n");
#else
Tady dam cokoliv, sem se prekladac nedostane !!!
asdf
printf("\nNejsem pod Woknousama, huraaa...\n");
#endif
}
lze též:
#ifndef WOKNA - tj. if not def - jestliže není def.
zbytek je stejný
#define WIN 2000
main()
{
double d;
d = 2 * PIPI;
printf("\nd = %f\n", d);
#if WIN = 2000
printf("\nJsem pod Woknama 2000... UAAAA!!!\n");
#else
Tady dam cokoliv, sem se prekladac nedostane !!!
asdf
printf("\nNejsem pod Woknousama, huraaa...\n");
#endif
}
#define MOD %
#define POSUN ('a' - 'A')
#define KONEC_RADKU '\n'
Makra
- předpřipravená jsou např. v ctype.h
#define je_velke(c) ((c) >= 'A' && (c) >=, , x dx/dt\n" ); /* problem dependent */
actual_time = run_simulation( step_size, final_time );
/* Print final result */
printf( "%3.5f> ", actual_time );
for( i = 0; i < NUM_STATE_VARIABLES; i++)
printf( "%2.5f ", state[ i ] );
printf( "\n\n correct output: %f\n", cos( actual_time ) );
simulation_error = fabs( state[ 0 ] - cos( actual_time ));
step_size *= STEP_SIZE_SCALING_FACTOR;
}
}
double run_simulation( double step, double final_time )
{
int i;
register double step_size = step;
double t = 0.0;
float new_state[ NUM_STATE_VARIABLES ];
for( i = 0; i < NUM_STATE_VARIABLES; i++ )
state[ i ] = initial_state[ i ];
while( t = MONITOR_START_TIME) && (t = feature_size )
{
x_index = (((n - feature_size) >> 1) * 3) + STATE_FEATURE_START;
camera = camera_origin;
}
else
{
x_index = ((n >> 1) * 3) + STATE_FEATURE_START;
camera = a;
}
/* The angular velocity information is converted to a global
rotation, which is the one used by all equations. */
if( R == NULL )
R = matrix( 1, 3, 1, 3 );
rotation_q[0] = sqrt( 1.0 -(0.25*((camera[ STATE_Wx ]*camera[ STATE_Wx ]) +
(camera[ STATE_Wy ]*camera[ STATE_Wy ]) +
(camera[ STATE_Wz ]*camera[ STATE_Wz ]))));
rotation_q[1] = camera[ STATE_Wx ] * 0.5;
rotation_q[2] = camera[ STATE_Wy ] * 0.5;
rotation_q[3] = camera[ STATE_Wz ] * 0.5;
if( rotation_q[0] < MIN_QUATERNION_MAGNITUDE )
{
rotation_q[0] = 1.0;
rotation_q[1] = 0.0; rotation_q[2] = 0.0; rotation_q[3] = 0.0;
}
quaternion_to_rotation( rotation_q, R );
Beta = a[ STATE_B ]; /* the inverse of the focal length */
fx = a[ x_index + X - 1 ];
fy = a[ x_index + Y - 1 ];
fz = a[ x_index + Z - 1 ];
/* Calculate transformed version of the coordinates, depending on the
state estimate. */
image_pos[X] = camera[ STATE_Tx ]
+ (fx * R[X][X]) + (fy * R[X][Y]) + (fz * R[X][Z]);
image_pos[Y] = camera[ STATE_Ty ]
+ (fx * R[Y][X]) + (fy * R[Y][Y]) + (fz * R[Y][Z]);
image_pos[Z] = (fx * R[Z][X]) + (fy * R[Z][Y]) + (fz * R[Z][Z]);
/* And some useful intermediate values */
D = ARBITRARY_SCALE / ( 1.0 + camera[ STATE_Tz ] + (Beta * image_pos[Z]));
D2 = (D * D);
for( n = STATE_FEATURE_START; n 1.0 )
dyda[ STATE_B ] = -XcD2 * (image_pos[Z] + (camera[ STATE_Tz ]/Beta));
else
dyda[ STATE_B ] = -XcD2 * image_pos[Z];
/* The derivative relative to the X world location */
dyda[ x_index ] = (D*R[X][X]) - (XcBD2*R[Z][X]);
/* The derivative relative to the Y world location */
dyda[ x_index + 1 ] = (D*R[X][Y]) - (XcBD2*R[Z][Y]);
/* The derivative relative to the Z world location */
dyda[ x_index + 2 ] = (D*R[X][Z]) - (XcBD2*R[Z][Z]);
}
else
{
YcD2 = image_pos[Y] * D2;
YcBD2 = YcD2 * Beta;
*yfit = image_pos[Y] / (1.0 + camera[ STATE_Tz ] + (Beta*image_pos[Z]));
dyda[ STATE_Tx ] = 0;
dyda[ STATE_Ty ] = D;
dyda[ STATE_Tz ] = -YcD2;
/* Calculate the rotational derivatives for the y measurement */
temp = (D*((rotation_q[3]*fx)
+ (rotation_q[0]*fy)
- (rotation_q[1]*fz)))
- (YcBD2*((-rotation_q[2]*fx)
+ (rotation_q[1]*fy)
+ (rotation_q[0]*fz)));
temp2 = (D*((rotation_q[2]*fx)
- (rotation_q[1]*fy)
- (rotation_q[0]*fz)));
temp2 = temp2 - (YcBD2*((rotation_q[3]*fx)
+(rotation_q[0]*fy)
-(rotation_q[1]*fz)));
dyda[ STATE_Wx ] = (x_part * temp) + temp2;
temp2 = (D*((rotation_q[1]*fx)
+ (rotation_q[2]*fy)
+ (rotation_q[3]*fz)));
temp2 = temp2 - (YcBD2*(-(rotation_q[0]*fx)
+(rotation_q[3]*fy)
-(rotation_q[2]*fz)));
dyda[ STATE_Wy ] = (y_part * temp) + temp2;
temp2 = (D*((rotation_q[0]*fx)
- (rotation_q[3]*fy)
+ (rotation_q[2]*fz)));
temp2 = temp2 - (YcBD2*((rotation_q[1]*fx)
+(rotation_q[2]*fy)
+(rotation_q[3]*fz)));
dyda[ STATE_Wz ] = (z_part * temp) + temp2;
if( Beta > 1.0 )
dyda[ STATE_B ] = -YcD2 * (image_pos[Z] + (camera[ STATE_Tz ]/Beta));
else
dyda[ STATE_B ] = -YcD2 * image_pos[Z];
/* The derivative relative to the X world location */
dyda[ x_index+X-1 ] = (D*R[Y][X]) - (YcBD2*R[Z][X]);
/* The derivative relative to the Y world location */
dyda[ x_index+Y-1 ] = (D*R[Y][Y]) - (YcBD2*R[Z][Y]);
/* The derivative relative to the Z world location */
dyda[ x_index+Z-1 ] = (D*R[Y][Z]) - (YcBD2*R[Z][Z]);
}
}
#undef X
#undef Y
#undef Z
#undef VECSIZE
/* expdiff.c
explicit diffusion simulation
J. Watlington, 10/16/95
*/
#include
#include
#include
#define DEBUG
#define DEBUG_PERIOD 20.0
#define NUM_POINTS 500
#define NUM_BUFFERS 2
#define MIN_TOTAL_CHANGE 0.001
#define MAX_TIME 200.0
#define DIFF_COEFF 1.0
#define DELTA_X 1.0
#define DEFAULT_DELTA_T 1.0
#define START_IMPULSE_AMPL 1.0
#define START_IMPULSE_LOC ( NUM_POINTS / 2 )
typedef long double sim_type;
void display_lattice( sim_type *lattice );
void main( int argc, char **argv )
{
int x;
int buf;
int cur_buf = 1;
int prev_buf = 0;
long double t = 0.0;
long double delta_t = DEFAULT_DELTA_T;
long double total_change = 10.0 * MIN_TOTAL_CHANGE;
sim_type present_value;
sim_type new_value;
sim_type state[ NUM_BUFFERS ][ NUM_POINTS + 2 ];
/* Parse arguments, if provided */
if( argc > 2 )
{
printf( "usage: %s []\n", argv[0] );
exit( -1 );
}
else if( argc > 1 )
{
sscanf( argv[1], "%Lf", &delta_t );
}
printf( "running till total change less than %f\n", MIN_TOTAL_CHANGE );
printf( "using a %f second time step\n", delta_t );
/* Initialize the simulation state to initial conditions */
for( buf = 0; buf < NUM_BUFFERS; buf++ )
for( x = 0; x < (NUM_POINTS + 2); x++ )
state[ buf ][ x ] = 0.0;
state[ prev_buf ][ START_IMPULSE_LOC ] = START_IMPULSE_AMPL;
#ifdef DEBUG
printf( "\nAt time t = %f, here are the results :\n", t );
display_lattice( state[ prev_buf ] );
#endif
/* And loop until the simulation stops changing... */
while( (total_change > MIN_TOTAL_CHANGE) && (t < MAX_TIME) )
{
/* Perform one iteration through the lattice, calculating the
new values. */
for( total_change = 0.0, x = 1; x = NUM_BUFFERS ) cur_buf = 0;
if( ++prev_buf >= NUM_BUFFERS ) prev_buf = 0;
t += delta_t;
#ifdef DEBUG
if( fmod( t, DEBUG_PERIOD ) == 0.0 )
{
printf( "\nAt time t = %f, here are the results :\n", t );
display_lattice( state[ prev_buf ] );
}
#endif
}
if( t >= MAX_TIME )
printf( "The solution never stabilized !!!\n" );
printf( "\nAt time t = %f, here are the results :\n", t );
display_lattice( state[ prev_buf ] );
}
#define NUM_COLS 10
#define NUM_ROWS ( NUM_POINTS / NUM_COLS )
void display_lattice( sim_type *lattice )
{
int y;
int x;
int index;
for( index = 1, y = 0; y < NUM_ROWS; y++ )
{
printf( "%d:", (NUM_COLS * y) );
for( x = 0; x < NUM_COLS; x++, index++ )
{
printf( " %1.4f", lattice[ index ] );
}
printf( "\n" );
}
}
/* fhplattice.c
This application solves for the behavior of a lattice gas,
using cellular automata in a hexagonal lattice (FHP)
J. Watlington, 10/25/95
Usage: fhplattice [ block | random | test ] [ -s ]
Modified:
*/
#include
#include
#include "display.h"
#define SCATTER_ALTERNATELY
#define DEFAULT_MAX_ITERATIONS 2000
#define MAX_ARRAY_SIZE 1024
#define DEFAULT_ARRAY_SIZE 512
/* The following define how the array is seeded */
#define SEED_BLOCK_SIZE ((array_size) / 4)
#define SEED_BLOCK_START ((3 *(array_size)) / 8)
#define SEED_RAND_SEED 0xFF67533
#define SEED_RAND_THRESHOLD 22000
#define SEED_BLOCK 0
#define SEED_BLOCK_AND_RND 1
#define SEED_TEST 2
#define DEFAULT_ARRAY_SEED SEED_BLOCK_AND_RND
/* The following global variables are used for command line parameters */
int array_size = DEFAULT_ARRAY_SIZE;
int array_seed = DEFAULT_ARRAY_SEED;
int max_iterations = DEFAULT_MAX_ITERATIONS;
/* This is the structure that will represent the lattice of nodes */
#define DEGREE_OF_INTERCONNECT 6
#define NUM_RULES 64 /* 2^DEGREE_OF_INTERCONNECT */
#define MAX_PARTICLES 6 /* used only for display */
#ifndef USE_BIT_STORAGE
typedef struct {
char northeast;
char northwest;
char east;
char west;
char southeast;
char southwest;
} lattice_node;
#else
typedef struct {
char northeast:1,
northwest:1,
east:1,
west:1,
southeast:1,
southwest:1,
reserved:2;
} lattice_node;
#endif
/* One of the few peculiarities of this program is the manner in
which I represent the lattice arrays. For ease of access, I
store an array of pointers (d) to the rows of the array. */
typedef struct {
int size; /* Assume square array ! */
lattice_node *d[ MAX_ARRAY_SIZE ];
} lattice;
/* These are the rules the determine the behavior of this lattice gas */
lattice_node rules[ NUM_RULES ] = { /* { NE, NW, E, W, SE, SW } Col. Scatter */
{ 0,0,0,0,0,0 }, { 1,0,0,0,0,0 }, { 0,1,0,0,0,0 }, { 1,1,0,0,0,0 },
{ 0,0,1,0,0,0 }, { 1,0,1,0,0,0 }, { 0,1,1,0,0,0 }, { 1,1,1,0,0,0 },
{ 0,0,0,1,0,0 }, { 1,0,0,1,0,0 }, { 0,1,0,1,0,0 }, { 1,1,0,1,0,0 },
{ 0,1,0,0,1,0 }, { 1,0,1,1,0,0 }, { 0,1,1,1,0,0 }, { 1,1,1,1,0,0 }, /* 0 2b */
{ 0,0,0,0,1,0 }, { 1,0,0,0,1,0 }, { 0,0,1,1,0,0 }, { 1,1,0,0,1,0 }, /* 2 2b */
{ 0,0,1,0,1,0 }, { 1,0,1,0,1,0 }, { 0,1,1,0,1,0 }, { 1,1,1,0,1,0 },
{ 0,0,0,1,1,0 }, { 0,1,1,0,0,1 }, { 0,1,0,1,1,0 }, { 1,1,0,1,1,0 }, /* 1 3b */
{ 0,0,1,1,1,0 }, { 1,0,1,1,1,0 }, { 0,1,1,1,1,0 }, { 1,1,1,1,1,0 },
{ 0,0,0,0,0,1 }, { 0,0,1,1,0,0 }, { 0,1,0,0,0,1 }, { 1,1,0,0,0,1 }, /* 1 2b */
{ 0,0,1,0,0,1 }, { 1,0,1,0,0,1 }, { 1,0,0,1,1,0 }, { 1,1,1,0,0,1 }, /* 2 3b */
{ 0,0,0,1,0,1 }, { 1,0,0,1,0,1 }, { 0,1,0,1,0,1 }, { 1,1,0,1,0,1 },
{ 0,0,1,1,0,1 }, { 1,0,1,1,0,1 }, { 0,1,1,1,0,1 }, { 1,1,1,1,0,1 },
{ 0,0,0,0,1,1 }, { 1,0,0,0,1,1 }, { 0,1,0,0,1,1 }, { 1,1,0,0,1,1 },
{ 0,0,1,0,1,1 }, { 1,0,1,0,1,1 }, { 0,1,1,0,1,1 }, { 1,1,1,0,1,1 },
{ 0,0,0,1,1,1 }, { 1,0,0,1,1,1 }, { 0,1,0,1,1,1 }, { 1,1,0,1,1,1 },
{ 0,0,1,1,1,1 }, { 1,0,1,1,1,1 }, { 0,1,1,1,1,1 }, { 1,1,1,1,1,1 },
};
#ifdef SCATTER_ALTERNATELY
static int scatter_dir = 0;
static lattice_node scatter[ 4 ] = {
{ 0,0,1,1,0,0 }, { 0,1,0,0,1,0 }, { 1,0,0,0,0,1 }, { 0,0,1,1,0,0 }
};
#endif
/* These are prototypes of functions internal to this code module */
void parse_arguments( int argc, char **argv );
lattice *alloc_lattice( int size );
void seed_lattice( lattice *l, int seed );
void calc_collisions( lattice *l, lattice *temp );
void calc_collision_row( lattice *in, lattice *out,
int prev_row_index, int cur_row_index,
int next_row_index );
void display_lattice( window_tag wt, lattice *l );
/* This is the top level of the program */
void main( int argc, char **argv )
{
lattice *nodes[ 2 ];
int next_buf = 1;
int cur_buf = 0;
int num_iters = 0;
window_tag w;
parse_arguments( argc, argv );
nodes[ cur_buf ] = alloc_lattice( array_size );
nodes[ next_buf ] = alloc_lattice( array_size );
seed_lattice( nodes[ cur_buf ], array_seed );
if( (w = display_init_window( "FHP", array_size, array_size,
MAX_PARTICLES + 1)) < 0 )
{
printf( "Unable to open display window.\n" );
exit( -1 );
}
display_lattice( w, nodes[ cur_buf ] );
while( num_iters++ < max_iterations ) {
calc_collisions( nodes[ cur_buf ], nodes[ next_buf ] );
display_lattice( w, nodes[ next_buf ] );
cur_buf = next_buf;
next_buf = 1 - next_buf;
}
}
void calc_collisions( lattice *in, lattice *out )
{
int size = in->size - 1;
int row;
calc_collision_row( in, out, size, 0, 1 );
for( row = 1; row < size; row++ )
calc_collision_row( in, out, row - 1, row, row + 1 );
calc_collision_row( in, out, size - 1, size, 0 );
}
void calc_collision_row( lattice *in, lattice *out,
int prev_row_index, int cur_row_index,
int next_row_index )
{
int adr;
int col;
int size = in->size - 1;
lattice_node *outcome;
lattice_node *cur_row_in = in->d[ cur_row_index ];
lattice_node *prev_row_out = out->d[ prev_row_index ];
lattice_node *cur_row_out = out->d[ cur_row_index ];
lattice_node *next_row_out = out->d[ next_row_index ];
/* Special case the first node in a row */
adr = 0;
if( cur_row_in->northeast != 0 ) adr |= 32;
if( cur_row_in->northwest != 0 ) adr |= 16;
if( cur_row_in->east != 0 ) adr |= 8;
if( cur_row_in->west != 0 ) adr |= 4;
if( cur_row_in->southeast != 0 ) adr |= 2;
if( cur_row_in->southwest != 0 ) adr |= 1;
outcome = rules + adr;
if( cur_row_index & 1 )
{ /* odd row */
prev_row_out[ 0 ].southwest = outcome->northeast;
prev_row_out[ size ].southeast = outcome->northwest; /* boundary */
cur_row_out[ 1 ].west = outcome->east;
cur_row_out[ size ].east = outcome->west; /* periodic boundary ! */
next_row_out[ 0 ].northwest = outcome->southeast;
next_row_out[ size ].northeast = outcome->southwest; /* boundary */
}
else
{ /* even row - offset in slightly */
prev_row_out[ 1 ].southwest = outcome->northeast;
prev_row_out[ 0 ].southeast = outcome->northwest;
cur_row_out[ 1 ].west = outcome->east;
cur_row_out[ size
Vloženo: 3.07.2009
Velikost: 1,95 MB
Komentáře
Tento materiál neobsahuje žádné komentáře.
Mohlo by tě zajímat:
Reference vyučujících předmětu KTE/ZPE - Základy programování pro elektrotechnikuPodobné materiály
Copyright 2023 unium.cz. Abychom mohli web rozvíjet a dále vylepšovat podle preferencí uživatelů, shromažďujeme statistiky o návštěvnosti, a to pomocí Google Analytics a Netmonitor. Tyto systémy pro unium.cz zaznamenávají, které stránky uživatel na webové stránce navštívil, odkud se na stránku dostal, kam z ní odešel, jaké používá zařízení, operační systém či prohlížeč, či jaký má preferenční jazyk. Statistiky jsou anonymní, takže unium.cz nezná identitu návštěvníka a spravuje cookies tak, že neumožňuje identifikovat konkrétní osoby. Používáním webu vyjadřujete souhlas použitím cookies a následujících služeb: