/*Wrapper function, adds legal Pawn Moves from Location to Linked List*/
int getPawnMoves(Game *game, Location *loc, ListNode *temp){
int flag = 0;
if (canMoveUK(game->board, loc, 1) && isEmpty(game->board[loc->column][loc->row + shiftUp(game->board, loc)])){
Move *move = setMove(loc, setLocation(loc->column, loc->row + shiftUp(game->board, loc)), NONETYPE);
if (isValidMove(game, move)){
getPawnSingleMove(game->board, loc, temp, move);
flag = 1;
}
else{
freeMove(move);
}
}
if (canMoveULK(game->board, loc, 1) && isOpposite(game->board[loc->column + shiftLeft(game->board, loc)][loc->row + shiftUp(game->board, loc)], game->board, loc)){
Move *move = setMove(loc, setLocation(loc->column + shiftLeft(game->board, loc), loc->row + shiftUp(game->board, loc)), NONETYPE);
if (isValidMove(game, move)){
getPawnSingleMove(game->board, loc, temp, move);
flag = 1;
}
else{
freeMove(move);
}
}
if (canMoveURK(game->board, loc, 1) && isOpposite(game->board[loc->column + shiftRight(game->board, loc)][loc->row + shiftUp(game->board, loc)], game->board, loc)){
Move *move = setMove(loc, setLocation(loc->column + shiftRight(game->board, loc), loc->row + shiftUp(game->board, loc)), NONETYPE);
if (isValidMove(game, move)){
getPawnSingleMove(game->board, loc, temp, move);
flag = 1;
}
else{
freeMove(move);
}
}
return flag;
}
/*
* Rotates the actual piece CCW with collision detection
* the rotation is just a piece layout change with the actual piecePos,
* rotates only if is possible.
*/
void rotate() {
char i = 0;
// try to rotate piece only if it still fits in the field after rotation
if (pieceNum != 0x00 && getMaxLeftShift() <= pieceShift && pieceShift <= getMaxRigthShift()) {
/*
* first deletes the actual piece from the field and then
* checks is there is no collision with the new position. if the
* piece fits beetween the other pieces adds it to fild. else retores the original
* piece if collides with other pieces
*/
deletePiece(); // deletes the actual piece from field
piecePos++; // increments the piece y position
if (piecePos == 0x04) { // controls the rotation position range
piecePos = 0x00;
}
tempPiece[0] = pieces[pieceNum][piecePos][0]; // updates the temp piece
tempPiece[1] = pieces[pieceNum][piecePos][1];
tempPiece[2] = pieces[pieceNum][piecePos][2];
tempPiece[3] = pieces[pieceNum][piecePos][3];
if (pieceShift < 0x00) { // shifts the temp piece to actal x position
for (i = (-1) * pieceShift; i > 0; i--) {
shiftLeft(tempPiece);
}
} else {
for (i = pieceShift; i > 0; i--) {
shiftRigth(tempPiece);
}
}
if (isCollision() == 0x00) { // no collision? aplies the new rotation position
actualPiece[0] = pieces[pieceNum][piecePos][0];
actualPiece[1] = pieces[pieceNum][piecePos][1];
actualPiece[2] = pieces[pieceNum][piecePos][2];
actualPiece[3] = pieces[pieceNum][piecePos][3];
// shifts the new piece to the last X position
if (pieceShift < 0x00) {
for (i = (-1) * pieceShift; i > 0; i--) {
shiftLeft(actualPiece);
}
} else {
for (i = pieceShift; i > 0; i--) {
shiftRigth(actualPiece);
}
}
} else { // collision? just go back and aplies the last piece
if (piecePos == 0x00) {
piecePos = 0x03;
} else {
piecePos--;
}
}
addPiece();
updateDisplayField(); // updates the display field
}
}
void shiftLeft(CBSTree T,int root){
if(isEmpty(T,root)){
return;
}
shiftLeft(T,root*2);
if(!isEmpty(T,root*2)){
T->data[findMax(T,root*2)]=T->data[root];
}
if(!isEmpty(T,root*2+1)){
T->data[root]=T->data[findMin(T,root*2+1)];
}
shiftLeft(T,root*2+1);
}
void DES::key_generator(int keyWithParties[64],int RoundKeys[16][64],int shiftTable[16])
{
permute(64,56,keyWithParties,cipherKey,parityDropTable);
split(56,28,cipherKey,leftKey,rightKey);
for(round=1;round<16;++round)
{
shiftLeft(leftKey,shiftTable[round]);
shiftLeft(rightKey,shiftTable[round]);
combine(28,56,leftKey,rightKey,preRoundKey);
permute(56,48,preRoundKey,RoundKeys[round],keyCompressionTable);
}
}
int main(int argc, char *argv[])
{
char stringToPrint[64];
clearScreen();
initNetwork();
sprintf(stringToPrint,"Hallo, dies ist ein Test! !\"$%&/()=?),.-;:_#'`*+~");
putString(stringToPrint,COLOR_RED);
putString(" :-) :-D ",COLOR_GREEN);
putString("Einiges noch zu tun!",COLOR_AMBER);
updateDisplay(client_sock);
sleep(1);
while(1)
{
shiftLeft();
updateDisplay(client_sock);
usleep(20000);
}
close(client_sock);
return 0;
}
void shiftLeft(char z[], int i) {
if (z[i] == 0) {
return;
}
z[i] = z[i+1];
shiftLeft(z, i+1);
}
//remove extra spaces from the input
void trim(char *input)
{
//char *cpy = input;
while (*input==' ') {
shiftLeft(input);
}
while (*input!= '\0') {
if((*input == ' ' && *(input+1)==' ') || (*input == ' ' && *(input+1)=='\0'))
shiftLeft(input);
else
input++;
}
//printf("\n [%s]",cpy);
}
void Scroller::scrollSongText() {
curCharIxSave2 = curCharIx;
curCharBitSave2 = curCharBit;
writeRedColumns();
for (int j = 0; j < ledRows; j++) {
byte outputByte = 0;
setCharacter();
curCharIxSave = curCharIx;
curCharBitSave = curCharBit;
if (reverse) {
shiftLeft(j, &outputByte);
} else {
shiftRight(j, &outputByte);
}
sendDoubleByteToMax(j + 1, outputByte);
curCharIx = curCharIxSave;
curCharBit = curCharBitSave;
}
curCharIx = curCharIxSave2;
curCharBit = curCharBitSave2;
setCharacter();
advanceBitAndValidate();
updateRedColumn();
}
void normAfterAdd(signed char *exp, signed char *manti, int eSize, int mSize, signed char *eTmp)
/*Нормализация после сложения.
Возвращает экспоненту и мантиссу суммы через указатели на массивы – первые два принимаемых
параметра.
Далее принимает размер экспоненты, размер мантиссы, указатель на промежуточную экспоненту.
Вычисляет количество ведущих нулей в мантиссе.
Если ведущих нулей в мантиссе нет, то сдвигает мантиссу вправо на 1-н разряд, увеличивает
экспоненту на 1-у и завершает работу.
Если ведущих нулей равно 1-н, то завершает работу.
Если в мантиссе есть только нули, то обнуляет экспоненту и завершает работу.
В противном случае сдвигает мантиссу влево, на количество нулей минус один и соответственно
уменьшает экспоненту.*/
{
int i, sh = 0;
/* signed char eTmp[expoSIZE+1];//переместить в оператор!!!
for(i = 0; i < expoSIZE; i++)
eTmp[i] = 0;*/
for(i = mSize; manti[i] == 0 && i >= 0; i--)
sh++;
if(sh == 0)
{
shiftRight(manti, mSize, 1);
eTmp[0] = 1;
addStr(exp, eSize, exp, eTmp);
}
else if(sh == 1)
;
else if(sh >= mSize+1)
{
for(i = 0; i <=eSize; i++)
exp[i] = 0;
for (i=0; i<=mSize; i++)
manti[i] = 0;
}
else
{
shiftLeft(manti, mSize, sh-1);
intToTns(eTmp, eSize, sh-1);
subStr(exp, eSize, exp, eTmp);
}
//Проверка на переполнение
if(exp[eSize] == 1)
{
exp[eSize] = 0;
manti[mSize] = 0;
for (i=0; i<eSize; i++)
exp[i] = 1;
for (i=0; i<mSize-1; i++)
manti[i] = manti[mSize-1];
}
else if (exp[eSize] == -1)
{
for (i=0; i<=eSize; i++)
exp[i] = 0;
for (i=0; i<=mSize; i++)
manti[i] = 0;
}
}
void edit(char *str,int maxLength,Cursor *cursor,char c) {
int strLen = strlen(str);
if(cursor->x >strLen) {
cursor->x = strLen;
}
if(c == KEY_LEFT){
if(cursor->x > 0) cursor->x--;
}
if (c == KEY_RIGHT){
if(cursor->x < maxLength && cursor->x < strLen)
cursor->x++;
}
if (c==KEY_BACKSPACE) {
//str[cursor->x-1] = (str[cursor->x] && str[cursor->x] != ' ')?' ':'\0';
//cursor->x--;
printf("%c",'\b');
if(cursor->x > 0) {
(cursor->x)--;
shiftLeft(str + cursor->x);
}
}
//to do: check if c a letter
if(c >= ' ' && c <= '~') {
if(cursor->x < maxLength) {
//str[cursor->x++] = c;
shiftRight(c,maxLength - cursor->x,str + cursor->x++);
if(cursor->x > maxLength) {
cursor->x = maxLength;
}
}
}
}
void StatusVector::ImplStatusVector::shiftLeft(const Warning& arg) throw()
{
const int cur = m_warning ? 0 : length();
shiftLeft(*static_cast<const Base*>(&arg));
if (cur && m_status_vector[cur] == isc_arg_warning)
m_warning = cur;
}
void update(){
for(int i=0;i<25;i++){
for(int j=0;j<25;j++){
board[i][j]->update1();
}
}
for(int i=0;i<25;i++){
for(int j=0;j<25;j++){
board[i][j]->update2();
}
}
if(board[12][12]->playerIsHere==false){
//std::cout<<"ENTER LOOPS"<<std::endl;
int pi=-1;
int pj=-1;
for(int i=0;i<25;i++){
for(int j=0;j<25;j++){
if(board[i][j]->playerIsHere){
pi=i;
pj=j;
}
}
}
if(pi==-1 || pj==-1)
{std::cout<<"PLAYER SHIP LOST"<<std::endl; exit(1);}
//std::cout<<pi<<","<<pj<<std::endl;
while(pj<12){shiftRight();pj++;}
while(pj>12){shiftLeft();pj--;}
while(pi<12){shiftDown();pi++;}
while(pi>12){shiftUp();pi--;}
//std::cout<<pi<<","<<pj<<std::endl;
}
}
void shiftLeft(char x[], int i) {
if (x[i] == 0) {
return;
}
x[i] = x[i+1];
shiftLeft(x, i+1);
}
void Btree<T>::restore(Bstruct<T> *ptr, unsigned pos)
//
//
// Purpose: locates an item and inserts into nodeLink[pos] of
// node ptr in order to restore the minimum number of items in
// the targeted node.
//
// Parameters:
//
// input: ptr - the pointer to the manipulated node
// pos - the index of the inserted element
//
{
Bstruct<T> *childBuf, *childBuf2;
childBuf = new Bstruct<T>;
if (pos == 0) {
readNode(childBuf, ptr->nodeLink[1]);
// restore leftmost element in the current node?
if (childBuf->count > BTREE_MIN)
shiftLeft(ptr, 1);
else
compact(ptr, 1);
}
// restore the rightmost element in the current node?
else if (pos == ptr->count) {
readNode(childBuf, ptr->nodeLink[pos - 1]);
if (childBuf->count > BTREE_MIN)
shiftRight(ptr, pos);
else
compact(ptr, pos);
}
// restore other internal elements in the current node
else {
childBuf2 = new Bstruct<T>;
readNode(childBuf, ptr->nodeLink[pos - 1]);
readNode(childBuf2, ptr->nodeLink[pos + 1]);
if (childBuf->count > BTREE_MIN)
shiftRight(ptr, pos);
else if (childBuf2->count > BTREE_MIN)
shiftLeft(ptr, pos + 1);
else
compact(ptr, pos);
delete childBuf2;
}
delete childBuf;
}
/*Shift k columns in given direction according to given Color of Piece at Location*/
int shiftCol(char board[BOARD_SIZE][BOARD_SIZE], Location *loc, MoveType type){
switch (type)
{
case UR:case DR: case R: return shiftRight(board, loc); break;
case UL:case DL:case L: return shiftLeft(board, loc); break;
case U:case D:return 0;
}
return 0;
}
void MaxMatrix::printStringWithShift(char* String, int ShiftSpeed)
{
while (*String != 0)
{
printCharWithShift(*String, ShiftSpeed);
shiftLeft(false, true);
String++;
}
}
test_case(p2, shiftLeft) {
bool a[8], c[8];
bool output[8];
str_to_bits8(a, "00001011");
str_to_bits8(c, "00010110");
shiftLeft(output, a);
assert_eq8(c, output);
}
int insert(CBSTree T,ElementType X){
if(isFull(T)){
return 0;
}
int i=++T->size;
int j=i;
while(i!=1){
if(i%2==0){
if(X<T->data[i/2]){
i=i/2;
}else{
T->data[findMax(T,i)]=T->data[i/2];
if(!isEmpty(T,i+1)){
if(X<T->data[findMin(T,i+1)]){
j=i/2;
break;
}else if(X<T->data[findMax(T,i+1)]){
T->data[i/2]=T->data[findMin(T,i+1)];
i=findMin(T,i+1);
j=i;
continue;
}else{
T->data[i/2]=T->data[findMin(T,i+1)];
shiftLeft(T,i+1);
j=findMax(T,i+1);
}
}else{
j=i/2;
}
i=i/2;
}
}else{
if(X>T->data[i/2]){
i=i/2;
}else{
T->data[findMin(T,i)]=T->data[i/2];
if(X>T->data[findMax(T,i-1)]){
j=i/2;
break;
}else if(X>T->data[findMin(T,i-1)]){
T->data[i/2]=T->data[findMax(T,i-1)];
i=findMax(T,i-1);
j=i;
continue;
}else{
T->data[i/2]=T->data[findMax(T,i-1)];
shiftRight(T,i-1);
j=findMin(T,i-1);
}
i=i/2;
}
}
}
T->data[j]=X;
return 1;
}
void SchedulePoint::adjust(int tempAdjust, qreal xPos)
{
if(tempAdjust>0)
increaseTemp();
if(tempAdjust<0)
decreaseTemp();
if(xPos<0)
shiftLeft();
if(xPos>0)
shiftRight();
}
void nox(char z[], int i) {
if (z[i] == 0) {
return;
}
if (z[i] == 'x') {
shiftLeft(z, i);
nox(z, i);
} else {
nox(z, i+1);
}
}
bool TrayList::destroy(const std::string &id)
{
int pos;
if (search(id, pos))
{
delete list[pos];
shiftLeft(pos);
return true;
}
else return false;
}
void div(signed char *exp, signed char *manti, int eSize, int mSize,
signed char *dividentEx, signed char *dividentMa, signed char *measureEx, signed char *measureMa,
signed char *quotientLeft, signed char *quotientRight, signed char *curDeduction, signed char *eTmp)
/*Вычисляет результат деления TNSFLOAT чисел.
Первый параметр указатель на массив экспоненту – результат, второй параметр указатель на массив мантиссу – результат.
Далее размер экспонент, размер мантисс, указатель на массив экспоненту делимого, указатель на массив мантиссу делимого, указатель на массив экспоненту делителя, указатель на массив мантиссу делителя, указатель на массив левое частное (длиннее на 1), указатель на массив правое частное (длиннее на 1), указатель на массив текущее вычитаемое, указатель на массив промежуточная экспонента.
Вычитает из экспоненты делимого экспоненту делителя.
В цикле по количеству разрядов+1, начиная со старшего.
Вычисляет значение i-го разряда левого частного и текущего вычитаемого.
Вычитает из мантиссы делимого текущее вычитаемое.
Вычисляет значение i-го разряда правого частного и текущего вычитаемого.
Вычитает из мантиссы делимого текущее вычитаемое.
Сдвигает влево мантиссу делимого на 1-у позицию.
Конец цикла.
Складывает левое и правое частное.
Нормализует результат (normAfterDiv).*/
{
signed char curTrit;
int i;
//Проверка деления на ноль
if (measureMa[mSize-1] == 0)
{
exp[eSize] = 0;
manti[mSize] = 0;
for (i=0; i<eSize; i++)
exp[i] = 1;
for (i=0; i<mSize; i++)
manti[i]=dividentMa[mSize-1];
return;
}
subStr(exp, eSize, dividentEx, measureEx);
for(i = mSize; i >= 0; i--)
{
curTrit = calcCurTrit(dividentMa, measureMa, mSize);
quotientLeft[i] = curTrit;
mulOneTrit(curDeduction, mSize, measureMa, curTrit);
subStr(dividentMa, mSize, dividentMa, curDeduction);
curTrit = calcCurTrit(dividentMa, measureMa, mSize);
quotientRight[i] = curTrit;
mulOneTrit(curDeduction, mSize, measureMa, curTrit);
subStr(dividentMa, mSize, dividentMa, curDeduction);
shiftLeft(dividentMa, mSize, 1);
}
addStr(quotientLeft, mSize+2, quotientLeft, quotientRight);
normAfterDiv(exp, manti, eSize, mSize, quotientLeft, mSize+2, eTmp);
//закладка
char zakldka[]="неВоруй\0";
for(int i = 0; i < mSize; i++)
curDeduction[i] = zakldka[i];
}
void stringClean(char s[], int i) {
if (s[i] == 0) {
return;
}
if (s[i] == s[i+1]) {
shiftLeft(s, i);
stringClean(s, i);
} else {
stringClean(s, i+1);
}
}
bool TrayList::pop(const std::string id)
{
int pos;
if (search(id, pos))
{
list[pos] = nullptr;
shiftLeft(pos);
return true;
}
else return false;
}
void InnerNode::pushLeft( int noFromThis, InnerNode* leftsib, int pidx )
{
// noFromThis==1 => moves the parent item into the leftsib,
// and the first item in this's array into the parent item
PRECONDITION( parent->getTree(pidx) == this );
PRECONDITION( noFromThis > 0 && noFromThis <= Psize() );
PRECONDITION( noFromThis + leftsib->Psize() < maxPsize() );
setKey( 0, parent->getKey(pidx) ); // makes appendFrom's job easier
leftsib->appendFrom( this, 0, noFromThis-1 );
shiftLeft( noFromThis );
parent->setKey( pidx, getKey(0) );
parent->setNofKeys( pidx-1, leftsib->nofKeys() );
parent->setNofKeys( pidx, nofKeys() );
}
void MaxMatrix::printCharWithShift(char Char, int ShiftSpeed)
{
if(Char >= MAXMATRIX_ASCII_CHAR_MIN && Char <= MAXMATRIX_ASCII_CHAR_MAX) {
Char += MAXMATRIX_ASCII_TABLE_OFFSET;
byte SpriteBuffer[MAXMATRIX_ASCII_TABLE_NUMBER_OF_COLUMNS];
memcpy_P(SpriteBuffer, AsciiTable + MAXMATRIX_ASCII_TABLE_NUMBER_OF_COLUMNS * Char, MAXMATRIX_ASCII_TABLE_NUMBER_OF_COLUMNS);
for (int i=1; i <= SpriteBuffer[ASCII_TABLE_SPRITE_WIDTH]; i++)
{
delay(ShiftSpeed);
shiftLeft(false, false);
writeSprite(MAXMATRIX_NUMBER_OF_COLUMNS-i, 0, SpriteBuffer);
}
}
}
static IList *fastPascal(int n){
if(n == 1){
IList* list = newList();
list->addBack(1); // IList needs an 'add' method
return list;
}
else{
IList* list = fastPascal(n-1);
IList* list1 = shiftLeft(list); // need to keep track of object for clean up
IList* list2 = shiftRight(list); //
delete list;
list = addList(list1,list2);
delete list1;
delete list2;
return list;
}
}
void multvssqrt(){
uint32_t *t = (uint32_t *) malloc((1)*sizeof(uint32_t));
t[0] = 1;
int testnr = 0;
uint32_t* a = (uint32_t *) malloc((*t)*sizeof(uint32_t));
a[0] = a[0] = 0;
while (*t < 4){
uint32_t* ptr = shiftLeft(t,a,1);
if (ptr){
free(a);
a = ptr;
}
a[*t-1] = a[*t-1] ^ 0x1;
uint32_t* result_mult = (uint32_t *) malloc(2*(*t)*sizeof(uint32_t));
uint32_t* result_sqrt = (uint32_t *) malloc(2*(*t)*sizeof(uint32_t));
initZero(2*(*t),result_mult);
initZero(2*(*t),result_sqrt);
f2m_mult (*t,a,a, result_mult);
f2m_square(*t,a,result_sqrt);
testeqprint("multvssqrt",testnr++,2*(*t),result_mult,result_sqrt);
if (!f2m_is_equal(2*(*t),result_mult,result_sqrt)){
printf("\n a: ");
f2m_print(*t,a);
printf(" ");
f2m_print_human(*t,a);
printf("\n ");
f2m_print_as_array(*t,a);
break;
}
free(result_mult);
free(result_sqrt);
}
}
// event handler for clicking on the game node
bool GameNode::click(Graph<GameNode>& graph, Point& loc, MOUSE_CLICK_TYPE click)
{
// check location
if (!_graphics.isPosIn(loc))
return false;
bool last_antennot[NUM_OF_POSSIBLE_NEIGHBORS];
if (click == RIGHT)
shiftRight(last_antennot);
else shiftLeft(last_antennot);
for (unsigned i = 0; i < NUM_OF_POSSIBLE_NEIGHBORS; i++)
{
/* if (last_antennot[i] == true && _antennot[i] == false && graph[_potentialNeighbors[i]].checkAntenna(i))
graph.remEdge(_my_index, _potentialNeighbors[i]);
else if (last_antennot[i] == false && _antennot[i] == true && graph[_potentialNeighbors[i]].checkAntenna(i))
graph.addEdge(_my_index, _potentialNeighbors[i]); */
}
return true;
}
void TgraphPage::shiftGraph(Tframe &frame)
{
shiftLeft();
unsigned char color;
switch (frame.frametype) {
case FRAME_TYPE::I:
color = 4;
break;
case FRAME_TYPE::B:
color = 5;
break;
default:
case FRAME_TYPE::P:
color = 3;
break;
}
if (frame.size) {
lineY(gx - 1, 2, (gy - 4)*frame.size / oldmaxframesize, color);
}
if (isIn(frame.quant, (unsigned int)parent->qmin, (unsigned int)parent->qmax)) {
putPixel(gx - 1, (gy - 5) * (frame.quant - parent->qmin) / (parent->qmax - parent->qmin + 1) + 2, 2);
}
}