tabuleiro *resolver(tabuleiro *tab){
char tmp[100][100];
int lin,col;
tabuleiro *f, *w, *z, *x;
do{
for(lin=0;lin!=tab->tamanho[0];lin++)
for(col=0;col!=tab->tamanho[1];col++)
tmp[lin][col]=tab->quadro[lin][col];
f=aloca(tab);
w=verigual(tab,estra1(f));
f=aloca(w);
z=verigual(w,estra2(f));
f=aloca(z);
x=verigual(z,estra3(f));
f=aloca(x);
tab=verigual(x,estra4(f));
}while(changes(tmp,tab) && verifica(tab)!=2);
if(verifica(tab)==2);
else tab=aleatorio(tab,0);
return tab;
}
Matrix *new_M(int M, int N){
//cria mtriz Ma x Na de zeros
Matrix *A = NULL;
int i, j;
if(N > 0 && M > 0)
{
A = (Matrix *)aloca(sizeof(Matrix));
A->a = (double **)aloca(M*sizeof(double *));
for(i = 0; i < M; i++)
A->a[i] = (double *)aloca(N*sizeof(double));
A->rows = M;
A->columns = N;
for(i = 0; i < A->rows; i++)
for(j = 0; j < A->columns; j++)
A->a[i][j] = 0;
}
else
{
char msg[50];
sprintf(msg, "new_M recebeu tamanhos não positivos!\n");
reportBad(msg);
}
return(A);
}
void insereInicio(int matricula, char nome[20]) {
if(inicio != NULL) {
Aluno *novo = aloca(matricula, nome);
novo->proximo = inicio;
inicio = novo;
} else {
inicio = aloca(matricula, nome);
}
}
void insereFim(int matricula, char nome[20]) {
if(inicio != NULL) {
Aluno *percorre = inicio;
while(percorre->proximo != NULL) {
percorre = percorre->proximo;
}
percorre->proximo = aloca(matricula, nome);
} else {
inicio = aloca(matricula, nome);
}
}
int main(int argc, char *argv[]) {
int status;
while(TRUE){
printf("FERNANDO&BRUNO@SHELL$ ");
str = (char *)calloc(MAX_COM, sizeof (char));
command = (char *)calloc(MAX_PAR, sizeof (char));
parameters = aloca(MAX_PAR, MAX_PAR);
read_commandline(str);
if(!strcasecmp("exit\n", str)) break;
if(!strcasecmp("\n", str)) continue;
if(fork()==0){
cont = conta_pipe(str);
if(cont > 0){
cria_pipe();
}
else{
read_command(str, command, parameters);
execvp(command, parameters);
}
}
else
wait(&status);
}
return 0;
}
void Inversa::potenciaRegular(matriz *m, matriz *v, double tolerance){
double lambda=0;
double lambdaK;
double aux;
int h=0;
matriz *vk;
vk=(matriz*)malloc(sizeof(matriz));
vk->rows=v->rows;
vk->columns=v->columns;
vk->data=aloca(vk->rows,vk->columns);
do{
printf("loop: k = %d.\n",h+1);
igualaMatrizes(vk,normaEuclidiana(v)); // normalizando v, e vk <- v normalizado "psi"k
igualaMatrizes(v,times(m,vk)); // v+1
printf("autovetor:\n");
showMatriz(v);
printf("autovetor normalizado:\n");
showMatriz(normaEuclidiana(v));
lambdaK = times(transposta(vk),v)->data[0][0]; // retorna uma matriz 1x1, ou um escalar
printf("autovalor:\n");
printf("%f\n",lambdaK);
aux=fabs(lambdaK-lambda)/fabs(lambdaK);
printf("tolerancia: %f\n",aux);
lambda = lambdaK;
h++;
printf("==========================\n");
if(h==20)
stopProgram();
}while(aux>tolerance);
}
ArvAvl * insere_ArvAVL(ArvAVL * arv, int info ){
if( arv == NULL ){
arv = aloca(info);
}
else if( info < arv->info ){
arv->esq = insere( info, arv->esq );
if( altura( arv->esq ) - altura( arv->dir ) == 2 ){
if( info < arv->esq->info )
arv = rotacaoRR( arv );
else
arv = rotacaoLR( arv );
}
}
else if( info > arv->info ){
arv->dir = insere( info arv >dir);
if( altura( arv->dir ) - altura( arv->esq ) == 2 ){
if( info > arv->dir->info )
arv = rotacaoLL( arv );
else
arv = rotacaoRL( arv );
}
}
arv->altura = maior( altura( arv->esq ), altura( arv->dir ) ) + 1;
return arv;
}
// multiplicando duas matrizes
matriz * Inversa::times(matriz *m,matriz *n){
//Critério
if(m->columns!=n->rows){
printf( "Impossivel multiplicar! Parâmetros incorretos.\n" );
exit(0);
}
unsigned short q;// outro int
double buffer=0;
matriz *product;
product = (matriz*)malloc(sizeof(matriz));
//linhas de m e colunas de n
product->rows=m->rows;
product->columns=n->columns;
product->data=aloca(product->rows,product->columns);
for(q=0;q<m->rows;q++){
for(i=0;i<m->columns;i++){
for(j=0;j<n->rows;j++){
buffer+=(m->data[q][j]*n->data[j][i]);
product->data[q][i]=buffer;
}
buffer=0;
}
}
return product;
}
void Inversa::run(){
//showMatriz(m);
matriz *v;
v = (matriz*)malloc(sizeof(matriz));
v->rows=3;v->columns=1;
v->data = aloca(3,1);
v->data[0][0]=1;v->data[1][0]=-2;v->data[2][0]=2;
backupM(); //keep m
initInve();
gaussInversa(m);
normalizePivots();
printf("\n\n");
printf("%s\n\n","MTRIZ A DADA:" );
showMatriz(backup);
printf("%s\n\n","SUA INVERSA A¹ APROX:" );
showMatriz(mInve);
printf("DEVERIA SER I:\n");
printf("%s\n\n","APROX: A¹ x A:" );
savePartialResult(times(mInve,backup));
showMatriz(buffer);
printf("%s\n","APLICANDO POTENCIA NESSA MATRIZ APROX INVERSA:\n\n" );
printf("vetor inicial aleatório:\n");
showMatriz(v);
printf("============ INICIO ===========\n");
potenciaRegular(buffer,v,0.01);
printf("============ FIM ===========\n");
}
int main(){
double dt = 0.1;
double *time;
double t_start, t_end;
int time_steps, Nsamples;
Matrix *xSaved, *zSaved;
double z;
t_start = 0;
t_end = 10;
time_steps =(int)((double)(t_end - t_start)/dt + 0.5);
//arredonda para cima o resultado da divisão
time = (double *)aloca(time_steps*sizeof(double));
int i;
for(i = 0; i < time_steps; i++){
time[i] = i*dt;
}
Nsamples = time_steps;
xSaved = new_M(Nsamples, 3);
zSaved = new_M(Nsamples, 2);
for(i = 0; i < Nsamples; i++)
{
z = getVel();
Matrix *X = NULL;
X = intKalman(z);
xSaved->a[i][0] = time[i];
xSaved->a[i][1] = X->a[0][0];
xSaved->a[i][2] = X->a[1][0];
zSaved->a[i][0] = time[i];
zSaved->a[i][1] = z;
kill_M(&X);
}
const char fileX[] = "../data/X.dat";
const char fileZ[] = "../data/Z.dat";
MatrixPrint2File(xSaved, fileX);
MatrixPrint2File(zSaved, fileZ);
kill_M(&xSaved);
kill_M(&zSaved);
libera(time);
KalmanFilter_End();
EndProgram();
reportGood("O programa chegou ao fim!");
return(0);
}
void Inversa::backupM(){
backup = (matriz*)malloc(sizeof(matriz));
backup->columns=backup->rows=m->rows;
backup->data=aloca(backup->rows,backup->columns);
igualaMatrizes(backup,m);
}
void inicio(FILE* arq, char** mat, char ch, char* s, char* aux){
int i=0, j=0, cont=0;
printf ("Exibindo todos os candidatos:\n");
while( (ch=fgetc(arq))!= EOF){
*(s+i) = ch; //passa os nomes para string
*(aux+j) = ch; //salva linhas
if (ch == '\n'){
*(aux+j+1) = '\0';
if (aux[0] == 'R'){
cont++;
}
j=0;
} else {
j++;
}
i++;
putchar(ch);
}
*(s+i) = '\0'; //evitar problema com o ultmo nome
*(aux+j+1) = '\0';
if (aux[0] == 'R')
cont++;
mat = aloca(mat, cont+1); //aloca a matriz
i=0;
j=0;
cont=0;
while (*(s+i) == '\0'){
*(aux+j) = *(s+i);
if (*(s+i) = '\n'){
*(aux+j+1) = '\0';
if (aux[0] == 'R'){
strcpy (mat[cont], aux); //passa os nomes na string pra matriz
cont++;
}
j=0;
} else {
j++;
}
i++;
}
*(aux+j+1) = '\0';
if (aux[0] == 'R'){
strcpy (mat[cont], aux);//salva os clientes com R
cont++;
}
qsort (mat, (size_t)cont, sizeof(char*), comp);
fim(mat, cont);
}
int main()
{
pacote* p;
p = aloca(TAMANHO);
acessa_como_vetor(p, TAMANHO);
acessa_como_ponteiro(p, TAMANHO);
return 0;
}
void Inversa::savePartialResult(matriz *m){
buffer = (matriz*)malloc(sizeof(matriz));
buffer->columns=buffer->rows=m->rows;
buffer->data=aloca(buffer->rows,buffer->columns);
for(j=0;j<m->rows;j++)
for(i=0;i<m->columns;i++)
buffer->data[j][i]=m->data[j][i];
}
// flip na matriz para depois dar um gauss novamente..
matriz * Inversa::flipMatrix(matriz *m){
flip = (matriz*)malloc(sizeof(matriz));
flip->columns=flip->rows=m->rows;
flip->data=aloca(flip->rows,flip->columns);
for(k=0,i=(m->rows-1);k<m->rows;i--,k++)
for(l=0,j=(m->columns-1);l<m->columns;j--,l++)
flip->data[k][l] = m->data[i][j];
return flip;
}
void insereOrdenada(int matricula, char nome[20]) {
if(inicio != NULL) {
Aluno *novo = aloca(matricula, nome);
Aluno *atual, *anterior;
atual = inicio;
while(atual != NULL && atual->matricula <= matricula) {
anterior = atual;
atual = atual->proximo;
}
novo->proximo = atual;
if (atual == inicio) {
inicio = novo;
} else {
anterior->proximo = novo;
}
} else {
inicio = aloca(matricula, nome);
}
}
// dada uma matriz retorna sua transposta
matriz * Inversa::transposta(matriz *m){
matriz *transposta;
transposta = (matriz*)malloc(sizeof(matriz));
transposta->rows=m->columns;
transposta->columns=m->rows;
transposta->data=aloca(transposta->rows,transposta->columns);
for(i=0;i<m->rows;i++)
for(j=0;j<m->columns;j++)
transposta->data[j][i]=m->data[i][j];
return transposta;
}
void adicionaPalavra(Dicionario **primeiro,Dicionario **ultimo){
// printf("ultimo %d\t*ultimo %d\t&(**ultimo) %d\n", (int)ultimo , (int)*ultimo, (int)&(**ultimo));
fflush(stdin);
printf("Digite a palavra a ser adicionada : ");
if(*ultimo==NULL){
*primeiro = *ultimo = aloca();
}else {
(*ultimo)->prox = aloca();
*ultimo = (*ultimo)->prox;
}
gets( (*ultimo)->palavra );
// printf("ultimo %d\t*ultimo %d\t&(**ultimo) %d\n", (int)ultimo , (int)*ultimo, (int)&(**ultimo));
}
int main(){
int * a,*b,*c;
a=(int*)aloca(10);
*a=10;
b=(int*)aloca(11);
// printf("\n%d\n",b);
*b=45;
libera(a);
// printf("\nb %d\n",*b);
c=(int*)aloca(6);
*c=12;
libera(b);
libera(c);
int i=0;
/* for(i=0;i<tammem;i++){
printf("%d",memoria[i]);
}*/
return 0;
}
void entraFila(no *LISTA){
no *novo = aloca();
novo->prox = NULL;
if(LISTA->prox == NULL){
LISTA->prox = novo;
}else{
no *temp = LISTA->prox;
while(temp->prox != NULL)
{
temp = temp->prox;
}
temp->prox = novo;
}
}
void main (void) {
int inserir, exibir;
int a =5;
int b =5
;
int c =100;
int d =1000;
int **x;
x =aloca(a,b);
insere (x,a,b);
exibe(x,a,b);
//y = aloca(c,d);
//insere (y,c,d);
//exibe (y,c,d);
return 0;
}
//Inserir
void push(tpilha *PILHA)
{
tpilha *novo=aloca();
novo->prox = NULL;
if(vazia(PILHA))
PILHA->prox=novo;
else{
tpilha *aux = PILHA->prox;
while(aux->prox != NULL)
aux = aux->prox;
aux->prox = novo;
}
tam++;
}
/**
* Insere no final da lista encadeada
* @param LISTA
* @param chave
* @param nome
* @param idade
*/
void insereFim(node *LISTA, int chave, char nome[20], int idade) {
node *novo = aloca();
novo->chave = chave;
strcpy(novo->nome, nome);
novo->idade = idade;
novo->prox = NULL;
if (vazia(LISTA))
LISTA->prox = novo;
else {
node *tmp = LISTA->prox;
// loop até o final da lista
while (tmp->prox != NULL)
tmp = tmp->prox;
tmp->prox = novo;
}
}
void insere(node *PRONTOS) {
if(tam==10) {
desenha_linha1(70);
printf("\t\t\x1b[31m --- ERRO! ---\x1b[0m\n");
printf("\t\x1b[33m Limite de Processos Criados (10)\x1b[0m\n\n\n");
system("read -p \"Pressione enter para voltar\" saindo"); }
if(tam!=10) {
node *novo=aloca();
novo->prox = NULL;
if(vazia(PRONTOS))
PRONTOS->prox=novo;
else{ node *tmp = PRONTOS->prox;
while(tmp->prox != NULL)
tmp = tmp->prox;
tmp->prox = novo;
}
tam++;
}
}
void excluir(AGENDA **pAgenda, int *piEntradas)
{
char op;
int i=0;
char nome[40];
printf("\n\tDigite o Nome:");
fflush(stdin);
gets(nome);
/* Uso a sintaxe (*pAgenda)[i].nome pelo fato de ser ponteiro de ponteiro.
O paranteses neste caso serve para "fixar" a primeira posicao da memoria, pois
a linguagem C tende a trabalhar com ponteiros de ponteiros como se fossem
matrizes (que na pratica sao ponteiros para ponteiros) */
for(i=0; i < *piEntradas && strncmp( (*pAgenda)[i].nome, nome, strlen(nome))!=0;i++);
if( i>= *piEntradas )
{
printf("\nRegistro n?o encontrado");
}
else
{
fflush(stdin);
printf("\n\tRegistro %d", i);
printf("\n\tNome : %s", (*pAgenda)[i].nome );
printf("\n\tEmail : %s", (*pAgenda)[i].email );
printf("\n\tFone : %d", (*pAgenda)[i].telefone );
printf("\n\tConfirma a exclusao ?");
op = getch();
if( op == 'S' || op == 's' )
{
/* copio o ultimo elemento para o elemento corrente */
(*pAgenda)[i] = (*pAgenda)[(*piEntradas)-1];
(*piEntradas)--;
/* excluo o ultimo elemento com realoc */
aloca(pAgenda, piEntradas);
}
}
}
int main()
{
Matrix **A, **B;
Matrix *X1, *X2, *X3, *X5, *X10;
char file[] = "./../data/tab1.dat";
A = (Matrix **)aloca(3 * sizeof(Matrix *));
B = (Matrix **)aloca(2 * sizeof(Matrix *));
X1 = PolynomialFitting(file, 17, 1);
X2 = PolynomialFitting(file, 17, 2);
X3 = PolynomialFitting(file, 17, 3);
X5 = PolynomialFitting(file, 17, 5);
X10 = PolynomialFitting(file, 17, 10);
//exemplo pg 230 : resultado ok!
A[0] = X1;
A[1] = X2;
A[2] = X3;
B[0] = X5;
B[1] = X10;
MakeGnuplotMultPlotScript("plot1-a.GNU", \
"./../data/tab1.dat", A, 3, "./../LaTeX/graph/quest1-a");
MakeGnuplotMultPlotScript("plot1-b.GNU", \
"./../data/tab1.dat", B, 2, "./../LaTeX/graph/quest1-b");
printf("O erro da aproximação com n = 1 é : %.6lf\n",\
FindFittingError(X1, file, 17));
printf("O erro da aproximação com n = 2 é : %.6lf\n",\
FindFittingError(X2, file, 17));
printf("O erro da aproximação com n = 3 é : %.6lf\n",\
FindFittingError(X3, file, 17));
printf("O erro da aproximação com n = 5 é : %.6lf\n",\
FindFittingError(X5, file, 17));
printf("O erro da aproximação com n = 10 é : %.6lf\n",\
FindFittingError(X10, file, 17));
print_coeff_table(X1, "tab-quest1-X1.tab");
print_coeff_table(X2, "tab-quest1-X2.tab");
print_coeff_table(X3, "tab-quest1-X3.tab");
print_coeff_table(X5, "tab-quest1-X5.tab");
print_coeff_table(X10, "tab-quest1-X10.tab");
kill_M(&X1);
kill_M(&X2);
kill_M(&X3);
kill_M(&X5);
kill_M(&X10);
libera(A);
libera(B);
EndProgram();
return(0);
}
int main()
{
int casos, h;
int m;
int i, j;
int o, d;
int sai, demora, chega;
char buf[40];
Rota *r;
int novo, espera;
scanf(" %d", &casos);
inicializa();
for(h = 1; h <= casos; h++){
n = 0;
scanf(" %d", &m);
while(m--){
scanf(" %s", buf);
i = acha(buf);
if(i == n){
strcpy(cidade[i].nome, buf);
cidade[i].visitado = 0;
cidade[i].min = INFI;
cidade[i].prox = NULL;
n++;
}
scanf(" %s", buf);
j = acha(buf);
if(j == n){
strcpy(cidade[j].nome, buf);
cidade[j].visitado = 0;
cidade[j].min = INFI;
cidade[j].prox = NULL;
n++;
}
scanf(" %d %d", &sai, &demora);
chega = (sai + demora) % 24;
if((6 <= sai && sai < 18) || demora > 12 ||(6 < chega && chega <= 18))
continue;
r = aloca();
r->d = j;
r->sai = sai % 24;
r->demora = demora;
r->prox = cidade[i].prox;
cidade[i].prox = r;
}
/*
for(i = 0; i< n; i++){
printf("%s | ", cidade[i].nome);
for(r = cidade[i].prox; r != NULL; r = r->prox){
printf("%s ", cidade[r->d].nome);
}
printf("\n");
}
*/
scanf(" %s", buf);
o = acha(buf);
scanf(" %s", buf);
d = acha(buf);
cidade[o].min = 18;
while(1){
i = minimo();
if(i == n || i == d)
break;
cidade[i].visitado = 1;
for(r = cidade[i].prox; r != NULL; r = r->prox){
espera = r->sai - (cidade[i].min % 24);
if(espera < 0)
espera += 24;
espera %= 24;
novo = cidade[i].min + espera + r->demora;
if(novo < cidade[r->d].min)
cidade[r->d].min = novo;
}
}
/*
for(i = 0; i< n; i++)
printf("%s - %d\n", cidade[i].nome, cidade[i].min);
printf("\n");
*/
printf("Test Case %d.\n", h);
if(cidade[d].min == INFI)
printf("There is no route Vladimir can take.\n");
else
printf("Vladimir needs %d litre(s) of blood.\n", (cidade[d].min - 12)/24);
for(i = 0 ; i < n; i++)
destroi(cidade[i].prox);
}
return 0;
}
int cpytuple(buffer *b,char *tuple,FILE *p){
int o;
int count = 0;
int jj = 0;
int tTam = 0; //variais de controle
char *bh = NULL;
bh = aloca(bh);
union c_double vdouble;
union c_int vint;
for(o = 0;o<tamanho;o++){
if(vr[jj].tipo == 'S'){
if(tTam == 0){
tTam = vr[jj].tam;
}
if(tTam != vr[jj].tam){
//copia uma string de tamanho definido
tTam = vr[jj].tam;
fread(bh,sizeof(char),vr[jj].tam,p);
o = (vr[jj].tam + o) - 1;
count = count + vr[jj].tam;
concatString(tuple,bh,o - vr[jj].tam +1);
bh = aloca(bh);
}
else{
//copia string
fread(bh,sizeof(char),vr[jj].tam,p);
o = (vr[jj].tam + o) -1;
count = count + vr[jj].tam;
concatString(tuple,bh, o - vr[jj].tam +1);
bh = aloca(bh);
}
}
else if(vr[jj].tipo == 'D'){
double k;
//copia do arquivo um dado double
if(tTam != vr[jj].tam)
tTam = vr[jj].tam;
fread(&k,sizeof(double),1,p);
vdouble.numd = k;
cpyvar(tuple,vdouble.cnumd,o,sizeof(double));
o = (vr[jj].tam + o) - 1;
count = count + vr[jj].tam;
}
else{
int l;
//copia um dado tipo int
if(tTam != vr[jj].tam)
tTam = vr[jj].tam;
fread(&l,sizeof(int),1,p);
vint.num = l;
cpyvar(tuple,vint.cnum,o,sizeof(int));
o = (vr[jj].tam + o) - 1;
count = count + vr[jj].tam;
}
if(count >=vr[jj].tam-1){
jj++;
count = 0;
}
}
free(bh);
if(cpytoBuffer(b,tuple) == 0)
return 0;
return -1;
}
int bufferpool(buffer *b, char *arqMeta,char *arqDados){
FILE *p = fopen(arqMeta,"rb");
if(!p){
//retorna se encontrar erro ao abrir o arquivo
return -1;
}
int l = 0;
int i = 0;
char aux='a'; //inicializa com valor qualquer
char aux1[2];
fread(&att,sizeof(int),1,p); //Recebe o numero de atributos
strVazia(att);//Define que todas as strings do tipo nome estão vazias
while(i < att){
while(aux != '\0'){
//Procura uma string no arquivo
fread(&aux,sizeof(char),1,p);
aux1[0] = aux;
aux1[1] = '\0'; //transforma aux em uma string para uso da funcao strcat
strcat(vr[l].nome,aux1);//concatena a string nome com aux1 enquanto o while for verdadeiro
}
fread(&vr[l].tipo,sizeof(char),1,p);
//Le o tipo do atributo
fread(&vr[l].tam,sizeof(int),1,p);
//le o tamnho do atributo
l++;
i++;
aux = 'a';//seta aux para que entre no while interno na proxima execucao
}
fclose(p);
p = fopen(arqDados,"r+");
if(!p){
//retorna se encontrar erro ao abrir o arquivo
return -1;
}
int g = 0;
int getMax = 0;
int o; // controle
fseek(p,0,SEEK_END);
long pos = ftell(p); //pega o tamanho do arquivo
rewind(p);
for(g=0;g<att;g++){
getMax = getMax + vr[g].tam;//pega tamanho da tupla
}
tamanho = getMax;
getMax = pos/getMax;//numero de tuplas
char *tuple = NULL;
tuple = aloca(tuple);
for(o = 0;o<getMax;o++){
cpytuple(b,tuple,p);
}
free(tuple);
fclose(p);
return 0;
}
void Inversa::initInve(){
mInve = (matriz*)malloc(sizeof(matriz));
mInve->columns=mInve->rows=m->rows;
mInve->data=aloca(mInve->rows,mInve->columns);
identityMatriz(mInve);
}