int main()
{
	int x=3, alfa(int, int);
	x=alfa(x,x); //
	printf("\n1- %d\n",x); //terceiro print: 1-1
	system ("pause");
	return 0;
}
 void Angle::operator -= (Angle const& beta)
 {
   //cos(alpha - beta) = cos(alpha) * cos(beta) + sin(alpha) * sin(beta)
   //sin(alpha - beta) = sin(alpha) * cos(beta) - sin(beta) * cos(alpha)
   Point alfa(Value);
   Value.X = alfa.X * beta.Value.X + alfa.Y * beta.Value.Y;
   Value.Y = alfa.Y * beta.Value.X - beta.Value.Y * alfa.X;
 }
Пример #3
0
int main(int argc, const char *argv[])
{
	int i,n;
	float x,y,menor=181, numero;
	
	/* descobre o numero de loops */
	printf("Digite o numero de loops\n");
	scanf("%d",&n);

	for(i=0;i<n;i++)
	{
		printf("Digite um valor para o x \n");
		scanf("%f",&x);
		printf("Digite um valor para o y \n");
		scanf("%f",&y);

	/* retira as coordenadas invalidas */

		if(x==0 && y==0)
		{
			printf("O valor digitado é invalido");
			i--;
		}
	        else
	        {
			if(x>=0 && y>=0)	
			{
		            /*verifica qual o menor angulo formado pelas coordenadas x e y */
				numero=alfa(x,y);
	
	                	if (numero<menor)
	                	{
	                    		menor=numero;
	                	}
	                
			}
	            	else
	            	{
				printf("O valor digitado é invalido");
				i--;
			}
		}
	
	}

	/* chama a funcao que retorna o menor angulo  */
	printf("O menor valor é %f\n", menor);

	return 0;
}
Foam::backwardDiffusionFvPatchScalarField::backwardDiffusionFvPatchScalarField
(
    const fvPatch& p,
    const DimensionedField<scalar, volMesh>& iF
)
:
    mixedUserDefinedFvPatchScalarField(p, iF)
{
	alfa()    = 0.0;
	beta()    = 0.0;
        eta()     = 0.0;
	omega0()  = 0.0;
	rho0()    = 0.0;
        epsilon() = 0.0;
        nameInternal_ = dimensionedInternalField().name();
}
Пример #5
0
int main()
{
   clock_t t;
   long fr;

   for (int k=0; k<64000; k++) back[k] = back[k] / 7;

   srand(666);
   if (!add_stars()) { printf("err\n"); exit(1); }

	open_vid();
//   set_mode(0x13);
//   for (int i=0; i<256; i++) set_col(i, i/12, i/8, i/4);

   translate_object(stars, 0.0, 0.0, 2.0);

   fr = 0;
   t = clock();
	while (!ptc_console_key(console))
   {
//      memfill_d((long)screen, 16000, 0);
//      memcopy_d((long)back, (long)screen, 16000);
	memcpy(screen, back, 64000);
//      memset(screen, 0, 64000);
      rotate_object_local(stars);
      cast_object(stars);
      vis_object(stars);
      render_object(stars);
      alfa();
//      memcpy((char *)0xA0000, old_screen, 64000);
//      memcopy_d((long)old_screen, 0xA0000, 16000);
	show(old_screen);

      rotate_object(stars, 9, 9, 9);
      fr++;
   }
   t = clock() - t;
//   getch();

	close_vid();
//   set_mode(3);
   printf("f/s = %f\n", ((float)fr * CLOCKS_PER_SEC / (float)t));
   return 0;
}
void Foam::backwardDiffusionFvPatchScalarField::updateCoeffs()
{
    if (updated())
    {
        return;
    }

    const label patchi = patch().index();

    // Calculating alfa
    const volVectorField& U = db().lookupObject<volVectorField>("U");
    tmp<vectorField> n = patch().nf();
    alfa() = -(n & U.boundaryField()[patchi]);
    
    // Calculating eta
    const volScalarField& rho = db().lookupObject<volScalarField>("rho");
    eta() = rho0() / rho.boundaryField()[patchi];

    nameInternal_ = dimensionedInternalField().name();
    bool soretEffect  = db().foundObject<volScalarField>("gas::Dsoret_" + nameInternal_);

    // Calculating epsilon
    if (soretEffect == true)
    {
        const volScalarField& Dsoret = db().lookupObject<volScalarField>("gas::Dsoret_" + nameInternal_);
    	const volScalarField& T = db().lookupObject<volScalarField>("T");
    	epsilon() = -T.boundaryField()[patchi].snGrad() / T.boundaryField()[patchi] * Dsoret.boundaryField()[patchi];
    }
    else
    { 
	epsilon() = 0.;
    }

    // Calculating beta
    nameInternal_ = dimensionedInternalField().name();
    const volScalarField& Dmix = db().lookupObject<volScalarField>("gas::Dmix_" + nameInternal_);
    beta() = Dmix.boundaryField()[patchi]*this->patch().deltaCoeffs();

    if (debug)
    {
    }

    mixedUserDefinedFvPatchScalarField::updateCoeffs();
}
Пример #7
0
int main()
{
float radiandos=180,x,y;


printf("Digite um valor para o x \n");
scanf("%f",&x);
printf("Digie um valor para o y \n");
scanf("%f",&y);
	if(x>=0 && y>=0)	
	{
		printf("O valor é %f",alfa(x,y));
	}else{
		printf("O valor digitado é invalido");
	}
	

	return 0;
}
Пример #8
0
int allting(int* kommunikationsform, std::string kommunikationsformer) {
  if (*kommunikationsform > 3 || kommunikationsformer == "kompensering")
    return 6365;
  int kommunikationsport = *kommunikationsform + 1;
  std::string* kompis = new std::string("komplettering");
  int* komplementering = ana(kommunikationsport, kompis);
  std::string konditionering("konjunktiv");
  std::string* konfigurering = adressbuss(&kommunikationsport, konditionering);
  std::string* konkretisering = new std::string("kontant");
  std::string konservering = amortering(kommunikationsport, konkretisering);
  std::string* kontra = new std::string("konung");
  int* kontring = anskaffning(kommunikationsport, kontra);
  std::string konvertering("kopiering");
  std::string* kopia = alfa(&kommunikationsport, konvertering);
  std::string* kopp = new std::string("korg");
  std::string koppling = antagligen(kommunikationsport, kopp);
  int korp(24731);
  return korp;
} // allting
Foam::backwardDiffusionFvPatchScalarField::backwardDiffusionFvPatchScalarField
(
    const fvPatch& p,
    const DimensionedField<scalar, volMesh>& iF,
    const dictionary& dict
)
:
    mixedUserDefinedFvPatchScalarField(p, iF)
{
    // Name of field
    nameInternal_ = dimensionedInternalField().name();

    // Set the nominal value
    omega0() = scalarField("omega0", dict, p.size());
    rho0()   = scalarField("rho0", dict, p.size());

    // Fixed value condition is forced
    alfa() = 1000.;
    eta()  = 1.;

    // Calculating epsilon
    epsilon() = 0;

    // Calculating beta
    const double Dmix = 1e-10;
    beta() = Dmix*this->patch().deltaCoeffs();

    // Read value if available
    if (dict.found("value"))
    {
        fvPatchField<scalar>::operator=
        (
            scalarField("value", dict, p.size())
        );
    }
    else
    {
        evaluate();
    }
}
Пример #10
0
int main(int argc, char **argv)
{
 try
 {
  Aplicacao app(argc,argv);
  QTranslator tradutor;
  QString ling_fallback="pgmodeler.en_US";

  app.addLibraryPath(AtributosGlobais::DIR_PLUGINS);

  /** issue#23 **/
  /* Caso o pgModeler não encontre um arquivo de tradução da lingua nativa do sistema o qual está
     sendo executado será carregado o arquivo pgmodeler.en_US (lingua fallback) */
  if(!tradutor.load(QString("pgmodeler.") + QLocale::system().name(), AtributosGlobais::DIR_LINGUAS))
   //Carrega a lingua fallback
   tradutor.load(ling_fallback, AtributosGlobais::DIR_LINGUAS);

  //Instala o tradutor na aplicação
  app.installTranslator(&tradutor);

  //Carregando uma splash screen
  QPixmap pixmap(":imagens/imagens/pgmodeler_logo.png");
  QPixmap alfa(":imagens/imagens/pgmodeler_logo_alfa.png");
  pixmap.setAlphaChannel(alfa);

  QSplashScreen splash(pixmap);
  QFont fnt=splash.font();
  fnt.setPointSize(8.5f);
  splash.setFont(fnt);
  //Exibe a versão do pgmodeler na base do splash
  splash.showMessage(QString("v%1  ").arg(AtributosGlobais::VERSAO_PGMODELER), Qt::AlignBottom | Qt::AlignRight, Qt::white);
  splash.show();
  splash.repaint();

  /* Aloca o formulário principal.
     Durante a sua alocação pode ser disparadas uma série de exceções que a
     aplicação não é capaz de caputar pois o formulário ainda não foi atribuído
     a esta, desta forma, a alocação do formulário e feita dentro de um
     try-catch para possível captura de erros. A aplicação será abortada
     e o erro mostrado no console caso ocorra. */
  FormPrincipal fmain;

  //Atribui o formulário alocado à aplicação
  app.setMainWidget(&fmain);

  //Indicando para a splash screen que ela deve fechar quando a janela principal for exibida
  splash.finish(&fmain);

  //Exibe o formulário principal e prossegue com a execução da aplicação
  fmain.showMaximized();

  //Executa a aplicação
  app.exec();

  return(0);
 }
 //Caso um erro seja capturado durante a inicialização da aplicação
 catch(Excecao &e)
 {
  deque<Excecao> excecoes;
  deque<Excecao>::iterator itr, itr_end;
  unsigned idx=0;

  //Obtém a lista de exceções geradas
  e.obterListaExcecoes(excecoes);
  itr=excecoes.begin();
  itr_end=excecoes.end();

  //Exibe todas as exceções no console
  while(itr!=itr_end)
  {
   cout << "[" << idx << "] " << itr->obterArquivo().toStdString() << " (" << itr->obterLinha().toStdString() << ")" << endl;
   cout << "    " << itr->obterLocal().toStdString() << endl;
   cout << "      [" << Excecao::obterNomeErro(itr->obterTipoErro()).toStdString() << "] ";
   cout << itr->obterMensagemErro().toStdString() << endl << endl;
   itr++; idx++;
  }

  //Retorna o código de erro da última exceção e aborta a aplicação
  return(e.obterTipoErro());
 }
}
void alinhamento(char* seq1, char* seq2, elemento ***c) {
    
    int n = strlen(seq1); // sequencia um fica nas colunas
    int m = strlen(seq2); // sequencia dois fica nas linhas
    
    //criando a matriz de tamanho n*m dinamicamente
    
    *c = (elemento **) malloc( (m+1) * sizeof(elemento *) );
    
    for (int i = 0; i < m+1; i++)
       (*c)[i] = (elemento *) malloc( (n+1) * sizeof (elemento));
    
    
    //preenchendo a primeira colunha com o custo de gap
    (*c)[0][0].ele = 0;
    (*c)[0][0].i = -1;
    (*c)[0][0].j = -1;
    for (int i = 1; i <m+1; i++) {
        (*c)[i][0].ele = gap*i;
        (*c)[i][0].i = i-1;
        (*c)[i][0].j = 0;
    }
    
    //preenchendo a primeira linha com o custo de gap
    
    for (int i = 1; i <n+1; i++) {
        (*c)[0][i].ele = gap*i;
        (*c)[0][i].i = 0;
        (*c)[0][i].j = i-1;
    }
    
    
    //preenchendo a matriz com os custos
    
    int op;
    
    for (int i=1;i<m+1;i++) {
        for (int j=1;j<n+1;j++) {
            
            //descobrindo o maior custo
            
            (*c)[i][j].ele = max( alfa(seq1[j-1],seq2[i-1]) + (*c)[i-1][j-1].ele , gap + (*c)[i][j-1].ele , gap + (*c)[i-1][j].ele , &op);
            
            
            //preenchendo de onde o valor veio, ou seja, a setinha
            
            if(op==1) {
                  (*c)[i][j].i = i-1;
                  (*c)[i][j].j = j-1;
            } 
            else {
                   if(op==2) {
                         (*c)[i][j].i = i;
                         (*c)[i][j].j = j-1;
                   } 
                   else {
                         (*c)[i][j].i = i-1;
                         (*c)[i][j].j = j;
                   }
            }
            
            
            
            
        }
        
    }
    
}
Пример #12
0
autoFeatureWeights FeatureWeights_computeRELIEF
(
    ///////////////////////////////
    // Parameters                //
    ///////////////////////////////

    PatternList pp,         // source pattern
                        //
    Categories c,       // source categories
                        //
    long k              // k(!)
                        //
)

