void test_empty() { IntVec v; CYBOZU_TEST_EQUAL((int)v.size(), 0); CYBOZU_TEST_ASSERT(v.empty()); for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) { printf("%d\n", i->val()); } v.push_back(3, 1); CYBOZU_TEST_EQUAL((int)v.size(), 1); CYBOZU_TEST_ASSERT(!v.empty()); for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) { CYBOZU_TEST_EQUAL(i->pos(), (size_t)3); CYBOZU_TEST_EQUAL(i->val(), 1); } v.push_back(4, 2); CYBOZU_TEST_EQUAL((int)v.size(), 2); int j = 0; for (typename IntVec::const_iterator i = v.begin(); i != v.end(); ++i) { CYBOZU_TEST_EQUAL(i->pos(), size_t(j + 3)); CYBOZU_TEST_EQUAL(i->val(), j + 1); j++; } v.clear(); CYBOZU_TEST_EQUAL((int)v.size(), 0); CYBOZU_TEST_ASSERT(v.empty()); IntVec v1, v2; for (int i = 0; i < 3; i++) { v1.push_back(i, i); v2.push_back(i, i); } CYBOZU_TEST_ASSERT(v1 == v2); v2.push_back(10, 10); CYBOZU_TEST_ASSERT(v1 != v2); }
int solve(const IntVec& A, const IntVec& B, int k) { IntVec q(k); int n = 0; int NA = A.size() >= k ? k : A.size(); int NB = B.size() >= k ? k : B.size(); for (int i = 0; i < NA; ++i) { for (int j = 0; j < NB; ++j) { int s = A[i] + B[i]; if (n == k) { if (s < q[0]) { pop_heap(q.begin(), q.end()); q[n - 1] = A[i] + B[j]; push_heap(q.begin(), q.begin() + n); } } else { q[n++] = A[i] + B[j]; push_heap(q.begin(), q.begin() + n); } // cout << n << "," << q << endl; } } // cout << q << endl; return q[0]; }
static int findRotatedIndex(IntVec const& vec) { if (vec.size() < 1) return 0; int prev_val = vec[0]; for (int i=1; i<vec.size(); ++i) { int curr_val = vec[i]; if (prev_val > curr_val) return i; prev_val = curr_val; } return 0; }
bool SparseMatrix::assemble (const Matrix& eM, const SAM& sam, SystemVector& B, const IntVec& meen) { StdVector* Bptr = dynamic_cast<StdVector*>(&B); if (!Bptr) return false; if (eM.rows() < meen.size() || eM.cols() < meen.size()) return false; assemSparse(eM,*this,*Bptr,meen,sam.meqn,sam.mpmceq,sam.mmceq,sam.ttcc); return true; }
// // Initialise with domain data // bool DataVar::initFromMeshData(const_DomainChunk_ptr dom, const IntVec& data, int fsCode, Centering c, NodeData_ptr nodes, const IntVec& id) { cleanup(); domain = dom; rank = 0; ptsPerSample = 1; centering = c; sampleID = id; meshName = nodes->getName(); siloMeshName = nodes->getFullSiloName(); numSamples = data.size(); if (numSamples > 0) { float* c = new float[numSamples]; dataArray.push_back(c); IntVec::const_iterator it; for (it=data.begin(); it != data.end(); it++) *c++ = static_cast<float>(*it); } initialized = true; return initialized; }
void CEditableObject::GetBoneWorldTransform(u32 bone_idx, float t, CSMotion* motion, Fmatrix& matrix) { VERIFY(bone_idx<m_Bones.size()); int idx = bone_idx; matrix.identity(); IntVec lst; do{ lst.push_back(idx); }while((idx=m_Bones[idx]->Parent()?m_Bones[idx]->Parent()->SelfID:-1)>-1); for (int i=lst.size()-1; i>=0; i--){ idx = lst[i]; Flags8 flags = motion->GetMotionFlags(idx); Fvector T,R; Fmatrix rot, mat; motion->_Evaluate(idx,t,T,R); if (flags.is(st_BoneMotion::flWorldOrient)){ rot.setXYZi(R.x,R.y,R.z); mat.identity(); mat.c.set(T); mat.mulA_43(matrix); mat.i.set(rot.i); mat.j.set(rot.j); mat.k.set(rot.k); }else{ mat.setXYZi(R.x,R.y,R.z); mat.c.set(T); mat.mulA_43(matrix); } matrix.set(mat); } }
void term() { const double logN = log(double(tf_.size())); idf_.resize(df_.size()); for (size_t i = 0, n = df_.size(); i < n; i++) { idf_[i] = logN - log(double(df_[i])); } for (size_t i = 0, n = df_.size(); i < n; i++) { const Int2Int& iv = tf_[i]; DoubleSvec v; for (Int2Int::const_iterator j = iv.begin(), je = iv.end(); j != je; ++j) { v.push_back(j->first, j->second * idf_[j->first]); } sv_.push_back(v); } }
long long minCost(vector <string> road, vector <int> altitude) { int sz = (int)road.size(); // generate alt table IntVec alt = altitude; sort(alt.begin(), alt.end()); unique(alt.begin(), alt.end()); LL mincost[64][64]; memset(mincost, 0x3f, sizeof(mincost)); LIIQueue q; int i, j; for (i = 0; i < (int)alt.size(); ++i) { LL cost = abs(alt[i] - altitude[0]); mincost[0][i] = cost; q.push(LII(-cost, II(0, alt[i]))); } // dijkstra while (q.size() > 0) { LII current = q.top(); q.pop(); int from = current.second.first; if (from == (sz-1)) { return -current.first; } for (i = 0; i < (int)alt.size(); ++i) { if (alt[i] > current.second.second) { break; } for (j = 0; j < sz; ++j) { if (road[from][j] == 'Y') { LL cost = -current.first + abs(alt[i] - altitude[j]); if (cost < mincost[j][i]) { mincost[j][i] = cost; q.push(LII(-cost, II(j, alt[i]))); } } } } } return -1; }
void put(int maxNum = 0x7fffffff) const { printf("docNum=%d, wordNum=%d\n", (int)tf_.size(), (int)df_.size()); for (int i = 0, n = std::min(maxNum, (int)sv_.size()); i < n; i++) { const DoubleSvec& v = sv_[i]; for (DoubleSvec::const_iterator j = v.begin(), je = v.end(); j != je; ++j) { printf("%d:%f ", (int)j->pos(), j->val()); } printf("\n"); } }
bool can(LL n) { int i = 0; LLVec t(g.size()); ILLMap::const_iterator it; for (it = e.begin(); it != e.end(); ++it) { LL r = it->second; while (r > 0) { LL c = min(r, n - t[i]); if (g[i] < it->first || c <= 0) { ++i; if (i >= (int)g.size()) { return false; } continue; } r -= c; t[i] += c; } } return true; }
// sort freq order void term(int lowerLimit = 3, double upperRateLimit = 0.98) { fprintf(stderr, "#doc=%d, #word=%d\n", docNum_, (int)df_.size()); for (size_t i = 0, n = id2word_.size(); i < n; i++) { const int freq = df_[i]; if (freq <= lowerLimit) continue; pv_.push_back(Pair(i, freq)); } int pvNum = (int)(pv_.size() * upperRateLimit); fprintf(stderr, "shrink %d -> %d\n", (int)pv_.size(), pvNum); std::partial_sort(pv_.begin(), pv_.begin() + pvNum, pv_.end()); pv_.resize(pvNum); }
int main () { typedef vector <int> IntVec; IntVec v (10); for (int i = 0; i < v.size (); i++) v[i] = (i + 1) * (i + 1); IntVec::iterator iter; iter = find_if (v.begin (), v.end (), div_3); if (iter != v.end ()) cout << "Value " << *iter << " at offset " << (iter - v.begin ()) << " is divisible by 3" << endl; return 0; }
static void assemSparse (const RealArray& V, SparseMatrix& SM, size_t col, const IntVec& mnen, const int* meqn, const int* mpmceq, const int* mmceq, const Real* ttcc) { for (size_t d = 0; d < mnen.size(); d++, col++) { Real vd = d < V.size() ? V[d] : V.back(); int ieq = mnen[d]; int ceq = -ieq; if (ieq > 0) SM(ieq,col) += vd; else if (ceq > 0) for (int ip = mpmceq[ceq-1]; ip < mpmceq[ceq]-1; ip++) { ieq = meqn[mmceq[ip]-1]; SM(ieq,col) += vd; } } }
void SpeckleyElements::reorderArray(IntVec& v, const IntVec& idx, int elementsPerIndex) { IntVec newArray(v.size()); IntVec::iterator arrIt = newArray.begin(); IntVec::const_iterator idxIt; if (elementsPerIndex == 1) { for (idxIt=idx.begin(); idxIt!=idx.end(); idxIt++) { *arrIt++ = v[*idxIt]; } } else { for (idxIt=idx.begin(); idxIt!=idx.end(); idxIt++) { int i = *idxIt; copy(&v[i*elementsPerIndex], &v[(i+1)*elementsPerIndex], arrIt); arrIt += elementsPerIndex; } } v.swap(newArray); }
bool loadKeywordFile(const std::string& keyFile) { std::ifstream ifs(keyFile.c_str(), std::ios::binary); if (!ifs) return false; std::string word; while (std::getline(ifs, word)) { size_t pos = word.find('\t'); if (pos == std::string::npos) break; word.resize(pos); std::pair<Str2Int::iterator, bool> ret = word2id_.insert(Str2Int::value_type(word, (int)id2word_.size())); if (ret.second) { id2word_.push_back(word); } else { fprintf(stderr, "ERR already set %s\n", word.c_str()); } } df_.resize(id2word_.size()); fprintf(stderr, "#word = %d\n", (int)df_.size()); return true; }
LLPair eval(const IntVec &program, size_t pos) { int sz = (int)program.size(); size_t i; LLPairQueue q; for (i = 0; i <= sz*2; ++i) { q.push_front(LLPair(0, 0)); } for (i = 0; i < sz; ++i) { LLPair c(program[i], i == pos); if (program[i] == 0) { LLPair a = q.front(); q.pop_front(); LLPair b = q.front(); q.pop_front(); c.first = a.first + b.first; c.second = a.second + b.second; } q.push_front(c); } return q.front(); }
double rec(int i, int M) { if (memo[i][M] > 0) { return memo[i][M]; } double &res = memo[i][M]; int G = min(Max, M+_gain[i]); int d = G+1; if ((i+1) < (int)_day.size()) { d = _day[i+1] - _day[i]; } if (M > d) { res = rec(i+1, M-d); } else { res = _day[i]+M; } if (G > d) { res = max(res, (1.0-_win[i])*_day[i] + _win[i]*rec(i+1, G-d)); } else { res = max(res, (1.0-_win[i])*_day[i] + _win[i]*(_day[i]+G)); } return res; }
//prime factors, less than or equal to num. //check each prime number to square root void factor(i64 num, I64PairVec& ifac, const IntVec& prime) { //special case, not prime factor for 1 ifac.clear(); if(num==1){ ifac.push_back(IntPair(1,1)); return; } i64 n1 = num; int ubound = sqrt((double) num); for(unsigned int i = 0; i < prime.size(); ++i) { int nth = 0; if( n1 % prime[i] == 0){ while(n1% prime[i] ==0) { n1/=prime[i]; ++nth; } ifac.push_back(IntPair(prime[i], nth)); } if(n1 == 1 || prime[i] > ubound)break; } if(n1 > 1) ifac.push_back(I64Pair(n1, 1)); }
bool ASMstruct::addXNodes (unsigned short int dim, size_t nXn, IntVec& nodes) { if (dim != ndim-1) { std::cerr <<" *** ASMstruct::addXNodes: Invalid boundary dimension "<< dim <<", only "<< (int)ndim-1 <<" is allowed."<< std::endl; return false; } else if (!geo || shareFE == 'F') return false; // logic error else if (MNPC.size() == nel && MLGE.size() == nel) { // Extend the element number and element topology arrays to double size, // to account for extra-ordinary elements associated with contact surfaces myMLGE.resize(2*nel,0); myMNPC.resize(2*nel); } else if (MLGE.size() != 2*nel || MNPC.size() != 2*nel) { // Already added interface elements, currently not allowed std::cerr <<" *** ASMstruct::addXNodes: Already have interface elements." << std::endl; return false; } // Add nXn extra-ordinary nodes to the list of global node numbers for (size_t i = 0; i < nXn; i++) { if (nodes.size() == i) nodes.push_back(++gNod); myMLGN.push_back(nodes[i]); } return true; }
bool SIMoutput::dumpVector (const Vector& vsol, const char* fname, utl::LogStream& os, std::streamsize precision) const { if (vsol.empty() || myPoints.empty()) return true; size_t i, j, k; Matrix sol1; Vector lsol; for (i = 0; i < myModel.size(); i++) { if (myModel[i]->empty()) continue; // skip empty patches std::vector<ResPtPair>::const_iterator pit; ResPointVec::const_iterator p; std::array<RealArray,3> params; IntVec points; // Find all evaluation points within this patch, if any for (j = 0, pit = myPoints.begin(); pit != myPoints.end(); ++pit) for (p = pit->second.begin(); p != pit->second.end(); j++, ++p) if (this->getLocalPatchIndex(p->patch) == (int)(i+1)) if (opt.discretization >= ASM::Spline) { points.push_back(p->inod > 0 ? p->inod : -(j+1)); for (k = 0; k < myModel[i]->getNoParamDim(); k++) params[k].push_back(p->u[k]); } else if (p->inod > 0) points.push_back(p->inod); if (points.empty()) continue; // no points in this patch // Evaluate/extracto nodal solution variables myModel[i]->extractNodeVec(vsol,lsol); if (opt.discretization >= ASM::Spline) { if (!myModel[i]->evalSolution(sol1,lsol,params.data(),false)) return false; } else { if (!myModel[i]->getSolution(sol1,lsol,points)) return false; } // Formatted output, use scientific notation with fixed field width std::streamsize flWidth = 8 + precision; std::streamsize oldPrec = os.precision(precision); std::ios::fmtflags oldF = os.flags(std::ios::scientific | std::ios::right); for (j = 0; j < points.size(); j++) { if (points[j] < 0) os <<" Point #"<< -points[j]; else { points[j] = myModel[i]->getNodeID(points[j]); os <<" Node #"<< points[j]; } os <<":\t"<< fname <<" ="; for (k = 1; k <= sol1.rows(); k++) os << std::setw(flWidth) << utl::trunc(sol1(k,j+1)); os << std::endl; } os.precision(oldPrec); os.flags(oldF); } return true; }
RotatedIndex(IntVec const& vec) { size = vec.size(); shift = findRotatedIndex(vec); }
//////////////////////////////////////////////////////////////////////////////////////// // GenerateStrips() // // in_indices: input index list, the indices you would use to render // in_numIndices: number of entries in in_indices // primGroups: array of optimized/stripified PrimitiveGroups // numGroups: number of groups returned // // Be sure to call delete[] on the returned primGroups to avoid leaking mem // bool GenerateStrips(const unsigned short* in_indices, const unsigned int in_numIndices, PrimitiveGroup** primGroups, unsigned short* numGroups, bool validateEnabled) { int i = 0; //put data in format that the stripifier likes WordVec tempIndices; tempIndices.resize(in_numIndices); unsigned short maxIndex = 0; unsigned short minIndex = 0xFFFF; for(i = 0; i < in_numIndices; i++) { tempIndices[i] = in_indices[i]; if (in_indices[i] > maxIndex) maxIndex = in_indices[i]; if (in_indices[i] < minIndex) minIndex = in_indices[i]; } NvStripInfoVec tempStrips; NvFaceInfoVec tempFaces; NvStripifier stripifier; //do actual stripification stripifier.Stripify(tempIndices, cacheSize, minStripSize, maxIndex, tempStrips, tempFaces); //stitch strips together IntVec stripIndices; unsigned int numSeparateStrips = 0; if(bListsOnly) { //if we're outputting only lists, we're done *numGroups = 1; (*primGroups) = new PrimitiveGroup[*numGroups]; PrimitiveGroup* primGroupArray = *primGroups; //count the total number of indices unsigned int numIndices = 0; for(i = 0; i < tempStrips.size(); i++) { numIndices += tempStrips[i]->m_faces.size() * 3; } //add in the list numIndices += tempFaces.size() * 3; primGroupArray[0].type = PT_LIST; primGroupArray[0].numIndices = numIndices; primGroupArray[0].indices = new unsigned short[numIndices]; //do strips unsigned int indexCtr = 0; for(i = 0; i < tempStrips.size(); i++) { for(int j = 0; j < tempStrips[i]->m_faces.size(); j++) { //degenerates are of no use with lists if(!NvStripifier::IsDegenerate(tempStrips[i]->m_faces[j])) { primGroupArray[0].indices[indexCtr++] = tempStrips[i]->m_faces[j]->m_v0; primGroupArray[0].indices[indexCtr++] = tempStrips[i]->m_faces[j]->m_v1; primGroupArray[0].indices[indexCtr++] = tempStrips[i]->m_faces[j]->m_v2; } else { //we've removed a tri, reduce the number of indices primGroupArray[0].numIndices -= 3; } } } //do lists for(i = 0; i < tempFaces.size(); i++) { primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v0; primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v1; primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v2; } } else { stripifier.CreateStrips(tempStrips, stripIndices, bStitchStrips, numSeparateStrips, bRestart, restartVal); //if we're stitching strips together, we better get back only one strip from CreateStrips() assert( (bStitchStrips && (numSeparateStrips == 1)) || !bStitchStrips); //convert to output format *numGroups = numSeparateStrips; //for the strips if(tempFaces.size() != 0) (*numGroups)++; //we've got a list as well, increment (*primGroups) = new PrimitiveGroup[*numGroups]; PrimitiveGroup* primGroupArray = *primGroups; //first, the strips int startingLoc = 0; for(int stripCtr = 0; stripCtr < numSeparateStrips; stripCtr++) { int stripLength = 0; if(!bStitchStrips) { int i; //if we've got multiple strips, we need to figure out the correct length for(i = startingLoc; i < stripIndices.size(); i++) { if(stripIndices[i] == -1) break; } stripLength = i - startingLoc; } else stripLength = stripIndices.size(); primGroupArray[stripCtr].type = PT_STRIP; primGroupArray[stripCtr].indices = new unsigned short[stripLength]; primGroupArray[stripCtr].numIndices = stripLength; int indexCtr = 0; for(int i = startingLoc; i < stripLength + startingLoc; i++) primGroupArray[stripCtr].indices[indexCtr++] = stripIndices[i]; //we add 1 to account for the -1 separating strips //this doesn't break the stitched case since we'll exit the loop startingLoc += stripLength + 1; } //next, the list if(tempFaces.size() != 0) { int faceGroupLoc = (*numGroups) - 1; //the face group is the last one primGroupArray[faceGroupLoc].type = PT_LIST; primGroupArray[faceGroupLoc].indices = new unsigned short[tempFaces.size() * 3]; primGroupArray[faceGroupLoc].numIndices = tempFaces.size() * 3; int indexCtr = 0; for(int i = 0; i < tempFaces.size(); i++) { primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v0; primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v1; primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v2; } } } //validate generated data against input if (validateEnabled) { const int NUMBINS = 100; std::vector<NvFaceInfo> in_bins[NUMBINS]; //hash input indices on first index for (i = 0; i < in_numIndices; i += 3) { NvFaceInfo faceInfo(in_indices[i], in_indices[i + 1], in_indices[i + 2]); in_bins[in_indices[i] % NUMBINS].push_back(faceInfo); } for (i = 0; i < *numGroups; ++i) { switch ((*primGroups)[i].type) { case PT_LIST: { for (int j = 0; j < (*primGroups)[i].numIndices; j += 3) { unsigned short v0 = (*primGroups)[i].indices[j]; unsigned short v1 = (*primGroups)[i].indices[j + 1]; unsigned short v2 = (*primGroups)[i].indices[j + 2]; //ignore degenerates if (NvStripifier::IsDegenerate(v0, v1, v2)) continue; if (!TestTriangle(v0, v1, v2, in_bins, NUMBINS)) { Cleanup(tempStrips, tempFaces); return false; } } break; } case PT_STRIP: { //int brokenCtr = 0; bool flip = false; for (int j = 2; j < (*primGroups)[i].numIndices; ++j) { unsigned short v0 = (*primGroups)[i].indices[j - 2]; unsigned short v1 = (*primGroups)[i].indices[j - 1]; unsigned short v2 = (*primGroups)[i].indices[j]; if (flip) { //swap v1 and v2 unsigned short swap = v1; v1 = v2; v2 = swap; } //ignore degenerates if (NvStripifier::IsDegenerate(v0, v1, v2)) { flip = !flip; continue; } if (!TestTriangle(v0, v1, v2, in_bins, NUMBINS)) { Cleanup(tempStrips, tempFaces); return false; } flip = !flip; } break; } case PT_FAN: default: break; } } } //clean up everything Cleanup(tempStrips, tempFaces); return true; }
//////////////////////////////////////////////////////////////////////////////////////// // CreateStrips() // // Generates actual strips from the list-in-strip-order. // void NvStripifier::CreateStrips(const NvStripInfoVec& allStrips, IntVec& stripIndices, const bool bStitchStrips, unsigned int& numSeparateStrips, const bool bRestart, const unsigned int restartVal) { assert(numSeparateStrips == 0); NvFaceInfo tLastFace(0, 0, 0); NvFaceInfo tPrevStripLastFace(0, 0, 0); size_t nStripCount = allStrips.size(); //we infer the cw/ccw ordering depending on the number of indices //this is screwed up by the fact that we insert -1s to denote changing strips //this is to account for that int accountForNegatives = 0; for (size_t i = 0; i < nStripCount; i++) { NvStripInfo *strip = allStrips[i]; int nStripFaceCount = strip->m_faces.size(); assert(nStripFaceCount > 0); // Handle the first face in the strip { NvFaceInfo tFirstFace(strip->m_faces[0]->m_v0, strip->m_faces[0]->m_v1, strip->m_faces[0]->m_v2); // If there is a second face, reorder vertices such that the // unique vertex is first if (nStripFaceCount > 1) { int nUnique = NvStripifier::GetUniqueVertexInB(strip->m_faces[1], &tFirstFace); if (nUnique == tFirstFace.m_v1) { SWAP(tFirstFace.m_v0, tFirstFace.m_v1); } else if (nUnique == tFirstFace.m_v2) { SWAP(tFirstFace.m_v0, tFirstFace.m_v2); } // If there is a third face, reorder vertices such that the // shared vertex is last if (nStripFaceCount > 2) { if(IsDegenerate(strip->m_faces[1])) { int pivot = strip->m_faces[1]->m_v1; if(tFirstFace.m_v1 == pivot) { SWAP(tFirstFace.m_v1, tFirstFace.m_v2); } } else { int nShared0, nShared1; GetSharedVertices(strip->m_faces[2], &tFirstFace, &nShared0, &nShared1); if ( (nShared0 == tFirstFace.m_v1) && (nShared1 == -1) ) { SWAP(tFirstFace.m_v1, tFirstFace.m_v2); } } } } if( (i == 0) || !bStitchStrips || bRestart) { if(!IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1)) stripIndices.push_back(tFirstFace.m_v0); } else { // Double tap the first in the new strip stripIndices.push_back(tFirstFace.m_v0); // Check CW/CCW ordering if (NextIsCW(stripIndices.size() - accountForNegatives) != IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1)) { stripIndices.push_back(tFirstFace.m_v0); } } stripIndices.push_back(tFirstFace.m_v0); stripIndices.push_back(tFirstFace.m_v1); stripIndices.push_back(tFirstFace.m_v2); // Update last face info tLastFace = tFirstFace; } for (int j = 1; j < nStripFaceCount; j++) { int nUnique = GetUniqueVertexInB(&tLastFace, strip->m_faces[j]); if (nUnique != -1) { stripIndices.push_back(nUnique); // Update last face info tLastFace.m_v0 = tLastFace.m_v1; tLastFace.m_v1 = tLastFace.m_v2; tLastFace.m_v2 = nUnique; } else { //we've hit a degenerate stripIndices.push_back(strip->m_faces[j]->m_v2); tLastFace.m_v0 = strip->m_faces[j]->m_v0;//tLastFace.m_v1; tLastFace.m_v1 = strip->m_faces[j]->m_v1;//tLastFace.m_v2; tLastFace.m_v2 = strip->m_faces[j]->m_v2;//tLastFace.m_v1; } } // Double tap between strips. if (bStitchStrips && !bRestart) { if (i != nStripCount - 1) stripIndices.push_back(tLastFace.m_v2); } else if (bRestart) { stripIndices.push_back(restartVal); } else { //-1 index indicates next strip stripIndices.push_back(-1); accountForNegatives++; numSeparateStrips++; } // Update last face info tLastFace.m_v0 = tLastFace.m_v1; tLastFace.m_v1 = tLastFace.m_v2; tLastFace.m_v2 = tLastFace.m_v2; } if(bStitchStrips || bRestart) numSeparateStrips = 1; }
static void assemSparse (const Matrix& eM, SparseMatrix& SM, Vector& SV, const IntVec& meen, const int* meqn, const int* mpmceq, const int* mmceq, const Real* ttcc) { // Add elements corresponding to free dofs in eM into SM int i, j, ip, nedof = meen.size(); for (j = 1; j <= nedof; j++) { int jeq = meen[j-1]; if (jeq < 1) continue; SM(jeq,jeq) += eM(j,j); for (i = 1; i < j; i++) { int ieq = meen[i-1]; if (ieq < 1) continue; SM(ieq,jeq) += eM(i,j); SM(jeq,ieq) += eM(j,i); } } // Add (appropriately weighted) elements corresponding to constrained // (dependent and prescribed) dofs in eM into SM and/or SV for (j = 1; j <= nedof; j++) { int jceq = -meen[j-1]; if (jceq < 1) continue; int jp = mpmceq[jceq-1]; Real c0 = ttcc[jp-1]; // Add contributions to SV (right-hand-side) if (!SV.empty()) for (i = 1; i <= nedof; i++) { int ieq = meen[i-1]; int iceq = -ieq; if (ieq > 0) SV(ieq) -= c0*eM(i,j); else if (iceq > 0) for (ip = mpmceq[iceq-1]; ip < mpmceq[iceq]-1; ip++) if (mmceq[ip] > 0) { ieq = meqn[mmceq[ip]-1]; SV(ieq) -= c0*ttcc[ip]*eM(i,j); } } // Add contributions to SM for (jp = mpmceq[jceq-1]; jp < mpmceq[jceq]-1; jp++) if (mmceq[jp] > 0) { int jeq = meqn[mmceq[jp]-1]; for (i = 1; i <= nedof; i++) { int ieq = meen[i-1]; int iceq = -ieq; if (ieq > 0) { SM(ieq,jeq) += ttcc[jp]*eM(i,j); SM(jeq,ieq) += ttcc[jp]*eM(j,i); } else if (iceq > 0) for (ip = mpmceq[iceq-1]; ip < mpmceq[iceq]-1; ip++) if (mmceq[ip] > 0) { ieq = meqn[mmceq[ip]-1]; SM(ieq,jeq) += ttcc[ip]*ttcc[jp]*eM(i,j); } } } } }
bool findNum(IntVec const& vec, int target) { RotatedIndex rotation(vec); cout << "Rotation shift: " << rotation.shift << endl; return binarySearch(vec, 0, vec.size()-1, target, rotation); }
bool SIMoutput::dumpResults (const Vector& psol, double time, utl::LogStream& os, const ResPointVec& gPoints, bool formatted, std::streamsize precision) const { if (gPoints.empty()) return true; size_t i, j, k; Matrix sol1, sol2; Vector reactionFS; const Vector* reactionForces = myEqSys->getReactions(); for (i = 0; i < myModel.size(); i++) { if (myModel[i]->empty()) continue; // skip empty patches ResPointVec::const_iterator p; std::array<RealArray,3> params; IntVec points; // Find all evaluation points within this patch, if any for (j = 0, p = gPoints.begin(); p != gPoints.end(); j++, p++) if (this->getLocalPatchIndex(p->patch) == (int)(i+1)) if (opt.discretization >= ASM::Spline) { points.push_back(p->inod > 0 ? p->inod : -(j+1)); for (k = 0; k < myModel[i]->getNoParamDim(); k++) params[k].push_back(p->u[k]); } else if (p->inod > 0) points.push_back(p->inod); if (points.empty()) continue; // no points in this patch myModel[i]->extractNodeVec(psol,myProblem->getSolution()); if (opt.discretization >= ASM::Spline) { // Evaluate the primary solution variables if (!myModel[i]->evalSolution(sol1,myProblem->getSolution(), params.data(),false)) return false; // Evaluate the secondary solution variables LocalSystem::patch = i; if (myProblem->getNoFields(2) > 0) { const_cast<SIMoutput*>(this)->setPatchMaterial(i+1); if (!myModel[i]->evalSolution(sol2,*myProblem,params.data(),false)) return false; } } else // Extract nodal primary solution variables if (!myModel[i]->getSolution(sol1,myProblem->getSolution(),points)) return false; // Formatted output, use scientific notation with fixed field width std::streamsize flWidth = 8 + precision; std::streamsize oldPrec = os.precision(precision); std::ios::fmtflags oldF = os.flags(std::ios::scientific | std::ios::right); for (j = 0; j < points.size(); j++) { if (!formatted) os << time <<" "; else if (points[j] < 0) os <<" Point #"<< -points[j] <<":\tsol1 ="; else { points[j] = myModel[i]->getNodeID(points[j]); os <<" Node #"<< points[j] <<":\tsol1 ="; } for (k = 1; k <= sol1.rows(); k++) os << std::setw(flWidth) << utl::trunc(sol1(k,j+1)); if (opt.discretization >= ASM::Spline) { if (formatted && sol2.rows() > 0) os <<"\n\t\tsol2 ="; for (k = 1; k <= sol2.rows(); k++) os << std::setw(flWidth) << utl::trunc(sol2(k,j+1)); } if (reactionForces && points[j] > 0) // Print nodal reaction forces for nodes with prescribed DOFs if (mySam->getNodalReactions(points[j],*reactionForces,reactionFS)) { if (formatted) os <<"\n\t\treac ="; for (k = 0; k < reactionFS.size(); k++) os << std::setw(flWidth) << utl::trunc(reactionFS[k]); } os << std::endl; } os.precision(oldPrec); os.flags(oldF); } return true; }
// makes a new paving from a vtk file // expects 3d, structured point data in file SPMinimalnode* SPMinimalnode::vtkPaving(const std::string filename) { SPMinimalnode* newTree = NULL; try { size_t expectedDims = 3; IntVec Xs; IntVec Ys; IntVec Zs; // get the spacing and fill in the coordinates vectors using // getCoordinatesFromVtk. // getCoordinatesFromVtk expects 10 header lines with spacings on 4th IntVec spacing = getCoordinatesFromVtk(Xs, Ys, Zs, filename); bool success = ((spacing.size() == expectedDims) && (spacing[0] > 0) && (spacing[0] == spacing[1]) && (spacing[0] == spacing[2])); if (success) { ivector rootbox(expectedDims); double maxXYZ = spacing[0] * 1.0; ImageList boxes; double totalListVol = 0; IntVecItr xIt = Xs.begin(); IntVecItr yIt = Ys.begin(); IntVecItr zIt = Zs.begin(); for (xIt = Xs.begin(); xIt < Xs.end(); xIt++, yIt++, zIt++) { ivector box(expectedDims); // make the box so that its boundaries are on the inner edges // of the voxel interval xdim(Sup(_interval(*xIt/maxXYZ)), Inf(_interval(*xIt + 1.0)/maxXYZ)); interval ydim(Sup(_interval(*yIt/maxXYZ)), Inf(_interval(*yIt + 1.0)/maxXYZ)); interval zdim(Sup(_interval(*zIt/maxXYZ)), Inf(_interval(*zIt + 1.0)/maxXYZ)); box[1] = xdim; box[2] = ydim; box[3] = zdim; boxes.push_back(box); totalListVol += Volume(box); } rootbox[1] = interval(0.0, 1.0); rootbox[2] = interval(0.0, 1.0); rootbox[3] = interval(0.0, 1.0); newTree = makeTreeFromVoxels(rootbox, boxes, maxXYZ, expectedDims); } if (newTree != NULL) { newTree->setNodeName("X"); newTree->recursiveRename(); } return newTree; } catch(std::exception const& e) { delete newTree; newTree = NULL; throw; } }
//////////////////////////////////////////////////////////////////////////////////////// // GenerateStrips() // // in_indices: input index list, the indices you would use to render // in_numIndices: number of entries in in_indices // primGroups: array of optimized/stripified PrimitiveGroups // numGroups: number of groups returned // // Be sure to call delete[] on the returned primGroups to avoid leaking mem // void GenerateStrips(const U16* in_indices, const U32 in_numIndices, PrimitiveGroup** primGroups, U16* numGroups) { //put data in format that the stripifier likes WordVec tempIndices; tempIndices.resize(in_numIndices); U16 maxIndex = 0; U32 i; for(i = 0; i < in_numIndices; i++) { tempIndices[i] = in_indices[i]; if(in_indices[i] > maxIndex) maxIndex = in_indices[i]; } NvStripInfoVec tempStrips; NvFaceInfoVec tempFaces; NvStripifier stripifier; //do actual stripification stripifier.Stripify(tempIndices, cacheSize, minStripSize, maxIndex, tempStrips, tempFaces); //stitch strips together IntVec stripIndices; U32 numSeparateStrips = 0; if(bListsOnly) { //if we're outputting only lists, we're done *numGroups = 1; (*primGroups) = new PrimitiveGroup[*numGroups]; PrimitiveGroup* primGroupArray = *primGroups; //count the total number of indices U32 numIndices = 0; U32 i; for(i = 0; i < tempStrips.size(); i++) { numIndices += tempStrips[i]->m_faces.size() * 3; } //add in the list numIndices += tempFaces.size() * 3; primGroupArray[0].type = PT_LIST; primGroupArray[0].numIndices = numIndices; primGroupArray[0].indices = new U16[numIndices]; //do strips U32 indexCtr = 0; for(U32 k = 0; k < tempStrips.size(); k++) { for(U32 j = 0; j < tempStrips[i]->m_faces.size(); j++) { //degenerates are of no use with lists if(!NvStripifier::IsDegenerate(tempStrips[i]->m_faces[j])) { primGroupArray[0].indices[indexCtr++] = tempStrips[k]->m_faces[j]->m_v0; primGroupArray[0].indices[indexCtr++] = tempStrips[k]->m_faces[j]->m_v1; primGroupArray[0].indices[indexCtr++] = tempStrips[k]->m_faces[j]->m_v2; } else { //we've removed a tri, reduce the number of indices primGroupArray[0].numIndices -= 3; } } } //do lists for(i = 0; i < tempFaces.size(); i++) { primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v0; primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v1; primGroupArray[0].indices[indexCtr++] = tempFaces[i]->m_v2; } } else { stripifier.CreateStrips(tempStrips, stripIndices, bStitchStrips, numSeparateStrips); //if we're stitching strips together, we better get back only one strip from CreateStrips() assert( (bStitchStrips && (numSeparateStrips == 1)) || !bStitchStrips); //convert to output format *numGroups = numSeparateStrips; //for the strips if(tempFaces.size() != 0) (*numGroups)++; //we've got a list as well, increment (*primGroups) = new PrimitiveGroup[*numGroups]; PrimitiveGroup* primGroupArray = *primGroups; //first, the strips S32 startingLoc = 0; for(U32 stripCtr = 0; stripCtr < numSeparateStrips; stripCtr++) { S32 stripLength = 0; if(!bStitchStrips) { //if we've got multiple strips, we need to figure out the correct length U32 i; for(i = startingLoc; i < stripIndices.size(); i++) { if(stripIndices[i] == -1) break; } stripLength = i - startingLoc; } else stripLength = stripIndices.size(); primGroupArray[stripCtr].type = PT_STRIP; primGroupArray[stripCtr].indices = new U16[stripLength]; primGroupArray[stripCtr].numIndices = stripLength; S32 indexCtr = 0; for(S32 i = startingLoc; i < stripLength + startingLoc; i++) primGroupArray[stripCtr].indices[indexCtr++] = stripIndices[i]; //we add 1 to account for the -1 separating strips //this doesn't break the stitched case since we'll exit the loop startingLoc += stripLength + 1; } //next, the list if(tempFaces.size() != 0) { S32 faceGroupLoc = (*numGroups) - 1; //the face group is the last one primGroupArray[faceGroupLoc].type = PT_LIST; primGroupArray[faceGroupLoc].indices = new U16[tempFaces.size() * 3]; primGroupArray[faceGroupLoc].numIndices = tempFaces.size() * 3; S32 indexCtr = 0; for(U32 i = 0; i < tempFaces.size(); i++) { primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v0; primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v1; primGroupArray[faceGroupLoc].indices[indexCtr++] = tempFaces[i]->m_v2; } } } //clean up everything //delete strips for(i = 0; i < tempStrips.size(); i++) { for(U32 j = 0; j < tempStrips[i]->m_faces.size(); j++) { delete tempStrips[i]->m_faces[j]; tempStrips[i]->m_faces[j] = NULL; } delete tempStrips[i]; tempStrips[i] = NULL; } //delete faces for(i = 0; i < tempFaces.size(); i++) { delete tempFaces[i]; tempFaces[i] = NULL; } }
py::list toPyList(const IntVec& x) { py::list out; for (int i=0; i < x.size(); ++i) out.append(x[i]); return out; }