int main(int argc, char *argv[]){
int * a;
int * b;
double t;
const unsigned int N = (argc >= 2) ? atoi(argv[1]) : 8;
const unsigned int k1 = (argc >= 3) ? atoi(argv[2]) : 7;
const unsigned int k2 = (argc >= 4) ? atoi(argv[3]) : 9;
double resultado;
t = tick();
a = malloc(N*N*sizeof(int));
b = malloc(N*N*sizeof(int));
init_matrix(a, N, 0, k1);
init_matrix(b, N, 1, k2);
//a = read_ppm5("dos00064.pgm",&h, &w, &bbp);
//b = read_ppm5("dos00065.pgm",&h, &w, &bbp);
t = tick() - t;
printf("Alocacion y lectura de las matrices: %f\n", t);
//b[0][0]=-22;
t = tick();
resultado = MSE(a,b,N);
t = tick() - t;
printf("Procesamiento MSE en matrices: %f\n", t);
printf("\x1B[33mResultado final =====>>> %f\x1B[0m\n", resultado);
if (resultado == verificar (N, k1, k2))
printf("\x1B[32mVerificación: %f == %f\x1B[0m\n", resultado, verificar (N, k1, k2));
else
printf("\x1B[31mVerificación: %f == %f\x1B[0m\n", resultado, verificar (N, k1, k2));
return 0;
}
int main(int argc, char *argv[])
{
char *entrada=argv[1], *saida=argv[2]; //Obtendo o nome dos arquivos passados por parametro ao executar o programa
int instancias,aux;
FILE *input= fopen (entrada,"r"); //Abertura do arquivo de leitura de dados.
FILE *out= fopen (saida,"w+a"); //Abertura do arquivo para gravação dos dados de saida.
Matriz *MAT;
if(input == NULL ) //Verificar se o arquivo de entrada não pode ser aberto.
{
fprintf(out,"ERRO 01: Houve algum problema ao abrir o seu arquivo de texto, verifique se o arquivo existe ou se o nome digitado esta correto");
fclose(input);
fclose(out);
return 0;
}
fscanf(input,"%d ",&instancias);
if(instancias <= 0) //Verifica se o número de instãncias lido é permitido.
{
fprintf(out,"ERRO 02: Número de instâncias insuficiente");
fclose(out);
fclose(input);
return 0;
}
while(instancias > 0)//Loop para executar as leituras e operações das matrizes de acordo com o número de instâncias.
{
MAT = criar(MAT,input,out);
MAT = carregar(MAT,input);
MAT = verificar(MAT,input,out);
imprimir(MAT,out,instancias);
liberar(MAT);
instancias--;
}
fclose(out); //fechamento dos arquivos utilizados durante o programa
fclose(input);
return 0;
}
//Verifica se um conjunto contem outro. Retorna 0, caso falso e 1, caso verdadeiro.
int verificar_contem(conjunto * ca, conjunto * cb) {
//Verfifica se os dois ponteiros referenciam o mesmo conjunto.
if (ca == cb) {
return TRUE;
}
if ((ca == NULL) && (cb == NULL)) { //Verifica se os dois conjuntos são vazios
return TRUE;
} else if (ca == NULL) { //se ca for vazio e cb nao, ca nao contem cb
return FALSE;
} else if (cb == NULL) { //se cb for vazio e ca nao, ca contem cb
return TRUE;
} else { //se nenhum dos dois for vazio, verifica os elementos de cada um
while (cb != NULL) {
if (verificar(ca,cb->numero) == FALSE){
return FALSE;
}
cb = cb->prox;
}
}
return TRUE;
}
//Verifica se um conjunto esta contido em outro. Retorna TRUE, caso verdadeiro e FALSE, caso falso.
int verificar_contido(conjunto * ca, conjunto * cb) {
//Verfifica se os dois ponteiros referenciam o mesmo conjunto.
if (ca == cb) {
return TRUE;
}
/*
*EXPLICACAO LONGA ABAIXO!
*Se quiser seguir adiante com o codigo, pule e volte em caso de duvida.
*===========================================================================================================================================
*Esse if trabalha com a seguinte logica:
* se (ca == NULL) e (cb == NULL), entao TRUE;
* se (ca == NULL) e ¬(cb == NULL)[cb != NULL], entao TRUE;
* logo, se (ca == NULL), entao TRUE, como pode ser verificado com uma tabela verdade.
* Portanto, se ¬(ca == NULL)[ca != NULL], entao FALSE se (cb == NULL), pois um conjunto nao pode estar contido em outro conjunto que seja vazio;
* Daí, temos que, se ¬(ca == NULL) e (cb == NULL), então FALSE;
* A unica outra forma de a saida ser FALSE, e' o caso de tanto ca quanto cb serem diferentes de NULL, onde deverao ser testastos os seus valores. Portanto, o programa faz uma das verificacoes que possam dar em FALSE, caso nao seja (else), ele faz a segunda. Se nenhum dos dois casos FALSE acontecerem, o retorno e' TRUE.
*===========================================================================================================================================
*/
if ((ca != NULL) && (cb == NULL)) { //Primeira possibilidade de retornar FALSE.
return FALSE;
} else {
while (ca != NULL) {
if (verificar(cb, ca->numero) == FALSE) //Segunda possibilidade de retornar FALSE.
return FALSE;
ca = ca->prox;
}
}
//Caso nao caia em nenhuma das verificacoes do caso FALSO, retorno e' TRUE.
return TRUE;
}
int buscaren(int n){
int menor=0;
unsigned seed = (unsigned)time(NULL);
seed+=rand();
srand(seed);
int posision=rand()%8;
while(verificar(posision)){
posision=rand()%8;
}
if((posision>=0)&& (posision<n)){
// printf("\n||---> %d",i);
// printf("\n||----> %d",matrix[
menor=matrix[posision][n];
}
if((posision>=(n+1))&& (posision<(cantidad-1))){
menor=matrix[n][posision];
}
total=total+menor;
return posision;
}
main()
{
char opc,elem;
do{
printf("\nStack --> Opções: \n ");
printf("1 --> Inserir Elemento (PUSH)\n ");
printf("2 --> Retirar Elemento (POP)\n ");
printf("3 --> Ler Elemento do topo (TOP)\n ");
printf("4 --> Tamanho da stack (SIZE)\n ");
printf("5 --> Verificar se a stack esta vazia (ISEMPTY) \n ");
printf("6 --> Limpar a stack (LISTCLEAR)\n ");
printf("7 --> Listar a stack \n ");
printf("8 --> Verificar expressao matematica\n ");
printf("0 --> Sair\n \n");
fflush(stdin);
opc=getchar();
system("cls");
switch (opc)
{
case '1' :
printf("\n Introduza o elemento a inserir na Stack : ");
fflush(stdin);
elem=getchar();
push(elem);
break;
case '2' :
pop();
break;
case '3':
printf("--> %c",top());
break;
case '4':
printf("O tamanho da stack e %d\n",size());
break;
case '5':
if(isempty())
printf("A stack esta vazia\n");
else
printf("A stack nao esta vazia\n");
break;
case '6':
listclear();
break;
case '7':
listar();
break;
case '8':
verificar();
break;
default: printf("\n ERRO: Opção inválida! ");
break;
}
}
while (opc != '0');
}
void ModuloMonitoramento::executarMonitoramento() {
syslog(LOG_INFO, "Executando monitoramento. Total de verificadores: %d",
(unsigned int)verificadores.size());
for (unsigned int i = 0; i < verificadores.size(); i++) {
Verificador *v = ModuloMonitoramento::verificadores.at(i);
verificar(*v);
}
}
/************************************
analizar:
Funcion principal que controla el
analisis semantico.
*************************************/
int analizar(char* tag, char* attr,int n_line){
char *atributo;
char *valor;
n_linea=n_line;
atributo = strtok(attr, "=");
//VERIFICAMOS QUE EL ATRIBUTO SEA VALIDO PARA ESE TAG
//verificar(tag,attr);
//LUEGO SI PASA ESTA PRUEBA VALIDAMOS EL VALOR DEL ATRIBUTO
valor = strtok(NULL, "\"\"");
verificar(tag,attr,valor);
}
main() {
reset();
enable_interrupt();
while() {
elegir_luz();
encender_luz();
}
/***** rutina de interrupcion *****/
if (scan_inter () != 1) {
if (shift_reg == FLAG) {
switch (p_buffer) {
case (0) : comienzo = 1;
break;
case (1) : if (comienzo==1) {
p_buffer = 0;
device = gchar();
if ( device == IDENTIFICATIVO) {
acknowledge();
p_out = 0;
wserial( gout () );
more = 1;
}
}
break;
default : if ( device == IDENTIFICATIVO ) {
if (verificar() == NAK) no_acknowledge ();
else {
ack_nak = interpretar ();
if ( ack_nak == ACK ) acknowledge ();
else no_acknowledge ();
}
p_out = 0;
wserial( gout () );
more = 1;
}
break;
}
p_buffer = 0;
}
else pchar(shift_reg);
}
else {
if (more == 0) goto RTI;
wserial( gout () );
if (shift_reg == 'f') {
p_out = 1;
more = 0;
}
}
RTI ();
}
int main(void)
{
int arr[5] = {1, 2, 3, 4, 5};
int elm;
printf("Ingrese el elemento a buscar:\n");
scanf("%d", &elm);
if (verificar(elm, arr) == 1) {
printf("El elemento si existe\n");
} else {
printf("El elemento no existe\n");
}
return 0;
}
//Insere um elemento no conjunto, caso ja nao exista uma ocorrencia do mesmo no conjunto.
conjunto * inserir(conjunto * c, int numero) {
if (c != NULL) { // verifica se o conjunto é nulo
if (verificar(c, numero) == TRUE) { // se não for, verifica se existe uma ocorrência do número
return c;
}
}
conjunto * novo = (conjunto *) malloc(sizeof(conjunto));
novo->numero = numero;
novo->prox = c;
c = novo;
return c;
}
