int check_cmd(int argc, char **argv)
{
int i;
int cycles;
i = 1;
cycles = -1;
if (!ft_strcmp(argv[i], "-dump"))
{
if (i + 2 < argc)
{
if ((cycles = ft_atoi(argv[i + 1])) <= 0)
ft_er("Cycle must be positiv");
i += 2;
}
else
ft_er("Wrong number of arguments");
}
while (i < argc)
{
i = check_n(argc, argv, i);
i = check_a(argc, argv, i);
i = check_c(argv, i);
}
return (cycles);
}
int main(void){
struct{
char name[50],tel[30];
int height;
}data[10];
size_t min=50;
int min_l;
int i;
for(i=0;i<10;++i){
scanf("%s %s %d",data[i].name,data[i].tel,&data[i].height);
}
printf(" name phone height\n");
for(i=0;i<10;++i){
if(check_a(data[i].name)==2){
printf("%10s %10s %3d\n",data[i].name,data[i].tel,data[i].height);
}
}
}
int __attribute__((noinline)) try_a(my_uintptr_t x)
{
my_uintptr_t heap[2];
my_uintptr_t *hp = heap;
hp[0] = x;
hp[1] = 0;
return check_a((my_uintptr_t)(void*)((char*)hp + 1));
}
static int fill_program(t_program *program, int i, int argc,
const char **argv)
{
if (check_a(program, i, argc, argv) == RET_FAILURE)
return (RET_FAILURE);
if (check_n(program, i, argc, argv) == RET_FAILURE)
return (RET_FAILURE);
if (check_file(program, i, argv) == RET_FAILURE)
return (RET_FAILURE);
return (RET_SUCCESS);
}
/**
* Returns 1 if the given INF code is a ":a" one.
*/
char check_a(unichar* INF_code) {
/* We produce an artifical dictionary entry with the given INF code,
* and then, we tokenize it in order to get grammatical and inflectional
* codes in a structured way. */
unichar temp[2000];
u_strcpy(temp,"x,");
u_strcat(temp,INF_code);
struct dela_entry* d=tokenize_DELAF_line(temp,0);
char res=check_a(d);
/* We free the artifical dictionary entry */
free_dela_entry(d);
return res;
}
void ps1_checker_2(s_ps1 ps1_st,
bool *escaped,
bool *checked)
{
check_n(ps1_st, escaped, checked);
check_dollar(ps1_st, escaped, checked);
check_a(ps1_st, escaped, checked);
check_e(ps1_st, escaped, checked);
check_r(ps1_st, escaped, checked);
}
void my_compute(int *pile1, int *pile2, int size, int opt)
{
int c;
int ret;
char *buf;
int r[3][5];
r[0][4] = opt;
my_init1(&c, r[0], size, &buf);
while (++c && (r[0][3] = my_sort(pile1, r[0][1], size, -1)))
{
if (my_init2(pile1, pile2, r[0], r) && r[0][4] == 2)
my_debug(pile1, pile2, r[0][1], r[0][2]);
if ((ret = check_a(pile1, pile2, &buf, r)) == 0)
return ;
else if (ret == 1)
continue ;
if ((ret = check_b(pile1, pile2, &buf, r)) == 0)
return ;
}
if (opt == 2)
my_debug(pile1, pile2, r[0][1], r[0][2]);
return (my_end(opt, c - 1, buf, **r - 1));
}
int main(int argc, char*argv[])
{
// 6 config, each has three files to read
char *files[] = {
"../resources/config_32N32M_B.txt",
"../resources/config_32N32M_A.txt",
"../resources/config_32N32M_prior.txt",
"../resources/config_64N64M_B.txt",
"../resources/config_64N64M_A.txt",
"../resources/config_64N64M_prior.txt",
"../resources/config_128N128M_B.txt",
"../resources/config_128N128M_A.txt",
"../resources/config_128N128M_prior.txt",
"../resources/config_256N256M_B.txt",
"../resources/config_256N256M_A.txt",
"../resources/config_256N256M_prior.txt",
"../resources/config_512N512M_B.txt",
"../resources/config_512N512M_A.txt",
"../resources/config_512N512M_prior.txt",
"../resources/config_1024N1024M_B.txt",
"../resources/config_1024N1024M_A.txt",
"../resources/config_1024N1024M_prior.txt",
};
// variables
int i,j,k;
int Len;
int debug=0;
int job=0;
// select job frome commmand line
int argi;
if (argc == 1)
{
puts("Please specify an option.\nUsage: \"./ocl_fo -job number(0-5) \"\n");
exit(1);
}
for (argi = 1; argi < argc; ++argi)
{
if (!strcmp(argv[argi], "-job"))
{
need_argument(argc, argv,argi);
job = atoi(argv[++argi]) ;
continue;
}
if (argv[argi][0] == '-')
{
fatal("'%s' is not a valid command-line option.\n",argv[argi]);
}
}
//printf("job = %d\n", job);
if( job > 5) {
printf("Job number exceeds the limit 5! Exit Programm!\n");
exit(1);
}
HMM *word;
word = (HMM*)malloc(sizeof(HMM));
Len = getLineNum(files[job*3+2]);
printf("config_%dN_%dM\n",Len, Len);
//read B,A,prior
printf("Read the following files...");
//read_config(files,job,B,A,prior,Len);
read_config(word,files,job,Len,Len);
printf("Done!\n");
if( debug && job == 0 ) {
puts("a");
check_a(word);
puts("b");
check_b(word);
puts("pri");
check_pri(word);
}
//----------------------
// run forward algorithm
//----------------------
//---------------------------
// GPU Version
//---------------------------
run_opencl_fo(word);
//---------------------------
// CPU Version
//---------------------------
puts("\n=>CPU");
struct timeval cpu_timer;
int N = word->nstates;
int T = word->len;
float *B = word->b;
float *A = word->a;
float *prior = word->pri;
double tmp, alpha_sum;
double log_likelihood;
float *alpha; // NxT
alpha = (float*)malloc(sizeof(float)*N*T);
float *A_t; // NxN
A_t = (float*)malloc(sizeof(float)*N*N);
log_likelihood = 0.0;
// start timing
tic(&cpu_timer);
transpose(A, A_t, N, T);
for(j=0;j<T;++j)
{
alpha_sum = 0.0;
if(j==0){ // initialize
for(i=0;i<N;++i){
alpha[i*T + 0] = B[i*T + 0] * prior[i];
alpha_sum += alpha[i*T + 0];
}
}else{ // move forward
for(i=0;i<N;++i)
{ // go through each state
tmp = 0.0;
for(k=0;k<N;++k){
tmp += A_t[i*N + k] * alpha[k*T + j-1];
}
alpha[i*T + j] = (float)tmp * B[i*T + j];
alpha_sum += alpha[i*T + j];
}
}
// scaling
for(i=0;i<N;++i){
alpha[i*T + j] /= alpha_sum;
}
log_likelihood += log(alpha_sum);
}
// end timing
toc(&cpu_timer);
printf("log_likelihood = %lf\n", log_likelihood);
// free memory
free_hmm(word);
free(A_t);
free(alpha);
return 0;
}
int apt_clean()
{
newcmd("apt-get");
check_a();
}
int apt_build_dep()
{
newcmd("apt-get");
check_a();
}
int apt_source()
{
newcmd("apt-get");
check_a();
}
int apt_remove()
{
newcmd("apt-get");
check_a();
}
int apt_dist_upgrade()
{
newcmd("apt-get");
check_a();
}
int apt_install()
{
newcmd("apt-get");
check_a();
}
