.RU

ПРИЛОЖЕНИЯ ПРИЛОЖЕНИЕ A - Отчет о научно-исследовательской работе


^ ПРИЛОЖЕНИЯ


ПРИЛОЖЕНИЕ A
Исходный текст расчетной программы стохастического моделирования


/*

* Используемые типы данных и сервисные функции определены и реализованы в

* каркасной библиотеке LibV, распространяемой в исходных текстах

* на условиях лицензии BSD. Исходный текст библиотеки доступен на сервере исполнителя http://www.libv.org

*/


/*

* Имя файла модуля: cmo.c

* Назначение модуля: интерфейс с управляющим файлом, основной модуль.

*/


/*

* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

*

* cmo - (C)ontact (MO)deler.

*

* Vladimir A. Smirnov (kkatarn@sleepgate.ru, smirnov@nocnt.ru), 2011-2012

*

* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

* This program parses control file (see libv.org/libv/cmo/test.cmo) and

* creates box(es) with randomly distributed fibers, then computes number of

* "contacts" between them and than extrapolates volumetric content to the

* value corresponding the equality between numbers of fibers and

* contacts.

*

* The 'toy' version of this program - with visualization stuff - is in

* antiglut source tarball. This version is much more complicated, but

* includes no bells and whistles. Just to get the job done, nothing more.

*

* Precompiled versions for WinNT-32 and FreeBSD-amd64:

* http://libv.org/libv/cmo/cmo.exe

* http://libv.org/libv/cmo/cmo.elf-freebsd-amd64

*

* Here are also the examples of control scripts.

* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

*/


#include

#include "rgcache.h"

#include "genparse.h"

#include "seqparse.h"

#include "sysproto.h"


vhandle_t lex;

vp_stack_t gens = TYPED_STACK_EMPTY_INITIALIZER;

vp_stack_t seqs = TYPED_STACK_EMPTY_INITIALIZER;

vp_stack_t syss = TYPED_STACK_EMPTY_INITIALIZER;


int main(int argc, char *argv[])

