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;
}
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();
}
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();
}
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;
}
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();
}
}
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;
}
}
}
}
}
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;
}
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());
}
}