void SymbExpr::replace(SymbExpr *searched_se, SymbExpr *new_se){
if (_a != NULL && *_a == *searched_se){
set_a(new_se);
} else if (_a != NULL /* && *_a != *searched_se */ )
_a->replace(searched_se, new_se);
if (_b != NULL && *_b == *searched_se){
set_b(new_se);
} else if (_b != NULL /* && *_b != *searched_se */ )
_b->replace(searched_se, new_se);
}
OrbitProto *LineOrbit::serialize() {
auto ret = new OrbitProto();
ret->set_max_value(max_value);
auto lop = new LineOrbitProto();
lop->set_a(a);
lop->set_b(b);
lop->set_c(c);
ret->set_allocated_lineorbit(lop);
return ret;
}
void PCR::initialize_params(){
set_a(1.0);
set_b(1.0);
Vector h = response_histogram();
Vector b = beta();
b[0] = 0;
b.back()=0.001; // a should not be zero
for(uint i=1; i<h.size(); ++i)
b[i] = log(h[i]/h[0]);
set_beta(b);
}
int main ( int argc, const char *argv[] )
{
int n,m,*p,*q,result;
printf ( "Informe o numero de elementos de A: \n" );
// le a quatidade que A tera de n elementos
scanf ( "%d", &n );
printf ( "Informe os elementos de A: \n" );
// chama a funcao para preencher o vetor e p aponta
p=set_a(n);
printf ( "Informe o numero de elementos de B: \n" );
// le a quantidade que B tera de m elementos
scanf ( "%d", &m );
printf ( "Informe os elementos de B: \n" );
// chama a funcao para preencher o vetor e q aponta
q=set_b(m);
// recebe o resultado 1 ou 0
result = a_contains_b(p,n,q,m);
if (result==1)
{
printf ( "A esta contido em B\n" );
}
else
{
printf ( "A nao esta contido em B\n" );
}
// recebe o resultado 1 ou 0
result = ab_equals_ba(p,n,q,m);
if (result==1)
{
printf ( "A=B\n" );
}
else
{
printf ( "A!=B\n" );
}
return 0;
}
int main()
{
int a[3][3];
a[0][0] = 0; a[0][1] = 0; a[0][2] = 0;
a[1][0] = 0; a[1][1] = 0; a[1][2] = 0;
a[2][0] = 0; a[2][1] = 0; a[2][2] = 0;
int b;
int r;
int temp = 4;
int i = 1;
set_b(i, a[i][i]);
a[0][0] = 100; a[0][1] = 10; a[0][2] = 10;
a[1][0] = 1; a[1][1] = 10; a[1][2] = 100;
a[2][0] = 100; a[2][1] = 100; a[2][2] = 100;
b = 0;
r = p(i, a[i][b]);
printf("%d %d %d %d\n", i, temp, b, r);
printf("%d %d %d\n", a[0][0], a[0][1], a[0][2]);
printf("%d %d %d\n", a[1][0], a[1][1], a[1][2]);
printf("%d %d %d\n", a[2][0], a[2][1], a[2][2]);
}
void BM::set_params(double a, double b){set_a(a); set_b(b);}
inline void set_radiosity(trimesh &mesh, patch_handle patch, real_t value)
{
set_b(mesh.property(property_handles::radiosity(), patch), value);
}
void SECmp::canonize(void){
// recursive call
if (_a)
_a->canonize();
if (_b)
_b->canonize();
if (_op == CMP || _op == CMPU)
return; // we need a determinated CMP for further canonization
bool cancont;
do{
cancont=false;
// [<log_op>, [cmp, <expr1>, <expr2>]] -> [<log_op>, <expr1>, expr2>]
if (_a && _a->op() == CMP && _b == NULL){
set_b(_a->b()); // we must set b first, because we'll erase _a
set_a(_a->a());
cancont = true;
}
// The same for unsigned compare
if (_a && _a->op() == CMPU && _b == NULL){
/* change the operator into unsigned form */
switch(_op){
case LE:
_op = ULE;
break;
case LT:
_op = ULT;
break;
case GE:
_op = UGE;
break;
case GT:
_op = UGT;
break;
default:
break;
}
set_b(_a->b()); // we must set b first, because we'll erase _a
set_a(_a->a());
cancont = true;
}
// [<log_op>, [K, <valeur>], <expr>] && <expr> != const
// -> [reverse(<log_op>), <expr>, [K, <valeur>]]
if (_a && _b && _a->op() == CONST && _b->op() != CONST){
_op = reverse(_op);
SymbExpr *expr = _b;
_b = _a;
_a = expr;
cancont = true;
}
// [<log_op>, [+, <expr0>, <expr1>], <expr2>]
// -> [<log_op>, <expr0>, canonize([+, <expr2>, [-, <expr1>]])]
if (_a && _b && _a->op() == ADD && _a->a() && _a->b()){
SEAdd newb = SEAdd(_b->copy(), new SENeg(_a->b()->copy()));
set_b(&newb);
set_a(_a->a());
_b->canonize();
cancont = true;
}
// [<log_op>, [-, <expr0>], expr1]
// -> [reverse(<log_op>), <expr0>, canonize([-, <expr1>])]
if (_a && _b && _a->op() == NEG && _a->a()){
_op = reverse(_op);
set_a(_a->a());
SymbExpr *newb = new SENeg(_b->copy());
set_b(newb);
delete newb;
_b->canonize();
cancont = true;
}
}while(cancont);
}
SymbExpr& SECmp::operator=(const SECmp& expr){
_op = expr._op;
set_a(expr._a);
set_b(expr._b);
return *this;
}
tril::tril(bool in_b, bool in_u)
:data(0)
{
set_b(in_b);
set_u(in_u);
}
tril& tril::operator=(const bool& rhs)
{
set_b(rhs);
set_u(false);
return *this;
}
