template<class T> void Convert_To_Tetrahedralized_Volume( tetgenio& out, TETRAHEDRALIZED_VOLUME<T>& volume ) { ARRAY<VECTOR<T,3> > X; for( int i=0; i < out.numberofpoints; i++){ VECTOR<T,3> p; p.x = out.pointlist[ i*out.mesh_dim + 0 ]; p.y = out.pointlist[ i*out.mesh_dim + 1 ]; p.z = out.pointlist[ i*out.mesh_dim + 2 ]; X.Append(p); //LOG::cout << "V" << i+1 << " : " << p << std::endl; } ARRAY<VECTOR<int,4> > elements; for( int i=0; i < out.numberoftetrahedra; i++){ VECTOR<int,4> e; e(1) = out.tetrahedronlist[ i*out.numberofcorners + 0 ]; e(2) = out.tetrahedronlist[ i*out.numberofcorners + 1 ]; e(3) = out.tetrahedronlist[ i*out.numberofcorners + 2 ]; e(4) = out.tetrahedronlist[ i*out.numberofcorners + 3 ]; elements.Append(e); //LOG::cout << "T" << i+1 << " : " << e << std::endl; } int m = X.m; int n = elements.m; volume.mesh.Initialize_Mesh(m,elements); volume.particles.array_collection->Resize(m); volume.particles.X=X; }
bool CHotKeys::FindFirstConflict(ARRAY& keys, INT_PTR* pX, INT_PTR* pY) { bool bConflict = false; INT_PTR i, j; INT_PTR count = keys.GetSize(); DWORD key; for(i = 0; i < count && !bConflict; i++) { key = keys.ElementAt(i); // only check valid keys if(key == 0) continue; // scan the array for a duplicate for(j = i+1; j < count; j++ ) { if(keys.ElementAt(j) == key) { bConflict = true; break; } } } if(bConflict) { if(pX) *pX = i-1; if(pY) *pY = j; } return bConflict; }
void BaseVector :: SetElementVector (const ARRAY<INDEX> & pnum, const BaseVector & elvec) { int i; for (i = 1; i <= pnum.Size(); i++) (*this)(pnum.Get(i)) = elvec(i); }
///////////////////////////////////// // get_visibility() ///////////////////////////////////// void HatchingGroupFixed::get_visibility(TAGformat &d) { err_mesg(ERR_LEV_SPAM, "HatchingGroupFixed::get_visibility()"); BMESH *m = _patch->mesh(); if (LMESH::isa(m)) m = ((LMESH*)m)->cur_mesh(); int k, ctr=0; ARRAY<int> indices; CBface_list& faces = m->faces(); *d >> indices; for (k=0; k<indices.num(); k++) { HatchingSimplexDataFixed *hsdf = HatchingSimplexDataFixed::find(faces[indices[k]]); if (!hsdf) { hsdf = new HatchingSimplexDataFixed(faces[indices[k]]); ctr++; } hsdf->add(this); } err_mesg(ERR_LEV_SPAM, "HatchingGroupFixed::get_visibility() - Flagged %d tris and added %d new simplex data.", indices.num(), ctr); }
BOOL DeleteFormats(int parentID, ARRAY& formatIDs) { if(formatIDs.GetSize() <= 0) return TRUE; try { //Delete the requested data formats INT_PTR count = formatIDs.GetSize(); for(int i = 0; i < count; i++) { theApp.m_db.execDMLEx(_T("DELETE FROM Data WHERE lID = %d;"), formatIDs[i]); } CClip clip; if(clip.LoadFormats(parentID)) { DWORD CRC = clip.GenerateCRC(); //Update the main table with new size theApp.m_db.execDMLEx(_T("UPDATE Main SET CRC = %d WHERE lID = %d"), CRC, parentID); } } CATCH_SQLITE_EXCEPTION return TRUE; }
void BaseVector :: GetElementVector (const ARRAY<INDEX> & pnum, BaseVector & elvec) const { int i; for (i = 1; i <= pnum.Size(); i++) elvec(i) = (*this)(pnum.Get(i)); }
void CQListCtrl::LoadCopyOrCutToClipboard() { ARRAY arr; GetSelectionItemData(arr); INT_PTR count = arr.GetSize(); if(count <= 0) return; CProcessPaste paste; //Don't send the paste just load it into memory paste.m_bSendPaste = false; if(count > 1) paste.GetClipIDs().Copy(arr); else paste.GetClipIDs().Add(arr[0]); //Don't move these to the top BOOL bItWas = g_Opt.m_bUpdateTimeOnPaste; g_Opt.m_bUpdateTimeOnPaste = FALSE; paste.DoPaste(); g_Opt.m_bUpdateTimeOnPaste = bItWas; }
void Flags :: SetFlag (const char * name, const ARRAY<double> & val) { ARRAY<double> * numarray = new ARRAY<double>; for (int i = 1; i <= val.Size(); i++) numarray->Append (val.Get(i)); numlistflags.Set (name, numarray); }
void Vector :: AddElementVector (const ARRAY<INDEX> & pnum, const BaseVector & elvec) { int i; const Vector & helvec = elvec.CastToVector(); for (i = 1; i <= pnum.Size(); i++) Elem(pnum.Get(i)) += helvec.Get(i); }
void Vector :: GetElementVector (const ARRAY<INDEX> & pnum, BaseVector & elvec) const { int i; Vector & helvec = elvec.CastToVector(); for (i = 1; i <= pnum.Size(); i++) helvec.Elem(i) = Get(pnum.Get(i)); }
void LineSeg<D> :: GetRawData (ARRAY<double> & data) const { data.Append(2); for(int i=0; i<D; i++) data.Append(p1[i]); for(int i=0; i<D; i++) data.Append(p2[i]); }
void UVdata::split(CEdgeStrip& strip) { ARRAY<Bvert_list> chains; strip.get_chains(chains); for (int i=0; i<chains.num(); i++) split_chain(chains[i]); }
void Primitive :: GetTangentialSurfaceIndices (const Point<3> & p, ARRAY<int> & surfind, double eps) const { for (int j = 0; j < GetNSurfaces(); j++) if (fabs (GetSurface(j).CalcFunctionValue (p)) < eps) if (!surfind.Contains (GetSurfaceId(j))) surfind.Append (GetSurfaceId(j)); }
void Intersection (const FlatArray<T> & in1, const FlatArray<T> & in2, const FlatArray<T> & in3, ARRAY<T> & out) { out.SetSize(0); for(int i=0; i<in1.Size(); i++) if(in2.Contains(in1[i]) && in3.Contains(in1[i])) out.Append(in1[i]); }
/// array copy explicit ARRAY (const ARRAY<T> & a2) : FlatArray<T, BASE> (a2.Size(), a2.Size() ? new T[a2.Size()] : 0) { allocsize = this->size; ownmem = 1; for (int i = BASE; i < this->size+BASE; i++) (*this)[i] = a2[i]; }
void Solver::QPSolve(ARRAY<2, double>& a, ARRAY<1, double>& b, ARRAY<1, double>& f) { int n = f.dim(1); f.Fill(0); ARRAY<1, double> c = b; ARRAY<1, double> delta_f(n), delta_a(n); set<int> C, NC; set<int> ad_minus; for (int i = 1; i <= n; ++i) { if (c(i) < -1e-4) { ad_minus.insert(i); } } while (!ad_minus.empty()) { set<int>::iterator it = ad_minus.begin(); int d = *it; NC.erase(d); while (true) { fdirection(d, a, C, delta_f, delta_a); pair<double, int> sj = maxstep(f,c,delta_f,delta_a,C,NC,d); if (sj.first > 1e20) { return; } for (set<int>::iterator it = C.begin(); it != C.end(); ++it) if (*it != d) f(*it) += sj.first * delta_f(*it); f(d) += sj.first * delta_f(d); for (int i = 1; i <= n; ++i) { c(i) += delta_a(i) * sj.first; if (c(i) < -1e-4) { ad_minus.insert(i); } else { if (i == d) { sj.second = d; NC.erase(d); } ad_minus.erase(i); } } it = C.find(sj.second); if (it != C.end()) { NC.insert(*it); C.erase(it); } else { it = NC.find(sj.second); if (it != NC.end()) { C.insert(*it); NC.erase(it); } else { C.insert(d); ad_minus.erase(d); break; } } } } }
//##################################################################### // Function Compute_Level_Set_Helper //##################################################################### template<class T> void LEVELSET_MAKER_UNIFORM_2D<T>:: Compute_Level_Set_Helper(const TV_INT& index,T next,ARRAY<TV_INT>& next_todo,ARRAY<T,TV_INT>& phi) { if(!phi.Valid_Index(index)) return; T& p=phi(index); if(p!=FLT_MAX) return; p=next; next_todo.Append(index); }
//get all trigs: int GetTrig(int i) const { if (i <= charttrigs->Size()) { return charttrigs->Get(i); } else { return outertrigs->Get(i-charttrigs->Size()); } }
void *NMultiSet(MULTI *ma, int *k, void *d) { int i, j, m = 0, h; MDATA *pt = NULL; ARRAY *a; DATA *p, *p0 = NULL; if (ma->maxelem > 0 && ma->numelem >= ma->maxelem) { NMultiFreeData(ma); ma->numelem = 0; } h = Hash2(k, ma->ndim, 0, ma->ndim); a = &(ma->array[h]); if (a->dim == 0) { a->data = (DATA *) malloc(sizeof(DATA)); a->data->dptr = malloc(a->bsize); InitMDataData(a->data->dptr, a->block); a->data->next = NULL; pt = (MDATA *) a->data->dptr; } else { p = a->data; i = a->dim; j = 0; while (p) { pt = (MDATA *) p->dptr; for (m = 0; m < a->block && j < i; j++, m++) { if (memcmp(pt->index, k, ma->isize) == 0) { if (d) { memcpy(pt->data, d, ma->esize); } return pt->data; } pt++; } p0 = p; p = p->next; } if (m == a->block) { p0->next = (DATA *) malloc(sizeof(DATA)); p = p0->next; p->dptr = malloc(a->bsize); InitMDataData(p->dptr, a->block); p->next = NULL; pt = (MDATA *) p->dptr; } } ma->numelem++; pt->index = malloc(ma->isize); memcpy(pt->index, k, ma->isize); pt->data = malloc(ma->esize); if (a && a->InitData) a->InitData(pt->data, 1); if (d) memcpy(pt->data, d, ma->esize); (a->dim)++; return pt->data; }
void CQListCtrl::GetSelectionIndexes(ARRAY &arr) { arr.RemoveAll(); POSITION pos = GetFirstSelectedItemPosition(); while (pos) { arr.Add(GetNextSelectedItem(pos)); } }
void QickSort (const ARRAY<double> & values, ARRAY<int> & order) { int i, n = values.Size(); order.SetSize (n); for (i = 1; i <= n; i++) order.Elem(i) = i; QickSortRec (values, order, 1, order.Size()); }
void Flags :: SetFlag (const char * name, const ARRAY<char*> & val) { ARRAY<char*> * strarray = new ARRAY<char*>; for (int i = 1; i <= val.Size(); i++) { strarray->Append (new char[strlen(val.Get(i))+1]); strcpy (strarray->Last(), val.Get(i)); } strlistflags.Set (name, strarray); }
//##################################################################### // Function Build_Mesh //##################################################################### template<class T> void RED_GREEN_GRID_3D<T>:: Build_Mesh(TETRAHEDRON_MESH& tetrahedron_mesh,const ARRAY<T>* phi,ARRAY<int>& cell_to_tetrahedron_mapping,ARRAY<int>* node_to_particle_mapping) const { tetrahedron_mesh.Clean_Memory(); cell_to_tetrahedron_mapping.Clean_Memory();cell_to_tetrahedron_mapping.Resize(number_of_cells); if(node_to_particle_mapping){node_to_particle_mapping->Clean_Memory();node_to_particle_mapping->Resize(number_of_nodes);} for(int i=1;i<=uniform_grid.counts.x;i++) for(int j=1;j<=uniform_grid.counts.y;j++) for(int ij=1;ij<=uniform_grid.counts.z;ij++) if(elements(i,j,ij)) elements(i,j,ij)->Build_Tetrahedron_Mesh(tetrahedron_mesh,phi,cell_to_tetrahedron_mapping,node_to_particle_mapping); tetrahedron_mesh.number_nodes=node_to_particle_mapping?node_to_particle_mapping->Max():number_of_nodes; }
inline Wpt center (Wpt_list& pts, ARRAY<int>& N) { Wpt ret = Wpt(0); for (int i = 0; i < N.num(); i++) { ret += pts[N[i]]; } return ret / N.num(); }
void SplineSeg3<D> :: GetRawData (ARRAY<double> & data) const { data.Append(3); for(int i=0; i<D; i++) data.Append(p1[i]); for(int i=0; i<D; i++) data.Append(p2[i]); for(int i=0; i<D; i++) data.Append(p3[i]); }
void week3b() { ARRAY<int> lijst; // maakt een array met nul elementen lijst.append(13); // voegt toe aan het einde lijst[-1] = 12; // voegt toe aan het einde int n = lijst.length(); for(int i = 0; i < n; i++) { cout << "lijst[" << i << "]=" << lijst[i] << endl; } lijst[2] = 14; // moet een exception genereren }
void CQListCtrl::GetSelectionItemData(ARRAY &arr) { DWORD dwData; int i; arr.RemoveAll(); POSITION pos = GetFirstSelectedItemPosition(); while (pos) { i = GetNextSelectedItem(pos); dwData = GetItemData(i); arr.Add( dwData ); } }
int make_chain(ARRAY<NDCZpt*>& V, int (*cmp)(const void*, const void*)) { int i, j, s = 1; NDCZpt *tmp; V.sort(cmp); for (i=2; i<V.num(); i++) { for (j=s; j>=1 ; j--) if ((det(NDCvec(*(V[i]) - *(V[j])), NDCvec(*(V[j-1]) - *(V[j]))) > 0)) break; s = j+1; tmp = V[s]; V[s] = V[i]; V[i] = tmp; } return s; }
//##################################################################### // Function Command_Prompt_Response //##################################################################### template<class T,class RW> void OPENGL_COMPONENT_DEBUG_PARTICLES_2D<T,RW>:: Command_Prompt_Response() { if(!OPENGL_WORLD::Singleton()->prompt_response.empty()){ std::string command; std::istringstream sstream(OPENGL_WORLD::Singleton()->prompt_response); sstream>>command; if(command=="s"){ ARRAY<int> indices; int index; while(sstream>>index) indices.Append(index); opengl_particles.Clear_Selection(); opengl_particles.Select_Points(indices);}}
//##################################################################### // Function Cubic_MN_Weights //##################################################################### template<class T,class T2> ARRAY<T> CUBIC_MN_INTERPOLATION<T,T2>:: Cubic_MN_Weights(const T alpha) const { T alpha2=alpha*alpha; T alpha3=alpha2*alpha; ARRAY<T> weights; weights.Append(-alpha3/2.+alpha2-.5*alpha); //f_k-1 weights.Append(alpha3/2.-5*alpha2/2.+1); //f_k weights.Append(-alpha3/2.+2*alpha2+alpha/2.); //f_k+1 weights.Append(alpha3/2.-alpha2/2.); //f_k+2 for(int i=1;i<=weights.m;i++) weights(i)=max((T)0.,min((T)1.,weights(i))); return weights; }