//--------------------------------------------------------------------------- //! Divides this object with a value TParamFunc& TParamFunc::operator/=(long double Value) { Unique(); xFuncData->AddFront(CodeDiv); xFuncData->Add(Value); yFuncData->AddFront(CodeDiv); yFuncData->Add(Value); return *this; }
//--------------------------------------------------------------------------- //! Subtracts another parameter function from this object TParamFunc& TParamFunc::operator-=(const TParamFunc &Func) { Unique(); xFuncData->AddFront(CodeSub); xFuncData->Add(*Func.xFuncData); yFuncData->AddFront(CodeSub); yFuncData->Add(*Func.yFuncData); return *this; }
matrix* Closure(matrix* m, boolean close, group* lie_type) { matrix* result; lie_Index i,j; group* tp=(s=Ssrank(grp), lie_type==NULL ? mkgroup(s) : lie_type); tp->toraldim=Lierank(grp); tp->ncomp=0; /* start with maximal torus */ m=copymatrix(m); if (close) if (type_of(grp)==SIMPGRP) close = two_lengths(grp->s.lietype); else { for (i=0; i<grp->g.ncomp; i++) if (two_lengths(Liecomp(grp,i)->lietype)) break; close= i<grp->g.ncomp; } { entry* t; for (i=0; i<m->nrows; i++) if (!isroot(t=m->elm[i])) error("Set of root vectors contains a non-root\n"); else if (!isposroot(t=m->elm[i])) for (j=0; j<m->ncols; j++) t[j]= -t[j]; /* make positive root */ Unique(m,cmpfn); } { lie_Index next; for (i=0; i<m->nrows; i=next) { lie_Index d,n=0; simpgrp* c; next=isolcomp(m,i); fundam(m,i,&next); if (close) long_close(m,i,next),fundam(m,i,&next); c=simp_type(&m->elm[i],d=next-i); { j=tp->ncomp++; while(--j>=0 && grp_less(tp->liecomp[j],c)) n += (tp->liecomp[j+1]=tp->liecomp[j])->lierank; tp->liecomp[++j]=c; tp->toraldim -= d; /* insert component and remove rank from torus */ cycle_block(m,i-n,next,n); /* move the |d| rows down across |n| previous rows */ } } } if (lie_type==NULL) return result=copymatrix(m),freemem(m),freemem(tp),result; else return freemem(m),(matrix*)NULL; /* |Cartan_type| doesn't need |m| */ }
local void fundam(matrix* roots, lie_Index first, lie_Index* last) { lie_Index i,j,d; boolean changed; entry* t=mkintarray(s); matrix mm,* m=&mm; mm.elm=&roots->elm[first]; mm.nrows=*last-first; mm.ncols=roots->ncols; for (i=m->nrows-1; i>0; changed ? Unique(m,cmpfn),i=m->nrows-1 : --i) { entry* root_i=m->elm[i]; changed=false; for (j=i-1; j>=0; j--) { entry* root_j=m->elm[j]; entry c=Cart_inprod(root_j,root_i); if (c==2 && eqrow(root_j,root_i,s)) { cycle_block(m,j,m->nrows--,1); root_i=m->elm[--i]; } else if (c>0) { changed=true; { copyrow(root_j,t,s); add_xrow_to(t,-c,root_i,s); if (isposroot(t)) copyrow(t,root_j,s); else { j=i; c=Cart_inprod(root_i,root_j); copyrow(root_i,t,s); add_xrow_to(t,-c,root_j,s); if (isposroot(t)) copyrow(t,root_i,s); else { lie_Index k; entry* ln,* sh; /* the longer and the shorter root */ if (Norm(root_i)>Norm(root_j)) ln=root_i, sh=root_j; else ln=root_j, sh=root_i; switch (Norm(ln)) { case 2: subrow(ln,sh,sh,s); /* |sh=ln-sh| */ add_xrow_to(ln,-2,sh,s); /* |ln=ln-2*sh| */ break; case 3: /* |grp=@t$G_2$@>| now */ for (k=0; sh[k]==0; ++k) {} /* find the place of this $G_2$ component */ sh[k]=1; sh[k+1]=0; ln[k]=0; ln[k+1]=1; /* return standard basis of full system */ break; default: error("problem with norm 1 roots\n"); } } } } } } } cycle_block(roots,first+mm.nrows,roots->nrows,d=*last-first-mm.nrows); *last-=d; roots->nrows-=d; freearr(t); }
/////////////////////////////////////////////////////////////////////////////////////////// // Build() // // Builds a strip forward as far as we can go, then builds backwards, and joins the two lists // void NvStripInfo::Build(NvEdgeInfoVec &edgeInfos, NvFaceInfoVec &faceInfos) { // used in building the strips forward and backward WordVec scratchIndices; // build forward... start with the initial face NvFaceInfoVec forwardFaces, backwardFaces; forwardFaces.push_back(m_startInfo.m_startFace); MarkTriangle(m_startInfo.m_startFace); int v0 = (m_startInfo.m_toV1 ? m_startInfo.m_startEdge->m_v0 : m_startInfo.m_startEdge->m_v1); int v1 = (m_startInfo.m_toV1 ? m_startInfo.m_startEdge->m_v1 : m_startInfo.m_startEdge->m_v0); // easiest way to get v2 is to use this function which requires the // other indices to already be in the list. scratchIndices.push_back(v0); scratchIndices.push_back(v1); int v2 = NvStripifier::GetNextIndex(scratchIndices, m_startInfo.m_startFace); scratchIndices.push_back(v2); // // build the forward list // int nv0 = v1; int nv1 = v2; NvFaceInfo *nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, m_startInfo.m_startFace); while (nextFace != NULL && !IsMarked(nextFace)) { //check to see if this next face is going to cause us to die soon int testnv0 = nv1; int testnv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace); NvFaceInfo* nextNextFace = NvStripifier::FindOtherFace(edgeInfos, testnv0, testnv1, nextFace); if( (nextNextFace == NULL) || (IsMarked(nextNextFace)) ) { //uh, oh, we're following a dead end, try swapping NvFaceInfo* testNextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, testnv1, nextFace); if( ((testNextFace != NULL) && !IsMarked(testNextFace)) ) { //we only swap if it buys us something //add a "fake" degenerate face NvFaceInfo* tempFace = new NvFaceInfo(nv0, nv1, nv0, true); forwardFaces.push_back(tempFace); MarkTriangle(tempFace); scratchIndices.push_back(nv0); testnv0 = nv0; ++m_numDegenerates; } } // add this to the strip forwardFaces.push_back(nextFace); MarkTriangle(nextFace); // add the index //nv0 = nv1; //nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace); scratchIndices.push_back(testnv1); // and get the next face nv0 = testnv0; nv1 = testnv1; nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, nextFace); } // tempAllFaces is going to be forwardFaces + backwardFaces // it's used for Unique() NvFaceInfoVec tempAllFaces; for(size_t i = 0; i < forwardFaces.size(); i++) tempAllFaces.push_back(forwardFaces[i]); // // reset the indices for building the strip backwards and do so // scratchIndices.resize(0); scratchIndices.push_back(v2); scratchIndices.push_back(v1); scratchIndices.push_back(v0); nv0 = v1; nv1 = v0; nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, m_startInfo.m_startFace); while (nextFace != NULL && !IsMarked(nextFace)) { //this tests to see if a face is "unique", meaning that its vertices aren't already in the list // so, strips which "wrap-around" are not allowed if(!Unique(tempAllFaces, nextFace)) break; //check to see if this next face is going to cause us to die soon int testnv0 = nv1; int testnv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace); NvFaceInfo* nextNextFace = NvStripifier::FindOtherFace(edgeInfos, testnv0, testnv1, nextFace); if( (nextNextFace == NULL) || (IsMarked(nextNextFace)) ) { //uh, oh, we're following a dead end, try swapping NvFaceInfo* testNextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, testnv1, nextFace); if( ((testNextFace != NULL) && !IsMarked(testNextFace)) ) { //we only swap if it buys us something //add a "fake" degenerate face NvFaceInfo* tempFace = new NvFaceInfo(nv0, nv1, nv0, true); backwardFaces.push_back(tempFace); MarkTriangle(tempFace); scratchIndices.push_back(nv0); testnv0 = nv0; ++m_numDegenerates; } } // add this to the strip backwardFaces.push_back(nextFace); //this is just so Unique() will work tempAllFaces.push_back(nextFace); MarkTriangle(nextFace); // add the index //nv0 = nv1; //nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace); scratchIndices.push_back(testnv1); // and get the next face nv0 = testnv0; nv1 = testnv1; nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, nextFace); } // Combine the forward and backwards stripification lists and put into our own face vector Combine(forwardFaces, backwardFaces); }
int run_test_case(int casenum__) { switch (casenum__) { case 0: { string S = "banana"; string expected__ = "ban"; clock_t start__ = clock(); string received__ = Unique().removeDuplicates(S); return verify_case(casenum__, expected__, received__, clock()-start__); } case 1: { string S = "aardvark"; string expected__ = "ardvk"; clock_t start__ = clock(); string received__ = Unique().removeDuplicates(S); return verify_case(casenum__, expected__, received__, clock()-start__); } case 2: { string S = "xxxxx"; string expected__ = "x"; clock_t start__ = clock(); string received__ = Unique().removeDuplicates(S); return verify_case(casenum__, expected__, received__, clock()-start__); } case 3: { string S = "topcoder"; string expected__ = "topcder"; clock_t start__ = clock(); string received__ = Unique().removeDuplicates(S); return verify_case(casenum__, expected__, received__, clock()-start__); } // custom cases /* case 4: { string S = ; string expected__ = ; clock_t start__ = clock(); string received__ = Unique().removeDuplicates(S); return verify_case(casenum__, expected__, received__, clock()-start__); }*/ /* case 5: { string S = ; string expected__ = ; clock_t start__ = clock(); string received__ = Unique().removeDuplicates(S); return verify_case(casenum__, expected__, received__, clock()-start__); }*/ /* case 6: { string S = ; string expected__ = ; clock_t start__ = clock(); string received__ = Unique().removeDuplicates(S); return verify_case(casenum__, expected__, received__, clock()-start__); }*/ default: return -1; } }
Window::Unique Window::Create(const std::string &title, Settings &settings, unsigned int x, unsigned int y) { return Unique(new Window(title, settings, x, y)); }
/////////////////////////////////////////////////////////////////////////////////////////// // Build() // // Builds a strip forward as far as we can go, then builds backwards, and joins the two lists // void NvStripInfo::Build(NvEdgeInfoVec &edgeInfos, NvFaceInfoVec &faceInfos){ // used in building the strips forward and backward static WordVec scratchIndices; scratchIndices.resize(0); // build forward... start with the initial face NvFaceInfoVec forwardFaces, backwardFaces; forwardFaces.push_back(m_startInfo.m_startFace); MarkTriangle(m_startInfo.m_startFace); int v0 = (m_startInfo.m_toV1 ? m_startInfo.m_startEdge->m_v0 : m_startInfo.m_startEdge->m_v1); int v1 = (m_startInfo.m_toV1 ? m_startInfo.m_startEdge->m_v1 : m_startInfo.m_startEdge->m_v0); // easiest way to get v2 is to use this function which requires the // other indices to already be in the list. scratchIndices.push_back(u16(v0)); scratchIndices.push_back(u16(v1)); int v2 = NvStripifier::GetNextIndex(scratchIndices, m_startInfo.m_startFace); scratchIndices.push_back(u16(v2)); // // build the forward list // int nv0 = v1; int nv1 = v2; NvFaceInfo *nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, m_startInfo.m_startFace); while (nextFace != NULL && !IsMarked(nextFace)) { //this tests to see if a face is "unique", meaning that its vertices aren't already in the list // so, strips which "wrap-around" are not allowed if(!Unique(forwardFaces, nextFace)) break; // add this to the strip forwardFaces.push_back(nextFace); MarkTriangle(nextFace); // add the index nv0 = nv1; nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace); scratchIndices.push_back(u16(nv1)); // and get the next face nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, nextFace); } // tempAllFaces is going to be forwardFaces + backwardFaces // it's used for Unique() NvFaceInfoVec tempAllFaces; for(int i = 0; i < forwardFaces.size(); i++) tempAllFaces.push_back(forwardFaces[i]); // // reset the indices for building the strip backwards and do so // scratchIndices.resize(0); scratchIndices.push_back(u16(v2)); scratchIndices.push_back(u16(v1)); scratchIndices.push_back(u16(v0)); nv0 = v1; nv1 = v0; nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, m_startInfo.m_startFace); while (nextFace != NULL && !IsMarked(nextFace)) { //this tests to see if a face is "unique", meaning that its vertices aren't already in the list // so, strips which "wrap-around" are not allowed if(!Unique(tempAllFaces, nextFace)) break; // add this to the strip backwardFaces.push_back(nextFace); //this is just so Unique() will work tempAllFaces.push_back(nextFace); MarkTriangle(nextFace); // add the index nv0 = nv1; nv1 = NvStripifier::GetNextIndex(scratchIndices, nextFace); scratchIndices.push_back(u16(nv1)); // and get the next face nextFace = NvStripifier::FindOtherFace(edgeInfos, nv0, nv1, nextFace); } // Combine the forward and backwards stripification lists and put into our own face vector3 Combine(forwardFaces, backwardFaces); }
/** Update function from symbol list. * \param SymbolList: List of custom functions/constants. */ bool TParamFunc::Update(const TSymbolList &SymbolList) { Unique(); bool Result = xFuncData->Update(SymbolList); return !yFuncData->Update(SymbolList) ? false : Result; }
/** Optimize the internal data for the function. */ void TParamFunc::Simplify() { Unique(); xFuncData->Simplify(); yFuncData->Simplify(); }