Graphics::VertexArray *Thruster::CreateGeometry()
{
Graphics::VertexArray *verts =
new Graphics::VertexArray(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0);
//zero at thruster center
//+x down
//+y right
//+z backwards (or thrust 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);
//add four intersecting planes to create a volumetric effect
for (int i=0; i < 4; i++) {
verts->Add(one, topLeft);
verts->Add(two, topRight);
verts->Add(three, botRight);
verts->Add(three, botRight);
verts->Add(four, botLeft);
verts->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));
}
return verts;
}
void RunTests()
{
Solution s;
TreeNode one(1);
TreeNode two(2);
TreeNode four(4);
TreeNode four_2(4);
TreeNode five(5);
TreeNode seven(7);
TreeNode eight(8);
TreeNode eleven(11);
TreeNode thirteen(13);
// Simple problems
_ASSERT(!s.hasPathSum(nullptr, 1));
_ASSERT(s.hasPathSum(&one, 1));
// Sample problem
five.left = &four;
five.right = &eight;
four.left = &eleven;
four.right = nullptr;
eleven.left = &seven;
eleven.right = &two;
seven.left = nullptr;
seven.right = nullptr;
two.left = nullptr;
two.right = nullptr;
eight.left = &thirteen;
eight.right = &four_2;
thirteen.left = nullptr;
thirteen.right = nullptr;
four_2.left = nullptr;
four_2.right = &one;
one.left = nullptr;
one.right = nullptr;
_ASSERT(s.hasPathSum(&five, 22));
}
vecN<vecN<OutputType, 2>, 3>
quadratic_from_cubicT(c_array<const vecN<InputType, 2> > pts)
{
FASTUIDRAWassert(pts.size() == 4);
vecN<IntermediateType, 2> p0(pts[0]), p1(pts[1]), p2(pts[2]), p3(pts[3]);
IntermediateFloatType three(3), four(4);
vecN<IntermediateFloatType, 2> q0(pts[0]), q1(pts[1]), q2(pts[2]), q3(pts[3]);
vecN<IntermediateFloatType, 2> C;
/* see the discussion at compute_quadratic_cubic_approximate_error()
* for what the error between the returned quadratic and original
* cubic is.
*/
C = (three * q2 - q3 + three * q1 - q0) / four;
vecN<vecN<OutputType, 2>, 3> return_value;
return_value[0] = vecN<OutputType, 2>(pts[0]);
return_value[1] = vecN<OutputType, 2>(C);
return_value[2] = vecN<OutputType, 2>(pts[3]);
return return_value;
}
void tst_QList::append() const
{
/* test append(const QList<T> &) function */
QString one("one");
QString two("two");
QString three("three");
QString four("four");
QList<QString> list1;
QList<QString> list2;
QList<QString> listTotal;
list1.append(one);
list1.append(two);
list2.append(three);
list2.append(four);
list1.append(list2);
qDebug() << list1;
listTotal.append(one);
listTotal.append(two);
listTotal.append(three);
listTotal.append(four);
QCOMPARE(list1, listTotal);
}
static void
PK_skip_specials P2C(FILE *, f, struct font *, fontp)
{
int i, j;
do
{
PK_flag_byte = one (f);
if (PK_flag_byte >= PK_CMD_START)
{
switch (PK_flag_byte)
{
case PK_X1:
case PK_X2:
case PK_X3:
case PK_X4:
{
i = 0;
for (j = PK_CMD_START; j <= PK_flag_byte; j++)
i = (i * 256) + one (f);
while (i--)
(void) one (f);
break;
}
case PK_Y:
(void) four (f);
case PK_POST:
case PK_NOOP:
break;
default:
oops ("Unexpected %d in PK file %s", PK_flag_byte,
fontp->fontname);
break;
}
}
}
while (PK_flag_byte != PK_POST && PK_flag_byte >= PK_CMD_START);
}
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));
}
}
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 CALLBACK GamePhase::Blink(PVOID lpParameter, BOOLEAN TimerOrWaitFired)
{
// player posun o 1, enemy++ a pokud % dif = 0, pak taky posun o 1 random smerem
switch (GamePhase::direction) {
case 0: // doprava
GamePhase::player = make_pair(GamePhase::player.first + 1, GamePhase::player.second);
if (GamePhase::player.first == windowWidthC - 8) GamePhase::player = make_pair(0, GamePhase::player.second);
break;
case 1: // nahoru
GamePhase::player = make_pair(GamePhase::player.first, GamePhase::player.second - 1);
if (GamePhase::player.second == -1) GamePhase::player = make_pair(GamePhase::player.first, windowHeightC - 9);
break;
case 2: // doleva
GamePhase::player = make_pair(GamePhase::player.first - 1, GamePhase::player.second);
if (GamePhase::player.first == -1) GamePhase::player = make_pair(windowWidthC - 9, GamePhase::player.second);
break;
case 3: // dolu
GamePhase::player = make_pair(GamePhase::player.first, GamePhase::player.second + 1);
if (GamePhase::player.second == windowHeightC - 8) GamePhase::player = make_pair(GamePhase::player.first, 0);
break;
}
GamePhase::playerPath.push_back(GamePhase::player);
if (GamePhase::playerPath.size() >= 100)
{
GamePhase::RemoveTail(*GamePhase::playerPath.begin());
GamePhase::playerPath.erase(GamePhase::playerPath.begin());
}
switch (GamePhase::enemyDirection) {
case 0: // doprava
GamePhase::enemy = make_pair(GamePhase::enemy.first + 1, GamePhase::enemy.second);
if (GamePhase::enemy.first == windowWidthC - 8) GamePhase::enemy = make_pair(0, GamePhase::enemy.second);
break;
case 1: // nahoru
GamePhase::enemy = make_pair(GamePhase::enemy.first, GamePhase::enemy.second - 1);
if (GamePhase::enemy.second == -1) GamePhase::enemy = make_pair(GamePhase::enemy.first, windowHeightC - 9);
break;
case 2: // doleva
GamePhase::enemy = make_pair(GamePhase::enemy.first - 1, GamePhase::enemy.second);
if (GamePhase::enemy.first == -1) GamePhase::enemy = make_pair(windowWidthC - 9, GamePhase::enemy.second);
break;
case 3: // dolu
GamePhase::enemy = make_pair(GamePhase::enemy.first, GamePhase::enemy.second + 1);
if (GamePhase::enemy.second == windowHeightC - 8) GamePhase::enemy = make_pair(GamePhase::enemy.first, 0);
break;
}
GamePhase::enemyPath.push_back(GamePhase::enemy);
if (GamePhase::enemyPath.size() >= 100)
{
GamePhase::RemoveTail(*GamePhase::enemyPath.begin());
GamePhase::enemyPath.erase(GamePhase::enemyPath.begin());
}
GamePhase::enemyCounter++;
if (GamePhase::enemyCounter == GamePhase::enemyNextMove)
{
GamePhase::enemyCounter = 0;
random_device rd;
mt19937 engine(rd());
uniform_int_distribution<unsigned> dist(10, 20);
GamePhase::enemyNextMove = dist(engine);
uniform_int_distribution<unsigned> four(0, 1);
GamePhase::enemyDirection += 1 - 2 * four(engine);
if (GamePhase::enemyDirection < 0) GamePhase::enemyDirection = 3;
else if (GamePhase::enemyDirection > 3) GamePhase::enemyDirection = 0;
}
GamePhase::Draw();
GamePhase::CheckCollision();
}
void GamePhase::InitGoodGame()
{
// 3x 10x10 policka, ctvrte na vyber
// width,height = 50, + borders: 52
vector<vector<CHAR_INFO>> contentVector;
vector<CHAR_INFO> rowVector;
CHAR_INFO chInfo;
chInfo.Attributes = backgroundColorBlackC | foregroundColorGrayC;
for (size_t i = 0; i < 42; i++)
{
for (size_t j = 0; j < 42; j++)
{
chInfo.Char.AsciiChar = pieceOfEvilC;
if (i == 0)
{
if (j == 0) chInfo.Char.AsciiChar = borderCornerLeftUpC;
else if (j == 41) chInfo.Char.AsciiChar = borderCornerRightUpC;
else chInfo.Char.AsciiChar = borderEdgeHorizontalC;
}
else if (i == 41)
{
if (j == 0) chInfo.Char.AsciiChar = borderCornerLeftDownC;
else if (j == 41) chInfo.Char.AsciiChar = borderCornerRightDownC;
else chInfo.Char.AsciiChar = borderEdgeHorizontalC;
}
else if (j == 0 || j == 41) chInfo.Char.AsciiChar = borderEdgeVerticalC;
rowVector.push_back(chInfo);
}
contentVector.push_back(rowVector);
rowVector.clear();
}
SMALL_RECT sr;
sr.Bottom = 42;
sr.Right = 42;
for (size_t k = 0; k < 8; k++)
{
sr.Top = 5 + (k / 4) * 47;
sr.Left = 51 + (k % 4) * 52;
ScreenManager::ReplaceCharsAtRect(contentVector, sr);
}
//bool *rndStart = new bool[40, 40];
bool *rndStart = new bool[1600];
random_device rd;
mt19937 engine(rd());
uniform_int_distribution<unsigned> dist(0, 39);
for (size_t i = 0; i < 40; i++)
{
for (size_t j = 0; j < 40; j++)
{
//rndStart.push_back(nope);
rndStart[i * 40 + j] = nope;
}
}
vector<pair<size_t, size_t>> bits;
for (size_t i = 0; i < 50; i++)
{
bits.push_back(make_pair(dist(engine), dist(engine)));
rndStart[bits[i].first * 40 + bits[i].second] = yep;
}
dist = uniform_int_distribution<unsigned>(0, 49);
uniform_int_distribution<unsigned> fourty(0, 39);
uniform_int_distribution<unsigned> four(0, 3);
vector<pair<size_t, size_t>> chosenBits;
for (size_t i = 0; i < 4 * monster.GetDifficulty(); i++)
{
chosenBits.push_back(make_pair(dist(engine), four(engine)));
}
// game panels
size_t loc = four(engine);
for (size_t k = 0; k < 8; k++)
{
contentVector.clear();
rowVector.clear();
if (k < 3)
{
for (size_t i = 0; i < 40; i++)
{
for (size_t j = 0; j < 40; j++)
{
chInfo.Attributes = backgroundColorBlackC | foregroundColorWhiteC;
chInfo.Char.AsciiChar = rndStart[i * 40 + j] ? pieceOfGodC : pieceOfEvilC;
rowVector.push_back(chInfo);
}
contentVector.push_back(rowVector);
rowVector.clear();
}
} else if (k == 3) {
for (size_t i = 0; i < 40; i++)
{
for (size_t j = 0; j < 40; j++)
{
chInfo.Attributes = backgroundColorBlackC | foregroundColorWhiteC;
chInfo.Char.AsciiChar = (i + j) % 2 == 0 ? pieceOfEvilC : pieceOfGodC;
rowVector.push_back(chInfo);
}
contentVector.push_back(rowVector);
rowVector.clear();
}
}
else if (k == 4 + loc) {
for (size_t i = 0; i < 40; i++)
{
for (size_t j = 0; j < 40; j++)
{
chInfo.Attributes = backgroundColorBlackC | foregroundColorWhiteC;
chInfo.Char.AsciiChar = rndStart[i * 40 + j] ? pieceOfGodC : pieceOfEvilC;
rowVector.push_back(chInfo);
}
contentVector.push_back(rowVector);
rowVector.clear();
}
} else {
vector<pair<size_t, size_t>> rndBits;
for (size_t i = 0; i < 50; i++)
{
rndStart[bits[i].first * 40 + bits[i].second] = nope;
}
for (size_t i = 0; i < 50; i++)
{
rndBits.push_back(make_pair(fourty(engine), fourty(engine)));
rndStart[rndBits[i].first * 40 + rndBits[i].second] = yep;
}
for (size_t i = 0; i < 40; i++)
{
for (size_t j = 0; j < 40; j++)
{
chInfo.Attributes = backgroundColorBlackC | foregroundColorWhiteC;
chInfo.Char.AsciiChar = rndStart[i * 40 + j] ? pieceOfGodC : pieceOfEvilC;
rowVector.push_back(chInfo);
}
contentVector.push_back(rowVector);
rowVector.clear();
}
for (size_t i = 0; i < 50; i++)
{
rndStart[rndBits[i].first * 40 + rndBits[i].second] = nope;
}
for (size_t i = 0; i < 50; i++)
{
rndStart[bits[i].first * 40 + bits[i].second] = yep;
}
}
sr.Left = 51 + 1 + (k % 4) * 52;
sr.Top = 5 + 1 + (k / 4) * 47;
sr.Bottom = 40;
sr.Right = 40;
ScreenManager::ReplaceCharsAtRect(contentVector, sr);
if (k < 3)
{
for (size_t i = 0; i < 50; i++)
{
rndStart[bits[i].first * 40 + bits[i].second] = nope;
}
for (size_t i = 0; i < chosenBits.size(); i++)
{
switch (chosenBits[i].second)
{
case 0: //+,0
if (bits[chosenBits[i].first].first < 39) bits[chosenBits[i].first] = make_pair(bits[chosenBits[i].first].first + 1, bits[chosenBits[i].first].second);
break;
case 1: //0,+
if (bits[chosenBits[i].first].second < 39) bits[chosenBits[i].first] = make_pair(bits[chosenBits[i].first].first, bits[chosenBits[i].first].second - 1);
break;
case 2: //-,0
if (bits[chosenBits[i].first].first > 0) bits[chosenBits[i].first] = make_pair(bits[chosenBits[i].first].first - 1, bits[chosenBits[i].first].second);
break;
case 3: //0,-
if (bits[chosenBits[i].first].second > 0) bits[chosenBits[i].first] = make_pair(bits[chosenBits[i].first].first, bits[chosenBits[i].first].second + 1);
break;
}
}
for (size_t i = 0; i < 50; i++)
{
rndStart[bits[i].first * 40 + bits[i].second] = yep;
}
}
}
vector<Key *> keys;
keys.push_back(new Key('a'));
keys.push_back(new Key('b'));
keys.push_back(new Key('c'));
keys.push_back(new Key('d'));
vector<function<void()>> f;
for (size_t i = 0; i < 4; i++)
{
if (i == loc) f.push_back(GamePhase::returnFunctionCorrect);
else f.push_back(GamePhase::returnFunctionBad);
}
GamePhase::alertManager.CreateAndShowAlerts(keys, GamePhase::alertRect, backgroundColorBlackC | foregroundColorWhiteC, commonWaitingSpeedC, f, false);
delete[] rndStart;
}
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);
}
}
static void
read_PK_char(struct font *fontp, wide_ubyte ch)
{
int i, j;
int n;
int row_bit_pos;
Boolean paint_switch;
BMUNIT *cp;
struct glyph *g;
FILE *fp = fontp->file;
long fpwidth;
BMUNIT word = 0;
int word_weight, bytes_wide;
int rows_left, h_bit, count;
g = &fontp->glyph[ch];
PK_flag_byte = g->x2;
PK_dyn_f = PK_flag_byte >> 4;
paint_switch = ((PK_flag_byte & 8) != 0);
PK_flag_byte &= 0x7;
if (PK_flag_byte == 7)
n = 4;
else if (PK_flag_byte > 3)
n = 2;
else
n = 1;
if (debug & DBG_PK)
Printf("loading pk char %d, char type %d ", ch, n);
/*
* now read rest of character preamble
*/
if (n != 4)
fpwidth = num(fp, 3);
else {
fpwidth = sfour(fp);
(void)four(fp); /* horizontal escapement */
}
(void)num(fp, n); /* vertical escapement */
{
unsigned long w, h;
w = num(fp, n);
h = num(fp, n);
if (w > 0x7fff || h > 0x7fff)
oops("Character %d too large in file %s", ch, fontp->fontname);
g->bitmap.w = w;
g->bitmap.h = h;
}
g->x = snum(fp, n);
g->y = snum(fp, n);
g->dvi_adv = fontp->dimconv * fpwidth;
if (debug & DBG_PK) {
if (g->bitmap.w != 0)
Printf(", size=%dx%d, dvi_adv=%ld", g->bitmap.w, g->bitmap.h,
g->dvi_adv);
Putchar('\n');
}
alloc_bitmap(&g->bitmap);
cp = (BMUNIT *) g->bitmap.bits;
/*
* read character data into *cp
*/
bytes_wide = ROUNDUP((int)g->bitmap.w, BMBITS) * BMBYTES;
PK_bitpos = -1;
if (PK_dyn_f == 14) { /* get raster by bits */
bzero(g->bitmap.bits, (int)g->bitmap.h * bytes_wide);
for (i = 0; i < (int)g->bitmap.h; i++) { /* get all rows */
cp = ADD(g->bitmap.bits, i * bytes_wide);
#ifndef WORDS_BIGENDIAN
row_bit_pos = -1;
#else
row_bit_pos = BMBITS;
#endif
for (j = 0; j < (int)g->bitmap.w; j++) { /* get one row */
if (--PK_bitpos < 0) {
word = one(fp);
PK_bitpos = 7;
}
#ifndef WORDS_BIGENDIAN
if (++row_bit_pos >= BMBITS) {
cp++;
row_bit_pos = 0;
}
#else
if (--row_bit_pos < 0) {
cp++;
row_bit_pos = BMBITS - 1;
}
#endif
if (word & (1 << PK_bitpos))
*cp |= 1 << row_bit_pos;
}
}
}
else { /* get packed raster */
rows_left = g->bitmap.h;
h_bit = g->bitmap.w;
PK_repeat_count = 0;
word_weight = BMBITS;
word = 0;
while (rows_left > 0) {
count = PK_packed_num(fp);
while (count > 0) {
if (count < word_weight && count < h_bit) {
#ifndef WORDS_BIGENDIAN
if (paint_switch)
word |= bit_masks[count] << (BMBITS - word_weight);
#endif
h_bit -= count;
word_weight -= count;
#ifdef WORDS_BIGENDIAN
if (paint_switch)
word |= bit_masks[count] << word_weight;
#endif
count = 0;
}
else if (count >= h_bit && h_bit <= word_weight) {
if (paint_switch)
word |= bit_masks[h_bit] <<
#ifndef WORDS_BIGENDIAN
(BMBITS - word_weight);
#else
(word_weight - h_bit);
#endif
*cp++ = word;
/* "output" row(s) */
for (i = PK_repeat_count * bytes_wide / BMBYTES; i > 0; --i) {
*cp = *SUB(cp, bytes_wide);
++cp;
}
rows_left -= PK_repeat_count + 1;
PK_repeat_count = 0;
word = 0;
word_weight = BMBITS;
count -= h_bit;
h_bit = g->bitmap.w;
}
else {
if (paint_switch)
#ifndef WORDS_BIGENDIAN
word |= bit_masks[word_weight] <<
(BMBITS - word_weight);
#else
word |= bit_masks[word_weight];
#endif
*cp++ = word;
word = 0;
count -= word_weight;
h_bit -= word_weight;
word_weight = BMBITS;
}
}
paint_switch = 1 - paint_switch;
}
if (cp != ((BMUNIT *) (g->bitmap.bits + bytes_wide * g->bitmap.h)))
oops("Wrong number of bits stored: char. %d, font %s", ch,
fontp->fontname);
if (rows_left != 0 || h_bit != g->bitmap.w)
oops("Bad pk file (%s), too many bits", fontp->fontname);
}
}
int main()
{
Node<std::string> six("6");
Node<std::string> five("5");
Node<std::string> four("4");
Node<std::string> three("3");
Node<std::string> two("2");
Node<std::string> one("1");
Node<std::string> zero("0");
DAG<std::string> myGraph;
myGraph.beginTransaction();
myGraph.addEdge(four, one);
myGraph.addEdge(two, three);
myGraph.addEdge(three, one);
myGraph.addEdge(five, two);
myGraph.addEdge(five, zero);
myGraph.addEdge(four, zero);
myGraph.endTransaction();
myGraph.report();
Node<std::string> next;
if (myGraph.next(next))
{
std::cout << "Next: " << next.value << std::endl;
myGraph.remove(next);
}
if (myGraph.next(next))
{
std::cout << "Next: " << next.value << std::endl;
myGraph.remove(next);
}
myGraph.addNode(six);
if (myGraph.next(next))
{
std::cout << "Next: " << next.value << std::endl;
myGraph.remove(next);
}
if (myGraph.next(next))
{
std::cout << "Next: " << next.value << std::endl;
myGraph.remove(next);
}
if (myGraph.next(next))
{
std::cout << "Next: " << next.value << std::endl;
myGraph.remove(next);
}
if (myGraph.next(next))
{
std::cout << "Next: " << next.value << std::endl;
myGraph.remove(next);
}
if (myGraph.next(next))
{
std::cout << "Next: " << next.value << std::endl;
myGraph.remove(next);
}
return 0;
}
GPL_NONE, /* GF_CHAR_LOC */
GPL_NONE, /* GF_CHAR_LOC0 */
GPL_NONE, /* GF_PRE */
GPL_NONE, /* GF_POST */
GPL_NONE, /* GF_POSTPOST */
six(GPL_NONE) /* 250 through 255 */
};
/*
* Types of the various opcodes.
*/
char gf_gt[256] = {
sixty_four(GT_PAINT0), /* GF_PAINT_0 through GF_PAINT_63 */
three(GT_PAINT), /* GF_PAINT1 through GF_PAINT3 */
GT_BOC, /* GF_BOC */
GT_BOC1, /* GF_BOC1 */
GT_EOC, /* GF_EOC */
GT_SKIP0, /* GF_SKIP0 */
three(GT_SKIP), /* GF_SKIP1 through GF_SKIP3 */
one_sixty_five(GT_NEW_ROW),/* GF_NEW_ROW_0 throgh GF_NEW_ROW_164 */
four(GT_XXX), /* GF_XXX1 through GF_XXX4 */
GT_YYY, /* GF_YYY */
GT_NOP, /* GF_NOP */
GT_CHAR_LOC, /* GF_CHAR_LOC */
GT_CHAR_LOC0, /* GF_CHAR_LOC0 */
GT_PRE, /* GF_PRE */
GT_POST, /* GF_POST */
GT_POSTPOST, /* GF_POSTPOST */
six(GT_UNDEF) /* 250 through 255 */
};
Limbs::Limbs(Encoding &g)
:genome(g)
{
//create Traits
Trait spindly(1, -3, 3, "spindly");
Trait thin(1, -2, 1, "thin");
Trait thick(-2, 3, 0, "thick");
Trait round(3, -1, -1, "round");
Trait zero(0, 0, 3, "0");
Trait one(1, 1, 3, "1");
Trait two(3, 1, -3, "2");
Trait three(-1, 1, 3, "3");
Trait four(3, 1, -3, "4");
Trait five(-1, 1, 3, "5");
Trait six(2, 1, -3, "6");
Trait seven(-2, 2, 3, "7");
Trait eight(0, 3, 2, "8");
Trait nine(-3, 2, 3, "9");
Trait ten(-2, 3, 2, "10");
Trait eleven(-3, 2, 3, "11");
Trait twelve(-3, 3, 2, "12");
Trait thirteen(-3, 2, 3, "13");
Trait fourteen(-3, 3, 3, "14");
Trait fifteen(-3, 2, 3, "15");
//create all maps
if (thicknessK.empty() ) {
thicknessK["spindly"] = 0;
thicknessK["thin"] = 1;
thicknessK["thick"] = 2;
thicknessK["round"] = 3;
thicknessM[0] = spindly;
thicknessM[1] = thin;
thicknessM[2] = thick;
thicknessM[3] = round;
numM[0] = zero;
numM[1] = one;
numM[2] = two;
numM[3] = three;
numM[4] = four;
numM[5] = five;
numM[6] = six;
numM[7] = seven;
numM[8] = eight;
numM[9] = nine;
numM[10] = ten;
numM[11] = eleven;
numM[12] = twelve;
numM[13] = thirteen;
numM[14] = fourteen;
numM[15] = fifteen;
}
//decode the number of limbs so that there can
//only be a non-zero even number of them
number = decodeNumber();
int numValue = std::stoi(number);
if (numValue % 2 != 0) {
encodeNumber(numValue + 1);
number = decodeNumber();
}
if (numValue == 0) {
encodeNumber(2);
number = decodeNumber();
}
thickness = decodeThickness();
}
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);
}
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;
}
Projectile::Projectile(): Body()
{
m_orient = matrix4x4d::Identity();
m_type = 1;
m_age = 0;
m_parent = 0;
m_radius = 0;
m_flags |= FLAG_DRAW_LAST;
//set up materials
m_sideMat.texture0 = Graphics::TextureBuilder::Billboard(projectileTextureFilename).GetOrCreateTexture(Pi::renderer, "billboard");
m_sideMat.unlit = true;
m_sideMat.twoSided = true;
m_glowMat.texture0 = Graphics::TextureBuilder::Billboard(projectileGlowTextureFilename).GetOrCreateTexture(Pi::renderer, "billboard");
m_glowMat.unlit = true;
m_glowMat.twoSided = true;
//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);
m_sideVerts.Reset(new Graphics::VertexArray(Graphics::ATTRIB_POSITION | Graphics::ATTRIB_UV0));
m_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++) {
m_sideVerts->Add(one, topLeft);
m_sideVerts->Add(two, topRight);
m_sideVerts->Add(three, botRight);
m_sideVerts->Add(three, botRight);
m_sideVerts->Add(four, botLeft);
m_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++) {
m_glowVerts->Add(vector3f(-gw, -gw, gz), topLeft);
m_glowVerts->Add(vector3f(-gw, gw, gz), topRight);
m_glowVerts->Add(vector3f(gw, gw, gz), botRight);
m_glowVerts->Add(vector3f(gw, gw, gz), botRight);
m_glowVerts->Add(vector3f(gw, -gw, gz), botLeft);
m_glowVerts->Add(vector3f(-gw, -gw, gz), topLeft);
gw -= 0.1f; // they get smaller
gz -= 0.2; // as they move back
}
}
unsigned long
#else
void
#endif
read_VF_index(struct font *fontp, wide_bool hushcs)
{
FILE *VF_file = fontp->file;
ubyte cmnd;
ubyte *avail, *availend; /* available space for macros */
long checksum;
#ifdef Omega
struct macro *newmacro;
unsigned long maxcc = 0;
int i;
#endif
Boolean dummy = False;
fontp->read_char = NULL;
fontp->flags |= FONT_VIRTUAL;
fontp->set_char_p = set_vf_char;
if (debug & DBG_PK)
Printf("Reading VF file %s\n", fontp->filename);
/*
* Read preamble.
*/
Fseek(VF_file, (long)one(VF_file), 1); /* skip comment */
checksum = four(VF_file);
if (checksum != fontp->checksum && checksum != 0 && fontp->checksum != 0
&& !hushcs)
Fprintf(stderr,
"Checksum mismatch (dvi = %lu, vf = %lu) in font file %s\n",
fontp->checksum, checksum, fontp->filename);
(void)four(VF_file); /* skip design size */
/*
* Read the fonts.
*/
fontp->vf_table = xmalloc(VFTABLELEN * sizeof(struct font *));
bzero((char *)fontp->vf_table, VFTABLELEN * sizeof(struct font *));
fontp->vf_chain = NULL;
fontp->first_font = NULL;
while ((cmnd = one(VF_file)) >= FNTDEF1 && cmnd <= FNTDEF4) {
struct font *newfontp = define_font(VF_file, cmnd, fontp,
fontp->vf_table, VFTABLELEN,
&fontp->vf_chain,
&dummy);
if (fontp->first_font == NULL)
fontp->first_font = newfontp;
}
/*
* Prepare macro array.
*/
#ifdef Omega
fontp->maxchar = 65535;
fontp->macro = xmalloc(65536 * sizeof(struct macro));
bzero((char *)fontp->macro, 65536 * sizeof(struct macro));
#else
fontp->macro = xmalloc(256 * sizeof(struct macro));
bzero((char *)fontp->macro, 256 * sizeof(struct macro));
#endif
/*
* Read macros.
*/
avail = availend = NULL;
for (; cmnd <= LONG_CHAR; cmnd = one(VF_file)) {
struct macro *m;
int len;
unsigned long cc;
long width;
if (cmnd == LONG_CHAR) { /* long form packet */
len = four(VF_file);
cc = four(VF_file);
width = four(VF_file);
#ifdef Omega
if (cc >= 65536) {
#else
if (cc >= 256) {
#endif
Fprintf(stderr,
"Virtual character %lu in font %s ignored.\n",
cc, fontp->fontname);
Fseek(VF_file, (long)len, 1);
continue;
}
}
else { /* short form packet */
len = cmnd;
cc = one(VF_file);
width = num(VF_file, 3);
}
#ifdef Omega
maxcc = (cc > maxcc) ? cc : maxcc;
#endif
m = &fontp->macro[cc];
m->dvi_adv = width * fontp->dimconv;
if (len > 0) {
if (len <= availend - avail) {
m->pos = avail;
avail += len;
}
else {
m->free_me = True;
if (len <= VF_PARM_1) {
m->pos = avail = xmalloc(VF_PARM_2);
availend = avail + VF_PARM_2;
avail += len;
}
else
m->pos = xmalloc((unsigned)len);
}
Fread((char *)m->pos, 1, len, VF_file);
m->end = m->pos + len;
}
if (debug & DBG_PK)
Printf("Read VF macro for character %lu; dy = %ld, length = %d\n",
cc, m->dvi_adv, len);
}
if (cmnd != POST)
oops("Wrong command byte found in VF macro list: %d", cmnd);
Fclose(VF_file);
fontp->file = NULL;
n_files_left++;
#ifdef Omega
newmacro = xmalloc((maxcc + 1) * sizeof(struct macro));
for (i = 0; i <= maxcc; i++) {
newmacro[i] = fontp->macro[i];
}
free(fontp->macro);
fontp->macro = newmacro;
fontp->maxchar = maxcc;
return maxcc;
#endif
}
void five(int size)
{
four(size);
}
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;
}
static void tst1() {
unsynch_mpq_manager nm;
polynomial::manager m(nm);
polynomial_ref x(m);
x = m.mk_polynomial(m.mk_var());
polynomial_ref p(m);
p = 3*x - 2;
algebraic_numbers::manager am(nm);
scoped_anum_vector rs1(am);
std::cout << "p: " << p << "\n";
am.isolate_roots(p, rs1);
display_anums(std::cout, rs1);
SASSERT(rs1.size() == 1);
std::cout.flush();
p = (x^2) - 2;
std::cout << "p: " << p << "\n";
rs1.reset();
am.isolate_roots(p, rs1);
display_anums(std::cout, rs1);
SASSERT(rs1.size() == 2);
scoped_anum sqrt2(am);
am.set(sqrt2, rs1[1]);
scoped_mpq q(nm);
nm.set(q, 1, 3);
scoped_anum aq(am);
am.set(aq, q); // create algebraic number representing 1/3
am.add(sqrt2, aq, aq);
std::cout << "sqrt(2) + 1/3: ";
am.display_decimal(std::cout, aq, 10); std::cout << " "; am.display_interval(std::cout, aq);
std::cout << " "; am.display_root(std::cout, aq); std::cout << "\n";
am.set(aq, q);
am.add(rs1[0], aq, aq);
std::cout << "-sqrt(2) + 1/3: ";
am.display_decimal(std::cout, aq, 10); std::cout << " "; am.display_interval(std::cout, aq);
std::cout << " "; am.display_root(std::cout, aq); std::cout << "\n";
p = ((x^5) - x - 1)*(x-1)*(x-2);
std::cout << "p: " << p << "\n";
rs1.reset();
am.isolate_roots(p, rs1);
display_anums(std::cout, rs1);
SASSERT(rs1.size() == 3);
scoped_anum gauss(am);
am.set(gauss, rs1[1]);
std::cout << "compare(" << sqrt2 << ", " << gauss << "): " << am.compare(sqrt2, gauss) << "\n";
statistics st;
am.collect_statistics(st);
st.display_smt2(std::cout);
p = ((x^2) - 2)*((x^2) - 3);
std::cout << "p: " << p << "\n";
rs1.reset();
am.isolate_roots(p, rs1);
display_anums(std::cout, rs1);
SASSERT(rs1.size() == 4);
scoped_anum hidden_sqrt2(am);
am.set(hidden_sqrt2, rs1[2]);
std::cout << "compare(" << sqrt2 << ", " << hidden_sqrt2 << "): " << am.compare(sqrt2, hidden_sqrt2) << "\n";
st.reset();
am.collect_statistics(st);
st.display_smt2(std::cout);
std::cout << "sqrt(2)^4: " << (sqrt2^4) << "\n";
SASSERT(is_int(power(sqrt2, 4)));
SASSERT(power(sqrt2, 4) == 4);
scoped_anum sqrt2_gauss(am);
am.add(sqrt2, gauss, sqrt2_gauss);
std::cout << "sqrt2 + gauss: " << sqrt2_gauss << " "; am.display_root(std::cout, sqrt2_gauss); std::cout << "\n";
std::cout << "sqrt2*sqrt2: " << sqrt2*sqrt2 << "\n";
std::cout << "sqrt2*sqrt2 == 2: " << (sqrt2*sqrt2 == 2) << std::endl;
scoped_anum three(am);
am.set(three, -3);
std::cout << "(-3)^(1/5): " << root(three, 5) << "\n";
std::cout << "sqrt(2)^(1/3): " << root(sqrt2, 3) << "\n";
std::cout << "as-root-object(sqrt(2)^(1/3)): " << root_obj_pp(root(sqrt2, 3)) << "\n";
std::cout << "(sqrt(2) + 1)^(1/3): " << root(sqrt2 + 1, 3) << "\n";
std::cout << "as-root-object((sqrt(2) + 1)^(1/3)): " << root_obj_pp(root(sqrt2 + 1, 3)) << "\n";
std::cout << "(sqrt(2) + gauss)^(1/5): " << root(sqrt2 + gauss, 5) << "\n";
std::cout << "as-root-object(sqrt(2) + gauss)^(1/5): " << root_obj_pp(root(sqrt2 + gauss, 5)) << "\n";
std::cout << "(sqrt(2) / sqrt(2)): " << sqrt2 / hidden_sqrt2 << "\n";
std::cout << "(sqrt(2) / gauss): " << sqrt2 / gauss << "\n";
std::cout << "(sqrt(2) / gauss) 30 digits: " << decimal_pp(sqrt2 / gauss, 30) << "\n";
std::cout << "as-root-object(sqrt(2) / gauss): " << root_obj_pp(sqrt2 / gauss) << "\n";
std::cout << "is_int(sqrt(2)^(1/3)): " << am.is_int(root(sqrt2, 3)) << "\n";
scoped_anum tmp(am);
scoped_anum four(am);
am.set(four, 4);
am.set(tmp, sqrt2);
am.inv(tmp);
std::cout << "1/sqrt(2): " << tmp << "\n";
am.mul(tmp, four, tmp);
std::cout << "4*1/sqrt(2): " << tmp << " " << root_obj_pp(tmp) << "\n";
am.mul(tmp, sqrt2, tmp);
std::cout << "sqrt(2)*4*(1/sqrt2): " << tmp << " " << root_obj_pp(tmp) << "\n";
std::cout << "is_int(sqrt(2)*4*(1/sqrt2)): " << am.is_int(tmp) << ", after is-int: " << tmp << "\n";
p = (998*x - 1414)*((x^2) - 15);
std::cout << "p: " << p << "\n";
rs1.reset();
am.isolate_roots(p, rs1);
std::cout << "is-rational(sqrt2): " << am.is_rational(sqrt2) << "\n";
scoped_anum qr(am);
am.set(qr, rs1[1]);
std::cout << "qr: " << root_obj_pp(qr);
std::cout << ", is-rational: " << am.is_rational(qr) << ", val: " << root_obj_pp(qr) << "\n";
return;
std::cout << "compare(" << sqrt2 << ", " << gauss << "): " << am.compare(sqrt2, gauss) << "\n";
p = (x^16) - 136*(x^14) + 6476*(x^12) - 141912*(x^10) + 1513334*(x^8) - 7453176*(x^6) + 13950764*(x^4) - 5596840*(x^2) + 46225;
std::cout << "p: " << p << "\n";
rs1.reset();
am.isolate_roots(p, rs1);
display_anums(std::cout, rs1);
}
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);
}
DPL_NONE, /* DVI_Z0 */
SEQ_S, /* DVI_Z1 through DVI_Z4 */
sixty_four(DPL_NONE), /* DVI_FNTNUM0 through DVI_FNTNUM63 */
SEQ_U, /* DVI_FNT1 through DVI_FNT4 */
SEQ_U, /* DVI_XXX1 through DVI_XXX4 */
SEQ_U, /* DVI_FNTDEF1 through DVI_FNTDEF4 */
DPL_NONE, /* DVI_PRE */
DPL_NONE, /* DVI_POST */
DPL_NONE, /* DVI_POSTPOST */
six(DPL_NONE) /* 250 through 255 */
};
char dvi_dt[256] = {
one_twenty_eight(DT_CHAR),
/* characters 0 through 127 */
four(DT_SET), /* DVI_SET1 through DVI_SET4 */
DT_SETRULE, /* DVI_SETRULE */
four(DT_PUT), /* DVI_PUT1 through DVI_PUT4 */
DT_PUTRULE, /* DVI_PUTRULE */
DT_NOP, /* DVI_NOP */
DT_BOP, /* DVI_BOP */
DT_EOP, /* DVI_EOP */
DT_PUSH, /* DVI_PUSH */
DT_POP, /* DVI_POP */
four(DT_RIGHT), /* DVI_RIGHT1 through DVI_RIGHT4 */
DT_W0, /* DVI_W0 */
four(DT_W), /* DVI_W1 through DVI_W4 */
DT_X0, /* DVI_X0 */
four(DT_X), /* DVI_X1 through DVI_X4 */
four(DT_DOWN), /* DVI_DOWN1 through DVI_DOWN4 */
DT_Y0, /* DVI_Y0 */
void * cbFunc(gpointer data)
{
Shared *shared = static_cast<Shared*>(data);
if(!shared)
{
throw std::runtime_error("Could not cast shared object.");
}
vector<DictionaryList<string> > insertList;
while(1)
{
DBObject* obj = shared->queue.pop();
if( obj->quit )
{
delete obj;
break;
}
DictionaryList<string> dict;
NameValuePair<string> one("key", obj->key);
NameValuePair<string> two("value", obj->value);
NameValuePair<string> three("source", obj->source);
NameValuePair<string> four("time", boost::lexical_cast<string>(obj->time));
NameValuePair<string> five("sequence", boost::lexical_cast<string>(obj->sequence));
dict.push_back(one);
dict.push_back(two);
dict.push_back(three);
dict.push_back(four);
dict.push_back(five);
insertList.push_back(dict);
if(insertList.size() > bufferLength)
{
shared->db->exec("BEGIN IMMEDIATE TRANSACTION");
for(int i=0; i< insertList.size(); i++)
{
DictionaryList<string> d = insertList[i];
shared->db->insert(d);
}
shared->db->exec("END TRANSACTION");
insertList.clear();
}
delete obj;
}
/// final flush of whatever is still in the queue:
shared->db->exec("BEGIN IMMEDIATE TRANSACTION");
for(int i=0; i< insertList.size(); i++)
{
DictionaryList<string> d = insertList[i];
shared->db->insert(d);
}
shared->db->exec("END TRANSACTION");
return NULL;
}
static void
demoUnicodeStringStorage() {
// These sample code lines illustrate how to use UnicodeString, and the
// comments tell what happens internally. There are no APIs to observe
// most of this programmatically, except for stepping into the code
// with a debugger.
// This is by design to hide such details from the user.
int32_t i;
printf("\n* demoUnicodeStringStorage() ------- ***\n\n");
// * UnicodeString with internally stored contents
// instantiate a UnicodeString from a single code point
// the few (2) UChars will be stored in the object itself
UnicodeString one((UChar32)0x24001);
// this copies the few UChars into the "two" object
UnicodeString two=one;
printf("length of short string copy: %d\n", two.length());
// set "one" to contain the 3 UChars from readonly
// this setTo() variant copies the characters
one.setTo(readonly, UPRV_LENGTHOF(readonly));
// * UnicodeString with allocated contents
// build a longer string that will not fit into the object's buffer
one+=UnicodeString(writeable, UPRV_LENGTHOF(writeable));
one+=one;
one+=one;
printf("length of longer string: %d\n", one.length());
// copying will use the same allocated buffer and increment the reference
// counter
two=one;
printf("length of longer string copy: %d\n", two.length());
// * UnicodeString using readonly-alias to a const UChar array
// construct a string that aliases a readonly buffer
UnicodeString three(FALSE, readonly, UPRV_LENGTHOF(readonly));
printUnicodeString("readonly-alias string: ", three);
// copy-on-write: any modification to the string results in
// a copy to either the internal buffer or to a newly allocated one
three.setCharAt(1, 0x39);
printUnicodeString("readonly-aliasing string after modification: ", three);
// the aliased array is not modified
for(i=0; i<three.length(); ++i) {
printf("readonly buffer[%d] after modifying its string: 0x%lx\n",
i, readonly[i]);
}
// setTo() readonly alias
one.setTo(FALSE, writeable, UPRV_LENGTHOF(writeable));
// copying the readonly-alias object with fastCopyFrom() (new in ICU 2.4)
// will readonly-alias the same buffer
two.fastCopyFrom(one);
printUnicodeString("fastCopyFrom(readonly alias of \"writeable\" array): ", two);
printf("verify that a fastCopyFrom(readonly alias) uses the same buffer pointer: %d (should be 1)\n",
one.getBuffer()==two.getBuffer());
// a normal assignment will clone the contents (new in ICU 2.4)
two=one;
printf("verify that a regular copy of a readonly alias uses a different buffer pointer: %d (should be 0)\n",
one.getBuffer()==two.getBuffer());
// * UnicodeString using writeable-alias to a non-const UChar array
UnicodeString four(writeable, UPRV_LENGTHOF(writeable), UPRV_LENGTHOF(writeable));
printUnicodeString("writeable-alias string: ", four);
// a modification writes through to the buffer
four.setCharAt(1, 0x39);
for(i=0; i<four.length(); ++i) {
printf("writeable-alias backing buffer[%d]=0x%lx "
"after modification\n", i, writeable[i]);
}
// a copy will not alias any more;
// instead, it will get a copy of the contents into allocated memory
two=four;
two.setCharAt(1, 0x21);
for(i=0; i<two.length(); ++i) {
printf("writeable-alias backing buffer[%d]=0x%lx after "
"modification of string copy\n", i, writeable[i]);
}
// setTo() writeable alias, capacity==length
one.setTo(writeable, UPRV_LENGTHOF(writeable), UPRV_LENGTHOF(writeable));
// grow the string - it will not fit into the backing buffer any more
// and will get copied before modification
one.append((UChar)0x40);
// shrink it back so it would fit
one.truncate(one.length()-1);
// we still operate on the copy
one.setCharAt(1, 0x25);
printf("string after growing too much and then shrinking[1]=0x%lx\n"
" backing store for this[1]=0x%lx\n",
one.charAt(1), writeable[1]);
// if we need it in the original buffer, then extract() to it
// extract() does not do anything if the string aliases that same buffer
// i=min(one.length(), length of array)
if(one.length()<UPRV_LENGTHOF(writeable)) {
i=one.length();
} else {
i=UPRV_LENGTHOF(writeable);
}
one.extract(0, i, writeable);
for(i=0; i<UPRV_LENGTHOF(writeable); ++i) {
printf("writeable-alias backing buffer[%d]=0x%lx after re-extract\n",
i, writeable[i]);
}
}
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;
}
int main()
{
/* part1.c */
printf("== one() ==\n");
one(3, 4);
one(10, 10);
printf("== two() ==\n");
two(50);
two(100);
printf("== three() ==\n");
three();
printf("== four() ==\n");
four(0.5);
four(1.5);
printf("== five() ==\n");
five(3, 3);
five(3, 4);
/* part2.c */
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");
seven(2, 12);
seven(14, 20);
printf("== eight() ==\n");
eight();
printf("== nine() ==\n");
nine();
printf("== ten() ==\n");
int i_ten = 100;
ten(&i_ten);
printf("%d == 0?\n", i_ten);
/* part3.c */
printf("== eleven() ==\n");
eleven();
printf("== twelve() ==\n");
twelve();
printf("== thirteen() ==\n");
thirteen();
printf("== fourteen() ==\n");
fourteen("red");
fourteen("orange");
fourteen("blue");
fourteen("green");
printf("== fifteen() ==\n");
fifteen(1);
fifteen(2);
fifteen(3);
/* part4.c */
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;
}
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;
}
void TeXFontDefinition::read_VF_index()
{
#ifdef DEBUG_FONTS
qCDebug(OkularDviDebug) << "font::read_VF_index()";
#endif
FILE *VF_file = file;
unsigned char cmnd;
// available space for macros
unsigned char *avail, *availend;
flags |= FONT_VIRTUAL;
set_char_p = &dviRenderer::set_vf_char;
#ifdef DEBUG_FONTS
qCDebug(OkularDviDebug) << "TeXFontDefinition::read_VF_index: reading VF pixel file " << filename;
#endif
// Read preamble.
fseek(VF_file, (long) one(VF_file), 1); /* skip comment */
quint32 const file_checksum = four(VF_file);
if (file_checksum && checksum && file_checksum != checksum)
qCCritical(OkularDviDebug) << "Checksum mismatch dvi = " << checksum << "u, vf = " << file_checksum <<
"u) in font file" << filename << endl;
(void) four(VF_file); /* skip design size */
// Read the fonts.
first_font = NULL;
while ((cmnd = one(VF_file)) >= FNTDEF1 && cmnd <= FNTDEF4) {
int TeXnumber = num(VF_file, (int) cmnd - FNTDEF1 + 1);
quint32 checksum = four(VF_file);
quint32 scale = four(VF_file);
quint32 design = four(VF_file);
Q_UNUSED(design);
quint16 len = one(VF_file) + one(VF_file); /* sequence point in the middle */
char *fontname = new char[len + 1];
fread(fontname, sizeof(char), len, VF_file);
fontname[len] = '\0';
#ifdef DEBUG_FONTS
qCDebug(OkularDviDebug) << "Virtual font defines subfont \"" << fontname << "\" scale=" << scale << " design=" << design;
#endif
// According to Knuth's documentation found in the web source code
// of the "vftovp" program (which seems to be the standard
// definition of virtual fonts), the "scale" is a fixed point
// number which describes extra enlargement that the virtual font
// imposes. One obtains the enlargement by dividing 2^20.
double enlargement_factor = double(scale)/(1<<20) * enlargement;
// TeXFontDefinition *newfontp = font_pool->appendx(fontname, checksum, (quint32)(scaled_size_in_DVI_units*enlargement_factor), enlargement_factor);
TeXFontDefinition *newfontp = font_pool->appendx(QString::fromLocal8Bit(fontname), checksum, (quint32)((double(scale)/(1<<20))*scaled_size_in_DVI_units), enlargement_factor);
// Insert font in dictionary and make sure the dictionary is big
// enough.
if (vf_table.capacity()-2 <= vf_table.count())
// Not quite optimal. The size of the dictionary should be a
// prime. I don't care.
vf_table.reserve(vf_table.capacity()*2);
vf_table.insert(TeXnumber, newfontp);
if (first_font == NULL)
first_font = newfontp;
}
// Prepare macro array.
macrotable = new macro[max_num_of_chars_in_font];
if (macrotable == 0) {
qCCritical(OkularDviDebug) << "Could not allocate memory for a macro table.";
exit(0);
}
// Read macros.
avail = availend = NULL;
for (; cmnd <= LONG_CHAR; cmnd = one(VF_file)) {
macro *m;
int len;
unsigned long cc;
long width;
if (cmnd == LONG_CHAR) { /* long form packet */
len = four(VF_file);
cc = four(VF_file);
width = four(VF_file);
if (cc >= 256) {
qCCritical(OkularDviDebug) << "Virtual character" << cc << "in font"
<< fontname << "ignored.";
fseek(VF_file, (long) len, 1);
continue;
}
} else { /* short form packet */
len = cmnd;
cc = one(VF_file);
width = num(VF_file, 3);
}
m = ¯otable[cc];
m->dvi_advance_in_units_of_design_size_by_2e20 = width;
if (len > 0) {
if (len <= availend - avail) {
m->pos = avail;
avail += len;
} else {
m->free_me = true;
if (len <= VF_PARM_1) {
m->pos = avail = new unsigned char [VF_PARM_2];
availend = avail + VF_PARM_2;
avail += len;
} else
m->pos = new unsigned char[len];
}
fread((char *) m->pos, 1, len, VF_file);
m->end = m->pos + len;
}
}
if (cmnd != POST)
oops(i18n("Wrong command byte found in VF macro list: %1", cmnd));
fclose (VF_file);
file = NULL;
}