{
	autoPatternList p = Data_copy (pp);
	autoFeatureWeights me = FeatureWeights_create (p -> nx);

	/////////////////////////////////
	// Initial weights <- 0        //
	/////////////////////////////////

	for (long i = 1; i <= p->nx; i++) {
		my fweights -> data [1] [i] = 0.0;
	}

	/////////////////////////////////
	// Normalization               //
	/////////////////////////////////

	autoNUMvector <double> min (0L, p->nx - 1);
	autoNUMvector <double> max (0L, p->nx - 1);
	for (long x = 1; x <= p -> nx; x ++) {
		max [x] = p -> z [1] [x];   // BUG: this will just crash because of array index out of bounds
		min [x] = max [x];
	}

	for (long y = 1; y <= p -> ny; y ++) {
		for (long x = 1; x <= p->nx; x++) {
			if (p->z[y][x] > max[x]) max[x] = p->z[y][x];
			if (p->z[y][x] < min[x]) min[x] = p->z[y][x];
		}
	}

	autoNUMvector <double> alfa (0L, p -> nx - 1);
	for (long x = 1; x <= p -> nx; x ++) {
		alfa [x] = max [x] - min [x];   // BUG: this will just crash because of array index out of bounds
	}

	for (long y = 1; y <= p->ny; y++) {
		for (long x = 1; x <= p->nx; x++) {
			if (alfa [x] != 0.0) {
				p->z[y][x] = (p->z[y][x] - min[x]) / alfa[x];
			} else {
				p->z[y][x] = 0.0;
			}
		}
	}

	/////////////////////////////////
	// Computing prior class probs //
	/////////////////////////////////

	autoNUMvector <double> priors (0L, c->size - 1);   // worst-case allocations
	autoNUMvector <long> classes (0L, c->size - 1);//
	autoNUMvector <long> enemies (0L, c->size - 1);//
	autoNUMvector <long> friends (0L, c->size - 1);//
	long nclasses = FeatureWeights_computePriors (c, classes.peek(), priors.peek());
	Melder_assert (nclasses >= 2);

	/////////////////////////////////
	// Updating the w.vector       //
	/////////////////////////////////

	for (long y = 1; y <= p -> ny; y ++) {

		long nfriends = KNN_kFriends (p.get(), p.get(), c, y, k, friends.peek());
		long nenemies = KNN_kUniqueEnemies (p.get(), p.get(), c, y, nclasses - 1, enemies.peek());

		if (nfriends && nenemies) {
			autoNUMvector <double> classps (0L, nenemies - 1);
			for (long eq = 0; eq < nenemies; eq ++) {
				for (long iq = 0; iq < nclasses; iq ++) {
					if (FeatureWeights_areFriends (c->at [enemies [eq]], c->at [classes [iq]])) {
						classps [eq] = priors [iq];
						break;
					}
				}
			}
			for (long x = 1; x <= p -> nx; x ++) {
				double p1 = 0.0;
				double p2 = 0.0;
				for (long ec = 0; ec < nfriends; ec ++) {
					p1 += fabs (p -> z [y] [x] - p -> z [friends [ec]] [x]) / (p -> ny * nfriends);
				}
				for (long ec = 0; ec < nenemies; ec++) {
					p2 += (fabs (p->z[y][x] - p->z[enemies[ec]][x]) * classps[ec]) / p->ny;
				}
				my fweights -> data [1] [x] = my fweights -> data [1] [x] - p1 + p2;
			}
		}
	}
	return me;
}
Пример #13
0
int main(int argc, char **argv)
{
 try
 {
  //Captura o sinal de segmentation fault e inicia o crashhandler
  signal(SIGSEGV, executarCrashHandler);

  Aplicacao app(argc,argv);
  QTranslator tradutor;

  app.addLibraryPath(AtributosGlobais::DIR_PLUGINS);

  //Tenta carregar a tradução conforme o locale do sistema
  tradutor.load(QLocale::system().name(), AtributosGlobais::DIR_LINGUAS);

  //Instala o tradutor na aplicação
  app.installTranslator(&tradutor);

  //Carregando uma splash screen
  QPixmap pixmap(":imagens/imagens/pgmodeler_logo.png");
  QPixmap alfa(":imagens/imagens/pgmodeler_logo_alfa.png");
  pixmap.setAlphaChannel(alfa);

  //Desenha o texto da versão atual no canto inferior direito do pixmap
  QFont fnt;
  QPainter p;
  fnt.setFamily("Dejavu Sans");
  fnt.setBold(true);
  fnt.setPointSize(7.5f);

  QFontMetrics fm(fnt);
  QString str_ver=QString("v%1").arg(AtributosGlobais::VERSAO_PGMODELER);
  QRect ret=fm.boundingRect(str_ver);

  p.begin(&pixmap);
  p.setFont(fnt);
  p.setPen(QColor(255,255,255));
  p.drawText(QPointF((pixmap.size().width()*0.55f)-(ret.width()/2),
                      pixmap.size().width()-17), str_ver);
  p.end();

  QSplashScreen splash(pixmap);
  splash.show();
  splash.repaint();

  /* Aloca o formulário principal.
     Durante a sua alocação pode ser disparadas uma série de exceções que a
     aplicação não é capaz de caputar pois o formulário ainda não foi atribuído
     a esta, desta forma, a alocação do formulário e feita dentro de um
     try-catch para possível captura de erros. A aplicação será abortada
     e o erro mostrado no console caso ocorra. */
  FormPrincipal fmain;

  //Atribui o formulário alocado à aplicação
  app.setMainWidget(&fmain);

  //Indicando para a splash screen que ela deve fechar quando a janela principal for exibida
  splash.finish(&fmain);

  //Exibe o formulário principal e prossegue com a execução da aplicação
  fmain.showMaximized();

  //Executa a aplicação
  app.exec();

  return(0);
 }
 //Caso um erro seja capturado durante a inicialização da aplicação
 catch(Excecao &e)
 {
  //Retorna o código de erro da última exceção e aborta a aplicação
  return(e.obterTipoErro());
 }
}