{

CALLER_NAME(main)

vboolean verbose = false;

int i;

char *script = "test.cmo";

FILE *out = stdout;

logStartConsoleLog();

logUpperLevel(LOG_TRACE);

for(i = 1;i < argc;i++)

{

if(!strcmp(argv[i], "--verbose"))

verbose = true;

else if(!strcmp(argv[i], "--autoname"))

{

if(out != stdout)

{

fclose(out);

puts("--autoname is meaningless with --outfile.");

return -1;

}

out = NULL;

}

else if(!strcmp(argv[i], "--outfile"))

{

if(out == NULL)

{

puts("--outfile is meaningless with --autoname.");

return -1;

}

if(++i >= argc)

return -1;

if(strcmp(argv[i],"-"))

{

out = fopen(argv[i],"wb");

if(!out)

{

perror("fopen");

return -1;

}

}

}

else if(!strcmp(argv[i], "--seed"))

{

s32_t seed = 0;

if(++i >= argc)

return -1;

if(strToInt(argv[i], &seed))

{

global_rgc_seed = seed;

}

else

{

printf("Wrong value for seed: '%s'\n", argv[i]);

return -1;

}

}

else

script = argv[i];

}


lex = lexParseFile(script, "{}()[];!");

if(!lex)

return -1;


lexSetInteger(lex, LEX_COMMENT_CHAR, '#');

lexEnable(lex, LEX_ONE_CHAR_COMMENTS);

lexEnable(lex, LEX_ALIAS_TRANSLATION);

lexSetInteger(lex, LEX_FP_DOMAIN, LEX_FP_DOMAIN_POSITIVE);

lexEnable(lex, LEX_FP_DOMAIN_CHECK);


while(lexNext(lex))

{

if(lexLastWas(lex, "generators"))

{

if(parseGenerators(lex, &gens) > 0)

continue;

/*

* It is Ok if there are no generators in block.

*/

GENERIC_PARSE_WARNING(lex, "empty 'generators' block");

continue;

}

else if(lexLastWas(lex, "sequence"))

{

if(parseSequence(lex, &gens, &seqs))

continue;

/*

* Error was already reported.

*/

break;

}

else if(lexLastWas(lex,"!"))

{

/* preprocessor directive */

if(!lexNext(lex))

{

SYN_UNEXPECTED_EOF(lex);

break;

}

if(lexLastWas(lex, "define"))

{

char alias_key[MAX_ID_LEN];

if(lexNext(lex))

strCopy(alias_key, lexLast(lex), MAX_ID_LEN);

if(lexNext(lex))

{

if(verbose)

conPrintf("Alias defined: '%s' ->'%s'.\n",

alias_key, lexLast(lex));

lexDefineAlias(lex, alias_key, lexLast(lex));

continue;

}

SYN_UNEXPECTED_EOF(lex);

}

else

{

PARSE_ERROR(lex, "unknown preprocessor directive");

break;

}

}

else



SYN_EXPECTED(lex,"generators

break;

}

if(!lexLast(lex))

{

if(verbose)

{

genPrint(&gens);

seqPrint(&seqs);

}

if(sysCreateSystems(&seqs, &syss))

{

if(verbose)

sysPrint(&syss);

#ifndef THREADED

if(sysSequentialScheduler(&syss))

#else /* THREADED */

if(sysParallelScheduler(&syss))

#endif /* THREADED */

{

sysPostprocess(&syss, out);

}

else

{

ERROR_GENERIC("error during computation");

}

}

else

{

ERROR_GENERIC("error creating systems");

}

}

if(out && out != stdout)

fclose(out);

sysDestroy(&syss);

genDestroy(&gens);

seqDestroy(&seqs);

lexDestroy(lex);

if(verbose)

memPrintStats();

return 0;

}

/*

* Имя файла модуля: rgcache.c

* Назначение модуля: ускорение работы с генератором псевдослучайных чисел.

*/

#include "rgcache.h"


rgcache_p V_GLOBAL

rgcReset(rgcache_p rgc,

vec_t min, vec_t max, /* for uniforms */

vec_t mean, vec_t stdev /* for gaussians */)

{

if(!rgc)

return rgcCreate(0,NULL,min,max,mean,stdev);

rgc->min = min;

rgc->max = max;

rgc->mean = mean;

rgc->stdev = stdev;

rgc->g_idx = rgc->u_idx = 0;

ranNextGaussianVector(rgc->rg,rgc->g_cache,rgc->mean,rgc->stdev);

ranNextVectorRange(rgc->rg,rgc->u_cache,rgc->min,rgc->max);

return rgc;

}


s32_t global_rgc_seed = 0;


rgcache_p V_GLOBAL

rgcCreate(u32_t cache_size, /* can be 0 */

vhandle_t rg, /* can be NULL */

vec_t min, vec_t max, /* for uniforms */

vec_t mean, vec_t stdev /* for gaussians */)

{

rgcache_p rgc = (rgcache_p)memAlloc(sizeof(rgcache_t));

if(!cache_size)

cache_size = RGCACHE_SIZE;

rgc->u_cache = vecAlloc(cache_size);

rgc->g_cache = vecAlloc(cache_size);

if(rg == LIBV_INVALID_HANDLE)

{

rgc->own_rg = true;

rgc->rg = ranCreateGenerator(++global_rgc_seed);

}

else

{

rgc->own_rg = false;

rgc->rg = rg;

}

return rgcReset(rgc, min, max, mean, stdev);

}


void V_GLOBAL

rgcDestroy(rgcache_p rgc)

{

if(!rgc)

return;

memFree(rgc->u_cache);

memFree(rgc->g_cache);

if(rgc->own_rg)

ranDestroyGenerator(rgc->rg);

memFree(rgc);

}


vec_t V_GLOBAL

rgcNext(rgcache_p rgc)

{

if(rgc->u_idx == rgc->u_cache->size)

{

rgc->u_idx = 0;

ranNextVectorRange(rgc->rg,rgc->u_cache,rgc->min,rgc->max);

}

return rgc->u_cache->elements[rgc->u_idx++];

}


vec_t V_GLOBAL

rgcNextGaussian(rgcache_p rgc)

{

if(rgc->g_idx == rgc->g_cache->size)

{

rgc->g_idx = 0;

ranNextGaussianVector(rgc->rg,rgc->g_cache,rgc->mean,rgc->stdev);

}

return rgc->g_cache->elements[rgc->g_idx++];

}

/*

* Имя файла модуля: rgcache.h

* Назначение модуля: заголовочный файл для модуля rgcache.c.

*/

#ifndef RGCACHE_H

#define RGCACHE_H


#include


#define RGCACHE_SIZE 1024;


typedef struct rgcache_s

{

vboolean own_rg;

vhandle_t rg;

vec_t min, max;

vec_t mean, stdev;

u32_t g_idx;

u32_t u_idx;

vector_p g_cache;

vector_p u_cache;

} rgcache_t, *rgcache_p;


extern s32_t global_rgc_seed;


rgcache_p V_GLOBAL

rgcCreate(u32_t cache_size, /* can be 0 */

vhandle_t rg, /* can be NULL */

vec_t min, vec_t max, /* for uniforms */

vec_t mean, vec_t stdev /* for gaussians */);


rgcache_p V_GLOBAL

rgcReset(rgcache_p rgc,

vec_t min, vec_t max, /* for uniforms */

vec_t mean, vec_t stdev /* for gaussians */);


void V_GLOBAL rgcDestroy(rgcache_p rgc);

vec_t V_GLOBAL rgcNext(rgcache_p rgc);

vec_t V_GLOBAL rgcNextGaussian(rgcache_p rgc);


#endif /* RGCACHE_H */


/*

* Имя файла модуля: genparse.c

* Назначение модуля: реализация объекта "генератор скаляров".

*/

#include "genparse.h"


static vboolean

fg_next_constant(struct fgen_s *self,vec_t *ret_val)

{

if(ret_val)

*ret_val = self->last;

return true;

}


static vboolean

fg_next_uniform(struct fgen_s *self,vec_t *ret_val)

{

self->last = rgcNext(self->u.uniform.rgc);

if(ret_val)

*ret_val = self->last;

return true;

}


static vboolean

fg_next_gaussian(struct fgen_s *self,vec_t *ret_val)

{

self->last = rgcNextGaussian(self->u.uniform.rgc);

if(ret_val)

*ret_val = self->last;

return true;

}


static vboolean

fg_next_linear(struct fgen_s *self,vec_t *ret_val)

{

if(self->finished)

return false;

self->last = self->u.ilinear.val;

self->u.ilinear.val += self->u.ilinear.delta;

self->u.ilinear.idx++;

if(self->u.ilinear.idx > self->u.ilinear.steps)

self->finished = true;

if(ret_val)

*ret_val = self->last;

return true;

}


static vboolean

fg_next_log10(struct fgen_s *self,vec_t *ret_val)

{

if(self->finished)

return false;

self->last = (vec_t)pow(10, self->u.ilog10.log10val);

self->u.ilog10.log10val += self->u.ilog10.log10delta;

self->u.ilog10.idx++;

if(self->u.ilog10.idx > self->u.ilog10.steps)

self->finished = true;

if(ret_val)

*ret_val = self->last;

return true;

}


static void

fg_dummy_reset(struct fgen_s *self)

{

V_ASSERT(self);

return;

}


static void

fg_iterator_reset(struct fgen_s *self)

{

switch(self->type)

{

case fg_linear_iterator:

self->u.ilinear.idx = 0;

self->last = self->u.ilinear.val = self->u.ilinear.from;

break;

case fg_log10_iterator:

self->u.ilog10.idx = 0;

self->u.ilog10.log10val = self->u.ilog10.log10from;

self->last = (vec_t)pow(10, self->u.ilog10.log10val);

break;

default:

V_ASSERT(0);

}

self->finished = false;

return;

}


static void

fg_generic_destroy(struct fgen_s *self)

{

if(!self)

return;

if(self->name)

memFree(self->name);

memFree(self);

}


static void

fg_random_destroy(struct fgen_s *self)

{

if(self && self->u.uniform.rgc)

rgcDestroy(self->u.uniform.rgc);

fg_generic_destroy(self);

}


fgen_p V_GLOBAL

genConstant(vec_t val, char *name)

{

fgen_p fg =

(fgen_p)memAllocZ(sizeof(fgen_t));

fg->type = fg_constant;

if(name)

fg->name = strDup(name);

else

{

char buf[256];

sprintf(buf, "%g", val);

fg->name = strDup(buf);

}

fg->finished = false;

fg->next = fg_next_constant;

fg->reset = fg_dummy_reset;

fg->destroy = fg_generic_destroy;

fg->last = val;

return fg;

}


static vboolean

parseConstantGen(vhandle_t lex,vp_stack_p storage)

{

CALLER_NAME(parseConstantGen)

vec_t val;

char name[MAX_ID_LEN];

if(!lexNext(lex))

{

SYN_EXPECTED(lex, "name of constant");

return false;

}

strCopy(name, lexLast(lex), MAX_ID_LEN);

if(!lexNextFloat(lex,&val))

{

SYN_EXPECTED(lex, "floating-point value for constant");

return false;

}

vpsPush(storage, genConstant(val, name));

return true;

}


fgen_p V_GLOBAL

genUniform(vec_t min, vec_t max, char *name)

{

fgen_p fg =

(fgen_p)memAllocZ(sizeof(fgen_t));

fg->type = fg_uniform;

if(name)

fg->name = strDup(name);

else

{

char buf[512];

sprintf(buf, "uniform_min_%g_max_%g", min, max);

fg->name = strDup(buf);

}

fg->finished = false;

fg->next = fg_next_uniform;

fg->reset = fg_dummy_reset;

fg->destroy = fg_random_destroy;

fg->u.uniform.min = min;

fg->u.uniform.max = max;

fg->u.uniform.rgc =

rgcReset(NULL, fg->u.uniform.min, fg->u.uniform.max, 0, 1);

return fg;

}


static vboolean

parseUniformGen(vhandle_t lex,vp_stack_p storage)

{

CALLER_NAME(parseUniformGen)

vec_t min, max;

char name[MAX_ID_LEN];

if(!lexNext(lex))

{

SYN_EXPECTED(lex, "name of uniform");

return false;

}

strCopy(name, lexLast(lex), MAX_ID_LEN);

if(!lexNextFloat(lex, &min))

{

SYN_EXPECTED(lex, "floating-point minimal value for uniform");

return false;

}

if(!lexNextFloat(lex, &max))

{

SYN_EXPECTED(lex, "floating-point maximal value for uniform");

return false;

}

vpsPush(storage, genUniform(min, max, name));

return true;

}


fgen_p V_GLOBAL

genGaussian(vec_t mean, vec_t stdev, char *name)

{

fgen_p fg =

(fgen_p)memAllocZ(sizeof(fgen_t));

fg->type = fg_gaussian;

if(name)

fg->name = strDup(name);

else

{

char buf[512];

sprintf(buf, "gaussian_mean_%g_stdev_%g", mean, stdev);

fg->name = strDup(buf);

}

fg->finished = false;

fg->next = fg_next_gaussian;

fg->reset = fg_dummy_reset;

fg->destroy = fg_random_destroy;

fg->u.gaussian.mean = mean;

fg->u.gaussian.stdev = stdev;

fg->u.gaussian.rgc =

rgcReset(NULL, 0, 1, fg->u.gaussian.mean, fg->u.gaussian.stdev);

return fg;

}


static vboolean

parseGaussianGen(vhandle_t lex,vp_stack_p storage)

{

CALLER_NAME(parseGaussianGen)

vec_t mean, stdev;

char name[MAX_ID_LEN];

if(!lexNext(lex))

{

SYN_EXPECTED(lex, "name of gaussian");

return false;

}

strCopy(name, lexLast(lex), MAX_ID_LEN);

if(!lexNextFloat(lex, &mean))

{

SYN_EXPECTED(lex, "floating-point mean for gaussian");

return false;

}

if(!lexNextFloat(lex, &stdev))

{

SYN_EXPECTED(lex, "floating-point standart deviation for gaussian");

return false;

}

vpsPush(storage, genGaussian(mean, stdev, name));

return true;

}


static vboolean

parseIterator(vhandle_t lex,vp_stack_p storage)

{

#define MAXSTEPS 65536

CALLER_NAME(parseIterator)

vec_t from, to;

s32_t steps;

fgen_p fg =

(fgen_p)memAllocZ(sizeof(fgen_t));

fg->name = strDup(lexNext(lex));

fg->finished = false;

fg->reset = fg_iterator_reset;

fg->destroy = fg_generic_destroy;

if(!lexNextFloat(lex,&from))

goto parse_error;

if(!lexNextIs(lex,"to"))

goto parse_error;

if(!lexNextFloat(lex,&to))

goto parse_error;

if(!lexNext(lex))

goto parse_error;

if(lexLastWas(lex, "steps"))



if(!lexNextInteger(lex, &steps)

else if(lexLastWas(lex, "logsteps"))



if(!lexNextInteger(lex, &steps)

else

goto parse_error;

vpsPush(storage, fg);

return true;

parse_error:;

PARSE_ERROR(lex, "generic error");

fg_generic_destroy(fg);

return false;

}


/*

* Returns number of generators stored in 'store'.

*/

unsigned V_GLOBAL

parseGenerators(vhandle_t lex,vp_stack_p store)

{

u32_t i, stored = 0;

fgen_p fg, newg;

CALLER_NAME(parseGenerators)

if(!lexLastWas(lex,"generators"))

conlPrintf(LOG_WARNING,"%s(): prev keyword was strange-\n",caller_name);

if(!lexNextIs(lex,"{"))

{

SYN_EXPECTED(lex,"{");

return stored;

}

/* TODO: lexNextMatches() */

while(!lexNextIs(lex, "}"))

{

if(!lexLast(lex))

{

SYN_UNEXPECTED_EOF(lex);

break;

}

if(lexLastWas(lex, "constant"))

{

if(!parseConstantGen(lex, store))

break;

}

else if(lexLastWas(lex, "uniform"))

{

if(!parseUniformGen(lex, store))

break;

}

else if(lexLastWas(lex, "gaussian"))

{

if(!parseGaussianGen(lex, store))

break;

}

else if(lexLastWas(lex, "iterator"))

{

if(!parseIterator(lex, store))

break;

}

else



SYN_EXPECTED(lex, "constant

if(!lexNextIs(lex, ";"))

{

SYN_EXPECTED(lex, ";");

/*

* Be evil - discard last good result in case of missed ; ;)

*/

vpsPop(store, (void_p)&newg);

newg->destroy(newg);

break;

}

stored++;

/*

* Check for duplicate names

*/

newg = (fgen_p)vpsGet(store, vpsCount(store) - 1);

for(i = 0;i < vpsCount(store) - 1;i++)

{

fg = vpsGet(store, i);

if(!strcmp(newg->name, fg->name))

{

conlPrintf(LOG_WARNING,

"%s(): in \"%s\", line %u: duplicate name \"%s\", discarded.\n",

caller_name, lexSourceName(lex), lexLastLine(lex),

newg->name);

vpsPop(store, (void_p)&newg);

newg->destroy(newg);

stored--;

}

}

}

return stored;

}


void V_GLOBAL

genDestroy(vp_stack_p store)

{

fgen_p g;

while(vpsPop(store,(void_p*)&g))

g->destroy(g);

vpsClear(store);

}


/*

* In case of more than 100 gens & more than 1000 systems,

* it is better to vpsSort() & bsearch(). But I don't bother.

*/

fgen_p V_GLOBAL

genFind(vp_stack_p store, char *name)

{

u32_t i;

fgen_p g;

for(i = 0;i < vpsCount(store);i++)

{

g = (fgen_p)vpsGet(store, i);

if(!strcmp(g->name, name))

return g;

}

return NULL;

}


void V_GLOBAL

genPrint(vp_stack_p store)

{

u32_t i;

fgen_p g;

printf("Parsed %u generator(s).\n", vpsCount(store));

for(i = 0;i < vpsCount(store);i++)

{

g = (fgen_p)vpsGet(store, i);

conPrintf("Gen No %u: \"%s\" of type ", i, g->name);

switch(g->type)

{

case fg_constant:

conPrintf("constant, value \"%g\".\n", g->last);

break;

case fg_uniform:

conPrintf("uniform, min \"%g\", max \"%g\".\n",

g->u.uniform.min, g->u.uniform.max);

break;

case fg_gaussian:

conPrintf("gaussian, mean \"%g\", stdev \"%g\".\n",

g->u.gaussian.mean, g->u.gaussian.stdev);

break;

case fg_linear_iterator:

conPrintf("linear iterator, from \"%g\", to \"%g\", %u steps.\n",

g->u.ilinear.from, g->u.ilinear.to, g->u.ilinear.steps);

break;

case fg_log10_iterator:

conPrintf("logarithmic iterator, from \"10^(%g)\", to \"10^(%g)\", %u steps.\n",

g->u.ilog10.log10from, g->u.ilog10.log10to, g->u.ilog10.steps);

break;

default:

conPuts("unknown");

}

}

}

/*

* Имя файла модуля: genparse.h

* Назначение модуля: заголовочный файл для модуля genparse.c

*/

#ifndef GENPARSE_H

#define GENPARSE_H


#include

#include "rgcache.h"


/*

* Names can be arbitrary length, but only MAX_ID_LEN are meaningful.

*/

#define MAX_ID_LEN 128


typedef enum

{

fg_constant = 1,

fg_uniform = 2,

fg_gaussian = 3,

fg_iterators = 99,

fg_linear_iterator = 100,

fg_log10_iterator = 101

} fgen_type;


#define IS_ITERATOR(gen) \

((gen)->type > fg_iterators)


/*

* TODO1: extend 'iterator' with 'logbase', with selected algorithm

* the arbitrary base logarithmic interpolation can be easily performed.

*/


/*

* TODO2: consider storing all values of iterator in array.

* Such approach have two advantages:

* a) arrays (still unimplemented) can be handled as iterators;

* b) both arrays and iterators can be filled with random generators.

*/


typedef struct fgen_s

{

char *name;

fgen_type type;

vec_t last; /* last returned value */

vboolean finished; /* iterations complete */

union

{

struct

{

rgcache_p rgc;

vec_t min, max;

} uniform;

struct

{

rgcache_p rgc; /* must be at the same place */

vec_t mean, stdev;

} gaussian;

struct

{

u32_t steps, idx; /* required for bidirectional iterators */

vec_t from, to, val, delta;

} ilinear;

struct

{

u32_t steps, idx; /* required for bidirectional iterators */

vec_t log10from, log10to, log10val, log10delta;

} ilog10;

} u;

vboolean (*next)(struct fgen_s *self,vec_t *ret_val);

void (*reset)(struct fgen_s *self);

void (*destroy)(struct fgen_s *self);

} fgen_t, *fgen_p;


#define GEN_NUM_ITERATIONS(gen) \

((gen)->u.ilinear.steps + 1)


/*

* For all genXXX(), 'name' can be NULL.

* In such case, as a name will be used:

* constant: just string with same number: "%g";

* uniform: "uniform_min_%g_max_%g";

* gaussian: "gaussian_mean_%g_stdev_%g";

* linear: "iterator_linear_from_%g_to_%g_steps_%u";

* loglinear: "iterator_loglinear_from_%g_to_%g_steps_%u";

*/

fgen_p V_GLOBAL genConstant(vec_t val, char *name);

fgen_p V_GLOBAL genUniform(vec_t min, vec_t max, char *name);

fgen_p V_GLOBAL genGaussian(vec_t mean, vec_t stdev, char *name);

/*

fgen_p V_GLOBAL genLinear(vec_t from, vec_t to, u32_t steps, char *name);

fgen_p V_GLOBAL genLoglinear(vec_t from, vec_t to, u32_t steps, char *name);

*/


/*

* Returns number of generators stored in 'store'.

*/

unsigned V_GLOBAL parseGenerators(vhandle_t lex,vp_stack_p store);


void V_GLOBAL genDestroy(vp_stack_p store);


fgen_p V_GLOBAL genFind(vp_stack_p store, char *name);


void V_GLOBAL genPrint(vp_stack_p store);


#endif /* GENPARSE_H */


/*

* Имя файла модуля: seqparse.c

* Назначение модуля: реализация объекта "вычислительный эксперимент".

*/

#include "seqparse.h"


vboolean V_GLOBAL

parseSequence(vhandle_t lex, vp_stack_p generators, vp_stack_p store)

{

/* FIXME: no dynamic data, use bstack_t for storage */

CALLER_NAME(parseSequence)

STATIC_STRING(duplicate_definition, "duplicate definition")

STATIC_STRING(generator_undefined, "generator undefined")

int i;

vec_t raw_bbox[6];

char name[MAX_ID_LEN];

char vc_name[MAX_ID_LEN];

char len_name[MAX_ID_LEN];

char diam_name[MAX_ID_LEN];

fgen_p gens[3] = {NULL, NULL, NULL};

#define GOT_VC 1

#define GOT_FL 2

#define GOT_FD 4

#define GOT_BBOX 8

#define GOT_ALL 15 /* (GOT_BBOX|GOT_VC|GOT_LEN|GOT_DIAM) */

u32_t got_flags = 0;

tseq_p seq;

if(!lexNext(lex))

{

SYN_UNEXPECTED_EOF(lex);

return false;

}

strCopy(name, lexLast(lex), MAX_ID_LEN);

if(!lexNextIs(lex, "{"))

{

SYN_EXPECTED(lex, "{");

return false;

}

while(lexNext(lex))

{

if(lexLastWas(lex, "}"))

{

if((got_flags & GOT_ALL) != GOT_ALL)

{

conlPrintf(LOG_ERROR,

"%s(), at line %u: too few parameters to start simulation: \n",

caller_name,

lexLastLine(lex));

if(!(got_flags & GOT_VC))

conlPuts(LOG_ERROR,"\tvolumetric_content undefined\n");

if(!(got_flags & GOT_FL))

conlPuts(LOG_ERROR,"\tfiber_length undefined\n");

if(!(got_flags & GOT_FD))

conlPuts(LOG_ERROR,"\tfiber_diameter undefined\n");

if(!(got_flags & GOT_BBOX))

conlPuts(LOG_ERROR,"\tbounding_box undefined\n");

return false;

}

break;

}

else if(lexLastWas(lex, "bounding_box"))

{

if(got_flags & GOT_BBOX)

{

PARSE_ERROR(lex, duplicate_definition);

return false;

}

/* parse 6 floats, followed by ';' */

lexPush(lex, LEX_STATE_BIT);

lexDisable(lex, LEX_FP_DOMAIN_CHECK);

for(i = 0;i < 6;i++)

{

if(!lexNextFloat(lex, raw_bbox + i))

{

lexPop(lex, LEX_STATE_BIT);

SYN_EXPECTED(lex, "floating-point value for bbox");

return false;

}

}

lexPop(lex, LEX_STATE_BIT);

if(!lexNextIs(lex, ";"))

{

SYN_EXPECTED(lex, ";");

return false;

}

got_flags = got_flags | GOT_BBOX;

}

else if(lexLastWas(lex, "volumetric_content"))

{

if(got_flags & GOT_VC)

{

PARSE_ERROR(lex, duplicate_definition);

return false;

}

strCopy(vc_name, strSafe(lexNext(lex)), MAX_ID_LEN);

gens[GEN_VC] = genFind(generators, vc_name);

if(!gens[GEN_VC])

{

PARSE_ERROR(lex, generator_undefined);

return false;

}

/*

* Volumetric content must be either constant or iterator.

*/

switch(gens[GEN_VC]->type)

{

case fg_constant:

case fg_linear_iterator:

case fg_log10_iterator:

break;

default:

SYN_EXPECTED(lex, "non-random generator");

return false;

}

if(!lexNextIs(lex, ";"))

{

SYN_EXPECTED(lex, ";");

return false;

}

got_flags = got_flags | GOT_VC;

}

else if(lexLastWas(lex, "fiber_length"))

{

if(got_flags & GOT_FL)

{

PARSE_ERROR(lex, duplicate_definition);

return false;

}

strCopy(len_name, strSafe(lexNext(lex)), MAX_ID_LEN);

gens[GEN_FL] = genFind(generators, len_name);

if(!gens[GEN_FL])

{

PARSE_ERROR(lex, generator_undefined);

return false;

}

if(!lexNextIs(lex, ";"))

{

SYN_EXPECTED(lex, ";");

return false;

}

got_flags = got_flags | GOT_FL;

}

else if(lexLastWas(lex, "fiber_diameter"))

{

if(got_flags & GOT_FD)

{

PARSE_ERROR(lex, duplicate_definition);

return false;

}

strCopy(diam_name, strSafe(lexNext(lex)), MAX_ID_LEN);

gens[GEN_FD] = genFind(generators, diam_name);

if(!gens[GEN_FD])

{

PARSE_ERROR(lex, generator_undefined);

return false;

}

if(!lexNextIs(lex, ";"))

{

SYN_EXPECTED(lex, ";");

return false;

}

got_flags = got_flags | GOT_FD;

}

else

{

PARSE_ERROR(lex, "unknown keyword");

return false;

}

}

if(!lexLast(lex))

{

SYN_UNEXPECTED_EOF(lex);

return false;

}

V_ASSERT(got_flags & GOT_ALL);

/*

* All Ok. Can do allocations.

*/

seq = (tseq_p)memAllocZ(sizeof(tseq_t));

seq->num_systems = 0;

strCopy(seq->name, name, MAX_ID_LEN);

/* mins & maxs from origin & extents */

vec3Scale(raw_bbox + 3, raw_bbox + 3, (vec_t)0.5);

vec3Sub(seq->bbox[0], raw_bbox, raw_bbox + 3);

vec3Add(seq->bbox[1], raw_bbox, raw_bbox + 3);

/* store generators */

seq->gens[0] = gens[0];

seq->gens[1] = gens[1];

seq->gens[2] = gens[2];

/* find iterators and store their positions */

seq->nesting_level = 0;

for(i = 0;i < 3;i++)

{

if(IS_ITERATOR(seq->gens[i]))

seq->iterators[seq->nesting_level++] = i;

}

/*

* If volumetric content must be iterated, this have to be done

* in the INNER loop. The above code should do the job, but-

*/

switch(seq->nesting_level)

{

case 3:

if(seq->iterators[2] == GEN_VC)

{

/* move it one position up */

seq->iterators[2] = seq->iterators[1];

seq->iterators[1] = GEN_VC;

V_ASSERT(0);

}

/* fall throw */

case 2:

if(seq->iterators[1] == GEN_VC)

{

/* move it one position up */

seq->iterators[1] = seq->iterators[0];

seq->iterators[0] = GEN_VC;

V_ASSERT(0);

}

break;

default:

break;

}

vpsPush(store, seq);

return true;

}


u32_t V_GLOBAL

seqSysAmount(tseq_p seq)

{

/*

* TODO: the 'switch' here can be avoided (for(;
*/

switch(seq->nesting_level)

{

case 0:

return 1;

case 1:

return GEN_NUM_ITERATIONS(seq->gens[seq->iterators[0]]);

case 2:

return GEN_NUM_ITERATIONS(seq->gens[seq->iterators[0]]) *

GEN_NUM_ITERATIONS(seq->gens[seq->iterators[1]]);

case 3:

return GEN_NUM_ITERATIONS(seq->gens[seq->iterators[0]]) *

GEN_NUM_ITERATIONS(seq->gens[seq->iterators[1]]) *

GEN_NUM_ITERATIONS(seq->gens[seq->iterators[2]]);

default:

V_ASSERT(0);

break;

}

V_ASSERT(0);

return (u32_t)(-1);

}


void V_GLOBAL

seqDestroy(vp_stack_p store)

{

void_p ptr;

while(vpsPop(store, &ptr))

memFree(ptr);

vpsClear(store);

}


void V_GLOBAL

seqPrint(vp_stack_p store)

{

u32_t i, j;

tseq_p seq;

conPrintf("Parsed %u sequence(s).\n", vpsCount(store));

for(i = 0;i < vpsCount(store);i++)

{

static char *gn[3] = {

"Volumetric content",

"Fiber length",

"Fiber diameter"};

seq = (tseq_p)vpsGet(store, i);

conPrintf("Seq No %u (%s) of nesting_level %u:\n"

"bounding box [%g,%g,%g]-[%g,%g,%g]\nGenerators:\n",

i, seq->name, seq->nesting_level,

seq->bbox[0][0],seq->bbox[0][1],seq->bbox[0][2],

seq->bbox[1][0],seq->bbox[1][1],seq->bbox[1][2]);

for(j = 0;j < 3;j++)

conPrintf("%s: '%s'.\n",gn[j], seq->gens[j]->name);

if(seq->nesting_level)

{

conPrintf("Iterator(s):\n");

for(j = 0;j nesting_level;j++)

conPrintf("%s: '%s'.\n",gn[seq->iterators[j]],

seq->gens[seq->iterators[j]]->name);

}

conPrintf("Total number of experiments: %u\n", seqSysAmount(seq));

}

}

/*

* Имя файла модуля: seqparse.h

* Назначение модуля: заголовочный файл для модуля seqparse.c

*/

#ifndef SEQPARSE_H

#define SEQPARSE_H


#include

#include "rgcache.h"

#include "genparse.h"


#define GEN_VC 0

#define GEN_FL 1

#define GEN_FD 2


typedef struct tseq_s

{

char name[MAX_ID_LEN];

vec3_t bbox[2];

/*

* Number of iterators among generators.

* 0 - one experiment;

* 1 - non-nested loop;

* 2 - doubly nested loop;

* 3 - triply-nested loop.

*/

u32_t nesting_level;

/*

* #0 - volumetric content;

* #1 - fiber length;

* #2 - fiber diameter.

*/

fgen_p gens[3];

/*

* Indices in 'gens' pointing to iterators.

* Actual number of indices is equal to 'nesting_level'.

*/

u32_t iterators[3];

/*

* There are 2 stages of modeling process.

* 1. Generation of the test systems. Here non-reentrant code

* (generators are shared between all tasks) is used.

*

* 2. Computing number of contacts. Computation-intensive stage,

* subject to later parallelization.

*

* Thus, total number of test systems depends on 'nesting_level' and

* parameters of iterators (fg->u.ilinear.steps + 1).

* The seqSysAmount() is for initial determination of the former.

*/

u32_t num_systems;

} tseq_t, *tseq_p;


vboolean V_GLOBAL parseSequence(vhandle_t lex, vp_stack_p generators, vp_stack_p store);

u32_t V_GLOBAL seqSysAmount(tseq_p seq);

void V_GLOBAL seqDestroy(vp_stack_p store);

void V_GLOBAL seqPrint(vp_stack_p store);


#endif /* SEQPARSE_H */

/*

* Имя файла модуля: sysproc.c

* Назначение модуля: реализация объекта "очередь выполнения".

*/

#include "sysproto.h"


void V_GLOBAL

sysPrint(vp_stack_p syss)

{

u32_t i;

vec_t total_time = 0;

tsys_p s;

for(i = 0;i < vpsCount(syss);i++)

{

s = (tsys_p)vpsGet(syss, i);

conPrintf(

"System '%s': vf = %g, "

"fibers = %u, time to process: app. %.2g seconds.\n",

s->name, s->volumetric_content,

stackCount(&s->fs), s->time_estimation);

total_time += s->time_estimation;

}

conPrintf("Total: %u systems, "

"app. %.2g minutes to compute (2.4GHz Lynn core, GCC 4.2).\n",

vpsCount(syss), total_time / 60);

}


/*

* FIXME1: не использовать libc.

* (вроде-бы "CON" у меня в libv открывает вывод на консоль - не помню уже)

*

* FIXME2: что-то более осмысленное, нежели столбец экстраполированных значений

* объемной степени наполнения - "топологическая характеристика" или что-то...

*/

void V_GLOBAL

sysPrintOut(vp_stack_p syss, FILE *out)

{

u32_t i;

tsys_p s;

vboolean autonaming = out ? false : true;

char buf[4096];

char lastname[MAX_ID_LEN] = "";

for(i = 0;i < vpsCount(syss);i++)

{

s = (tsys_p)vpsGet(syss, i);

if(autonaming && strcmp(lastname, s->parent_name))

{

char buf[MAX_ID_LEN + 512];

if(out)

fclose(out);

strCopy(lastname, s->parent_name, MAX_ID_LEN);

sprintf(buf, "%s.csv", lastname);

out = fopen(buf, "wb");

if(!out)

{

perror("fopen");

return;

}

}

floatToStrEx(buf, 4096, s->volume, ',');

fprintf(out,"%u;%s;volume;%s;", (unsigned)i, s->name, buf);

floatToStrEx(buf, 4096, s->volumetric_content, ',');

fprintf(out,"vf;%s;fibers;%u;contacts;%u;", buf,

stackCount(&s->fs), stackCount(&s->cs));

floatToStrEx(buf, 4096,

(vec_t)stackCount(&s->cs) / (vec_t)stackCount(&s->fs), ',');

fprintf(out,"rcv;%s;",buf);

floatToStrEx(buf, 4096, s->average_length, ',');

fprintf(out,"average_length;%s;",buf);

floatToStrEx(buf, 4096, s->average_diameter, ',');

fprintf(out,"average_diameter;%s;",buf);

floatToStrEx(buf, 4096, s->average_length / s->average_diameter, ',');

fprintf(out,"form_factor;%s;",buf);

floatToStrEx(buf, 4096, s->extrapolated_vc, ',');

fprintf(out,"extrapolated_vf;%s\n",buf);

}

}


/*

* First two checks are performed in the inner loop.

* In principle, 4 versions of new_fiber() can be implemented,

* for covering all possible cases of generators' combinations.

* But the following code is several orders of magnitude slower,

* so don't bother.

*/

static void

new_fiber(vhandle_t rg,vec3_t mins, vec3_t maxs,

fgen_p lengen, fgen_p diamgen, fp_p dest)

{

vec3_t fibcenter, halfdir;


if(IS_ITERATOR(lengen)) /* loop is in outer code */

dest->length = lengen->last;

else

{

vboolean result = lengen->next(lengen, &dest->length);

V_ASSERT(result);

}


if(IS_ITERATOR(diamgen)) /* loop is in outer code */

dest->radius = diamgen->last;

else

{

vboolean result = diamgen->next(diamgen, &dest->radius);

V_ASSERT(result);

}


dest->radius *= (vec_t)0.5;

dest->volume = M_PI * dest->radius * dest->radius * dest->length;

ranNextVec3RangeV(rg, fibcenter, mins, maxs);

ranDirection(rg, halfdir);

vec3Scale(halfdir, halfdir, (vec_t)0.5 * dest->length);

vec3Sub(dest->p1, fibcenter, halfdir);

vec3Add(dest->p2, fibcenter, halfdir);

}


/*

* Estimation of computation time.

*

* Reference system (sleepgate.ru server): 2.4GHz Xeon (Lynnfield),

* 64-bit FreeBSD 8.2-STABLE, gcc 4.2.2.

*

* 200000 fibers, (2e+5)^2 / 2 = 2e+10 checks: app. 800 seconds,

* rate is 25e+6 cps.

*

* On 2GHz C2D mobile, WATCOM compiler - cps is about 4 times slower;

* if segCrossing() is compiled by icl 8 - app. 2.5 times slower.

*/


#define REF_C_RATE (25e+6)


static vec_t

sysEstimateTime(tsys_p sys)

{

double numchecks = (double)stackCount(&sys->fs);

numchecks *= numchecks * 0.5;

return (vec_t)(numchecks / REF_C_RATE);

}


#define FP_NUM_WARNING 200000

#define FP_NUM_ABORT 2000000


static vboolean

sysOne(vhandle_t rg,tseq_p seq, vp_stack_p store)

{

CALLER_NAME(sysOne)

fp_t fib;

fgen_p vfgen = seq->gens[GEN_VC];

u32_t count = 0;

vec3_t bs;

vec_t target_vc, fibs_volume, target_volume, sr = 0, slen = 0;

tsys_p s = (tsys_p)memAllocZ(sizeof(tsys_t));

vec3Copy(s->bbox[0], seq->bbox[0]);

vec3Copy(s->bbox[1], seq->bbox[1]);

vec3Sub(bs, s->bbox[1], s->bbox[0]);

s->volume = bs[0] * bs[1] * bs[2];

s->volumetric_content = 0;

stackInit(&s->fs, sizeof(fp_t));

stackInit(&s->cs, sizeof(fc_t));

/*

* Fill the box until the target volumetric content is reached.

* VF can be either constant, or iterator; if later, it will be

* iterated in outer code.

*/

target_vc = vfgen->last;

target_volume = s->volume * target_vc;

for(fibs_volume = 0;fibs_volume < target_volume;count++)

{

if(count == FP_NUM_WARNING)

{

WARNING_GENERIC("Too many fibers,"

" computation will take more than 10 minutes");

}

if(count == FP_NUM_ABORT)

{

ERROR_GENERIC("Too many fibers, DAY to complete the task!\n"

"Redesign the system");

stackClear(&s->fs);

memFree(s);

return false;

}

new_fiber(rg, s->bbox[0], s->bbox[1],

seq->gens[GEN_FL], seq->gens[GEN_FD], &fib);

stackPush(&s->fs, &fib);

fibs_volume += fib.volume;

slen += fib.length;

sr += fib.radius;

}

s->average_diameter = sr * 2 / stackCount(&s->fs);

s->average_length = slen / stackCount(&s->fs);

s->volumetric_content = fibs_volume / s->volume;

strCopy(s->parent_name, seq->name, MAX_ID_LEN);

sprintf(s->name, "%s_%03u", seq->name, (unsigned)seq->num_systems++);

s->time_estimation = sysEstimateTime(s);

vpsPush(store, s);

return true;

}


static vboolean

sys1DArray(vhandle_t rg, tseq_p seq, vp_stack_p store)

{

/*

* Loop thow values of seq->gens[seq->iterators[0]].

*/

fgen_p ig = seq->gens[seq->iterators[0]];

ig->reset(ig);

do

{

ig->next(ig, NULL);

if(!sysOne(rg, seq, store))

return false;

} while(!ig->finished);

return true;

}


static vboolean

sys2DArray(vhandle_t rg, tseq_p seq, vp_stack_p store)

{

/*

* Loop thow values of seq->gens[seq->iterators[1]].

*/

fgen_p ig = seq->gens[seq->iterators[1]];

ig->reset(ig);

do

{

ig->next(ig, NULL);

if(!sys1DArray(rg, seq, store))

return false;

} while(!ig->finished);

return true;

}


static vboolean

sys3DArray(vhandle_t rg, tseq_p seq, vp_stack_p store)

{

/*

* Loop thow values of seq->gens[seq->iterators[2]]

* Here second non-VF iterator is incremented.

*/

fgen_p ig = seq->gens[seq->iterators[2]];

ig->reset(ig);

do

{

ig->next(ig, NULL);

if(!sys2DArray(rg, seq, store))

return false;

} while(!ig->finished);

return true;

}


vboolean V_GLOBAL

sysCreateSystems(vp_stack_p seqs, vp_stack_p store)

{

static s32_t extra_seed = 137;

u32_t i;

tseq_p seq;

vhandle_t rg = ranCreateGenerator(extra_seed);

for(i = 0;i < vpsCount(seqs);i++)

{

seq = (tseq_p)vpsGet(seqs, i);

switch(seq->nesting_level)

{

case 0:

if(!sysOne(rg, seq, store))

goto err_exit;

break;

case 1:

if(!sys1DArray(rg, seq, store))

goto err_exit;

break;

case 2:

if(!sys2DArray(rg, seq, store))

goto err_exit;

break;

case 3:

if(!sys3DArray(rg, seq, store))

goto err_exit;

break;

default:

V_ASSERT(0);

}

}

ranDestroyGenerator(rg);

return true;

err_exit:;

ranDestroyGenerator(rg);

return false;

}


void V_GLOBAL

sysDestroy(vp_stack_p store)

{

tsys_p ptr;

while(vpsPop(store, (void_p)&ptr))

{

stackClear(&ptr->fs);

stackClear(&ptr->cs);

memFree(ptr);

}

vpsClear(store);

}


/*

* The core. Quite simple.

*/

static void

find_contacts(tsys_p sys)

{

u32_t i, j, num_fibers;

fp_p fibers, f1, f2;

fc_t contact;

num_fibers = stackCount(&sys->fs);

f1 = fibers = (fp_p)stackGetStorage(&sys->fs);

for(i = 0;i < num_fibers;i++, f1++)

{

for(j = i + 1, f2 = fibers + j;j < num_fibers;j++, f2++)

{

/*

* NOTE: early out is already implemented in segCrossing().

*/

if(!segCrossing(f1->p1, f1->p2, f2->p1, f2->p2,

&contact.dist, contact.cp))

continue;

if(contact.dist > (f1->radius + f2->radius))

continue;

contact.f1 = f1;

contact.f2 = f2;

contact.nf1 = i;

contact.nf2 = j;

stackPush(&sys->cs, &contact);

}

}

if(stackCount(&sys->cs))

{

sys->extrapolated_vc = sys->volumetric_content *

(vec_t)stackCount(&sys->fs) / (vec_t)stackCount(&sys->cs);

if(sys->extrapolated_vc > 1)

sys->extrapolated_vc = 1;

}

else

sys->extrapolated_vc = 1;

}


vboolean V_GLOBAL

sysSequentialScheduler(vp_stack_p syss)

{

u32_t i;

for(i = 0;i < vpsCount(syss);i++)

find_contacts((tsys_p)vpsGet(syss, i));

return true;

}


vboolean V_GLOBAL

sysParallelScheduler(vp_stack_p syss)

{

#define NUM_THREADS 12

bstack_t runq;

SMP_BALANCE_QUEUE(runq, syss);

#include "shed-smp.c.partial"

return true;

}


/*

* Postprocessor.

*/

vboolean V_GLOBAL

sysPostprocess(vp_stack_p syss, FILE *out)

{

sysPrintOut(syss, out);

return true;

}

/*

* Имя файла модуля: sysproto.h

* Назначение модуля: заголовочный файл для модуля sysproc.c

*/

#ifndef SYSPROTO_H

#define SYSPROTO_H


#include

#include "rgcache.h"

#include "genparse.h"

#include "seqparse.h"


/*

* Filler particle: fiber.

*/

typedef struct fp_s

{

vec3_t p1, p2;

vec_t length, radius;

vec_t volume;

} fp_t, *fp_p;


/*

* Contact point

*/

typedef struct fc_s

{

/*

* Pointers to contacting fibers. Assume that no more fibers

* will be added: doing so can lead to memRealloc() and invalidation

* of pointers.

*/

fp_p f1, f2;

int nf1, nf2; /* indiced of fibers. redundant */

vec_t dist; /* minimal distance between axes of fibers */

vec3_t cp; /* contact point */

} fc_t, *fc_p;


/*

* System to be modeled.

*/

typedef struct tsys_s

{

char parent_name[MAX_ID_LEN];

char name[MAX_ID_LEN + 256];

vec3_t bbox[2];

vec_t volume;

vec_t volumetric_content;

vec_t extrapolated_vc;

vec_t average_length;

vec_t average_diameter;

vec_t time_estimation; /* estimation of computation time */

bstack_t fs; /* of fp_t */

bstack_t cs; /* of fc_t */

} tsys_t, *tsys_p;


vboolean V_GLOBAL sysCreateSystems(vp_stack_p seqs, vp_stack_p syss_dest);

void V_GLOBAL sysDestroy(vp_stack_p syss);

void V_GLOBAL sysPrint(vp_stack_p syss);

vboolean V_GLOBAL sysSequentialScheduler(vp_stack_p syss);

/* vboolean V_GLOBAL sysParallelScheduler(vp_stack_p syss); */

#define sysParallelScheduler sysSequentialScheduler

vboolean V_GLOBAL sysPostprocess(vp_stack_p syss, FILE *out);


#endif /* SYSPROTO_H */



prava-rabotnikov-antimonopolnogo-organa-pri-federalnij-zakon.html
prava-rebenka-v-seme.html
prava-studentov-uchashihsya-i-abiturientov.html
prava-uchebno-metodicheskij-kompleks-po-discipline-teoriya-gosudarstva-i-prava-dlya-specialnosti-050301-yurisprudenciya-ust-kamenogorsk-2005.html
prava-zhivoj-i-nezhivoj-prirodi.html
pravda-kak-visshaya-cennost.html
  • textbook.bystrickaya.ru/ispolzovanie-pokazatelej-effektivnosti-tormozheniya-tehnicheskij-reglament-o-bezopasnosti-kolesnih-transportnih-sredstv.html
  • uchebnik.bystrickaya.ru/vi-uchebnij-plan-rezhim-obucheniya-publichnij-doklad-mou-srednyaya-obsheobrazovatelnaya-shkola-10-za-2009-2010-uchebnij-god.html
  • thesis.bystrickaya.ru/prikaz-30-avgusta-2010-g-8902-13-ozachislenii-na-osnovanii-resheniya-priemnoj-komissii-ot-29-avgusta-2010-g-protokol-4-prikazivayu.html
  • credit.bystrickaya.ru/otchet-vracha-interna-primernij-plan-podgotovki-soderzhanie-programmi-obshie-razdeli-po-specialnosti-razdeli-po-smezhnim.html
  • exchangerate.bystrickaya.ru/dogovor-arendi-transportnih-sredstv.html
  • laboratornaya.bystrickaya.ru/programma-uchebnoj-disciplini-laboratornij-praktikum-po-tehnologii-pe-i-um-napravlenie-podgotovki.html
  • grade.bystrickaya.ru/obem-kreditov-programmi-sostavlyaet-129-kreditov-6-kreditov-praktika-8-kreditov-fizvospitaniya-3-kredita-gosudarstvennaya-attestaciya-ects-249-kreditov-kod-disciplini-shifr-stranica-13.html
  • institut.bystrickaya.ru/tema-15-tema-1.html
  • predmet.bystrickaya.ru/seleznevo-d-m-b-olenev.html
  • tasks.bystrickaya.ru/124-sebestoimost-tovarnoj-produkcii-kursovoj-proekt-po-kursu-predmetno-orientirovannie-eis-na-temu-sostavlenie.html
  • education.bystrickaya.ru/26-12-08-01-novogodnyaya-tur-bez-nochnih-pereezdov.html
  • pisat.bystrickaya.ru/sudebnij-poryadok-razresheniya-individualnih-trudovih-sporov-chast-11.html
  • credit.bystrickaya.ru/plan-obshaya-harakteristika-aminokislot-opredelenie-klassifikaciya-nomenklatura-izomeriya-sposobi-polucheniya-fizicheskie-i-himicheskie-svojstva-oblasti-primeneniya-aminokislot.html
  • assessments.bystrickaya.ru/dieta-i-racionalnoe-pitanie-stoit-li-stavit-znak-ravenstva-pisha-mozhet-sluzhit-ne-tolko-istochnikom-neobhodimih.html
  • laboratornaya.bystrickaya.ru/rabochaya-programma-disciplini-tehnicheskie-sredstva-avtomatizacii-napravlenie-oop.html
  • uchit.bystrickaya.ru/tema-1-psihologiya-i-psihologi-osnovnaya-obrazovatelnaya-programma-visshego-professionalnogo-obrazovaniya-po-napravleniyu.html
  • report.bystrickaya.ru/gosudarstvennij-obrazovatelnij-standart-visshego-professionalnogo-obrazovaniya-gosudarstvennie-trebovaniya-k-minimumu-soderzhaniya-i-urovnyu-podgotovki-vipusknika-po-specialnosti.html
  • university.bystrickaya.ru/glava-16-kontrol-v-sisteme-gosudarstvennogo-upravleniya-kontrolnie-voprosi-i-zadaniya-37.html
  • portfolio.bystrickaya.ru/osnovnie-organizacionnie-i-massovie-meropriyatiya-utverdit-plan-raboti-otdela-po-voprosam-obrazovaniya-na-2010-2011.html
  • student.bystrickaya.ru/2-soderzhanie-territorii-stroitelstva-zdanij-i-pomeshenij-pravila-pozharnoj-bezopasnosti-pri-ekspluatacii-zdanij.html
  • upbringing.bystrickaya.ru/koncepciya-ii-go-mezhdunarodnogo-socialno-ekonomicheskogo-foruma-finno-ugorskoj-molodezhi-meropriyatie.html
  • teacher.bystrickaya.ru/glava-vi-predislovie-ko-vtoromu-izdaniyu.html
  • reading.bystrickaya.ru/kursovaya-rabotarabota-zashishena.html
  • institut.bystrickaya.ru/tehnologii-izgotovleniya-i-obrabotki-hudozhestvennih-izdelij.html
  • doklad.bystrickaya.ru/vneshnie-funkcii-gosudarstva.html
  • klass.bystrickaya.ru/avtor-nevdomij-prikladnaya-yuridicheskaya-psihologiya-stranica-38.html
  • lektsiya.bystrickaya.ru/prilozhenie-15-visshaya-attestacionnaya-komissiya-respubliki-belarus-postanovlenie.html
  • kontrolnaya.bystrickaya.ru/rabochaya-programma-disciplina-informacionnij-menedzhment-specialnost.html
  • uchitel.bystrickaya.ru/rabochaya-programma-upravlenie-personalom-naimenovanie-disciplini-dlya-specialnosti-ej-080801-prikladnaya-informatika-v-ekonomike-230202-informacionnie-sistemi-i-tehnologii.html
  • zadachi.bystrickaya.ru/nalog-na-dohodi-fizicheskih-lic-chast-2.html
  • abstract.bystrickaya.ru/1-voprosi-dlya-podgotovki-k-kandidatskomu-ekzamenu-po-specialnosti-08-00-01-ekonomicheskaya-teoriya.html
  • desk.bystrickaya.ru/oilim-dadisi-mtnmen-zhmis.html
  • ekzamen.bystrickaya.ru/richard-devis-bah-stranica-10.html
  • abstract.bystrickaya.ru/1041-avtorskoe-pravo-gosudarstvennij-rubrikator-nauchno-tehnicheskoj-informacii-grnti.html
  • otsenki.bystrickaya.ru/soderzhanie-uchebnogo-predmeta-rabochaya-programma-po-matematike-os-shkola-2100.html
  • © bystrickaya.ru
    Мобильный рефератник - для мобильных людей.