int level4()
{
lcdFillWindow(0, 239, 0, 319, BACKGROUND_COLOUR);
map m;
m.putRectangle(1, 3, 1, 4, 2);
m.putRectangle(3, 5, 1, 4, 2);
m.putRectangle(5, 7, 1, 4, 2);
m.putRectangle(7, 9, 1, 4, 2);
m.putRectangle(9, 11, 1, 4, 2);
m.putRectangle(11, 13, 1, 4, 2);
m.putRectangle(1, 6, 4, 6, 2);
m.putRectangle(6, 11, 4, 6, 2);
m.putRectangle(1, 13, 6, 15, 2);
m.putRectangle(4, 13, 6, 15, 2);
m.putRectangle(1, 3, 15, 18, 2);
m.putRectangle(3, 5, 15, 18, 2);
m.putRectangle(5, 7, 15, 18, 2);
m.putRectangle(7, 9, 15, 18, 2);
m.putRectangle(9, 11, 15, 18, 2);
m.putRectangle(11, 13, 15, 18, 2);
m.putSpeedBonus(7, 2);
m.putSpeedBonus(1, 10);
m.putSpeedBonus(13, 18);
m.putSpeedBonus(2, 1);
m.putSpeedBonus(1, 3);
m.setup();
enemy one(1, 9, &m);
enemy two(1, 12, &m);
enemy three(4, 9, &m);
enemy four(4, 12, &m);
pacman five(1, 1, &m);
wait(2000000);
return mainLoop(&five, &m, "EVEN BETTER", "LEVEL 4",
"SEHR SCHLECHT", "TRY AGAIN ");
}
void main()
{
FILE*file;
int cases;
int i,j,k;
char number[110];
file=fopen("input.txt","r");
fscanf(file,"%d",&cases);
for(i=0; i<cases; i++)
{
fscanf(file,"%s",number);
k=strlen(number);
for(j=0; j<k; j++)
{
number[j]-='0';
}
printf("%d %d %d %d %d %d %d %d %d %d\n",two(number,k),three(number,k),four(number,k),five(number,k),six(number,k),seven(number,k),eight(number,k),nine(number,k),ten(number,k),eleven(number,k));
}
}
void
read_PK_index(struct font *fontp, wide_bool hushcs)
{
int hppp, vppp;
long checksum;
fontp->read_char = read_PK_char;
if (debug & DBG_PK)
Printf("Reading PK pixel file %s\n", fontp->filename);
Fseek(fontp->file, (long)one(fontp->file), 1); /* skip comment */
(void)four(fontp->file); /* skip design size */
checksum = four(fontp->file);
if (checksum != fontp->checksum && checksum != 0 && fontp->checksum != 0
&& !hushcs)
Fprintf(stderr,
"Checksum mismatch (dvi = %lu, pk = %lu) in font file %s\n",
fontp->checksum, checksum, fontp->filename);
hppp = sfour(fontp->file);
vppp = sfour(fontp->file);
if (hppp != vppp && (debug & DBG_PK))
Printf("Font has non-square aspect ratio %d:%d\n", vppp, hppp);
/*
* Prepare glyph array.
*/
fontp->glyph = xmalloc(256 * sizeof(struct glyph));
bzero((char *)fontp->glyph, 256 * sizeof(struct glyph));
/*
* Read glyph directory (really a whole pass over the file).
*/
for (;;) {
int bytes_left, flag_low_bits;
unsigned int ch;
PK_skip_specials(fontp);
if (PK_flag_byte == PK_POST)
break;
flag_low_bits = PK_flag_byte & 0x7;
if (flag_low_bits == 7) {
bytes_left = four(fontp->file);
ch = four(fontp->file);
}
else if (flag_low_bits > 3) {
bytes_left = ((flag_low_bits - 4) << 16) + two(fontp->file);
ch = one(fontp->file);
}
else {
bytes_left = (flag_low_bits << 8) + one(fontp->file);
ch = one(fontp->file);
}
fontp->glyph[ch].addr = ftell(fontp->file);
fontp->glyph[ch].x2 = PK_flag_byte;
#ifdef linux
#ifndef SHORTSEEK
#define SHORTSEEK 2048
#endif
/* A bug in Linux libc (as of 18oct94) makes a short read faster
than a short forward seek. Totally non-intuitive. */
if (bytes_left > 0 && bytes_left < SHORTSEEK) {
char *dummy = xmalloc(bytes_left);
Fread(dummy, 1, bytes_left, fontp->file);
free(dummy);
}
else
/* seek backward, or long forward */
#endif /* linux */
Fseek(fontp->file, (long)bytes_left, 1);
if (debug & DBG_PK)
Printf("Scanning pk char %u, at %ld.\n", ch, fontp->glyph[ch].addr);
}
}
/**
* Determine if this transform layer should be drawn before another when they
* are both preserve-3d children.
*
* We want to find the relative z depths of the 2 layers at points where they
* intersect when projected onto the 2d screen plane. Intersections are defined
* as corners that are positioned within the other quad, as well as intersections
* of the lines.
*
* We then choose the intersection point with the greatest difference in Z
* depths and use this point to determine an ordering for the two layers.
* For layers that are intersecting in 3d space, this essentially guesses an
* order. In a lot of cases we only intersect right at the edge point (3d cubes
* in particular) and this generates the 'correct' looking ordering. For planes
* that truely intersect, then there is no correct ordering and this remains
* unsolved without changing our rendering code.
*/
static LayerSortOrder CompareDepth(Layer* aOne, Layer* aTwo) {
gfxRect ourRect = aOne->GetEffectiveVisibleRegion().GetBounds();
gfxRect otherRect = aTwo->GetEffectiveVisibleRegion().GetBounds();
gfx3DMatrix ourTransform = aOne->GetTransform();
gfx3DMatrix otherTransform = aTwo->GetTransform();
// Transform both rectangles and project into 2d space.
gfxQuad ourTransformedRect = ourTransform.TransformRect(ourRect);
gfxQuad otherTransformedRect = otherTransform.TransformRect(otherRect);
gfxRect ourBounds = ourTransformedRect.GetBounds();
gfxRect otherBounds = otherTransformedRect.GetBounds();
if (!ourBounds.Intersects(otherBounds)) {
return Undefined;
}
// Make a list of all points that are within the other rect.
// Could we just check Contains() on the bounds rects. ie, is it possible
// for layers to overlap without intersections (in 2d space) and yet still
// have their bounds rects not completely enclose each other?
nsTArray<gfxPoint> points;
for (PRUint32 i = 0; i < 4; i++) {
if (ourTransformedRect.Contains(otherTransformedRect.mPoints[i])) {
points.AppendElement(otherTransformedRect.mPoints[i]);
}
if (otherTransformedRect.Contains(ourTransformedRect.mPoints[i])) {
points.AppendElement(ourTransformedRect.mPoints[i]);
}
}
// Look for intersections between lines (in 2d space) and use these as
// depth testing points.
for (PRUint32 i = 0; i < 4; i++) {
for (PRUint32 j = 0; j < 4; j++) {
gfxPoint intersection;
gfxLineSegment one(ourTransformedRect.mPoints[i],
ourTransformedRect.mPoints[(i + 1) % 4]);
gfxLineSegment two(otherTransformedRect.mPoints[j],
otherTransformedRect.mPoints[(j + 1) % 4]);
if (one.Intersects(two, intersection)) {
points.AppendElement(intersection);
}
}
}
// No intersections, no defined order between these layers.
if (points.IsEmpty()) {
return Undefined;
}
// Find the relative Z depths of each intersection point and check that the layers are in the same order.
gfxFloat highest = 0;
for (PRUint32 i = 0; i < points.Length(); i++) {
gfxFloat ourDepth = RecoverZDepth(ourTransform, points.ElementAt(i));
gfxFloat otherDepth = RecoverZDepth(otherTransform, points.ElementAt(i));
gfxFloat difference = otherDepth - ourDepth;
if (fabs(difference) > fabs(highest)) {
highest = difference;
}
}
// If layers have the same depth keep the original order
if (highest >= 0) {
return ABeforeB;
} else {
return BBeforeA;
}
}
void DrawQuads()
{
if(g_DrawVertices->size() < 4 * 3)
return;
//Create verts to draw triangle
std::vector<float> vertices;
for(size_t i = 0; i < g_DrawVertices->size(); i += 12)
{
Vector3Df one((*g_DrawVertices)[i], (*g_DrawVertices)[i + 1], (*g_DrawVertices)[i + 2]);
Vector3Df two((*g_DrawVertices)[i + 3], (*g_DrawVertices)[i + 4], (*g_DrawVertices)[i + 5]);
Vector3Df three((*g_DrawVertices)[i + 6], (*g_DrawVertices)[i + 7], (*g_DrawVertices)[i + 8]);
Vector3Df four((*g_DrawVertices)[i + 9], (*g_DrawVertices)[i + 10], (*g_DrawVertices)[i + 11]);
AddToVector(vertices, one);
AddToVector(vertices, two);
AddToVector(vertices, three);
AddToVector(vertices, one);
AddToVector(vertices, three);
AddToVector(vertices, four);
}
//Create verts to draw triangle
std::vector<float> normals;
for(size_t i = 0; i < g_DrawNormals->size(); i += 12)
{
Vector3Df one((*g_DrawNormals)[i], (*g_DrawNormals)[i + 1], (*g_DrawNormals)[i + 2]);
Vector3Df two((*g_DrawNormals)[i + 3], (*g_DrawNormals)[i + 4], (*g_DrawNormals)[i + 5]);
Vector3Df three((*g_DrawNormals)[i + 6], (*g_DrawNormals)[i + 7], (*g_DrawNormals)[i + 8]);
Vector3Df four((*g_DrawNormals)[i + 9], (*g_DrawNormals)[i + 10], (*g_DrawNormals)[i + 11]);
AddToVector(normals, one);
AddToVector(normals, two);
AddToVector(normals, three);
AddToVector(normals, one);
AddToVector(normals, three);
AddToVector(normals, four);
}
std::vector<float> texCoord;
//Create tex coords to draw triangle
if(g_DrawTextureCoords->size() >= 4 * 2) //4 verts * 2 uv
{
for(size_t i = 0; i < g_DrawTextureCoords->size(); i += 8)
{
Vector2Df one((*g_DrawTextureCoords)[i], (*g_DrawTextureCoords)[i + 1]);
Vector2Df two((*g_DrawTextureCoords)[i + 2], (*g_DrawTextureCoords)[i + 3]);
Vector2Df three((*g_DrawTextureCoords)[i + 4], (*g_DrawTextureCoords)[i + 5]);
Vector2Df four((*g_DrawTextureCoords)[i + 6], (*g_DrawTextureCoords)[i + 7]);
AddToVector(texCoord, one);
AddToVector(texCoord, two);
AddToVector(texCoord, three);
AddToVector(texCoord, one);
AddToVector(texCoord, three);
AddToVector(texCoord, four);
}
}
DrawTriangles(vertices, texCoord, normals);
}
void checkRegret(void) {
ExpectationQuad<Real>::checkRegret();
// Check v'(eps)
Real x = eps_, two(2), p1(0.1), zero(0), one(1);
Real vx(0), vy(0);
Real dv = regret(x,1);
Real t(1), diff(0), err(0);
std::cout << std::right << std::setw(20) << "CHECK REGRET: v'(eps) is correct? \n";
std::cout << std::right << std::setw(20) << "t"
<< std::setw(20) << "v'(x)"
<< std::setw(20) << "(v(x+t)-v(x-t))/2t"
<< std::setw(20) << "Error"
<< "\n";
for (int i = 0; i < 13; i++) {
vy = regret(x+t,0);
vx = regret(x-t,0);
diff = (vy-vx)/(two*t);
err = std::abs(diff-dv);
std::cout << std::scientific << std::setprecision(11) << std::right
<< std::setw(20) << t
<< std::setw(20) << dv
<< std::setw(20) << diff
<< std::setw(20) << err
<< "\n";
t *= p1;
}
std::cout << "\n";
// check v''(eps)
vx = zero;
vy = zero;
dv = regret(x,2);
t = one;
diff = zero;
err = zero;
std::cout << std::right << std::setw(20) << "CHECK REGRET: v''(eps) is correct? \n";
std::cout << std::right << std::setw(20) << "t"
<< std::setw(20) << "v''(x)"
<< std::setw(20) << "(v'(x+t)-v'(x-t))/2t"
<< std::setw(20) << "Error"
<< "\n";
for (int i = 0; i < 13; i++) {
vy = regret(x+t,1);
vx = regret(x-t,1);
diff = (vy-vx)/(two*t);
err = std::abs(diff-dv);
std::cout << std::scientific << std::setprecision(11) << std::right
<< std::setw(20) << t
<< std::setw(20) << dv
<< std::setw(20) << diff
<< std::setw(20) << err
<< "\n";
t *= p1;
}
std::cout << "\n";
// Check v'(0)
x = zero;
vx = zero;
vy = zero;
dv = regret(x,1);
t = one;
diff = zero;
err = zero;
std::cout << std::right << std::setw(20) << "CHECK REGRET: v'(0) is correct? \n";
std::cout << std::right << std::setw(20) << "t"
<< std::setw(20) << "v'(x)"
<< std::setw(20) << "(v(x+t)-v(x-t))/2t"
<< std::setw(20) << "Error"
<< "\n";
for (int i = 0; i < 13; i++) {
vy = regret(x+t,0);
vx = regret(x-t,0);
diff = (vy-vx)/(two*t);
err = std::abs(diff-dv);
std::cout << std::scientific << std::setprecision(11) << std::right
<< std::setw(20) << t
<< std::setw(20) << dv
<< std::setw(20) << diff
<< std::setw(20) << err
<< "\n";
t *= p1;
}
std::cout << "\n";
// check v''(eps)
vx = zero;
vy = zero;
dv = regret(x,2);
t = one;
diff = zero;
err = zero;
std::cout << std::right << std::setw(20) << "CHECK REGRET: v''(0) is correct? \n";
std::cout << std::right << std::setw(20) << "t"
<< std::setw(20) << "v''(x)"
<< std::setw(20) << "(v'(x+t)-v'(x-t))/2t"
<< std::setw(20) << "Error"
<< "\n";
for (int i = 0; i < 13; i++) {
vy = regret(x+t,1);
vx = regret(x-t,1);
diff = (vy-vx)/(two*t);
err = std::abs(diff-dv);
std::cout << std::scientific << std::setprecision(11) << std::right
<< std::setw(20) << t
<< std::setw(20) << dv
<< std::setw(20) << diff
<< std::setw(20) << err
<< "\n";
t *= p1;
}
std::cout << "\n";
// Check v'(0)
x = -eps_;
vx = zero;
vy = zero;
dv = regret(x,1);
t = one;
diff = zero;
err = zero;
std::cout << std::right << std::setw(20) << "CHECK REGRET: v'(-eps) is correct? \n";
std::cout << std::right << std::setw(20) << "t"
<< std::setw(20) << "v'(x)"
<< std::setw(20) << "(v(x+t)-v(x-t))/2t"
<< std::setw(20) << "Error"
<< "\n";
for (int i = 0; i < 13; i++) {
vy = regret(x+t,0);
vx = regret(x-t,0);
diff = (vy-vx)/(two*t);
err = std::abs(diff-dv);
std::cout << std::scientific << std::setprecision(11) << std::right
<< std::setw(20) << t
<< std::setw(20) << dv
<< std::setw(20) << diff
<< std::setw(20) << err
<< "\n";
t *= p1;
}
std::cout << "\n";
// check v''(eps)
vx = zero;
vy = zero;
dv = regret(x,2);
t = one;
diff = zero;
err = zero;
std::cout << std::right << std::setw(20) << "CHECK REGRET: v''(-eps) is correct? \n";
std::cout << std::right << std::setw(20) << "t"
<< std::setw(20) << "v''(x)"
<< std::setw(20) << "(v'(x+t)-v'(x-t))/2t"
<< std::setw(20) << "Error"
<< "\n";
for (int i = 0; i < 13; i++) {
vy = regret(x+t,1);
vx = regret(x-t,1);
diff = (vy-vx)/(two*t);
err = std::abs(diff-dv);
std::cout << std::scientific << std::setprecision(11) << std::right
<< std::setw(20) << t
<< std::setw(20) << dv
<< std::setw(20) << diff
<< std::setw(20) << err
<< "\n";
t *= p1;
}
std::cout << "\n";
}
void CriticalCurves::setParameters(double radius_1, double radius_2, Arrangements_2 insets_1, Arrangements_2 insets_2)
{
Arrangement_2_iterator inset_1 = insets_1.begin();
Arrangement_2_iterator inset_2 = insets_2.begin();
while (inset_1 != insets_1.end() && inset_2 != insets_2.end())
{
Arrangement_2 arrangement;
// Add the curves of the inset.
for (Edge_iterator edge = inset_1->edges_begin(); edge != inset_1->edges_end(); ++edge)
{
insert(arrangement, edge->curve());
}
// Add the critical curves of type I.
for (Edge_iterator edge = inset_2->edges_begin(); edge != inset_2->edges_end(); ++edge)
{
if (CGAL::COLLINEAR == edge->curve().orientation())
{
// Displaced a segment.
Nt_traits nt_traits;
Algebraic_ft factor = nt_traits.convert(Rational(radius_1) + Rational(radius_2));
Conic_point_2 source = edge->curve().source();
Conic_point_2 target = edge->curve().target();
Algebraic_ft delta_x = target.x() - source.x();
Algebraic_ft delta_y = target.y() - source.y();
Algebraic_ft length = nt_traits.sqrt(delta_x * delta_x + delta_y * delta_y);
Algebraic_ft translation_x = factor * delta_y / length;
Algebraic_ft translation_y = - factor * delta_x / length;
Conic_point_2 point_1(source.x() + translation_x, source.y() + translation_y);
Conic_point_2 point_2(target.x() + translation_x, target.y() + translation_y);
Algebraic_ft a = - delta_y;
Algebraic_ft b = delta_x;
Algebraic_ft c = factor * length - (source.y() * target.x() - source.x() * target.y());
X_monotone_curve_2 x_monotone_curve(a, b, c, point_1, point_2);
insert(arrangement, x_monotone_curve);
}
else
{
// Displaces an arc.
Rational two(2);
Rational four(4);
Rational r = edge->curve().r();
Rational s = edge->curve().s();
Rational t = edge->curve().t();
Rational u = edge->curve().u();
Rational v = edge->curve().v();
Rational w = edge->curve().w();
Nt_traits nt_traits;
Rational x_center = - u / (two * r);
Rational y_center = - v / (two * r);
Rat_point_2 rat_center(x_center, y_center);
Conic_point_2 center(nt_traits.convert(x_center), nt_traits.convert(y_center));
Rational radius = Rational(radius_1) + two * Rational(radius_2);
Algebraic_ft coefficient = nt_traits.convert(radius / Rational(radius_2));
Conic_point_2 source_1 = edge->curve().source();
Algebraic_ft x_source_2 = center.x() + coefficient * (source_1.x() - center.x());
Algebraic_ft y_source_2 = center.y() + coefficient * (source_1.y() - center.y());
Conic_point_2 source_2(x_source_2, y_source_2);
Conic_point_2 target_1 = edge->curve().target();
Algebraic_ft x_target_2 = center.x() + coefficient * (target_1.x() - center.x());
Algebraic_ft y_target_2 = center.y() + coefficient * (target_1.y() - center.y());
Conic_point_2 target_2(x_target_2, y_target_2);
Rat_circle_2 circle(rat_center, radius * radius);
Conic_arc_2 conic_arc(circle, CGAL::COUNTERCLOCKWISE, source_2, target_2);
insert(arrangement, conic_arc);
}
}
// Add the critical curves of type II.
for (Edge_iterator edge = inset_2->edges_begin(); edge != inset_2->edges_end(); ++edge)
{
double x = CGAL::to_double(edge->curve().source().x());
double y = CGAL::to_double(edge->curve().source().y());
double radius = radius_1 + radius_2;
Rat_point_2 center(x, y);
Rat_circle_2 circle(center, radius * radius);
Conic_arc_2 conic_arc(circle);
insert(arrangement, conic_arc);
}
// Remove the curves which are not include in the inset.
Objects objects;
Face_handle face;
for (Edge_iterator edge = arrangement.edges_begin(); edge != arrangement.edges_end(); ++edge)
{
CGAL::zone(*inset_1, edge->curve(), std::back_inserter(objects));
for (Object_iterator object = objects.begin(); object != objects.end(); ++object)
{
if (assign(face, *object))
{
if (face->is_unbounded())
{
remove_edge(arrangement, edge);
break;
}
}
}
objects.clear();
}
// Print essential information on the standard input.
std::cout << "Arrangement:" << std::endl;
std::cout << " Number of vertices: " << arrangement.number_of_vertices() << std::endl;
std::cout << " Number of edges : " << arrangement.number_of_edges() << std::endl;
std::cout << " Number of face : " << arrangement.number_of_faces() << std::endl;
this->critical_curves.push_back(arrangement);
++inset_1;
++inset_2;
}
// Commit changes.
emit(criticalCurvesChanged());
return;
}
int other () {
one();
two();
one();
two();
}
main()
{
SymbolTable symtab ;
Attribute *attr1a = new Attribute(symtab.intern("attr1a"),"one-a");
Attribute *attr1b = new Attribute(symtab.intern("attr1b"),"one-b");
AttributeList *alist1 = new AttributeList ;
alist1->add(attr1a);
alist1->add(attr1b);
Element one(symtab.intern("One"), 1, alist1, 0);
Element two(symtab.intern("Two"), 2, 0, 0);
PQPosition posn_eq(PQEqual, 1);
PQPosition posn_neq(PQNotEqual, 1);
// /////////////////////////////////////////////////////////////////////////
// Test Position
// /////////////////////////////////////////////////////////////////////////
/* -------- Test Position Equal -------- */
cout << posn_eq.evaluate (one) << endl; // 1
cout << posn_eq.evaluate (two) << endl; // 0
cout << "---" << endl;
/* -------- Test Position Not Equal -------- */
cout << posn_neq.evaluate (one) << endl; // 0
cout << posn_neq.evaluate (two) << endl; // 1
cout << "---" << endl;
// ///////////////////////////////////////////////////////////////////////
// Test Attribute Comparison
// ///////////////////////////////////////////////////////////////////////
PQAttributeSelector pqas_eqa(symtab.intern("attr1a"), PQEqual, "one-a");
PQAttributeSelector pqas_eqb(symtab.intern("attr1a"), PQEqual, "one-b");
PQAttributeSelector pqas_neqa(symtab.intern("attr1a"), PQNotEqual, "one-a");
PQAttributeSelector pqas_neqb(symtab.intern("attr1a"), PQNotEqual, "one-b");
PQAttributeSelector pqas_eqa2(symtab.intern("attr2a"), PQEqual, "one-a");
PQAttributeSelector pqas_eqb2(symtab.intern("attr2a"), PQEqual, "one-b");
PQAttributeSelector pqas_neqa2(symtab.intern("attr2a"), PQNotEqual, "one-a");
PQAttributeSelector pqas_neqb2(symtab.intern("attr2a"), PQNotEqual, "one-b");
cout << pqas_eqa.evaluate(one) << endl ; // 1
cout << pqas_eqa.evaluate(two) << endl ; // 0
cout << pqas_eqb.evaluate(one) << endl ; // 0
cout << pqas_eqb.evaluate(two) << endl ; // 0
cout << pqas_neqa.evaluate(one) << endl ; // 0
cout << pqas_neqa.evaluate(two) << endl ; // 1
cout << pqas_neqb.evaluate(one) << endl ; // 1
cout << pqas_neqb.evaluate(two) << endl ; // 1
cout << pqas_eqa2.evaluate(one) << endl ; // 0
cout << pqas_eqa2.evaluate(two) << endl ; // 0
cout << pqas_eqb2.evaluate(one) << endl ; // 0
cout << pqas_eqb2.evaluate(two) << endl ; // 0
cout << pqas_neqa2.evaluate(one) << endl ; // 1
cout << pqas_neqa2.evaluate(two) << endl ; // 1
cout << pqas_neqb2.evaluate(one) << endl ; // 1
cout << pqas_neqb2.evaluate(two) << endl ; // 1
cout << "****" << endl;
// ///////////////////////////////////////////////////////////////////////
// composite
// ///////////////////////////////////////////////////////////////////////
// position = 1 and attr(attr1a) == "one-a"
PQPosition *p1 = new PQPosition(PQEqual, 1);
PQAttributeSelector *a1 = new PQAttributeSelector(symtab.intern("attr1a"),
PQEqual, "one-a");
PQAttributeSelector *a2 = new PQAttributeSelector(symtab.intern("attr1a"),
PQEqual, "value");
PQLogExpr l1 (p1, PQand, a1);
PQLogExpr l2 (p1, PQor, a1);
PQLogExpr l3 (p1, PQand, a2);
PQLogExpr l4 (p1, PQor, a2);
cout << l1.evaluate(one) << endl ; // 1
cout << l1.evaluate(two) << endl ; // 0
cout << l2.evaluate(one) << endl ; // 1
cout << l2.evaluate(two) << endl ; // 0
cout << l3.evaluate(one) << endl ; // 0
cout << l3.evaluate(two) << endl ; // 0
cout << l4.evaluate(one) << endl ; // 1
cout << l4.evaluate(two) << endl ; // 0
cout << "..." << endl;
cout << PQNot(&l4).evaluate(one) << endl ; // 0
cout << PQNot(&l4).evaluate(two) << endl ; // 1
}
two foo(A&&) {return two();}
void one_three()
{
printf("one\n");
two();
printf("three\n");
}
static void tst3() {
enable_trace("nlsat_interval");
unsynch_mpq_manager qm;
anum_manager am(qm);
small_object_allocator allocator;
nlsat::interval_set_manager ism(am, allocator);
scoped_anum sqrt2(am), m_sqrt2(am), two(am), m_two(am), three(am), one(am), zero(am);
am.set(two, 2);
am.set(m_two, -2);
am.set(one, 1);
am.root(two, 2, sqrt2);
am.set(m_sqrt2, sqrt2);
am.neg(m_sqrt2);
am.set(three, 3);
nlsat::literal p1(1, false);
nlsat::literal p2(2, false);
nlsat::literal p3(3, false);
nlsat::literal p4(4, false);
nlsat::literal np2(2, true);
nlsat::interval_set_ref s1(ism), s2(ism), s3(ism), s4(ism);
s1 = ism.mk_empty();
std::cout << "s1: " << s1 << "\n";
s2 = ism.mk(true, true, zero, false, false, sqrt2, np2);
std::cout << "s2: " << s2 << "\n";
s3 = ism.mk(false, false, zero, false, false, two, p1);
std::cout << "s3: " << s3 << "\n";
s4 = ism.mk_union(s2, s3);
std::cout << "s4: " << s4 << "\n";
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, zero, false, false, two, p1);
s2 = ism.mk(false, false, zero, false, false, two, p2);
tst_interval(s1, s2, 1);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, zero, false, false, two, p1);
s2 = ism.mk(false, false, m_sqrt2, false, false, one, p2);
s3 = ism.mk_union(s1, s2);
tst_interval(s1, s2, 2);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, m_sqrt2, false, false, one, p1);
s2 = ism.mk(false, false, zero, false, false, two, p2);
tst_interval(s1, s2, 2);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, m_sqrt2, false, false, one, p1);
s2 = ism.mk(false, false, two, false, false, three, p2);
tst_interval(s1, s2, 2);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, m_sqrt2, false, false, three, p1);
s2 = ism.mk(false, false, zero, false, false, two, p2);
tst_interval(s1, s2, 1);
// Case
// s1: [ ... ]
// s2: [ ... ] [ ... ]
s1 = ism.mk(false, false, m_two, false, false, two, p1);
s2 = ism.mk(false, false, m_sqrt2, false, false, zero, p2);
s3 = ism.mk(false, false, one, false, false, three, p2);
s2 = ism.mk_union(s2, s3);
tst_interval(s1, s2, 2);
// Case
// s1: [ ... ]
// s2: [ ... ]
s1 = ism.mk(false, false, m_two, false, false, two, p1);
s2 = ism.mk(false, false, two, false, false, three, p2);
tst_interval(s1, s2, 2);
s2 = ism.mk(true, false, two, false, false, three, p2);
tst_interval(s1, s2, 2);
s2 = ism.mk(true, false, two, false, false, three, p1);
tst_interval(s1, s2, 1);
s1 = ism.mk(false, false, m_two, true, false, two, p1);
tst_interval(s1, s2, 2);
s1 = ism.mk(false, false, two, false, false, two, p1);
s2 = ism.mk(false, false, two, false, false, three, p2);
tst_interval(s1, s2, 1);
// Case
// s1: [ ... ] [ ... ]
// s2: [ .. ] [ ... ] [ ... ]
s1 = ism.mk(false, false, m_two, false, false, zero, p1);
s3 = ism.mk(false, false, one, false, false, three, p1);
s1 = ism.mk_union(s1, s3);
s2 = ism.mk(true, true, zero, false, false, m_sqrt2, p2);
tst_interval(s1, s2, 3);
s3 = ism.mk(false, false, one, false, false, sqrt2, p2);
s2 = ism.mk_union(s2, s3);
s3 = ism.mk(false, false, two, true, true, zero, p2);
s2 = ism.mk_union(s2, s3);
tst_interval(s1, s2, 4);
// Case
s1 = ism.mk(true, true, zero, false, false, one, p1);
s2 = ism.mk(true, false, one, true, true, zero, p2);
tst_interval(s1, s2, 2);
s2 = ism.mk(true, false, one, false, false, two, p2);
s3 = ism.mk(false, false, two, true, true, zero, p1);
s2 = ism.mk_union(s2, s3);
tst_interval(s1, s2, 3);
}
void one(int a)
{
printf("one被调用 ---> %d \n",a);
two();
}
int main(void) {
i=EEPROM_read(Address); // de vazut adresele cum sunt puse!
//timer_1(1000); // set value in ms
DDRD = 0xf8;
DDRB = 0xff;
// set external interrupt on digital PIN 2
cli();
PORTD |= (1 << PORTD2); // turn On the Pull-up
EICRA |= (1 << ISC00); //
EICRA |= (1 << ISC01); // set INT0 to trigger on rising edge
EIMSK |= (1 << INT0); // Turns on INT0 - external interrupt mask register
sei();
clear(2);
clear(1);
while(1){
if(i<100 && i>=1){
nr_2=i%10;
nr_1=i/10;
if(nr_1>=1){
if(nr_1==0){
zero(1);
}
if(nr_1==1){
one(1);
}
if(nr_1==2){
two(1);
}
if(nr_1==3){
three(1);
}
if(nr_1==4){
four(1);
}
if(nr_1==5){
five(1);
}
if(nr_1==6){
six(1);
}
if(nr_1==7){
seven(1);
}
if(nr_1==8){
eight(1);
}
if(nr_1==9){
nine(1);
}
}
if(nr_2==0){
zero(2);
}
if(nr_2==1){
one(2);
}
if(nr_2==2){
two(2);
}
if(nr_2==3){
three(2);
}
if(nr_2==4){
four(2);
}
if(nr_2==5){
five(2);
}
if(nr_2==6){
six(2);
}
if(nr_2==7){
seven(2);
}
if(nr_2==8){
eight(2);
}
if(nr_2==9){
nine(2);
}
}
else{
i=0;
clear(2);
clear(1);
}
EEPROM_write(Address, i);
}
return 0;
}
void collideBallWithBall(Gem& a, Gem& b) {
vec2 dv = {(a.pos_x - b.pos_x).toFloat(), (a.pos_y - b.pos_y).toFloat()};
float d_sqr = length_sqr(dv);
if (d_sqr < (2*Gem::RADIUS)*(2*Gem::RADIUS)) {
fixed16_16 rel_vel_x = a.vel_x - b.vel_x;
fixed16_16 rel_vel_y = a.vel_y - b.vel_y;
vec2 rel_vel = {rel_vel_x.toFloat(), rel_vel_y.toFloat()};
float rel_speed_sqr = length_sqr(rel_vel);
if (rel_speed_sqr >= Gem::MERGE_SPEED*Gem::MERGE_SPEED) {
fixed32_0 two(2);
a.pos_x = (a.pos_x + b.pos_x) / two;
a.pos_y = (a.pos_y + b.pos_y) / two;
a.vel_x = a.vel_x + b.vel_x;
a.vel_y = a.vel_y + b.vel_y;
a.score_value += b.score_value;
b.pos_x = -9999;
b.pos_y = 9999;
b.vel_x = b.vel_y = 0;
b.score_value = 0;
} else {
float d = std::sqrt(d_sqr);
float sz = Gem::RADIUS - d / 2.0f;
vec2 normal = dv / d;
fixed24_8 push_back_x(sz * normal.x);
fixed24_8 push_back_y(sz * normal.y);
a.pos_x += push_back_x;
a.pos_y += push_back_y;
b.pos_x -= push_back_x;
b.pos_y -= push_back_y;
vec2 a_par, a_perp;
vec2 b_par, b_perp;
vec2 a_vel = {a.vel_x.toFloat(), a.vel_y.toFloat()};
vec2 b_vel = {b.vel_x.toFloat(), b.vel_y.toFloat()};
splitVector(a_vel, normal, &a_par, &a_perp);
splitVector(b_vel, -normal, &b_par, &b_perp);
static const float friction = 1.0f;
static const float bounce = 0.9f;
float A = (1.0f + bounce) / 2.0f;
float B = (1.0f - bounce) / 2.0f;
a_vel = A*b_par + B*a_par + friction*a_perp;
b_vel = A*a_par + B*b_par + friction*b_perp;
a.vel_x = fixed16_16(a_vel.x);
a.vel_y = fixed16_16(a_vel.y);
b.vel_x = fixed16_16(b_vel.x);
b.vel_y = fixed16_16(b_vel.y);
}
}
}
void test_epsilon_deleting()
{
std::cout << "Testing epsilon deleting..." << std::endl << std::endl;
State zero("0", state_type::NONFINAL);
State one("1", state_type::NONFINAL);
State two("2", state_type::FINAL);
State three("3", state_type::NONFINAL);
State four("4", state_type::FINAL);
State five("5", state_type::NONFINAL);
std::vector<State*> states;
std::set<State*> zeroStatesEps;
std::set<State*> oneStatesA;
std::set<State*> twoStatesEps;
std::set<State*> twoStatesA;
std::set<State*> threeStatesEps;
std::set<State*> fourStates;
std::set<State*> fiveStatesEps;
std::set<State*> fiveStatesB;
states.push_back(&zero);
states.push_back(&one);
states.push_back(&two);
states.push_back(&three);
states.push_back(&four);
states.push_back(&five);
zeroStatesEps.insert(&one);
zeroStatesEps.insert(&two);
zeroStatesEps.insert(&three);
oneStatesA.insert(&four);
twoStatesEps.insert(&four);
twoStatesA.insert(&five);
threeStatesEps.insert(&five);
fiveStatesEps.insert(&three);
fiveStatesB.insert(&four);
std::unordered_map<char , std::set<State*> > zeroTransitions;
std::unordered_map<char , std::set<State*> > oneTransitions;
std::unordered_map<char , std::set<State*> > twoTransitions;
std::unordered_map<char , std::set<State*> > threeTransitions;
std::unordered_map<char , std::set<State*> > fourTransitions;
std::unordered_map<char , std::set<State*> > fiveTransitions;
zeroTransitions[0] = zeroStatesEps;
oneTransitions['a'] = oneStatesA;
twoTransitions[0] = twoStatesEps;
twoTransitions['a'] = twoStatesA;
threeTransitions[0] = threeStatesEps;
fiveTransitions[0] = fiveStatesEps;
fiveTransitions['b'] = fiveStatesB;
std::unordered_map< State*, std::unordered_map<char , std::set<State*> > > transitions;
transitions[&zero] = zeroTransitions;
transitions[&one] = oneTransitions;
transitions[&two] = twoTransitions;
transitions[&three] = threeTransitions;
transitions[&four] = fourTransitions;
transitions[&five] = fiveTransitions;
Automata automata(transitions);
automata.setInitial(&zero);
automata.setStates(states);
std::cout << "Before:" << std::endl << automata << std::endl;
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
automata.removeEpsilonTransitions();
std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
std::cout << "After: " << std::endl << automata << std::endl;
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>( t2 - t1 ).count();
std::cout << "Execution time: " << duration << " milliseconds." << std::endl << std::endl;
}
void test_serialize()
{
std::cout << "Testing serialize..." << std::endl << std::endl;
State zero("0", state_type::NONFINAL);
State one("1", state_type::NONFINAL);
State two("2", state_type::NONFINAL);
State three("3", state_type::FINAL);
std::vector<State*> states;
std::set<State*> zeroStatesA;
std::set<State*> zeroStatesB;
std::set<State*> oneStatesA;
std::set<State*> twoStatesB;
states.push_back(&zero);
states.push_back(&one);
states.push_back(&two);
states.push_back(&three);
zeroStatesA.insert(&zero);
zeroStatesB.insert(&zero);
zeroStatesB.insert(&one);
oneStatesA.insert(&two);
twoStatesB.insert(&three);
std::unordered_map<char , std::set<State*> > zeroTransitions;
std::unordered_map<char , std::set<State*> > oneTransitions;
std::unordered_map<char , std::set<State*> > twoTransitions;
std::unordered_map<char , std::set<State*> > threeTransitions;
zeroTransitions['a'] = zeroStatesA;
zeroTransitions['b'] = zeroStatesB;
oneTransitions['a'] = oneStatesA;
twoTransitions['b'] = twoStatesB;
std::unordered_map< State*, std::unordered_map<char , std::set<State*> > > transitions;
transitions[&zero] = zeroTransitions;
transitions[&one] = oneTransitions;
transitions[&two] = twoTransitions;
transitions[&three] = threeTransitions;
Automata automata(transitions);
automata.setInitial(&zero);
automata.setCurrentState(&zero);
automata.setStates(states);
std::cout << "Avant: " << std::endl << automata << std::endl;
automata.determinise();
std::cout << "après: " << std::endl << automata << std::endl;
automata.minimise();
std::cout << "après après: " << std::endl << automata << std::endl;
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
automata.serialize(path);
std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>( t2 - t1 ).count();
std::cout << "Execution time: " << duration << " milliseconds." << std::endl << std::endl;
}
void test_parsing()
{
std::cout << "Testing parsing..." << std::endl << std::endl;
State zero("0", state_type::NONFINAL);
State one("1", state_type::NONFINAL);
State two("2", state_type::NONFINAL);
State three("3", state_type::FINAL);
std::vector<State*> states;
std::set<State*> zeroStatesA;
std::set<State*> zeroStatesB;
std::set<State*> oneStatesA;
std::set<State*> twoStatesB;
states.push_back(&zero);
states.push_back(&one);
states.push_back(&two);
states.push_back(&three);
zeroStatesA.insert(&zero);
zeroStatesB.insert(&zero);
zeroStatesB.insert(&one);
oneStatesA.insert(&two);
twoStatesB.insert(&three);
std::unordered_map<char , std::set<State*> > zeroTransitions;
std::unordered_map<char , std::set<State*> > oneTransitions;
std::unordered_map<char , std::set<State*> > twoTransitions;
std::unordered_map<char , std::set<State*> > threeTransitions;
zeroTransitions['a'] = zeroStatesA;
zeroTransitions['b'] = zeroStatesB;
oneTransitions['a'] = oneStatesA;
twoTransitions['b'] = twoStatesB;
std::unordered_map< State*, std::unordered_map<char , std::set<State*> > > transitions;
transitions[&zero] = zeroTransitions;
transitions[&one] = oneTransitions;
transitions[&two] = twoTransitions;
transitions[&three] = threeTransitions;
Automata automata(transitions);
automata.setInitial(&zero);
automata.setCurrentState(&zero);
automata.setStates(states);
std::cout << "Avant: " << std::endl << automata << std::endl;
automata.determinise();
std::cout << "après: " << std::endl << automata << std::endl;
automata.minimise();
std::cout << "après après: " << std::endl << automata << std::endl;
std::set<std::string> words;
words.insert("bab");
words.insert("ba");
words.insert("");
words.insert("aaaaaabbbab");
words.insert("bbbb");
for(auto word : words)
{
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
std::cout << "\"" << word << "\"";
std::cout << " accepted ? --> " << automata.isAcceptedWord(word) << std::endl;
std::cout << "word: ";
std::cout << word << std::endl;
std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>( t2 - t1 ).count();
std::cout << "Execution time: " << duration << " milliseconds." << std::endl << std::endl;
}
}
void simulateElectionRelatedStuff() {
GTIDManager mgr(GTID(1,1), 0, 0, 0, 0);
// make sure initialization is what we expect
mgr.catchUnappliedToLive();
GTID resetGTID(2,2);
mgr.resetAfterInitialSync(resetGTID, 1, 1);
// first simulation
ASSERT(GTID::cmp(mgr._lastLiveGTID, GTID(2,2)) == 0);
GTID p;
uint64_t ts;
uint64_t hash;
mgr.getGTIDForPrimary(&p, &ts, &hash);
ASSERT(GTID::cmp(p, GTID(2,3)) == 0);
ASSERT(GTID::cmp(mgr._lastLiveGTID, GTID(2,3)) == 0);
ASSERT(mgr.getHighestKnownPrimary() == 2);
// simulate a normal GTID coming in that bumps up the highestKnownPrimary
mgr.noteGTIDAdded(GTID(5,0), 2, 2);
ASSERT(mgr.getHighestKnownPrimary() == 5);
mgr.noteApplyingGTID(GTID(5,0));
mgr.noteGTIDApplied(GTID(5,0));
// normal GTID coming that does not bump up hkp
mgr.noteGTIDAdded(GTID(5,2), 2, 2);
ASSERT(mgr.getHighestKnownPrimary()== 5);
mgr.noteApplyingGTID(GTID(5,2));
mgr.noteGTIDApplied(GTID(5,2));
//
// test canAcknowledgeGTID and acceptPossiblePrimary
//
ASSERT(mgr.canAcknowledgeGTID()); // can acknowledge
// test possibilities for acceptPossiblePrimary
// new primary too low
ASSERT(mgr.acceptPossiblePrimary(3, GTID(5,5)) == VOTE_NO);
ASSERT(mgr.acceptPossiblePrimary(5, GTID(5,5)) == VOTE_NO);
ASSERT(mgr.canAcknowledgeGTID());
// GTID too low
ASSERT(mgr.acceptPossiblePrimary(6, GTID(5,1)) == VOTE_VETO);
ASSERT(mgr.canAcknowledgeGTID());
// both parameters no good
// in such case, low GTID takes precedence, and we veto
ASSERT(mgr.acceptPossiblePrimary(5, GTID(5,1)) == VOTE_VETO);
ASSERT(mgr.canAcknowledgeGTID());
// boundary case, where it is equal to _lastLiveGTID
ASSERT(GTID::cmp(GTID(5,2), mgr._lastLiveGTID) == 0);
ASSERT(mgr.acceptPossiblePrimary(6, GTID(5,2)) == VOTE_YES);
ASSERT(!mgr.canAcknowledgeGTID());
ASSERT(mgr.getHighestKnownPrimary()== 6);
ASSERT(mgr.acceptPossiblePrimary(8, GTID(5,2)) == VOTE_YES);
ASSERT(!mgr.canAcknowledgeGTID());
ASSERT(mgr.getHighestKnownPrimary()== 8);
mgr.noteGTIDAdded(GTID(6,0), 2, 2);
ASSERT(!mgr.canAcknowledgeGTID());
mgr.noteGTIDAdded(GTID(7,0), 2, 2);
ASSERT(!mgr.canAcknowledgeGTID());
mgr.noteGTIDAdded(GTID(8,0), 2, 2);
ASSERT(mgr.canAcknowledgeGTID());
mgr.noteApplyingGTID(GTID(6,2));
mgr.noteGTIDApplied(GTID(6,2));
mgr.noteApplyingGTID(GTID(7,2));
mgr.noteGTIDApplied(GTID(7,2));
mgr.noteApplyingGTID(GTID(8,2));
mgr.noteGTIDApplied(GTID(8,2));
ASSERT(mgr.getHighestKnownPrimary()== 8);
GTIDManager one(GTID(5,5), 0, 0, 0, 4);
ASSERT(one.getHighestKnownPrimary() == 5);
GTIDManager two(GTID(2,5), 0, 0, 0, 4);
ASSERT(two.getHighestKnownPrimary() == 4);
}
void run( Vector<Real> &s, Real &snorm, Real &del, int &iflag, int &iter, const Vector<Real> &x,
const Vector<Real> &grad, const Real &gnorm, ProjectedObjective<Real> &pObj ) {
Real tol = std::sqrt(ROL_EPSILON<Real>()), zero(0), one(1), two(2), half(0.5);
const Real gtol = std::min(tol1_,tol2_*gnorm);
// Gradient Vector
g_->set(grad);
Real normg = gnorm;
if ( pObj.isConActivated() ) {
primalVector_->set(grad.dual());
pObj.pruneActive(*primalVector_,grad.dual(),x);
g_->set(primalVector_->dual());
normg = g_->norm();
}
// Old and New Step Vectors
s.zero(); s_->zero();
snorm = zero;
Real snorm2(0), s1norm2(0);
// Preconditioned Gradient Vector
//pObj.precond(*v,*g,x,tol);
pObj.reducedPrecond(*v_,*g_,x,grad.dual(),x,tol);
// Basis Vector
p_->set(*v_);
p_->scale(-one);
Real pnorm2 = v_->dot(g_->dual());
iter = 0; iflag = 0;
Real kappa(0), beta(0), sigma(0), alpha(0), tmp(0), sMp(0);
Real gv = v_->dot(g_->dual());
pRed_ = zero;
for (iter = 0; iter < maxit_; iter++) {
//pObj.hessVec(*Hp,*p,x,tol);
pObj.reducedHessVec(*Hp_,*p_,x,grad.dual(),x,tol);
kappa = p_->dot(Hp_->dual());
if (kappa <= zero) {
sigma = (-sMp+sqrt(sMp*sMp+pnorm2*(del*del-snorm2)))/pnorm2;
s.axpy(sigma,*p_);
iflag = 2;
break;
}
alpha = gv/kappa;
s_->set(s);
s_->axpy(alpha,*p_);
s1norm2 = snorm2 + two*alpha*sMp + alpha*alpha*pnorm2;
if (s1norm2 >= del*del) {
sigma = (-sMp+sqrt(sMp*sMp+pnorm2*(del*del-snorm2)))/pnorm2;
s.axpy(sigma,*p_);
iflag = 3;
break;
}
pRed_ += half*alpha*gv;
s.set(*s_);
snorm2 = s1norm2;
g_->axpy(alpha,*Hp_);
normg = g_->norm();
if (normg < gtol) {
break;
}
//pObj.precond(*v,*g,x,tol);
pObj.reducedPrecond(*v_,*g_,x,grad.dual(),x,tol);
tmp = gv;
gv = v_->dot(g_->dual());
beta = gv/tmp;
p_->scale(beta);
p_->axpy(-one,*v_);
sMp = beta*(sMp+alpha*pnorm2);
pnorm2 = gv + beta*beta*pnorm2;
}
if (iflag > 0) {
pRed_ += sigma*(gv-half*sigma*kappa);
}
if (iter == maxit_) {
iflag = 1;
}
if (iflag != 1) {
iter++;
}
snorm = s.norm();
TrustRegion<Real>::setPredictedReduction(pRed_);
}
int main () {
one();
two();
one();
two();
}
int main()
{
printf("== one() ==\n");
one(3, 4);
one(10, 10);
printf("== two() ==\n");
const char* a = "20";
two(a);
const char* b = "100";
two(b);
printf("== three() ==\n");
three();
printf("== four() ==\n");
four(0.5);
four(1.5);
printf("== five() ==\n");
const int num1 = 3;
const int num2 = 3;
five(&num1, &num2);
const int num3 = 4;
five(&num1, &num3);
printf("== six() ==\n");
float *p_six;
int i4 = 4, i432 = 432;
p_six = six(&i4);
printf("%d == %f\n", i4, *p_six);
free(p_six);
p_six = six(&i432);
printf("%d == %f\n", i432, *p_six);
free(p_six);
printf("== seven() ==\n");
const char s = 'S';
seven(&s);
const char t = '_';
seven(&t);
printf("== eight() ==\n");
eight();
printf("== nine() ==\n");
nine();
printf("== ten() ==\n");
int i_ten = 100;
ten(&i_ten);
printf("%d == 0?\n", i_ten);
printf("== eleven() ==\n");
eleven();
printf("== twelve() ==\n");
twelve();
printf("== thirteen() ==\n");
thirteen(10);
printf("== fourteen() ==\n");
fourteen("red");
fourteen("orange");
fourteen("blue");
fourteen("green");
printf("== fifteen() ==\n");
fifteen(1);
fifteen(2);
fifteen(3);
printf("== sixteen() ==\n");
char *str = sixteen();
printf("%s\n", str);
free(str);
printf("== seventeen() ==\n");
seventeen(35);
seventeen(20);
printf("== eighteen() ==\n");
eighteen(3);
eighteen(5);
printf("== clear_bits() ==\n");
long int result;
result = clear_bits(0xFF, 0x55);
printf("%ld\n", result);
result = clear_bits(0x00, 0xF0);
printf("%ld\n", result);
result = clear_bits(0xAB, 0x00);
printf("%ld\n", result);
result = clear_bits(0xCA, 0xFE);
printf("%ld\n", result);
result = clear_bits(0x14, 0x00);
printf("%ld\n", result);
result = clear_bits(0xBB, 0xBB);
printf("%ld\n", result);
return 0;
}
int find_root(data__ &root, const f__ &fun, const data__ &f0) const
{
data__ xmn(xmin), xmx(xmax), two(2);
data__ fmin, fmid, fmax, xmid, data_abs, data_abs2;
typename iterative_root_base<data__>::iteration_type count;
// calculate the function evaluated at the minimum location
fmin=fun(xmn)-f0;
data_abs=std::abs(fmin);
if (this->test_converged(0, data_abs/f0, data_abs))
{
root=xmn;
return this->converged;
}
// calculate the function evaluated at the maximum location
fmax=fun(xmx)-f0;
data_abs=std::abs(fmax);
if (this->test_converged(0, data_abs/f0, data_abs))
{
root=xmx;
return this->converged;
}
count=0;
xmid=(xmx+xmn)/two;
fmid=fun(xmid)-f0;
data_abs=std::abs(xmx-xmn);
data_abs2=std::abs(fmid);
// this tests how close the min and max roots are to each other and tests how close the function evaluations are to zero
while (!this->test_converged(count, data_abs/xmid, data_abs) && !this->test_converged(count, data_abs2/f0, data_abs2))
{
// if middle point is opposite side of root as maximum point
if (fmid*fmax<0)
{
fmin=fmid;
xmn=xmid;
}
else if (fmid*fmin<0)
{
fmax=fmid;
xmx=xmid;
}
else
{
root=(xmn+xmx)/2;
return this->no_root_found;
}
xmid=(xmx+xmn)/two;
fmid=fun(xmid)-f0;
data_abs=std::abs(xmx-xmn);
data_abs2=std::abs(fmid);
++count;
}
root=xmid;
if (this->max_iteration_reached(count))
{
return this->max_iteration; // could not converge
}
return this->converged;
}
CXXCAPI int unittestMutex(void) {
Print printf(Platform::instance().output());
Print errorf(Platform::instance().error());
int errors = 0;
int status;
bool disabled;
printf("%s[%d]: begin\n", __FILE__, __LINE__);
::staticMutex.show();
Mutex mutex;
printf("%s[%d]: mutex begin\n", __FILE__, __LINE__);
mutex.show();
if ((status = mutex.begin()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
mutex.show();
printf("%s[%d]: mutex end\n", __FILE__, __LINE__);
mutex.show();
if ((status = mutex.end()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
mutex.show();
printf("%s[%d]: mutex recursion\n", __FILE__, __LINE__);
mutex.show();
if ((status = mutex.begin()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
mutex.show();
if ((status = mutex.attempt()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
mutex.show();
if ((status = mutex.begin()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
mutex.show();
if ((status = mutex.end()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
mutex.show();
if ((status = mutex.end()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
mutex.show();
if ((status = mutex.end()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
mutex.show();
printf("%s[%d]: critical section\n", __FILE__, __LINE__);
struct MyCriticalSection : public CriticalSection {
explicit MyCriticalSection(Mutex& mutexr, bool disable = true)
: CriticalSection(mutexr, disable)
{
++level;
}
virtual ~MyCriticalSection() {
--level;
}
int getStatus() { return this->status; }
bool getDisabled() { return this->disabled; }
};
{
MyCriticalSection one(mutex);
if ((status = one.getStatus()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
if (!(disabled = one.getDisabled())) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, disabled, true); ++errors; }
if (level != 1) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, level, 1); ++errors; }
mutex.show();
{
MyCriticalSection two(mutex);
if ((status = two.getStatus()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
if (!(disabled = two.getDisabled())) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, disabled, true); ++errors; }
if (level != 2) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, level, 2); ++errors; }
mutex.show();
}
if (level != 1) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, level, 1); ++errors; }
mutex.show();
}
if (level != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, level, 0); ++errors; }
mutex.show();
printf("%s[%d]: critical section enabled\n", __FILE__, __LINE__);
{
MyCriticalSection one(mutex, false);
if ((status = one.getStatus()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
if ((disabled = one.getDisabled())) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, disabled, false); ++errors; }
if (level != 1) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, level, 1); ++errors; }
mutex.show();
{
MyCriticalSection two(mutex, false);
if ((status = two.getStatus()) != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, status, 0); ++errors; }
if ((disabled = two.getDisabled())) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, disabled, false); ++errors; }
if (level != 2) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, level, 2); ++errors; }
mutex.show();
}
if (level != 1) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, level, 1); ++errors; }
mutex.show();
}
if (level != 0) { errorf("%s[%d]: %d!=%d!\n", __FILE__, __LINE__, level, 0); ++errors; }
mutex.show();
printf("%s[%d]: end errors=%d\n",
__FILE__, __LINE__, errors);
return errors;
}
int baz()
{
return two();
}
/**
* \brief Prints one two three.
* \details Prints "one" and "three" by it self, a function is called that
* prints "two".
*/
void oneThree(void)
{
printf("one\n");
two();
printf("three\n");
}
T one() { return two(); };
int main(int argc, char *argv[]) {
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
/*** Initialize communicator. ***/
Teuchos::GlobalMPISession mpiSession (&argc, &argv, &bhs);
Teuchos::RCP<const Teuchos::Comm<int> > comm = Tpetra::DefaultPlatform::getDefaultPlatform().getComm();
const int myRank = comm->getRank();
if ((iprint > 0) && (myRank == 0)) {
outStream = Teuchos::rcp(&std::cout, false);
}
else {
outStream = Teuchos::rcp(&bhs, false);
}
int errorFlag = 0;
// *** Example body.
try {
/*** Read in XML input ***/
std::string filename = "input.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
/*** Initialize main data structure. ***/
Teuchos::RCP<ElasticitySIMPOperators<RealT> > data = Teuchos::rcp(new ElasticitySIMPOperators<RealT>(comm, parlist, outStream));
/*** Build vectors and dress them up as ROL vectors. ***/
Teuchos::RCP<const Tpetra::Map<> > vecmap_u = data->getDomainMapA();
Teuchos::RCP<const Tpetra::Map<> > vecmap_z = data->getCellMap();
Teuchos::RCP<Tpetra::MultiVector<> > u_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > z_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > du_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > dw_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_u, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > dz_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > dz2_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<std::vector<RealT> > vscale_rcp = Teuchos::rcp(new std::vector<RealT>(1, 0));
Teuchos::RCP<std::vector<RealT> > vc_rcp = Teuchos::rcp(new std::vector<RealT>(1, 0));
Teuchos::RCP<std::vector<RealT> > vc_lam_rcp = Teuchos::rcp(new std::vector<RealT>(1, 0));
// Set all values to 1 in u, z.
u_rcp->putScalar(1.0);
// Set z to gray solution.
RealT volFrac = parlist->sublist("ElasticityTopoOpt").get("Volume Fraction", 0.5), one(1), two(2);
z_rcp->putScalar(volFrac);
(*vscale_rcp)[0] = one/std::pow(static_cast<RealT>(z_rcp->getGlobalLength())*(one-volFrac),two);
//test
/*data->updateMaterialDensity (z_rcp);
Teuchos::RCP<Tpetra::MultiVector<RealT> > rhs = Teuchos::rcp(new Tpetra::MultiVector<> (data->getVecF()->getMap(), 1, true));
data->ApplyMatAToVec(rhs, u_rcp);
data->outputTpetraVector(rhs, "KU0.txt");
data->ApplyInverseJacobian1ToVec(u_rcp, rhs, false);
data->outputTpetraVector(u_rcp, "KKU0.txt");
data->ApplyJacobian1ToVec(rhs, u_rcp);
data->outputTpetraVector(rhs, "KU1.txt");
data->ApplyInverseJacobian1ToVec(u_rcp, rhs, false);
data->outputTpetraVector(u_rcp, "KKU1.txt");
*/
//u_rcp->putScalar(1.0);
//z_rcp->putScalar(1.0);
// Randomize d vectors.
du_rcp->randomize();
dw_rcp->randomize();
dz_rcp->randomize();
dz2_rcp->randomize();
// Create ROL::TpetraMultiVectors.
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(u_rcp));
Teuchos::RCP<ROL::Vector<RealT> > zp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(z_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dup = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(du_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dwp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(dw_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dzp = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(dz_rcp));
Teuchos::RCP<ROL::Vector<RealT> > dz2p = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(dz2_rcp));
Teuchos::RCP<ROL::Vector<RealT> > vcp
= Teuchos::rcp(new ROL::PrimalScaledStdVector<RealT>(vc_rcp,vscale_rcp));
Teuchos::RCP<ROL::Vector<RealT> > vc_lamp
= Teuchos::rcp(new ROL::DualScaledStdVector<RealT>(vc_lam_rcp,vscale_rcp));
// Create ROL SimOpt vectors.
ROL::Vector_SimOpt<RealT> x(up,zp);
ROL::Vector_SimOpt<RealT> d(dup,dzp);
ROL::Vector_SimOpt<RealT> d2(dwp,dz2p);
/*** Build objective function, constraint and reduced objective function. ***/
Teuchos::RCP<ROL::Objective_SimOpt<RealT> > obj
= Teuchos::rcp(new Objective_PDEOPT_ElasticitySIMP<RealT>(data, parlist));
Teuchos::RCP<ROL::EqualityConstraint_SimOpt<RealT> > con
= Teuchos::rcp(new EqualityConstraint_PDEOPT_ElasticitySIMP<RealT>(data, parlist));
Teuchos::RCP<ROL::Reduced_Objective_SimOpt<RealT> > objReduced
= Teuchos::rcp(new ROL::Reduced_Objective_SimOpt<RealT>(obj, con, up, dwp));
Teuchos::RCP<ROL::EqualityConstraint<RealT> > volcon
= Teuchos::rcp(new EqualityConstraint_PDEOPT_ElasticitySIMP_Volume<RealT>(data, parlist));
/*** Build bound constraint ***/
Teuchos::RCP<Tpetra::MultiVector<> > lo_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
Teuchos::RCP<Tpetra::MultiVector<> > hi_rcp = Teuchos::rcp(new Tpetra::MultiVector<>(vecmap_z, 1, true));
lo_rcp->putScalar(0.0); hi_rcp->putScalar(1.0);
Teuchos::RCP<ROL::Vector<RealT> > lop = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(lo_rcp));
Teuchos::RCP<ROL::Vector<RealT> > hip = Teuchos::rcp(new ROL::TpetraMultiVector<RealT>(hi_rcp));
Teuchos::RCP<ROL::BoundConstraint<RealT> > bnd = Teuchos::rcp(new ROL::BoundConstraint<RealT>(lop,hip));
/*** Check functional interface. ***/
*outStream << "Checking Objective:" << "\n";
obj->checkGradient(x,d,true,*outStream);
obj->checkHessVec(x,d,true,*outStream);
obj->checkHessSym(x,d,d2,true,*outStream);
*outStream << "Checking Constraint:" << "\n";
con->checkAdjointConsistencyJacobian(*dup,d,x,true,*outStream);
con->checkAdjointConsistencyJacobian_1(*dwp, *dup, *up, *zp, true, *outStream);
con->checkAdjointConsistencyJacobian_2(*dwp, *dzp, *up, *zp, true, *outStream);
con->checkInverseJacobian_1(*up,*up,*up,*zp,true,*outStream);
con->checkInverseAdjointJacobian_1(*up,*up,*up,*zp,true,*outStream);
con->checkApplyJacobian(x,d,*up,true,*outStream);
con->checkApplyAdjointHessian(x,*dup,d,x,true,*outStream);
*outStream << "Checking Reduced Objective:" << "\n";
objReduced->checkGradient(*zp,*dzp,true,*outStream);
objReduced->checkHessVec(*zp,*dzp,true,*outStream);
*outStream << "Checking Volume Constraint:" << "\n";
volcon->checkAdjointConsistencyJacobian(*vcp,*dzp,*zp,true,*outStream);
volcon->checkApplyJacobian(*zp,*dzp,*vcp,true,*outStream);
volcon->checkApplyAdjointHessian(*zp,*vcp,*dzp,*zp,true,*outStream);
/*** Run optimization ***/
ROL::AugmentedLagrangian<RealT> augLag(objReduced,volcon,*vc_lamp,1.0,*zp,*vcp,*parlist);
ROL::Algorithm<RealT> algo("Augmented Lagrangian",*parlist,false);
algo.run(*zp,*vc_lamp,augLag,*volcon,*bnd,true,*outStream);
//ROL::MoreauYosidaPenalty<RealT> MYpen(objReduced,bnd,*zp,1.0);
//ROL::Algorithm<RealT> algo("Moreau-Yosida Penalty",*parlist,false);
//algo.run(*zp,*vc_lamp,MYpen,*volcon,*bnd,true,*outStream);
data->outputTpetraVector(z_rcp, "density.txt");
data->outputTpetraVector(u_rcp, "state.txt");
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
int main()
{
foo( one() )( two() );
Fun(),one(),two(),one();
}
void Projectile::BuildModel()
{
//set up materials
Graphics::MaterialDescriptor desc;
desc.textures = 1;
s_sideMat.reset(Pi::renderer->CreateMaterial(desc));
s_glowMat.reset(Pi::renderer->CreateMaterial(desc));
s_sideMat->texture0 = Graphics::TextureBuilder::Billboard("textures/projectile_l.png").GetOrCreateTexture(Pi::renderer, "billboard");
s_glowMat->texture0 = Graphics::TextureBuilder::Billboard("textures/projectile_w.png").GetOrCreateTexture(Pi::renderer, "billboard");
//zero at projectile position
//+x down
//+y right
//+z forwards (or projectile direction)
const float w = 0.5f;
vector3f one(0.f, -w, 0.f); //top left
vector3f two(0.f, w, 0.f); //top right
vector3f three(0.f, w, -1.f); //bottom right
vector3f four(0.f, -w, -1.f); //bottom left
//uv coords
const vector2f topLeft(0.f, 1.f);
const vector2f topRight(1.f, 1.f);
const vector2f botLeft(0.f, 0.f);
const vector2f botRight(1.f, 0.f);
s_sideVerts.reset(new Graphics::VertexArray(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0));
s_glowVerts.reset(new Graphics::VertexArray(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0));
//add four intersecting planes to create a volumetric effect
for (int i=0; i < 4; i++) {
s_sideVerts->Add(one, topLeft);
s_sideVerts->Add(two, topRight);
s_sideVerts->Add(three, botRight);
s_sideVerts->Add(three, botRight);
s_sideVerts->Add(four, botLeft);
s_sideVerts->Add(one, topLeft);
one.ArbRotate(vector3f(0.f, 0.f, 1.f), DEG2RAD(45.f));
two.ArbRotate(vector3f(0.f, 0.f, 1.f), DEG2RAD(45.f));
three.ArbRotate(vector3f(0.f, 0.f, 1.f), DEG2RAD(45.f));
four.ArbRotate(vector3f(0.f, 0.f, 1.f), DEG2RAD(45.f));
}
//create quads for viewing on end
float gw = 0.5f;
float gz = -0.1f;
for (int i=0; i < 4; i++) {
s_glowVerts->Add(vector3f(-gw, -gw, gz), topLeft);
s_glowVerts->Add(vector3f(-gw, gw, gz), topRight);
s_glowVerts->Add(vector3f(gw, gw, gz), botRight);
s_glowVerts->Add(vector3f(gw, gw, gz), botRight);
s_glowVerts->Add(vector3f(gw, -gw, gz), botLeft);
s_glowVerts->Add(vector3f(-gw, -gw, gz), topLeft);
gw -= 0.1f; // they get smaller
gz -= 0.2f; // as they move back
}
Graphics::RenderStateDesc rsd;
rsd.blendMode = Graphics::BLEND_ALPHA_ONE;
rsd.depthWrite = false;
rsd.cullMode = Graphics::CULL_NONE;
s_renderState = Pi::renderer->CreateRenderState(rsd);
}
