{
}
-MEDCouplingCMesh::MEDCouplingCMesh(const MEDCouplingCMesh& other, bool deepCpy):MEDCouplingMesh(other)
+MEDCouplingCMesh::MEDCouplingCMesh(const MEDCouplingCMesh& other, bool deepCopy):MEDCouplingMesh(other)
{
- if(deepCpy)
+ if(deepCopy)
{
if(other._x_array)
_x_array=other._x_array->deepCpy();
*/
DataArrayInt *MEDCouplingCMesh::checkTypeConsistencyAndContig(const std::vector<int>& code, const std::vector<const DataArrayInt *>& idsPerType) const throw(INTERP_KERNEL::Exception)
{
- int sz=code.size();
+ std::size_t sz=code.size();
if(sz!=0 && sz!=3)
throw INTERP_KERNEL::Exception("MEDCouplingCMesh::checkTypeConsistencyAndContig : code should be of size 2 exactly !");
if(code[0]==INTERP_KERNEL::NORM_ERROR)
int nbOfNodes=getCoordsAt(i)->getNbOfElems();
double ref=pos[i];
const double *w=std::find_if(d,d+nbOfNodes,std::bind2nd(std::greater<double>(),ref));
- int w2=std::distance(d,w);
+ int w2=(int)std::distance(d,w);
if(w2<nbOfNodes && w2!=0)
{
ret+=coeff*(w2-1);
for(int i=0;i<n1;i++,pos++)
{
cp[9*pos]=(int)INTERP_KERNEL::NORM_HEXA8;
- double tmp=(n1+1)*(n2+1);
+ int tmp=(n1+1)*(n2+1);
cp[9*pos+1]=i+1+j*(n1+1)+k*tmp;
cp[9*pos+2]=i+j*(n1+1)+k*tmp;
cp[9*pos+3]=i+(j+1)*(n1+1)+k*tmp;
{
if(arrRefs.empty())
throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime constructor : A field is null in list impossible to build a time definition !");
- _slices[i]=MEDCouplingDefinitionTimeSlice::New(fs[i],meshRefs[i],arrRefs[i],i);
+ _slices[i]=MEDCouplingDefinitionTimeSlice::New(fs[i],meshRefs[i],arrRefs[i],(int)i);
}
if(sz<=1)
return ;
ids.push_back(id);
if(ids.empty())
throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime::getIdsOnTime : No matching slice for such time !");
- int sz=ids.size();
+ std::size_t sz=ids.size();
if(sz>2)
throw INTERP_KERNEL::Exception("MEDCouplingDefinitionTime::getIdsOnTime : Too many slices match this time !");
//
arrIds.resize(sz);
arrIdsInField.resize(sz);
fieldIds.resize(sz);
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
_slices[ids[i]]->getIdsOnTime(tm,_eps,meshIds[i],arrIds[i],arrIdsInField[i],fieldIds[i]);
}
void MEDCouplingDefinitionTime::getTinySerializationInformation(std::vector<int>& tinyInfoI, std::vector<double>& tinyInfoD) const
{
- int sz=_slices.size();
+ int sz=(int)_slices.size();
tinyInfoD.resize(1);
tinyInfoD[0]=_eps;
tinyInfoI.resize(3*sz+2);
std::vector<double> tmp2;
tinyInfoI[i+2]=(int)_slices[i]->getTimeType();
_slices[i]->getTinySerializationInformation(tmp1,tmp2);
- tinyInfoI[i+sz+2]=tmp1.size();
- tinyInfoI[i+2*sz+2]=tmp2.size();
+ tinyInfoI[i+sz+2]=(int)tmp1.size();
+ tinyInfoI[i+2*sz+2]=(int)tmp2.size();
coreData.insert(coreData.end(),tmp1.begin(),tmp1.end());
tinyInfoD.insert(tinyInfoD.end(),tmp2.begin(),tmp2.end());
}
- tinyInfoI[1]=coreData.size();
+ tinyInfoI[1]=(int)coreData.size();
tinyInfoI.insert(tinyInfoI.end(),coreData.begin(),coreData.end());
}
{
}
-MEDCouplingExtrudedMesh::MEDCouplingExtrudedMesh(const MEDCouplingExtrudedMesh& other, bool deepCpy):MEDCouplingMesh(other),_cell_2D_id(other._cell_2D_id)
+MEDCouplingExtrudedMesh::MEDCouplingExtrudedMesh(const MEDCouplingExtrudedMesh& other, bool deepCopy):MEDCouplingMesh(other),_cell_2D_id(other._cell_2D_id)
{
- if(deepCpy)
+ if(deepCopy)
{
_mesh2D=other._mesh2D->clone(true);
_mesh1D=other._mesh1D->clone(true);
if(where==ids+nbOf3DCells)
throw INTERP_KERNEL::Exception("Invalid cellId specified >= getNumberOfCells() !");
int nbOfCells2D=_mesh2D->getNumberOfCells();
- int locId=std::distance(ids,where)%nbOfCells2D;
+ int locId=((int)std::distance(ids,where))%nbOfCells2D;
INTERP_KERNEL::NormalizedCellType tmp=_mesh2D->getTypeOfCell(locId);
return INTERP_KERNEL::CellModel::GetCellModel(tmp).getExtrudedType();
}
std::transform(nodes1D+3*i,nodes1D+3*(i+1),bbox1DMax,bbox1DMax,static_cast<const double& (*)(const double&, const double&)>(std::max<double>));
}
std::transform(bbox1DMax,bbox1DMax+3,bbox1DMin,tmp,std::minus<double>());
- int id=std::max_element(tmp,tmp+3)-tmp;
+ int id=(int)std::distance(tmp,std::max_element(tmp,tmp+3));
bbox[0]=bbox1DMin[0]; bbox[1]=bbox1DMax[0];
bbox[2]=bbox1DMin[1]; bbox[3]=bbox1DMax[1];
bbox[4]=bbox1DMin[2]; bbox[5]=bbox1DMax[2];
const double *coords=_mesh2D->getCoords()->getConstPointer();
for(std::vector<int>::const_iterator iter=nodalConnec.begin();iter!=nodalConnec.end();iter++)
std::transform(zoneToUpdate,zoneToUpdate+3,coords+3*(*iter),zoneToUpdate,std::plus<double>());
- std::transform(zoneToUpdate,zoneToUpdate+3,zoneToUpdate,std::bind2nd(std::multiplies<double>(),(double)(1./nodalConnec.size())));
+ std::transform(zoneToUpdate,zoneToUpdate+3,zoneToUpdate,std::bind2nd(std::multiplies<double>(),(double)(1./(int)nodalConnec.size())));
}
int MEDCouplingExtrudedMesh::FindCorrespCellByNodalConn(const std::vector<int>& nodalConnec, const int *revNodalPtr, const int *revNodalIndxPtr) throw(INTERP_KERNEL::Exception)
tinyInfo.insert(tinyInfo.end(),tinyInfo2.begin(),tinyInfo2.end());
littleStrings.insert(littleStrings.end(),ls2.begin(),ls2.end());
tinyInfo.push_back(_cell_2D_id);
- tinyInfo.push_back(tinyInfo1.size());
+ tinyInfo.push_back((int)tinyInfo1.size());
tinyInfo.push_back(_mesh3D_ids->getNbOfElems());
littleStrings.push_back(getName());
littleStrings.push_back(getDescription());
void MEDCouplingExtrudedMesh::resizeForUnserialization(const std::vector<int>& tinyInfo, DataArrayInt *a1, DataArrayDouble *a2, std::vector<std::string>& littleStrings) const
{
- int sz=tinyInfo.size();
+ std::size_t sz=tinyInfo.size();
int sz1=tinyInfo[sz-2];
std::vector<int> ti1(tinyInfo.begin(),tinyInfo.begin()+sz1);
std::vector<int> ti2(tinyInfo.begin()+sz1,tinyInfo.end()-3);
{
setName(littleStrings[littleStrings.size()-2].c_str());
setDescription(littleStrings.back().c_str());
- int sz=tinyInfo.size();
+ std::size_t sz=tinyInfo.size();
int sz1=tinyInfo[sz-2];
_cell_2D_id=tinyInfo[sz-3];
std::vector<int> ti1(tinyInfo.begin(),tinyInfo.begin()+sz1);
a1tmp->decrRef(); a2tmp->decrRef();
//
_mesh3D_ids=DataArrayInt::New();
- int szIds=std::distance(a1Ptr,a1->getConstPointer()+a1->getNbOfElems());
+ int szIds=(int)std::distance(a1Ptr,a1->getConstPointer()+a1->getNbOfElems());
_mesh3D_ids->alloc(szIds,1);
std::copy(a1Ptr,a1Ptr+szIds,_mesh3D_ids->getPointer());
}
const std::vector<std::string>& littleStrings);
private:
MEDCouplingExtrudedMesh(const MEDCouplingUMesh *mesh3D, MEDCouplingUMesh *mesh2D, int cell2DId) throw(INTERP_KERNEL::Exception);
- MEDCouplingExtrudedMesh(const MEDCouplingExtrudedMesh& other, bool deepCpy);
+ MEDCouplingExtrudedMesh(const MEDCouplingExtrudedMesh& other, bool deepCopy);
MEDCouplingExtrudedMesh();
void computeExtrusion(const MEDCouplingUMesh *mesh3D) throw(INTERP_KERNEL::Exception);
void computeExtrusionAlg(const MEDCouplingUMesh *mesh3D) throw(INTERP_KERNEL::Exception);
if(mesh!=_mesh)
{
if(_mesh)
- ((MEDCouplingMesh *)_mesh)->decrRef();
+ _mesh->decrRef();
_mesh=mesh;
if(_mesh)
{
MEDCouplingField::~MEDCouplingField()
{
if(_mesh)
- ((MEDCouplingMesh *)_mesh)->decrRef();
+ _mesh->decrRef();
delete _type;
}
{
}
-MEDCouplingField::MEDCouplingField(const MEDCouplingField& other):_name(other._name),_desc(other._desc),_nature(other._nature),
+MEDCouplingField::MEDCouplingField(const MEDCouplingField& other):RefCountObject(other),_name(other._name),_desc(other._desc),_nature(other._nature),
_mesh(0),_type(other._type->clone())
{
if(other._mesh)
DataArrayInt *&cellRest)
{
cellRest=DataArrayInt::New();
- cellRest->alloc(std::distance(partBg,partEnd),1);
+ cellRest->alloc((int)std::distance(partBg,partEnd),1);
std::copy(partBg,partEnd,cellRest->getPointer());
}
{
MEDCouplingMesh *ret=mesh->buildPart(start,end);
di=DataArrayInt::New();
- di->alloc(std::distance(start,end),1);
+ di->alloc((int)std::distance(start,end),1);
int *pt=di->getPointer();
std::copy(start,end,pt);
return ret;
for(std::vector<int>::const_iterator iter=conn.begin();iter!=conn.end();iter++)
mesh->getCoordinatesOfNode(*iter,coo);
int spaceDim=mesh->getSpaceDimension();
- int nbOfNodes=conn.size();
+ std::size_t nbOfNodes=conn.size();
std::vector<const double *> vec(nbOfNodes);
- for(int i=0;i<nbOfNodes;i++)
+ for(std::size_t i=0;i<nbOfNodes;i++)
vec[i]=&coo[i*spaceDim];
INTERP_KERNEL::AutoPtr<double> tmp=new double[nbOfNodes];
INTERP_KERNEL::barycentric_coords(vec,loc,tmp);
int sz=arr->getNumberOfComponents();
INTERP_KERNEL::AutoPtr<double> tmp2=new double[sz];
std::fill(res,res+sz,0.);
- for(int i=0;i<nbOfNodes;i++)
+ for(std::size_t i=0;i<nbOfNodes;i++)
{
arr->getTuple(conn[i],(double *)tmp2);
std::transform((double *)tmp2,((double *)tmp2)+sz,(double *)tmp2,std::bind2nd(std::multiplies<double>(),tmp[i]));
_discr_per_cell=dpc;
//
if(check)
- delete [] (int *)array;
+ delete [] const_cast<int *>(array);
}
void MEDCouplingFieldDiscretizationPerCell::buildDiscrPerCellIfNecessary(const MEDCouplingMesh *m)
return false;
if(_loc.size()!=otherC->_loc.size())
return false;
- int sz=_loc.size();
- for(int i=0;i<sz;i++)
+ std::size_t sz=_loc.size();
+ for(std::size_t i=0;i<sz;i++)
if(!_loc[i].isEqual(otherC->_loc[i],eps))
return false;
return true;
return false;
if(_loc.size()!=otherC->_loc.size())
return false;
- int sz=_loc.size();
- for(int i=0;i<sz;i++)
+ std::size_t sz=_loc.size();
+ for(std::size_t i=0;i<sz;i++)
if(!_loc[i].isEqual(otherC->_loc[i],eps))
return false;
return true;
(*it)->renumberInPlace(array2);
delete [] array2;
if(check)
- delete [] (int*)array;
+ delete [] const_cast<int*>(array);
}
DataArrayDouble *MEDCouplingFieldDiscretizationGauss::getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const
INTERP_KERNEL::NormalizedCellType typ=cli.getType();
const std::vector<double>& wg=cli.getWeights();
calculator.addGaussInfo(typ,INTERP_KERNEL::CellModel::GetCellModel(typ).getDimension(),
- &cli.getGaussCoords()[0],wg.size(),&cli.getRefCoords()[0],
+ &cli.getGaussCoords()[0],(int)wg.size(),&cli.getRefCoords()[0],
INTERP_KERNEL::CellModel::GetCellModel(typ).getNumberOfNodes());
}
int nbt=parts2[i]->getNumberOfTuples();
if(_discr_per_cell)
val=_discr_per_cell->getNumberOfTuples();
tinyInfo.push_back(val);
- tinyInfo.push_back(_loc.size());
+ tinyInfo.push_back((int)_loc.size());
if(_loc.empty())
tinyInfo.push_back(-1);
else
int dim=tinyInfo[2];
int delta=-1;
if(nbOfLoc>0)
- delta=(tinyInfo.size()-3)/nbOfLoc;
+ delta=((int)tinyInfo.size()-3)/nbOfLoc;
for(int i=0;i<nbOfLoc;i++)
{
std::vector<int> tmp(tinyInfo.begin()+3+i*delta,tinyInfo.begin()+3+(i+1)*delta);
MEDCouplingFieldDiscretizationPerCell::checkCoherencyBetween(mesh,da);
for(std::vector<MEDCouplingGaussLocalization>::const_iterator iter=_loc.begin();iter!=_loc.end();iter++)
(*iter).checkCoherency();
- int nbOfDesc=_loc.size();
+ int nbOfDesc=(int)_loc.size();
int nbOfCells=mesh->getNumberOfCells();
const int *dc=_discr_per_cell->getConstPointer();
for(int i=0;i<nbOfCells;i++)
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
buildDiscrPerCellIfNecessary(m);
- int id=_loc.size();
+ int id=(int)_loc.size();
MEDCouplingGaussLocalization elt(type,refCoo,gsCoo,wg);
_loc.push_back(elt);
int *ptr=_discr_per_cell->getPointer();
throw INTERP_KERNEL::Exception("Size of [begin,end) must be equal or greater than 1 !");
INTERP_KERNEL::NormalizedCellType type=m->getTypeOfCell(*begin);
MEDCouplingGaussLocalization elt(type,refCoo,gsCoo,wg);
- int id=_loc.size();
+ int id=(int)_loc.size();
int *ptr=_discr_per_cell->getPointer();
for(const int *w=begin+1;w!=end;w++)
{
int MEDCouplingFieldDiscretizationGauss::getNbOfGaussLocalization() const throw(INTERP_KERNEL::Exception)
{
- return _loc.size();
+ return (int)_loc.size();
}
int MEDCouplingFieldDiscretizationGauss::getGaussLocalizationIdOfOneCell(int cellId) const throw(INTERP_KERNEL::Exception)
it=idsRemaining.begin();
ret.resize(ret.size()+1);
DataArrayInt *part=DataArrayInt::New();
- part->alloc(ids.size(),1);
+ part->alloc((int)ids.size(),1);
std::copy(ids.begin(),ids.end(),part->getPointer());
ret.back()=part;
locIds.resize(locIds.size()+1);
array3[0]=0;
for(int i=1;i<nbOfCells;i++)
{
- INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell(std::distance(array,std::find(array,array+nbOfCells,i-1)));
+ INTERP_KERNEL::NormalizedCellType type=mesh->getTypeOfCell((int)std::distance(array,std::find(array,array+nbOfCells,i-1)));
const INTERP_KERNEL::CellModel& cm=INTERP_KERNEL::CellModel::GetCellModel(type);
array3[i]=array3[i-1]+cm.getNumberOfNodes();
}
(*it)->renumberInPlace(array2);
delete [] array2;
if(check)
- delete [] (int*)array;
+ delete [] const_cast<int *>(array);
}
DataArrayDouble *MEDCouplingFieldDiscretizationGaussNE::getLocalizationOfDiscValues(const MEDCouplingMesh *mesh) const
return cloneWithMesh(true);
}
-MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCpy) const
+MEDCouplingFieldDouble *MEDCouplingFieldDouble::buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCopy) const
{
- MEDCouplingTimeDiscretization *tdo=_time_discr->buildNewTimeReprFromThis(td,deepCpy);
+ MEDCouplingTimeDiscretization *tdo=_time_discr->buildNewTimeReprFromThis(td,deepCopy);
MEDCouplingFieldDouble *ret=new MEDCouplingFieldDouble(getNature(),tdo,_type->clone());
ret->setMesh(getMesh());
ret->setName(getName());
{
}
-MEDCouplingFieldDouble::MEDCouplingFieldDouble(const MEDCouplingFieldDouble& other, bool deepCpy):MEDCouplingField(other),
- _time_discr(other._time_discr->performCpy(deepCpy))
+MEDCouplingFieldDouble::MEDCouplingFieldDouble(const MEDCouplingFieldDouble& other, bool deepCopy):MEDCouplingField(other),
+ _time_discr(other._time_discr->performCpy(deepCopy))
{
}
std::vector<double> res2;
for(std::vector< const DataArrayDouble *>::const_iterator iter=arrs.begin();iter!=arrs.end();iter++)
{
- int sz=res2.size();
+ int sz=(int)res2.size();
res2.resize(sz+(*iter)->getNumberOfComponents());
_type->getValueOn(*iter,_mesh,spaceLoc,&res2[sz]);
}
std::vector<int> tinyInfo2;
_type->getTinySerializationIntInformation(tinyInfo2);
tinyInfo.insert(tinyInfo.end(),tinyInfo2.begin(),tinyInfo2.end());
- tinyInfo.push_back(tinyInfo2.size());
+ tinyInfo.push_back((int)tinyInfo2.size());
}
/*!
std::vector<double> tinyInfo2;
_type->getTinySerializationDbleInformation(tinyInfo2);
tinyInfo.insert(tinyInfo.end(),tinyInfo2.begin(),tinyInfo2.end());
- tinyInfo.push_back(tinyInfo2.size());
+ tinyInfo.push_back((int)tinyInfo2.size());
}
/*!
_time_discr->finishUnserialization(tinyInfoI2,tmp1,tinyInfoS);
_nature=(NatureOfField)tinyInfoI[2];
_type->finishUnserialization(tmp2);
- int nbOfElemS=tinyInfoS.size();
+ int nbOfElemS=(int)tinyInfoS.size();
_name=tinyInfoS[nbOfElemS-3];
_desc=tinyInfoS[nbOfElemS-2];
setTimeUnit(tinyInfoS[nbOfElemS-1].c_str());
renumberNodesWithoutMesh(nodeCor->getConstPointer());
nodeCor->decrRef();
}
- setMesh((MEDCouplingMesh *)other);
+ setMesh(const_cast<MEDCouplingMesh *>(other));
}
/*!
MEDCouplingFieldDouble *deepCpy() const;
MEDCouplingFieldDouble *clone(bool recDeepCpy) const;
MEDCouplingFieldDouble *cloneWithMesh(bool recDeepCpy) const;
- MEDCouplingFieldDouble *buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCpy) const;
+ MEDCouplingFieldDouble *buildNewTimeReprFromThis(TypeOfTimeDiscretization td, bool deepCopy) const;
TypeOfTimeDiscretization getTimeDiscretization() const;
void checkCoherency() const throw(INTERP_KERNEL::Exception);
void setNature(NatureOfField nat) throw(INTERP_KERNEL::Exception);
private:
MEDCouplingFieldDouble(TypeOfField type, TypeOfTimeDiscretization td);
MEDCouplingFieldDouble(const MEDCouplingFieldTemplate *ft, TypeOfTimeDiscretization td);
- MEDCouplingFieldDouble(const MEDCouplingFieldDouble& other, bool deepCpy);
+ MEDCouplingFieldDouble(const MEDCouplingFieldDouble& other, bool deepCopy);
MEDCouplingFieldDouble(NatureOfField n, MEDCouplingTimeDiscretization *td, MEDCouplingFieldDiscretization *type);
~MEDCouplingFieldDouble();
private:
std::vector<int> tinyInfo2;
_type->getTinySerializationIntInformation(tinyInfo2);
tinyInfo.insert(tinyInfo.end(),tinyInfo2.begin(),tinyInfo2.end());
- tinyInfo.push_back(tinyInfo2.size());
+ tinyInfo.push_back((int)tinyInfo2.size());
}
void MEDCouplingFieldTemplate::getTinySerializationDbleInformation(std::vector<double>& tinyInfo) const
{
if(_weight.empty())
return -1;
- return _gauss_coord.size()/_weight.size();
+ return (int)_gauss_coord.size()/(int)_weight.size();
}
int ParaMEDMEM::MEDCouplingGaussLocalization::getNumberOfPtsInRefCell() const
int dim=getDimension();
if(dim==0)
return -1;
- return _ref_coord.size()/dim;
+ return (int)_ref_coord.size()/dim;
}
bool ParaMEDMEM::MEDCouplingGaussLocalization::isEqual(const MEDCouplingGaussLocalization& other, double eps) const
bool ParaMEDMEM::MEDCouplingGaussLocalization::AreAlmostEqual(const std::vector<double>& v1, const std::vector<double>& v2, double eps)
{
- int sz=v1.size();
- if(sz!=(int)v2.size())
+ std::size_t sz=v1.size();
+ if(sz!=v2.size())
return false;
std::vector<double> tmp(sz);
std::transform(v1.begin(),v1.end(),v2.begin(),tmp.begin(),std::minus<double>());
MEDCouplingGaussLocalization(INTERP_KERNEL::NormalizedCellType type, const std::vector<double>& refCoo,
const std::vector<double>& gsCoo, const std::vector<double>& w) throw(INTERP_KERNEL::Exception);
INTERP_KERNEL::NormalizedCellType getType() const { return _type; }
- int getNumberOfGaussPt() const { return _weight.size(); }
+ int getNumberOfGaussPt() const { return (int)_weight.size(); }
int getDimension() const;
int getNumberOfPtsInRefCell() const;
void checkCoherency() const throw(INTERP_KERNEL::Exception);
}
if(!commonNodes.empty())
{
- cI.push_back(cI.back()+commonNodes.size()+1);
+ cI.push_back(cI.back()+(int)commonNodes.size()+1);
c.push_back(i);
c.insert(c.end(),commonNodes.begin(),commonNodes.end());
}
void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
{
int nbOfCompoOth=other.getNumberOfComponents();
- int newNbOfCompo=compoIds.size();
- for(int i=0;i<newNbOfCompo;i++)
+ std::size_t newNbOfCompo=compoIds.size();
+ for(std::size_t i=0;i<newNbOfCompo;i++)
if(compoIds[i]>=nbOfCompoOth)
{
std::ostringstream oss; oss << "Specified component ids is to high (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompoOth << ")";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- for(int i=0;i<newNbOfCompo;i++)
- setInfoOnComponent(i,other.getInfoOnComponent(compoIds[i]).c_str());
+ for(std::size_t i=0;i<newNbOfCompo;i++)
+ setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]).c_str());
}
void DataArray::copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other) throw(INTERP_KERNEL::Exception)
{
int nbOfCompo=getNumberOfComponents();
- int partOfCompoToSet=compoIds.size();
- if(partOfCompoToSet!=other.getNumberOfComponents())
+ std::size_t partOfCompoToSet=compoIds.size();
+ if((int)partOfCompoToSet!=other.getNumberOfComponents())
throw INTERP_KERNEL::Exception("Given compoIds has not the same size as number of components of given array !");
- for(
int i=0;i<partOfCompoToSet;i++)
+ for(
std::size_t i=0;i<partOfCompoToSet;i++)
if(compoIds[i]>=nbOfCompo)
{
std::ostringstream oss; oss << "Specified component ids is to high (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompo << ")";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- for(
int i=0;i<partOfCompoToSet;i++)
- setInfoOnComponent(compoIds[i],other.getInfoOnComponent(i).c_str());
+ for(
std::size_t i=0;i<partOfCompoToSet;i++)
+ setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i).c_str());
}
bool DataArray::areInfoEquals(const DataArray& other) const
throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
int nbOfTuples=getNumberOfTuples();
const double *w=getConstPointer();
- const double *end=w+nbOfTuples;
+ const double *end2=w+nbOfTuples;
const double vmin=val-eps;
const double vmax=val+eps;
- for(;w!=end;w++)
+ for(;w!=end2;w++)
if(*w<vmin || *w>vmax)
return false;
return true;
void DataArrayDouble::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- _mem.reAlloc(_info_on_compo.size()*nbOfTuples);
+ _mem.reAlloc((int)(_info_on_compo.size())*nbOfTuples);
_nb_of_tuples=nbOfTuples;
declareAsNew();
}
{
DataArrayDouble *ret=DataArrayDouble::New();
int nbComp=getNumberOfComponents();
- ret->alloc(std::distance(new2OldBg,new2OldEnd),nbComp);
+ ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
ret->copyStringInfoFrom(*this);
double *pt=ret->getPointer();
const double *srcPt=getConstPointer();
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
int nbComp=getNumberOfComponents();
int oldNbOfTuples=getNumberOfTuples();
- ret->alloc(std::distance(new2OldBg,new2OldEnd),nbComp);
+ ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
ret->copyStringInfoFrom(*this);
double *pt=ret->getPointer();
const double *srcPt=getConstPointer();
/*!
* Idem than DataArrayInt::selectByTupleIdSafe except that the input array is not constructed explicitely.
- * The convention is as python one. ['bg','end') with steps of 'step'.
+ * The convention is as python one. ['bg','end2') with steps of 'step'.
* Returns a newly created array.
*/
-DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
+DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
{
- if(end<bg)
+ if(end2<bg)
throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleId2 : end before begin !");
if(step<=0)
throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleId2 : invalid step should > 0 !");
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
int nbComp=getNumberOfComponents();
- int newNbOfTuples=(end-1-bg)/step+1;
+ int newNbOfTuples=(end2-1-bg)/step+1;
ret->alloc(newNbOfTuples,nbComp);
double *pt=ret->getPointer();
const double *srcPt=getConstPointer()+bg*nbComp;
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
- int newNbOfCompo=compoIds.size();
+ std::size_t newNbOfCompo=compoIds.size();
int oldNbOfCompo=getNumberOfComponents();
for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
if((*it)<0 || (*it)>=oldNbOfCompo)
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
int nbOfTuples=getNumberOfTuples();
- ret->alloc(nbOfTuples,newNbOfCompo);
+ ret->alloc(nbOfTuples,(int)newNbOfCompo);
ret->copyPartOfStringInfoFrom(*this,compoIds);
const double *oldc=getConstPointer();
double *nc=ret->getPointer();
for(int i=0;i<nbOfTuples;i++)
- for(int j=0;j<newNbOfCompo;j++,nc++)
+ for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
*nc=oldc[i*oldNbOfCompo+compoIds[j]];
ret->incrRef();
return ret;
default:
throw INTERP_KERNEL::Exception("Unexpected spacedim of coords. Must be 1, 2 or 3.");
}
- commIndex->alloc(cI.size(),1);
+ commIndex->alloc((int)cI.size(),1);
std::copy(cI.begin(),cI.end(),commIndex->getPointer());
comm->alloc(cI.back(),1);
std::copy(c.begin(),c.end(),comm->getPointer());
void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
{
copyPartOfStringInfoFrom2(compoIds,*a);
- int partOfCompoSz=compoIds.size();
+ std::size_t partOfCompoSz=compoIds.size();
int nbOfCompo=getNumberOfComponents();
int nbOfTuples=getNumberOfTuples();
const double *ac=a->getConstPointer();
double *nc=getPointer();
for(int i=0;i<nbOfTuples;i++)
- for(
int j=0;j<partOfCompoSz;j++,ac++)
+ for(
std::size_t j=0;j<partOfCompoSz;j++,ac++)
nc[nbOfCompo*i+compoIds[j]]=*ac;
}
int nbOfTuples=getNumberOfTuples();
for(const int *z=bgComp;z!=endComp;z++)
DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- int newNbOfTuples=std::distance(bgTuples,endTuples);
- int newNbOfComp=std::distance(bgComp,endComp);
+ int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
+ int newNbOfComp=(int)std::distance(bgComp,endComp);
a->checkNbOfElems(newNbOfTuples*newNbOfComp,msg);
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
int nbOfTuples=getNumberOfTuples();
DataArray::CheckValueInRange(nbComp,bgComp,"invalid begin component value");
DataArray::CheckClosingParInRange(nbComp,endComp,"invalid end component value");
- int newNbOfTuples=std::distance(bgTuples,endTuples);
+ int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
a->checkNbOfElems(newNbOfTuples*newNbOfComp,msg);
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
const double *vals=getConstPointer();
const double *loc=std::max_element(vals,vals+nbOfTuples);
- tupleId=std::distance(vals,loc);
+ tupleId=(int)std::distance(vals,loc);
return *loc;
}
throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
const double *vals=getConstPointer();
const double *loc=std::min_element(vals,vals+nbOfTuples);
- tupleId=std::distance(vals,loc);
+ tupleId=(int)std::distance(vals,loc);
return *loc;
}
int nbOfElems=getNbOfElems();
for(int i=0;i<nbOfElems;i++,ptr++)
{
- if(*ptr!=0.)
+ if(std::abs(*ptr)<std::numeric_limits<double>::min())
{
*ptr=numerator/(*ptr);
}
if(*cptr>=vmin && *cptr<=vmax)
res.push_back(i);
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(res.size(),1);
+ ret->alloc((int)res.size(),1);
std::copy(res.begin(),res.end(),ret->getPointer());
return ret;
}
{
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
- int nbElemsIn=std::distance(indArrBg,indArrEnd);
+ int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
int nbOfTuples=getNumberOfTuples();
int *pt=getPointer();
for(int i=0;i<nbOfTuples;i++,pt++)
const int *work=getConstPointer();
typedef std::reverse_iterator<const int *> rintstart;
rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater of equal 2
- rintstart end(arrBg);
+ rintstart end2(arrBg);
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
std::set<std::size_t> castsDetected;
for(int i=0;i<nbOfTuples;i++)
{
- rintstart res=std::find_if(bg,end,std::bind2nd(std::less_equal<int>(), work[i]));
+ rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
std::size_t pos=std::distance(bg,res);
std::size_t pos2=nbOfCast-pos;
if(pos2<nbOfCast)
{
if(getNumberOfComponents()!=1)
throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
- int nbElemsIn=std::distance(indArrBg,indArrEnd);
+ int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
int nbOfTuples=getNumberOfTuples();
const int *pt=getConstPointer();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
{
DataArrayInt *ret=DataArrayInt::New();
int nbComp=getNumberOfComponents();
- ret->alloc(std::distance(new2OldBg,new2OldEnd),nbComp);
+ ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
ret->copyStringInfoFrom(*this);
int *pt=ret->getPointer();
const int *srcPt=getConstPointer();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
int nbComp=getNumberOfComponents();
int oldNbOfTuples=getNumberOfTuples();
- ret->alloc(std::distance(new2OldBg,new2OldEnd),nbComp);
+ ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
ret->copyStringInfoFrom(*this);
int *pt=ret->getPointer();
const int *srcPt=getConstPointer();
/*!
* Idem than DataArrayInt::selectByTupleIdSafe except that the input array is not constructed explicitely.
- * The convention is as python one. ['bg','end') with steps of 'step'.
+ * The convention is as python one. ['bg','end2') with steps of 'step'.
* Returns a newly created array.
*/
-DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end, int step) const throw(INTERP_KERNEL::Exception)
+DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
{
- if(end<bg)
+ if(end2<bg)
throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleId2 : end before begin !");
if(step<=0)
throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleId2 : invalid step should > 0 !");
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
int nbComp=getNumberOfComponents();
- int newNbOfTuples=(end+1-bg)/step-1;
+ int newNbOfTuples=(end2+1-bg)/step-1;
ret->alloc(newNbOfTuples,nbComp);
int *pt=ret->getPointer();
const int *srcPt=getConstPointer()+bg*nbComp;
int *retIPtr=retI->getPointer();
*retIPtr=0;
for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
- retIPtr[1]=retIPtr[0]+(*it1).size();
+ retIPtr[1]=retIPtr[0]+(int)((*it1).size());
if(nbOfTuples!=retI->getIJ(targetNb,0))
throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
ret->alloc(nbOfTuples,1);
throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
int nbOfTuples=getNumberOfTuples();
const int *w=getConstPointer();
- const int *end=w+nbOfTuples;
- for(;w!=end;w++)
+ const int *end2=w+nbOfTuples;
+ for(;w!=end2;w++)
if(*w!=val)
return false;
return true;
void DataArrayInt::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
{
checkAllocated();
- _mem.reAlloc(_info_on_compo.size()*nbOfTuples);
+ _mem.reAlloc((int)_info_on_compo.size()*nbOfTuples);
_nb_of_tuples=nbOfTuples;
declareAsNew();
}
{
checkAllocated();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
- int newNbOfCompo=compoIds.size();
+ int newNbOfCompo=(int)compoIds.size();
int oldNbOfCompo=getNumberOfComponents();
for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
{
copyPartOfStringInfoFrom2(compoIds,*a);
- int partOfCompoSz=compoIds.size();
+ std::size_t partOfCompoSz=compoIds.size();
int nbOfCompo=getNumberOfComponents();
int nbOfTuples=getNumberOfTuples();
const int *ac=a->getConstPointer();
int *nc=getPointer();
for(int i=0;i<nbOfTuples;i++)
- for(
int j=0;j<partOfCompoSz;j++,ac++)
+ for(
std::size_t j=0;j<partOfCompoSz;j++,ac++)
nc[nbOfCompo*i+compoIds[j]]=*ac;
}
int nbOfTuples=getNumberOfTuples();
for(const int *z=bgComp;z!=endComp;z++)
DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
- int newNbOfTuples=std::distance(bgTuples,endTuples);
- int newNbOfComp=std::distance(bgComp,endComp);
+ int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
+ int newNbOfComp=(int)std::distance(bgComp,endComp);
a->checkNbOfElems(newNbOfTuples*newNbOfComp,msg);
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
int nbOfTuples=getNumberOfTuples();
DataArray::CheckValueInRange(nbComp,bgComp,"invalid begin component value");
DataArray::CheckClosingParInRange(nbComp,endComp,"invalid end component value");
- int newNbOfTuples=std::distance(bgTuples,endTuples);
+ int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
a->checkNbOfElems(newNbOfTuples*newNbOfComp,msg);
if(strictCompoCompare)
a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
if(*cptr==val)
res.push_back(i);
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(res.size(),1);
+ ret->alloc((int)res.size(),1);
std::copy(res.begin(),res.end(),ret->getPointer());
return ret;
}
if(*cptr!=val)
res.push_back(i);
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(res.size(),1);
+ ret->alloc((int)res.size(),1);
std::copy(res.begin(),res.end(),ret->getPointer());
return ret;
}
throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
checkAllocated();
int *start=getPointer();
- int *end=start+getNbOfElems();
+ int *end2=start+getNbOfElems();
int ret=0;
- for(int *val=start;val!=end;val++)
+ for(int *val=start;val!=end2;val++)
{
if(*val==oldValue)
{
if(vals2.find(*cptr)!=vals2.end())
res.push_back(i);
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(res.size(),1);
+ ret->alloc((int)res.size(),1);
std::copy(res.begin(),res.end(),ret->getPointer());
return ret;
}
if(vals2.find(*cptr)==vals2.end())
res.push_back(i);
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(res.size(),1);
+ ret->alloc((int)res.size(),1);
std::copy(res.begin(),res.end(),ret->getPointer());
return ret;
}
throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
const int *vals=getConstPointer();
const int *loc=std::max_element(vals,vals+nbOfTuples);
- tupleId=std::distance(vals,loc);
+ tupleId=(int)std::distance(vals,loc);
return *loc;
}
throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
const int *vals=getConstPointer();
const int *loc=std::min_element(vals,vals+nbOfTuples);
- tupleId=std::distance(vals,loc);
+ tupleId=(int)std::distance(vals,loc);
return *loc;
}
r.insert(pt,pt+nbOfTuples);
}
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(r.size(),1);
+ ret->alloc((int)r.size(),1);
std::copy(r.begin(),r.end(),ret->getPointer());
return ret;
}
r=s1;
}
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(r.size(),1);
+ ret->alloc((int)r.size(),1);
std::copy(r.begin(),r.end(),ret->getPointer());
return ret;
}
tmp[*w]=true;
else
throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
- int nbOfRetVal=std::count(tmp.begin(),tmp.end(),false);
+ int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
DataArrayInt *ret=DataArrayInt::New();
ret->alloc(nbOfRetVal,1);
int j=0;
std::vector<int> r;
std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(r.size(),1);
+ ret->alloc((int)r.size(),1);
std::copy(r.begin(),r.end(),ret->getPointer());
return ret;
}
int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
{
- int sz=std::distance(start,end);
+ std::size_t sz=std::distance(start,end);
int *ret=new int[sz];
int *work=new int[sz];
std::copy(start,end,work);
}
int *iter2=ret;
for(const int *iter=start;iter!=end;iter++,iter2++)
- *iter2=std::distance(work,std::find(work,work+sz,*iter));
+ *iter2=(int)std::distance(work,std::find(work,work+sz,*iter));
delete [] work;
return ret;
}
MEDCOUPLING_EXPORT std::string getVarOnComponent(int i) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT std::string getUnitOnComponent(int i) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void setInfoOnComponent(int i, const char *info) throw(INTERP_KERNEL::Exception);
- MEDCOUPLING_EXPORT int getNumberOfComponents() const { return _info_on_compo.size(); }
+ MEDCOUPLING_EXPORT int getNumberOfComponents() const { return (int)_info_on_compo.size(); }
MEDCOUPLING_EXPORT int getNumberOfTuples() const { return _nb_of_tuples; }
- MEDCOUPLING_EXPORT int getNbOfElems() const { return _info_on_compo.size()*_nb_of_tuples; }
+ MEDCOUPLING_EXPORT int getNbOfElems() const { return ((int)_info_on_compo.size())*_nb_of_tuples; }
MEDCOUPLING_EXPORT void checkNbOfTuplesAndComp(const DataArray& other, const char *msg) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const char *msg) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void checkNbOfElems(int nbOfElems, const char *msg) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT DataArrayDouble *renumberAndReduce(const int *old2New, int newNbOfTuple) const;
MEDCOUPLING_EXPORT DataArrayDouble *selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const;
MEDCOUPLING_EXPORT DataArrayDouble *selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const throw(INTERP_KERNEL::Exception);
- MEDCOUPLING_EXPORT DataArrayDouble *selectByTupleId2(int bg, int end, int step) const throw(INTERP_KERNEL::Exception);
+ MEDCOUPLING_EXPORT DataArrayDouble *selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT DataArrayDouble *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT DataArrayDouble *changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true) throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception);
- MEDCOUPLING_EXPORT void getTuple(int tupleId, double *res) const { std::copy(_mem.getConstPointerLoc(tupleId*_info_on_compo.size()),_mem.getConstPointerLoc((tupleId+1)*_info_on_compo.size()),res); }
- MEDCOUPLING_EXPORT double getIJ(int tupleId, int compoId) const { return _mem[tupleId*_info_on_compo.size()+compoId]; }
+ MEDCOUPLING_EXPORT void getTuple(int tupleId, double *res) const { std::copy(_mem.getConstPointerLoc(tupleId*((int)_info_on_compo.size())),_mem.getConstPointerLoc((tupleId+1)*((int)_info_on_compo.size())),res); }
+ MEDCOUPLING_EXPORT double getIJ(int tupleId, int compoId) const { return _mem[tupleId*((int)_info_on_compo.size())+compoId]; }
MEDCOUPLING_EXPORT double back() const throw(INTERP_KERNEL::Exception);
- MEDCOUPLING_EXPORT void setIJ(int tupleId, int compoId, double newVal) { _mem[tupleId*_info_on_compo.size()+compoId]=newVal; declareAsNew(); }
- MEDCOUPLING_EXPORT void setIJSilent(int tupleId, int compoId, double newVal) { _mem[tupleId*_info_on_compo.size()+compoId]=newVal; }
+ MEDCOUPLING_EXPORT void setIJ(int tupleId, int compoId, double newVal) { _mem[tupleId*((int)_info_on_compo.size())+compoId]=newVal; declareAsNew(); }
+ MEDCOUPLING_EXPORT void setIJSilent(int tupleId, int compoId, double newVal) { _mem[tupleId*((int)_info_on_compo.size())+compoId]=newVal; }
MEDCOUPLING_EXPORT double *getPointer() { return _mem.getPointer(); }
MEDCOUPLING_EXPORT static void SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet);
MEDCOUPLING_EXPORT const double *getConstPointer() const { return _mem.getConstPointer(); }
MEDCOUPLING_EXPORT void setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true) throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception);
MEDCOUPLING_EXPORT void setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception);
- MEDCOUPLING_EXPORT void getTuple(int tupleId, int *res) const { std::copy(_mem.getConstPointerLoc(tupleId*_info_on_compo.size()),_mem.getConstPointerLoc((tupleId+1)*_info_on_compo.size()),res); }
- MEDCOUPLING_EXPORT int getIJ(int tupleId, int compoId) const { return _mem[tupleId*_info_on_compo.size()+compoId]; }
+ MEDCOUPLING_EXPORT void getTuple(int tupleId, int *res) const { std::copy(_mem.getConstPointerLoc(tupleId*((int)_info_on_compo.size())),_mem.getConstPointerLoc((tupleId+1)*((int)_info_on_compo.size())),res); }
+ MEDCOUPLING_EXPORT int getIJ(int tupleId, int compoId) const { return _mem[tupleId*((int)_info_on_compo.size())+compoId]; }
MEDCOUPLING_EXPORT int back() const throw(INTERP_KERNEL::Exception);
- MEDCOUPLING_EXPORT void setIJ(int tupleId, int compoId, int newVal) { _mem[tupleId*_info_on_compo.size()+compoId]=newVal; declareAsNew(); }
- MEDCOUPLING_EXPORT void setIJSilent(int tupleId, int compoId, int newVal) { _mem[tupleId*_info_on_compo.size()+compoId]=newVal; }
+ MEDCOUPLING_EXPORT void setIJ(int tupleId, int compoId, int newVal) { _mem[tupleId*((int)_info_on_compo.size())+compoId]=newVal; declareAsNew(); }
+ MEDCOUPLING_EXPORT void setIJSilent(int tupleId, int compoId, int newVal) { _mem[tupleId*((int)_info_on_compo.size())+compoId]=newVal; }
MEDCOUPLING_EXPORT int *getPointer() { return _mem.getPointer(); }
MEDCOUPLING_EXPORT static void SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet);
MEDCOUPLING_EXPORT const int *getConstPointer() const { return _mem.getConstPointer(); }
_nb_of_elem=nbOfElem;
destroy();
if(ownership)
- _pointer.setInternal((T *)array);
+ _pointer.setInternal(const_cast<T *>(array));
else
_pointer.setExternal(array);
_ownership=ownership;
T *pointer=new T[newNbOfElements];
std::copy(_pointer.getConstPointer(),_pointer.getConstPointer()+std::min<int>(_nb_of_elem,newNbOfElements),pointer);
if(_ownership)
- destroyPointer((T *)_pointer.getConstPointer(),_dealloc);
+ destroyPointer(const_cast<T *>(_pointer.getConstPointer()),_dealloc);//Do not use getPointer because in case of _external
_pointer.setInternal(pointer);
_nb_of_elem=newNbOfElements;
_ownership=true;
void MemArray<T>::destroy()
{
if(_ownership)
- destroyPointer((T *)_pointer.getConstPointer(),_dealloc);
+ destroyPointer(const_cast<T *>(_pointer.getConstPointer()),_dealloc);//Do not use getPointer because in case of _external
_pointer.null();
_ownership=false;
}
crest.push_back(i);
}
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(crest.size(),1);
+ ret->alloc((int)crest.size(),1);
std::copy(crest.begin(),crest.end(),ret->getPointer());
return ret;
}
int MEDCouplingMultiFields::getNumberOfFields() const
{
- return _fs.size();
+ return (int)_fs.size();
}
const MEDCouplingFieldDouble *MEDCouplingMultiFields::getFieldAtPos(int id) const throw(INTERP_KERNEL::Exception)
m=(*it)->getMesh();
if(m)
{
- std::vector<MEDCouplingMesh *>::iterator it=std::find(ms.begin(),ms.end(),m);
- if(it==ms.end())
+ std::vector<MEDCouplingMesh *>::iterator it2=std::find(ms.begin(),ms.end(),m);
+ if(it2==ms.end())
{
ms.push_back(const_cast<MEDCouplingMesh *>(m));
- refs[id]=ms.size()-1;
+ refs[id]=(int)ms.size()-1;
}
else
- refs[id]=std::distance(ms.begin(),it);
+ refs[id]=(int)std::distance(ms.begin(),it2);
}
else
refs[id]=-1;
if(it3==ret.end())
{
ret.push_back(*it2);
- refs[id][id2]=ret.size()-1;
+ refs[id][id2]=(int)ret.size()-1;
}
else
- refs[id][id2]=std::distance(ret.begin(),it3);
+ refs[id][id2]=(int)std::distance(ret.begin(),it3);
}
else
refs[id][id2]=-1;
*/
MEDCouplingMultiFields::MEDCouplingMultiFields(const MEDCouplingMultiFields& other)
{
- int sz=other._fs.size();
+ std::size_t sz=other._fs.size();
_fs.resize(sz);
std::vector<int> refs;
std::vector< std::vector<int> > refs2;
std::vector<MEDCouplingMesh *> ms=other.getDifferentMeshes(refs);
- int msLgh=ms.size();
+ std::size_t msLgh=ms.size();
std::vector< MEDCouplingAutoRefCountObjectPtr<MEDCouplingMesh> > ms2(msLgh);
- for(int i=0;i<msLgh;i++)
+ for(std::size_t i=0;i<msLgh;i++)
ms2[i]=ms[i]->deepCpy();
std::vector<DataArrayDouble *> das=other.getDifferentArrays(refs2);
- int dasLgth=das.size();
+ std::size_t dasLgth=das.size();
std::vector< MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> > das2(dasLgth);
- for(int i=0;i<dasLgth;i++)
+ for(std::size_t i=0;i<dasLgth;i++)
das2[i]=das[i]->deepCpy();
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
{
if((const MEDCouplingFieldDouble *)other._fs[i])
{
tmp->decrRef();
if(refs[i]!=-1)
_fs[i]->setMesh(ms2[refs[i]]);
- int nbOfArr=refs2[i].size();
+ std::size_t nbOfArr=refs2[i].size();
std::vector<DataArrayDouble *> tmp2(nbOfArr);
- for(int j=0;j<nbOfArr;j++)
+ for(std::size_t j=0;j<nbOfArr;j++)
{
if(refs2[i][j]!=-1)
tmp2[j]=das2[refs2[i][j]];
{
std::vector<int> refs;
std::vector<MEDCouplingMesh *> ms=getDifferentMeshes(refs);
- nbOfDiffMeshes=ms.size();
+ nbOfDiffMeshes=(int)ms.size();
std::vector< std::vector<int> > refs2;
std::vector<DataArrayDouble *> fs=getDifferentArrays(refs2);
- nbOfDiffArr=fs.size();
+ nbOfDiffArr=(int)fs.size();
//
- int sz=refs.size();//==_fs.size()
+ std::size_t sz=refs.size();//==_fs.size()
int sz2=0;
- for(int i=0;i<sz;i++)
- sz2+=refs2[i].size();
+ for(std::size_t i=0;i<sz;i++)
+ sz2+=(int)refs2[i].size();
//
tinyInfo2.clear();
std::vector<int> doubleDaInd(sz);
std::vector<int> timeDiscrInt;
tinyInfo.resize(sz2+5*sz+3);
- tinyInfo[0]=sz;
+ tinyInfo[0]=(int)sz;
tinyInfo[1]=sz2;
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
{
std::vector<double> tmp;
std::vector<int> tmp2;
_fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationDbleInformation2(tmp);
_fs[i]->getTimeDiscretizationUnderGround()->getTinySerializationIntInformation2(tmp2);
- tinyInfo[3*sz+3+i]=tmp.size();
- tinyInfo[4*sz+3+i]=tmp2.size();
+ tinyInfo[3*sz+3+i]=(int)tmp.size();
+ tinyInfo[4*sz+3+i]=(int)tmp2.size();
tinyInfo2.insert(tinyInfo2.end(),tmp.begin(),tmp.end());
timeDiscrInt.insert(timeDiscrInt.end(),tmp2.begin(),tmp2.end());
}
- int sz3=timeDiscrInt.size();
+ int sz3=(int)timeDiscrInt.size();
tinyInfo[2]=sz3;
//
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
tinyInfo[i+3]=refs[i];
- for(int i=0;i<sz;i++)
- tinyInfo[i+sz+3]=refs2[i].size();
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
+ tinyInfo[i+sz+3]=(int)refs2[i].size();
+ for(std::size_t i=0;i<sz;i++)
tinyInfo[i+2*sz+3]=(int)_fs[i]->getTimeDiscretization();
int k=0;
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
for(std::vector<int>::const_iterator it=refs2[i].begin();it!=refs2[i].end();it++,k++)
tinyInfo[5*sz+k+3]=*it;
tinyInfo.insert(tinyInfo.end(),timeDiscrInt.begin(),timeDiscrInt.end());//tinyInfo has lgth==sz3+sz2+5*sz+3
const int *pos=std::find(POS_OF_NATUREOFFIELD,POS_OF_NATUREOFFIELD+NB_OF_POSSIBILITIES,(int)nat);
if(pos==POS_OF_NATUREOFFIELD+NB_OF_POSSIBILITIES)
throw INTERP_KERNEL::Exception("MEDCouplingNatureOfField::getRepr : Unrecognized nature of field !");
- int pos2=std::distance(POS_OF_NATUREOFFIELD,pos);
+ std::size_t pos2=std::distance(POS_OF_NATUREOFFIELD,pos);
return REPR_OF_NATUREOFFIELD[pos2];
}
}
{
}
-MEDCouplingPointSet::MEDCouplingPointSet(const MEDCouplingPointSet& other, bool deepCpy):MEDCouplingMesh(other),_coords(0)
+MEDCouplingPointSet::MEDCouplingPointSet(const MEDCouplingPointSet& other, bool deepCopy):MEDCouplingMesh(other),_coords(0)
{
if(other._coords)
- _coords=other._coords->performCpy(deepCpy);
+ _coords=other._coords->performCpy(deepCopy);
}
MEDCouplingPointSet::~MEDCouplingPointSet()
if(spaceDim==3)
{
std::vector<double> cpy(res);
- int nbNodes=endConn-startConn;
+ int nbNodes=(int)std::distance(startConn,endConn);
INTERP_KERNEL::PlanarIntersector<DummyClsMCPS,int>::projection(&res[0],&cpy[0],nbNodes,nbNodes,1.e-12,0.,0.,true);
res.resize(2*nbNodes);
for(int i=0;i<nbNodes;i++)
*/
bool MEDCouplingPointSet::isButterfly2DCell(const std::vector<double>& res, bool isQuad)
{
- int nbOfNodes=res.size()/2;
+ std::size_t nbOfNodes=res.size()/2;
std::vector<INTERP_KERNEL::Node *> nodes(nbOfNodes);
- for(int i=0;i<nbOfNodes;i++)
+ for(std::size_t i=0;i<nbOfNodes;i++)
{
INTERP_KERNEL::Node *tmp=new INTERP_KERNEL::Node(res[2*i],res[2*i+1]);
nodes[i]=tmp;
{
protected:
MEDCouplingPointSet();
- MEDCouplingPointSet(const MEDCouplingPointSet& other, bool deepCpy);
+ MEDCouplingPointSet(const MEDCouplingPointSet& other, bool deepCopy);
~MEDCouplingPointSet();
public:
void updateTime() const;
for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
if(INTERP_KERNEL::distance2<SPACEDIM>(pos+SPACEDIM*i,coordsPtr+SPACEDIM*(*it))<eps2)
commonNodes.push_back(*it);
- cI.push_back(cI.back()+commonNodes.size());
+ cI.push_back(cI.back()+(int)commonNodes.size());
c.insert(c.end(),commonNodes.begin(),commonNodes.end());
}
}
void MEDCouplingLinearTime::getValueForTime(double time, const std::vector<double>& vals, double *res) const
{
double alpha=(_end_time-time)/(_end_time-_start_time);
- int nbComp=vals.size()/2;
+ std::size_t nbComp=vals.size()/2;
std::transform(vals.begin(),vals.begin()+nbComp,res,std::bind2nd(std::multiplies<double>(),alpha));
std::vector<double> tmp(nbComp);
std::transform(vals.begin()+nbComp,vals.end(),tmp.begin(),std::bind2nd(std::multiplies<double>(),1-alpha));
{
meshDM1Conn.insert(meshDM1Conn.end(),tmp,tmp+nbOfNodesSon);
meshDM1ConnIndex.push_back(meshDM1ConnIndex.back()+nbOfNodesSon);
- int cellDM1Id=meshDM1Type.size();
+ int cellDM1Id=(int)meshDM1Type.size();
meshDM1Type.push_back((int)cmsId);
for(unsigned k=0;k<nbOfNodesSon;k++)
revNodalB[tmp[k]].push_back(cellDM1Id);
std::string name="Mesh constituent of "; name+=getName();
MEDCouplingUMesh *ret=MEDCouplingUMesh::New(name.c_str(),getMeshDimension()-1);
ret->setCoords(getCoords());
- int nbOfCellsInConstituent=meshDM1Type.size();
+ int nbOfCellsInConstituent=(int)meshDM1Type.size();
ret->allocateCells(nbOfCellsInConstituent);
revDescIndx->alloc(nbOfCellsInConstituent+1,1);
int *tmp3=revDescIndx->getPointer(); tmp3[0]=0;
for(int ii=0;ii<nbOfCellsInConstituent;ii++)
{
ret->insertNextCell((INTERP_KERNEL::NormalizedCellType)meshDM1Type[ii],meshDM1ConnIndex[ii+1]-meshDM1ConnIndex[ii],&meshDM1Conn[meshDM1ConnIndex[ii]]);
- tmp3[ii+1]=tmp3[ii]+revDescMeshConnB[ii].size();
+ tmp3[ii+1]=tmp3[ii]+((int)revDescMeshConnB[ii].size());
}
ret->finishInsertingCells();
revDesc->alloc(tmp3[nbOfCellsInConstituent],1);
descIndx->alloc(nbOfCells+1,1);
tmp3=descIndx->getPointer(); tmp3[0]=0;
for(int jj=0;jj<nbOfCells;jj++)
- tmp3[jj+1]=tmp3[jj]+descMeshConnB[jj].size();
+ tmp3[jj+1]=tmp3[jj]+((int)descMeshConnB[jj].size());
desc->alloc(tmp3[nbOfCells],1);
tmp3=desc->getPointer();
for(std::vector< std::vector<int> >::const_iterator iter3=descMeshConnB.begin();iter3!=descMeshConnB.end();iter3++)
work+=offset;
*work++=-1;
}
- unsigned newLgth=work-tmp-1;
- unsigned delta=newLgth-lgthOld;
+ std::size_t newLgth=std::distance(tmp,work)-1;
+ std::size_t delta=newLgth-lgthOld;
std::transform(connIndex+(*iter)+1,connIndex+connIndexLgth,connIndex+(*iter)+1,std::bind2nd(std::plus<int>(),delta));
connNew.insert(connNew.begin()+posP1,tmp+lgthOld,tmp+newLgth);
std::copy(tmp,tmp+lgthOld,connNew.begin()+pos+1);
delete [] tmp;
}
- _nodal_connec->alloc(connNew.size(),1);
+ _nodal_connec->alloc((int)connNew.size(),1);
int *newConnPtr=_nodal_connec->getPointer();
std::copy(connNew.begin(),connNew.end(),newConnPtr);
}
std::ostringstream oss; oss << "MEDCouplingUMesh::convertExtrudedPolyhedra : cell # " << i << " is a polhedron BUT it has NOT exactly 1 face !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- int n2=std::distance(c+ci[i]+1,c+ci[i+1]);
+ std::size_t n2=std::distance(c+ci[i]+1,c+ci[i+1]);
if(n2%2!=0)
{
std::ostringstream oss; oss << "MEDCouplingUMesh::convertExtrudedPolyhedra : cell # " << i << " is a polhedron with 1 face but there is a mismatch of number of nodes in face should be even !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
- int n1=n2/2;
+ int n1=(int)(n2/2);
newci[i+1]=7*n1+2+newci[i];//6*n1 (nodal length) + n1+2 (number of faces) - 1 (number of '-1' separator is equal to number of faces -1) + 1 (for cell type)
}
else
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[i]];
if(type==INTERP_KERNEL::NORM_POLYHED)
{
- int n1=std::distance(c+ci[i]+1,c+ci[i+1])/2;
+ std::size_t n1=std::distance(c+ci[i]+1,c+ci[i+1])/2;
newc=std::copy(c+ci[i],c+ci[i]+n1+1,newc);
*newc++=-1;
- for(int j=0;j<n1;j++)
+ for(std::size_t j=0;j<n1;j++)
{
newc[j]=c[ci[i]+1+n1+(n1-j)%n1];
newc[n1+5*j]=-1;
for(int j=connIndex[i]+1;j<connIndex[i+1];j++)
if(conn[j]>=0)
traducer[conn[j]]=1;
- nbrOfNodesInUse=std::count(traducer,traducer+nbOfNodes,1);
+ nbrOfNodesInUse=(int)std::count(traducer,traducer+nbOfNodes,1);
std::transform(traducer,traducer+nbOfNodes,traducer,MEDCouplingAccVisit());
return ret;
}
std::vector<int> c1,c2;
getNodeIdsOfCell(cellId,c1);
other->getNodeIdsOfCell(cellId,c2);
- int sz=c1.size();
- if(sz!=(int)c2.size())
+ std::size_t sz=c1.size();
+ if(sz!=c2.size())
return false;
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
{
std::vector<double> n1,n2;
getCoordinatesOfNode(c1[0],n1);
if(areCellsEqualInPool(candidates,compType,res))
{
int pos=resI.back();
- resI.push_back(res.size());
+ resI.push_back((int)res.size());
for(std::vector<int>::const_iterator it=res.begin()+pos;it!=res.end();it++)
isFetched[*it]=true;
}
ret->alloc(nbOfCells,1);
int *retPtr=ret->getPointer();
std::fill(retPtr,retPtr+nbOfCells,0);
- const int nbOfTupleSmCells=commonCellsI.size()-1;
+ const std::size_t nbOfTupleSmCells=commonCellsI.size()-1;
int id=-1;
std::vector<int> cellsToKeep;
- for(int i=0;i<nbOfTupleSmCells;i++)
+ for(std::size_t i=0;i<nbOfTupleSmCells;i++)
{
for(std::vector<int>::const_iterator it=commonCells.begin()+commonCellsI[i];it!=commonCells.begin()+commonCellsI[i+1];it++)
retPtr[*it]=id;
if(begin[0]!=0)
throw INTERP_KERNEL::Exception("-1D mesh has only one cell : 0 !");
incrRef();
- return (MEDCouplingUMesh *)this;
+ return const_cast<MEDCouplingUMesh *>(this);
}
}
std::vector<int> cellIdsKept;
fillCellIdsToKeepFromNodeIds(partBg,partEnd,true,cellIdsKept);
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(cellIdsKept.size(),1);
+ ret->alloc((int)cellIdsKept.size(),1);
std::copy(cellIdsKept.begin(),cellIdsKept.end(),ret->getPointer());
return ret;
}
{
std::set<int> connOfCell(conn+connIndex[i]+1,conn+connIndex[i+1]);
connOfCell.erase(-1);//polyhedron separator
- int refLgth=std::min(connOfCell.size(),fastFinder.size());
+ int refLgth=(int)std::min(connOfCell.size(),fastFinder.size());
std::set<int> locMerge;
std::insert_iterator< std::set<int> > it(locMerge,locMerge.begin());
std::set_intersection(connOfCell.begin(),connOfCell.end(),fastFinder.begin(),fastFinder.end(),it);
std::vector<int> cellIdsKept;
fillCellIdsToKeepFromNodeIds(begin,end,fullyIn,cellIdsKept);
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(cellIdsKept.size(),1);
+ ret->alloc((int)cellIdsKept.size(),1);
std::copy(cellIdsKept.begin(),cellIdsKept.end(),ret->getPointer());
ret->setName(getName());
return ret;
revDesc->decrRef();
//
DataArrayInt *ret2=DataArrayInt::New();
- ret2->alloc(ret.size(),1);
+ ret2->alloc((int)ret.size(),1);
std::copy(ret.begin(),ret.end(),ret2->getPointer());
ret2->setName("BoundaryCells");
return ret2;
newCI[0]=loc;
for(int i=0;i<nbCells;i++)
{
- int pos=std::distance(array,std::find(array,array+nbCells,i));
+ std::size_t pos=std::distance(array,std::find(array,array+nbCells,i));
int nbOfElts=connI[pos+1]-connI[pos];
newC=std::copy(conn+connI[pos],conn+connI[pos+1],newC);
loc+=nbOfElts;
newConn->decrRef();
newConnI->decrRef();
if(check)
- delete [] (int *)array;
+ delete [] const_cast<int *>(array);
}
/*!
if(pt[ptI[cellId]]!=INTERP_KERNEL::NORM_POLYHED)
return ptI[cellId+1]-ptI[cellId]-1;
else
- return std::count_if(pt+ptI[cellId]+1,pt+ptI[cellId+1],std::bind2nd(std::not_equal_to<int>(),-1));
+ return (int)std::count_if(pt+ptI[cellId]+1,pt+ptI[cellId+1],std::bind2nd(std::not_equal_to<int>(),-1));
}
/*!
* Copy constructor. If 'deepCpy' is false 'this' is a shallow copy of other.
* If 'deeCpy' is true all arrays (coordinates and connectivities) are deeply copied.
*/
-MEDCouplingUMesh::MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCpy):MEDCouplingPointSet(other,deepCpy),_iterator(-1),_mesh_dim(other._mesh_dim),
- _nodal_connec(0),_nodal_connec_index(0),
+MEDCouplingUMesh::MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCopy):MEDCouplingPointSet(other,deepCopy),_iterator(-1),_mesh_dim(other._mesh_dim),
+ _nodal_connec(0),_nodal_connec_index(0),
_types(other._types)
{
if(other._nodal_connec)
- _nodal_connec=other._nodal_connec->performCpy(deepCpy);
+ _nodal_connec=other._nodal_connec->performCpy(deepCopy);
if(other._nodal_connec_index)
- _nodal_connec_index=other._nodal_connec_index->performCpy(deepCpy);
+ _nodal_connec_index=other._nodal_connec_index->performCpy(deepCopy);
}
MEDCouplingUMesh::~MEDCouplingUMesh()
MEDCouplingUMesh *ret=MEDCouplingUMesh::New();
ret->_mesh_dim=_mesh_dim;
ret->setCoords(_coords);
- int nbOfElemsRet=end-begin;
+ std::size_t nbOfElemsRet=std::distance(begin,end);
int *connIndexRet=new int[nbOfElemsRet+1];
connIndexRet[0]=0;
const int *conn=_nodal_connec->getConstPointer();
DataArrayInt *connRetArr=DataArrayInt::New();
connRetArr->useArray(connRet,true,CPP_DEALLOC,connIndexRet[nbOfElemsRet],1);
DataArrayInt *connIndexRetArr=DataArrayInt::New();
- connIndexRetArr->useArray(connIndexRet,true,CPP_DEALLOC,nbOfElemsRet+1,1);
+ connIndexRetArr->useArray(connIndexRet,true,CPP_DEALLOC,(int)nbOfElemsRet+1,1);
ret->setConnectivity(connRetArr,connIndexRetArr,false);
ret->_types=types;
connRetArr->decrRef();
connIndexRetArr->decrRef();
ret->copyTinyInfoFrom(this);
std::string name(getName());
- int sz=strlen(PART_OF_NAME);
- if((int)name.length()>=sz)
+ std::size_t sz=strlen(PART_OF_NAME);
+ if(name.length()>=sz)
name=name.substr(0,sz);
if(name!=PART_OF_NAME)
{
{
std::string name="PartMeasureOfMesh_";
name+=getName();
- int nbelem=std::distance(begin,end);
+ int nbelem=(int)std::distance(begin,end);
DataArrayDouble* array=DataArrayDouble::New();
array->setName(name.c_str());
array->alloc(nbelem,1);
throw INTERP_KERNEL::Exception("Expected a umesh with ( meshDim == 2 spaceDim == 2 or 3 ) or ( meshDim == 1 spaceDim == 2 ) !");
MEDCouplingFieldDouble *ret=MEDCouplingFieldDouble::New(ON_CELLS,NO_TIME);
DataArrayDouble *array=DataArrayDouble::New();
- int nbelems=std::distance(begin,end);
+ std::size_t nbelems=std::distance(begin,end);
int nbComp=getMeshDimension()+1;
- array->alloc(nbelems,nbComp);
+ array->alloc((int)nbelems,nbComp);
double *vals=array->getPointer();
const int *connI=_nodal_connec_index->getConstPointer();
const int *conn=_nodal_connec->getConstPointer();
}
else
{
- for(int i=0;i<nbelems;i++)
+ for(std::size_t i=0;i<nbelems;i++)
{ vals[3*i]=0.; vals[3*i+1]=0.; vals[3*i+2]=1.; }
}
}
for(int j=0;j<nbOf2DCells;j++)
{
AppendExtrudedCell(conn+connI[j],conn+connI[j+1],nbOfNodesOf1Lev,isQuad,newc);
- *newConnIPtr++=newc.size();
+ *newConnIPtr++=(int)newc.size();
}
- newConn->alloc(newc.size()*nbOf1DCells,1);
+ newConn->alloc((int)(newc.size())*nbOf1DCells,1);
int *newConnPtr=newConn->getPointer();
int deltaPerLev=isQuad?2*nbOfNodesOf1Lev:nbOfNodesOf1Lev;
newConnIPtr=newConnI->getPointer();
std::transform(newConnIPtr+1,newConnIPtr+1+nbOf2DCells,newConnIPtr+1+iz*nbOf2DCells,std::bind2nd(std::plus<int>(),newConnIPtr[iz*nbOf2DCells]));
for(std::vector<int>::const_iterator iter=newc.begin();iter!=newc.end();iter++,newConnPtr++)
{
- int icell=iter-newc.begin();
+ int icell=(int)(iter-newc.begin());
if(std::find(newConnIPtr,newConnIPtr+nbOf2DCells,icell)==newConnIPtr+nbOf2DCells)
{
if(*iter!=-1)
types.insert(typ);
ret[3*i]=typ;
const int *work2=std::find_if(work+1,connI+nbOfCells,ParaMEDMEMImpl::ConnReader(conn,typ));
- ret[3*i+1]=std::distance(work,work2);
+ ret[3*i+1]=(int)std::distance(work,work2);
work=work2;
}
return ret;
{
if(code.empty())
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code is empty, should not !");
- int sz=code.size();
+ std::size_t sz=code.size();
std::size_t n=sz/3;
if(sz%3!=0)
throw INTERP_KERNEL::Exception("MEDCouplingUMesh::checkTypeConsistencyAndContig : code size is NOT %3 !");
for(std::vector<INTERP_KERNEL::NormalizedCellType>::const_iterator it=types.begin();it!=types.end();it++,kk++)
{
i=std::find_if(i,connI+nbOfCells,ParaMEDMEMImpl::ConnReader2(conn,(int)(*it)));
- int offset=std::distance(connI,i);
+ int offset=(int)std::distance(connI,i);
if(code[3*kk+2]==-1)
{
const int *j=std::find_if(i+1,connI+nbOfCells,ParaMEDMEMImpl::ConnReader(conn,(int)(*it)));
- int pos2=std::distance(i,j);
- for(
int k=0;k<pos2;k++)
- *retPtr++=k+offset;
+ std::size_t pos2=std::distance(i,j);
+ for(
std::size_t k=0;k<pos2;k++)
+ *retPtr++=(int)k+offset;
i=j;
}
else
}
types.push_back(curType);
i=std::find_if(i+1,connI+nbOfCells,ParaMEDMEMImpl::ConnReader(conn,(int)curType));
- typeRangeVals.push_back(std::distance(connI,i));
+ typeRangeVals.push_back((int)std::distance(connI,i));
}
//
DataArrayInt *castArr=0,*rankInsideCast=0,*castsPresent=0;
code[3*i+2]=-1;
}
}
- int sz2=idsInPflPerType2.size();
+ std::size_t sz2=idsInPflPerType2.size();
idsInPflPerType.resize(sz2);
- for(int i=0;i<sz2;i++)
+ for(std::size_t i=0;i<sz2;i++)
{
DataArrayInt *locDa=idsInPflPerType2[i];
locDa->incrRef();
idsInPflPerType[i]=locDa;
}
- int sz=idsPerType2.size();
+ std::size_t sz=idsPerType2.size();
idsPerType.resize(sz);
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
{
DataArrayInt *locDa=idsPerType2[i];
locDa->incrRef();
DataArrayInt *ret=0;
if(!ret1->areCellsIncludedIn(nM1LevMesh,2,ret))
{
- int tmp;
- ret->getMaxValue(tmp);
+ int tmp2;
+ ret->getMaxValue(tmp2);
ret->decrRef();
- std::ostringstream oss; oss << "MEDCouplingUMesh::emulateMEDMEMBDC : input N-1 mesh present a cell not in descending mesh ... Id of cell is " << tmp << " !";
+ std::ostringstream oss; oss << "MEDCouplingUMesh::emulateMEDMEMBDC : input N-1 mesh present a cell not in descending mesh ... Id of cell is " << tmp2 << " !";
throw INTERP_KERNEL::Exception(oss.str().c_str());
}
nM1LevMeshIds=ret;
for(const int *i=connI;i!=connI+nbOfCells;)
{
INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
- int pos=std::distance(orderBg,std::find(orderBg,orderEnd,curType));
+ int pos=(int)std::distance(orderBg,std::find(orderBg,orderEnd,curType));
if(pos<=lastPos)
return false;
lastPos=pos;
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmpa=DataArrayInt::New();
MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmpb=DataArrayInt::New();
tmpa->alloc(nbOfCells,1);
- tmpb->alloc(std::distance(orderBg,orderEnd),1);
+ tmpb->alloc((int)std::distance(orderBg,orderEnd),1);
tmpb->fillWithZero();
int *tmp=tmpa->getPointer();
int *tmp2=tmpb->getPointer();
const INTERP_KERNEL::NormalizedCellType *where=std::find(orderBg,orderEnd,(INTERP_KERNEL::NormalizedCellType)conn[*i]);
if(where!=orderEnd)
{
- int pos=std::distance(orderBg,where);
+ int pos=(int)std::distance(orderBg,where);
tmp2[pos]++;
tmp[std::distance(connI,i)]=pos;
}
for(const int *i=connI;i!=connI+nbOfCells;)
{
INTERP_KERNEL::NormalizedCellType curType=(INTERP_KERNEL::NormalizedCellType)conn[*i];
- int beginCellId=std::distance(connI,i);
+ int beginCellId=(int)std::distance(connI,i);
i=std::find_if(i+1,connI+nbOfCells,ParaMEDMEMImpl::ConnReader(conn,(int)curType));
- int endCellId=std::distance(connI,i);
+ int endCellId=(int)std::distance(connI,i);
int sz=endCellId-beginCellId;
int *cells=new int[sz];
for(int j=0;j<sz;j++)
if((INTERP_KERNEL::NormalizedCellType)conn[connIndex[*w]]==type)
r.push_back(*w);
DataArrayInt *ret=DataArrayInt::New();
- ret->alloc(r.size(),1);
+ ret->alloc((int)r.size(),1);
std::copy(r.begin(),r.end(),ret->getPointer());
return ret;
}
{
DataArrayDouble *ret=DataArrayDouble::New();
int spaceDim=getSpaceDimension();
- int nbOfTuple=std::distance(begin,end);
+ int nbOfTuple=(int)std::distance(begin,end);
ret->alloc(nbOfTuple,spaceDim);
double *ptToFill=ret->getPointer();
double *tmp=new double[spaceDim];
const int *nod=(*iter)->getNodalConnectivity()->getConstPointer();
const int *index=(*iter)->getNodalConnectivityIndex()->getConstPointer();
int nbOfCells=(*iter)->getNumberOfCells();
- int meshLgth=(*iter)->getMeshLength();
- nodalPtr=std::copy(nod,nod+meshLgth,nodalPtr);
+ int meshLgth2=(*iter)->getMeshLength();
+ nodalPtr=std::copy(nod,nod+meshLgth2,nodalPtr);
if(iter!=meshes.begin())
nodalIndexPtr=std::transform(index+1,index+nbOfCells+1,nodalIndexPtr,std::bind2nd(std::plus<int>(),offset));
else
nodalIndexPtr=std::copy(index,index+nbOfCells+1,nodalIndexPtr);
- offset+=meshLgth;
+ offset+=meshLgth2;
}
MEDCouplingUMesh *ret=MEDCouplingUMesh::New();
ret->setName("merge");
MEDCouplingUMesh *ret=MergeUMeshesOnSameCoords(meshes);
DataArrayInt *o2n=ret->zipConnectivityTraducer(compType);
corr.resize(meshes.size());
- int nbOfMeshes=meshes.size();
+ std::size_t nbOfMeshes=meshes.size();
int offset=0;
const int *o2nPtr=o2n->getConstPointer();
- for(int i=0;i<nbOfMeshes;i++)
+ for(std::size_t i=0;i<nbOfMeshes;i++)
{
DataArrayInt *tmp=DataArrayInt::New();
int curNbOfCells=meshes[i]->getNumberOfCells();
std::reverse_iterator<const int *> rConnBg(connEnd);
std::reverse_iterator<const int *> rConnEnd(connBg+1);
std::transform(rConnBg,rConnEnd,ii,std::bind2nd(std::plus<int>(),deltaz));
- int nbOfRadFaces=std::distance(connBg+1,connEnd);
- for(int i=0;i<nbOfRadFaces;i++)
+ std::size_t nbOfRadFaces=std::distance(connBg+1,connEnd);
+ for(std::size_t i=0;i<nbOfRadFaces;i++)
{
*ii++=-1;
int conn[4]={connBg[(i+1)%nbOfRadFaces+1],connBg[i+1],connBg[i+1]+deltaz,connBg[(i+1)%nbOfRadFaces+1]+deltaz};
bool MEDCouplingUMesh::IsPolygonWellOriented(bool isQuadratic, const double *vec, const int *begin, const int *end, const double *coords)
{
double v[3]={0.,0.,0.};
- int sz=std::distance(begin,end);
+ std::size_t sz=std::distance(begin,end);
if(isQuadratic)
sz/=2;
- for(int i=0;i<sz;i++)
+ for(std::size_t i=0;i<sz;i++)
{
v[0]+=coords[3*begin[i]+1]*coords[3*begin[(i+1)%sz]+2]-coords[3*begin[i]+2]*coords[3*begin[(i+1)%sz]+1];
v[1]+=coords[3*begin[i]+2]*coords[3*begin[(i+1)%sz]]-coords[3*begin[i]]*coords[3*begin[(i+1)%sz]+2];
bool MEDCouplingUMesh::IsPolyhedronWellOriented(const int *begin, const int *end, const double *coords)
{
std::vector<std::pair<int,int> > edges;
- int nbOfFaces=std::count(begin,end,-1)+1;
+ std::size_t nbOfFaces=std::count(begin,end,-1)+1;
const int *bgFace=begin;
- for(int i=0;i<nbOfFaces;i++)
+ for(std::size_t i=0;i<nbOfFaces;i++)
{
const int *endFace=std::find(bgFace+1,end,-1);
- int nbOfEdgesInFace=std::distance(bgFace,endFace);
- for(int j=0;j<nbOfEdgesInFace;j++)
+ std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
+ for(std::size_t j=0;j<nbOfEdgesInFace;j++)
{
std::pair<int,int> p1(bgFace[j],bgFace[(j+1)%nbOfEdgesInFace]);
if(std::find(edges.begin(),edges.end(),p1)!=edges.end())
}
bgFace=endFace+1;
}
- return INTERP_KERNEL::calculateVolumeForPolyh2<int,INTERP_KERNEL::ALL_C_MODE>(begin,std::distance(begin,end),coords)>-EPS_FOR_POLYH_ORIENTATION;
+ return INTERP_KERNEL::calculateVolumeForPolyh2<int,INTERP_KERNEL::ALL_C_MODE>(begin,(int)std::distance(begin,end),coords)>-EPS_FOR_POLYH_ORIENTATION;
}
/*!
void MEDCouplingUMesh::TryToCorrectPolyhedronOrientation(int *begin, int *end, const double *coords) throw(INTERP_KERNEL::Exception)
{
std::vector<std::pair<int,int> > edges;
- int nbOfFaces=std::count(begin,end,-1)+1;
+ std::size_t nbOfFaces=std::count(begin,end,-1)+1;
int *bgFace=begin;
std::vector<bool> isPerm(nbOfFaces);
- for(int i=0;i<nbOfFaces;i++)
+ for(std::size_t i=0;i<nbOfFaces;i++)
{
int *endFace=std::find(bgFace+1,end,-1);
- int nbOfEdgesInFace=std::distance(bgFace,endFace);
- for(int l=0;l<nbOfEdgesInFace;l++)
+ std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
+ for(std::size_t l=0;l<nbOfEdgesInFace;l++)
{
std::pair<int,int> p1(bgFace[l],bgFace[(l+1)%nbOfEdgesInFace]);
edges.push_back(p1);
}
int *bgFace2=endFace+1;
- for(int k=i+1;k<nbOfFaces;k++)
+ for(std::size_t k=i+1;k<nbOfFaces;k++)
{
int *endFace2=std::find(bgFace2+1,end,-1);
- int nbOfEdgesInFace2=std::distance(bgFace2,endFace2);
- for(int j=0;j<nbOfEdgesInFace2;j++)
+ std::size_t nbOfEdgesInFace2=std::distance(bgFace2,endFace2);
+ for(std::size_t j=0;j<nbOfEdgesInFace2;j++)
{
std::pair<int,int> p2(bgFace2[j],bgFace2[(j+1)%nbOfEdgesInFace2]);
if(std::find(edges.begin(),edges.end(),p2)!=edges.end())
}
bgFace=endFace+1;
}
- if(INTERP_KERNEL::calculateVolumeForPolyh2<int,INTERP_KERNEL::ALL_C_MODE>(begin,std::distance(begin,end),coords)<-EPS_FOR_POLYH_ORIENTATION)
+ if(INTERP_KERNEL::calculateVolumeForPolyh2<int,INTERP_KERNEL::ALL_C_MODE>(begin,(int)std::distance(begin,end),coords)<-EPS_FOR_POLYH_ORIENTATION)
{//not lucky ! The first face was not correctly oriented : reorient all faces...
bgFace=begin;
- for(int i=0;i<nbOfFaces;i++)
+ for(std::size_t i=0;i<nbOfFaces;i++)
{
int *endFace=std::find(bgFace+1,end,-1);
- int nbOfEdgesInFace=std::distance(bgFace,endFace);
+ std::size_t nbOfEdgesInFace=std::distance(bgFace,endFace);
std::vector<int> tmp(nbOfEdgesInFace-1);
std::copy(bgFace+1,endFace,tmp.rbegin());
std::copy(tmp.begin(),tmp.end(),bgFace+1);
/* outputs -> */cr,crI,cNb1,cNb2);
//
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> addCooDa=DataArrayDouble::New();
- addCooDa->alloc(addCoo.size()/2,2);
+ addCooDa->alloc((int)(addCoo.size())/2,2);
std::copy(addCoo.begin(),addCoo.end(),addCooDa->getPointer());
std::vector<const DataArrayDouble *> coordss(3);
coordss[0]=m1->getCoords(); coordss[1]=m2->getCoords(); coordss[2]=addCooDa;
MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> coo=DataArrayDouble::Aggregate(coordss);
MEDCouplingAutoRefCountObjectPtr<MEDCouplingUMesh> ret=MEDCouplingUMesh::New("Intersect2D",2);
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> conn=DataArrayInt::New(); conn->alloc(cr.size(),1); std::copy(cr.begin(),cr.end(),conn->getPointer());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> connI=DataArrayInt::New(); connI->alloc(crI.size(),1); std::copy(crI.begin(),crI.end(),connI->getPointer());
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c1=DataArrayInt::New(); c1->alloc(cNb1.size(),1); std::copy(cNb1.begin(),cNb1.end(),c1->getPointer()); cellNb1=c1;
- MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c2=DataArrayInt::New(); c2->alloc(cNb2.size(),1); std::copy(cNb2.begin(),cNb2.end(),c2->getPointer()); cellNb2=c2;
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> conn=DataArrayInt::New(); conn->alloc((int)cr.size(),1); std::copy(cr.begin(),cr.end(),conn->getPointer());
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> connI=DataArrayInt::New(); connI->alloc((int)crI.size(),1); std::copy(crI.begin(),crI.end(),connI->getPointer());
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c1=DataArrayInt::New(); c1->alloc((int)cNb1.size(),1); std::copy(cNb1.begin(),cNb1.end(),c1->getPointer()); cellNb1=c1;
+ MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c2=DataArrayInt::New(); c2->alloc((int)cNb2.size(),1); std::copy(cNb2.begin(),cNb2.end(),c2->getPointer()); cellNb2=c2;
ret->setConnectivity(conn,connI,true);
ret->setCoords(coo);
ret->incrRef(); c1->incrRef(); c2->incrRef(); desc1->decrRef(); descIndx1->decrRef(); desc2->decrRef(); descIndx2->decrRef();
if(_cell_id<_nb_cell)
{
INTERP_KERNEL::NormalizedCellType type=(INTERP_KERNEL::NormalizedCellType)c[ci[_cell_id]];
- int nbOfElems=std::distance(ci+_cell_id,std::find_if(ci+_cell_id,ci+_nb_cell,ParaMEDMEMImpl::ConnReader(c,type)));
+ int nbOfElems=(int)std::distance(ci+_cell_id,std::find_if(ci+_cell_id,ci+_nb_cell,ParaMEDMEMImpl::ConnReader(c,type)));
int startId=_cell_id;
_cell_id+=nbOfElems;
return new MEDCouplingUMeshCellEntry(_mesh,type,_cell,startId,_cell_id);
/// @endcond
private:
MEDCouplingUMesh();
- MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCpy);
+ MEDCouplingUMesh(const MEDCouplingUMesh& other, bool deepCopy);
~MEDCouplingUMesh();
void checkFullyDefined() const throw(INTERP_KERNEL::Exception);
void checkConnectivityFullyDefined() const throw(INTERP_KERNEL::Exception);
