void CreateEmpty (Queue * Q, int Max) { /*Algoritma*/ (*Q).T = (infotype*) malloc (Max * sizeof (infotype)); MaxEl(*Q) = Max-1; if ((*Q).T == NULL) { (*Q).T = (infotype*) malloc (1 * sizeof (infotype)); MaxEl(*Q) = 1; } Head(*Q) = Nil; Tail(*Q) = Nil; }
int main() { int i=0; stu *head1,*head2,*head3,*p; head1=Tail(); head2=Tail(); p=head1; while(p->next) { p=p->next; printf("%d %3.2f\t",p->id,p->score); } printf("\n"); p=head2; while(p->next) { p=p->next; printf("%d %3.2f\t",p->id,p->score); } printf("\n"); head3=Merge(head1,head2); p=head3; printf("Test\n"); while(p) { i++; printf("test\n"); p=p->next; printf("%d %f\n",p->id,p->score); } }
void Del (Queue *Q, infotype *X) /* Proses: Menghapus elemen pertama pada Q dengan aturan FIFO */ /* I.S. Q tidak kosong */ /* F.S. X = nilai elemen HEAD pada I.S., Jika Queue masih isi : HEAD diset tetap = 1, elemen-elemen setelah HEAD yang lama digeser ke "kiri", TAIL = TAIL – 1; Jika Queue menjadi kosong, HEAD = TAIL = Nil. */ { //kamus int i; //algoritma (*X)=InfoHead(*Q); if (Head(*Q)==Tail(*Q)) { Head(*Q) = Nil; Tail(*Q) = Nil; } else { i=Head(*Q); do { (*Q).T[i]=(*Q).T[i+1]; i++; }while(i!=Tail(*Q)); Tail(*Q)--; } }
void PrintQueue (Queue Q) { /* I.S. : Q terdefinisi, mungkin kosong */ /* F.S. : Semua elemen Q tertulis di layar, dengan format: [ el-head ... el-tail ], misalnya [4 8 12 9 10]. Jika kosong, tampilan di layar adalah []. */ /*kamus lokal*/ int i; /*algoritma*/ printf("["); if(!IsEmpty(Q)) { i = Head(Q); if(i<=Tail(Q)) { while(i<=Tail(Q)) { printf("%d ",Q.T[i]); i++; } } else { while(i<=MaxEl(Q)) { printf("%d ",Q.T[i]); i++; } i=1; while(i<=Tail(Q)) { printf("%d ",Q.T[i]); i++; } } } printf("]\n"); }
int NBElmt (Queue Q) { int n; if (IsEmpty(Q)) n = 0; else if (Head(Q) <= Tail(Q)) n = Tail(Q) - Head(Q) + 1; else n = Q.MaxEl - Tail(Q) + Head(Q) + 1; return n; }
void Del (Queue * Q, infotype * X) { /*Algoritma*/ (*X) = InfoHead(*Q); Head(*Q) +=1; if (Head(*Q) > Tail(*Q)) { Tail(*Q) = Nil; Head(*Q) = Nil; } }
// See documentation above. double asin(double x) { if (x < -.5) return -Tail(-x); else if (x <= .5) return Center(x); else return +Tail(+x); }
int NBElmt (Queue Q) /* Mengirimkan banyaknya elemen queue. Mengirimkan 0 jika Q kosong. */ { /*kamus lokal*/ int n; /*algoritma*/ if (IsEmpty(Q)) n = 0; else if (Head(Q) <= Tail(Q)) n = Tail(Q) - Head(Q) + 1; else n = Q.MaxEl - Tail(Q) + Head(Q) + 1; return n; }
int NBElmt(Queue Q) /* Mengirimkan banyaknya elemen queue. Mengirimkan 0 jika Q kosong. */ { if (IsEmptyQueue(Q)) { return 0; } else { return Tail(Q) - Head(Q) + 1 + (Head(Q) > Tail(Q) ? MaxEl(Q) : 0); } }
void Del (Queue *Q,infotype *X) { (*X) = InfoHead(*Q); if (Head(*Q) == Tail(*Q)) { Head(*Q) = Nil; Tail(*Q) = Nil; } else { Head(*Q)++; if (Head(*Q) == maxEl(*Q) + 1) Head(*Q) = 1; } }
UnitTestCase(const char* name, void (*routine)()): m_name(name), m_routine(routine), m_next(NULL) { if (Head() == NULL) Head() = this; if (Tail() == NULL) Tail() = Head(); else Tail()->m_next = this; Tail() = this; }
void Add (Queue *Q,infotype X) { if (IsEmpty(*Q)) { Tail(*Q) = 1; Head(*Q) = 1; } else { Tail(*Q) += 1; if (Tail(*Q) == (*Q).MaxEl + 1) Tail(*Q) = 1; } InfoTail(*Q) = X; }
void Ledger::Append(Decree decree) { // // A lock must be acquired before executing decree_handler in order to // help prevent out of order decrees. // std::lock_guard<std::recursive_mutex> lock(mutex); Decree tail = Tail(); if (IsRootDecreeOrdered(tail, decree)) { // // Append a system decree before executing handler so that post- // processing handlers have a full ledger including current decree. // decrees->Enqueue(decree); if (handlers.count(decree.type) > 0) { (*handlers[decree.type])(decree.content); } } else { LOG(LogLevel::Warning) << "Out of order decree. Ledger: " << tail.number << "/" << tail.root_number << " Received: " << decree.number << "/" << decree.root_number; } }
data_string& data_string::operator=(char * new_string) { if (!new_string) throw("Error memory alloc"); clean_up(); char *temp = new_string; while (*temp++ != '\0') this->size++; this->str = new char[this->size + 1]; if (this->str == NULL) throw("Error Alloc memory"); temp = new_string; for (size_t i = 0; i<=this->lenght(); i++) this->str[i] = temp[i]; this->_fill = this->lenght(); Head(this->str); Last(this->str + this->fill()); Tail(this->str + this->lenght()); return *this; }
static size_t SkipInputToken(string_view const Str, subst_strings* const Strings = nullptr) { const auto cTail = tokens::skip(Str, tokens::input); if (!cTail) return 0; string_view Tail(cTail); auto Range = Tail; brackets TitleBrackets{}; const auto TitleSize = ProcessBrackets(Range, L'?', TitleBrackets); if (!TitleSize) return 0; Range.remove_prefix(TitleSize); brackets TextBrackets{}; const auto TextSize = ProcessBrackets(Range, L'!', TextBrackets); if (!TextSize) return 0; Range.remove_prefix(TextSize); if (Strings) { Strings->Title.All = Tail.substr(0, TitleSize - 1); Strings->Text.All = Tail.substr(TitleSize, TextSize - 1); Strings->Title.Sub = TitleBrackets.str(); Strings->Text.Sub = TextBrackets.str(); } return tokens::input.size() + TitleSize + TextSize; }
extern void Enqueue (Item X, Queue *Q) { #ifdef DEBUG Item Y; int oldSize=Size(Q); if(Full(Q)) { printf("Violated precondition for Insert!\n"); exit(EXIT_FAILURE); } #endif if (Q->size == 0) { /*Checks to see if queue is empty*/ Q->tail = Q->head; } else { Q->tail = Q->tail + 1; } if (Q->tail == MAXQUEUESIZE) { Q->tail = 0; /*Circles through queue*/ } copyItem(&Q->items[Q->tail],X); Q->size++; #ifdef DEBUG Tail(Q,&Y); if(Empty(Q) || Size(Q)!=oldSize+1 || !equalItems(Y,Q->items[Q->tail])) { printf("Violated postcondition for Insert!\n"); exit(EXIT_FAILURE); } #endif }
MapObject::MapObject(object_type type) : Object(type) { tail = Tail(); parent = NULL; hitable = true; }
void data_string::resize(const size_t& s) { if (s == 0) { clean_up(); return; } char *cur_temp = this->str; size_t old_size = this->size; this->size = s; this->str = new char[this->size + 1]; if (this->str == NULL) throw("Error alloc memory"); for (size_t i = 0; i <= old_size && i < this->lenght(); i++) this->str[i] = cur_temp[i]; this->_fill = old_size>this->lenght() ? this->lenght() : this->fill(); this->str[this->fill()] = '\0'; delete[] cur_temp; Head(this->str); Last(this->str + this->fill()); Tail(this->str + this->lenght()); }
void display() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); float vert[3]; double d = particleWidth / 2.0; glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glShadeModel(GL_SMOOTH); glDepthMask(false); /* Ideally, I'd like to display the planes that the particles are coming from, but it's not working for me, so this'll be commented out. if (is3d) { point3d size, center; size.x = 2.0; size.y = 1; size.z = 2.0; center.x = 0.0; center.y = 1.0; center.z = 1.0; Cube top = Cube(size, center, 1.0, 1.0, 1.0); center.y = -1.0; Cube bottom = Cube(size, center, 1.0, 1.0, 1.0); top.render(0.0); bottom.render(0.0); } */ for (std::list<particle>::iterator i = particles->begin(); i != particles->end(); i++) { particle p = *i; double fade = (double)p.cyclesToKeepAround / (double)totalCycles; if (!is3d) { glBegin(GL_QUADS); glColor3f(p.color[0] * fade, p.color[1] * fade, p.color[2] * fade); glVertex2f(p.curr.x - d, p.curr.y - d); glVertex2f(p.curr.x + d, p.curr.y - d); glVertex2f(p.curr.x + d, p.curr.y + d); glVertex2f(p.curr.x - d, p.curr.y + d); glEnd(); glBegin(GL_TRIANGLES); glColor3f(p.color[0] * fade, p.color[1] * fade, p.color[2] * fade); glVertex2f(p.curr.x - d, p.curr.y + d); glVertex2f(p.curr.x + d, p.curr.y - d); glColor4f(1.0, 1.0, 1.0, fade); glVertex2f(p.start.x, p.start.y); glEnd(); } else { Cube c = Cube(d, p.curr, p.color[0], p.color[1], p.color[2]); c.render(fade); Tail t = Tail(p.curr, p.start, p.color[0], p.color[1], p.color[2]); t.size = d; t.render(fade); } } // draw the mouse pointer. if (!is3d) drawString(GLUT_BITMAP_9_BY_15, mouseAddr, curMousePos.x, curMousePos.y, curMousePos.z); glDepthMask(true); glFlush(); }
INLINE int PopTail() { AtomicCounter old_val; AtomicCounter new_val; do { old_val = fCounter; new_val = old_val; if (Head(old_val) == Tail(old_val)) { return WORK_STEALING_INDEX; } else { IncTail(new_val); } } while (!CAS1(&fCounter, Value(old_val), Value(new_val))); return fTaskList[Tail(old_val)]; }
boolean IsEmpty (Queue Q) /* Mengirim true jika Q kosong */ { /*kamus lokal*/ /*algoritma*/ return (Head(Q) == Nil && Tail(Q) == Nil); }
boolean IsFull (Queue Q) /* Mengirim true jika tabel penampung elemen Q sudah penuh yaitu mengandung MaxEl elemen */ { /*kamus lokal*/ int m = Head(Q) - Tail(Q); /*algoritma*/ return (m == 1) || (m == (-1*MaxEl(Q)+1)); }
data_string::data_string(const data_string& obj) { if (*this == obj) return; *this = obj; Head(this->str); Last(this->str + this->fill()); Tail(this->str + this->lenght()); }
CLiveInOutCalculator::CLiveInOutCalculator( const std::list<const CBaseInstruction*>& asmFunction ) : workflow( asmFunction ), liveIn( workflow.Size() ), liveOut( workflow.Size() ) { bool setsChanged = true; int mainFuncIndex = 0; std::vector<int> revTopsort = CTopSort::topSort( workflow, mainFuncIndex ); buildCommands( asmFunction ); buildDefines( asmFunction ); buildUses( asmFunction ); std::reverse( revTopsort.begin(), revTopsort.end() ); while( setsChanged ) { setsChanged = false; for( auto nodeIndex : revTopsort ) { std::set<std::string> newLiveIn = liveOut[nodeIndex]; auto currList = commands[nodeIndex]->DefinedVars(); while( currList != nullptr && currList->Head() != nullptr ) { auto inSet = newLiveIn.find( currList->Head()->GetName()->GetString() ); if( inSet != newLiveIn.end() ) { newLiveIn.erase( inSet ); } currList = currList->Tail(); } currList = commands[nodeIndex]->UsedVars(); while( currList != nullptr && currList->Head() != nullptr ) { newLiveIn.insert( currList->Head()->GetName()->GetString() ); currList = currList->Tail(); } std::set<std::string> newLiveOut; for( auto succ : workflow.GetNode( nodeIndex ).out ) { for( auto var : liveIn[succ] ) { newLiveOut.insert( var ); } } if( !theSame( newLiveIn, liveIn[nodeIndex] ) || !theSame( newLiveOut, liveOut[nodeIndex] ) ) { setsChanged = true; liveIn[nodeIndex] = newLiveIn; liveOut[nodeIndex] = newLiveOut; } } } }
void data_string::clean_up() { if (this->str != NULL) delete[]this->str; this->size = 0; this->_fill = 0; Head(NULL); Last(NULL); Tail(NULL); }
void TaskQueue::TaskQueueList::Clear() { auto tail = Tail(); for (int i = 0; i < kQueuesListsCount; ++i) { for (auto j = lists_[i], next = j; j != tail; j = next) { auto &list_entry = j->list_entries_[i]; next = list_entry.after; list_entry.before = list_entry.after = nullptr; } lists_[i] = tail; } }
int NBElmt (Queue Q) /* Mengirimkan banyaknya elemen queue. Mengirimkan 0 jika Q kosong. */ { if (IsEmpty(Q)) { return (0); } else { return Tail(Q); } }
/* *** Primitif Add/Delete *** */ void Add(Queue *Q, infotypeQueue X) /* Proses: Menambahkan X pada Q dengan aturan FIFO */ /* I.S. Q mungkin kosong, tabel penampung elemen Q TIDAK penuh */ /* F.S. X menjadi TAIL yang baru, TAIL "maju" dengan mekanisme circular buffer */ { if (IsEmptyQueue(*Q)) { Head(*Q) = 1; Tail(*Q) = 1; } else if (Tail(*Q) == MaxEl(*Q)) { Tail(*Q) = 1; } else { ++Tail(*Q); } InfoTail(*Q) = X; }
/* *** Operator-Operator Dasar Queue *** */ void Add (Queue *Q, infotype X) /* Proses : Menambahkan X pada Q dengan aturan FIFO */ /* I.S. Q mungkin kosong, tabel penampung elemen Q TIDAK penuh */ /* F.S. X menjadi TAIL yang baru, TAIL "maju" */ { if(IsEmpty(*Q)) { Head(*Q)=1; } Tail(*Q)++; InfoTail(*Q)=X; }
void Add(Queue *Q, infotype_dadu X) /* Menambahkan X sebagai elemen Queue Q */ /* I.S. Q mungkin kosong, tabel penampung elemen Q tidak penuh */ /* F.S. X menjadi TAIL yang baru, TAIL "maju" */ { if (IsEmpty(*Q)) { Head(*Q) = 1; } Tail(*Q)++; InfoTail(*Q) = X; }