//---------------------------------------------------------------------------
//! 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();
}
