// For each re-used semantic (e.g. TEXCOORD0) record the symbol for which it is output.
// This is so that you can specify the same semantic in multiple structures without
// having multiply defined attribute or varying symbols in the output. The one that is
// output is the one found with the largest dimension.
void HlslLinker::markDuplicatedInSemantics(GlslFunction* func)
{
int pCount = func->getParameterCount();
for (int ase = EAttrSemNone; ase < EAttrSemCount; ++ase)
{
std::vector<GlslSymbolOrStructMemberBase*> symsUsingSem;
for (int ii=0; ii<pCount; ii++)
{
GlslSymbol *sym = func->getParameter(ii);
appendDuplicatedInSemantics(sym, static_cast<EAttribSemantic>(ase), symsUsingSem);
}
if (symsUsingSem.size() > 1)
{
int index_of_largest = -1;
int largest_array_size = 0;
GlslSymbolOrStructMemberBase* sym_of_largest = 0;
for (unsigned int ii=0; ii < symsUsingSem.size(); ii++)
{
if (!ii || largest_array_size < getElements(symsUsingSem[ii]->type))
{
index_of_largest = ii;
sym_of_largest = symsUsingSem[ii];
largest_array_size = getElements(symsUsingSem[ii]->type);
}
}
for (unsigned int ii=0; ii < symsUsingSem.size(); ii++)
{
if (ii != index_of_largest)
{
symsUsingSem[ii]->suppressOutput(sym_of_largest);
}
}
}
}
}
bool
CoinPackedVectorBase::operator==(const CoinPackedVectorBase& rhs) const
{ if (getNumElements() == 0 || rhs.getNumElements() == 0) {
if (getNumElements() == 0 && rhs.getNumElements() == 0)
return (true) ;
else
return (false) ;
} else {
return (getNumElements()==rhs.getNumElements() &&
std::equal(getIndices(),getIndices()+getNumElements(),
rhs.getIndices()) &&
std::equal(getElements(),getElements()+getNumElements(),
rhs.getElements())) ;
}
}
int main (int argc,
char** argv)
// ---------------------------------------------------------------------------
// Driver for other routines.
// ---------------------------------------------------------------------------
{
Action mirror = UNDEFINED;
Point axis;
real_t angle = 0.;
int_t nvert, nel; // -- Numbers read from input.
int_t nrep = 1; // -- Number of times to repeat operation.
vector<Node*> vertices;
vector<Node*>* elements;
FEML* F;
Femlib::initialize (&argc, &argv);
getArgs (argc, argv, mirror, axis, angle, nrep, F);
nvert = getVertices (F, vertices, mirror, axis, angle, nrep);
nel = getElements (F, vertices, elements, nvert, nrep);
printUp (cout, const_cast<const vector<Node*>&>(vertices),
const_cast<const vector<Node*>*&>(elements),
nvert, nel, nrep, mirror);
Femlib::finalize();
return EXIT_SUCCESS;
}
void Object::_renderInternal()
{
Scene* scene = getScene();
getScene()->getShaderParamSet()->setCurObject( this );
RenderSystem* renderSystem = getScene()->_getRenderSystem();
{
CF_PROFILE( "SetupObjectRenderState" );
if ( mUsageRenderOption )
scene->_setupRenderOption( mRenderOption , mUsageRenderOption );
renderSystem->setFillMode( mRenderMode );
}
for( MeshIterator iter = getElements(); iter.haveMore() ; iter.next() )
{
Element* ele = iter.get();
unsigned restOptionBit = 0;
float opacity = _evalOpacity( ele->getMaterial() );
scene->_renderMesh( ele->getMesh() , ele->getMaterial() , mRenderMode , opacity , restOptionBit );
if ( restOptionBit )
scene->_setupRenderOption( mRenderOption , restOptionBit );
}
if ( mUsageRenderOption )
scene->_setupDefultRenderOption( mUsageRenderOption );
}
void
BCP_lp_relax::pack(BCP_buffer& buf) const {
const int major = getMajorDim();
const int minor = getMinorDim();
buf.pack(colOrdered_)
.pack(extraGap_)
.pack(extraMajor_)
.pack(major)
.pack(minor)
.pack(size_)
.pack(maxMajorDim_)
.pack(maxSize_);
const int * length = getVectorLengths();
const int * start = getVectorStarts();
const int * ind = getIndices();
const double * elem = getElements();
if (major > 0) {
buf.pack(length, major);
buf.pack(start, major+1);
for (int i = 0; i < major; ++i)
buf.pack(ind + start[i], length[i]);
for (int i = 0; i < major; ++i)
buf.pack(elem + start[i], length[i]);
}
buf.pack(_Objective).pack(_ColLowerBound).pack(_ColUpperBound)
.pack(_RowLowerBound).pack(_RowUpperBound);
}
void Object::addVertexNormal()
{
MeshIterator iter = getElements();
for( ; iter.haveMore() ; iter.next() )
{
iter.get()->getMesh()->addNormal();
}
}
void Object::updateAnimation( float dt )
{
for( MeshIterator iter = getElements();
iter.haveMore(); iter.next() )
{
iter.get()->getMaterial()->updateAnimation( dt );
}
}
int main() {
int n = getArraySize();
int a[n];
getElements(a, n);
bubbleSort(a, n);
displayArray(a, n);
return 0;
}
void Object::_cloneShareData()
{
MeshIterator iter = getElements();
for( ; iter.haveMore() ; iter.next() )
{
Element* ele = iter.get();
ele->getUnit().mesh = ele->getUnit().mesh->clone();
}
}
double
CoinPackedVectorBase::infNorm() const
{
register double norm = 0.0;
register const double* elements = getElements();
for (int i = getNumElements() - 1; i >= 0; --i) {
norm = CoinMax(norm, fabs(elements[i]));
}
return norm;
}
double
CoinPackedVectorBase::dotProduct(const double* dense) const
{
const double * elems = getElements();
const int * inds = getIndices();
double dp = 0.0;
for (int i = getNumElements() - 1; i >= 0; --i)
dp += elems[i] * dense[inds[i]];
return dp;
}
double
CoinPackedVectorBase::operator[](int i) const
{
if (!testedDuplicateIndex_)
duplicateIndex("operator[]", "CoinPackedVectorBase");
// Get a reference to a map of full storage indices to
// packed storage location.
const std::set< int > &sv = *indexSet("operator[]", "CoinPackedVectorBase");
#if 1
if (sv.find(i) == sv.end())
return 0.0;
return getElements()[findIndex(i)];
#else
// LL: suggested change, somthing is wrong with this
const size_t ind = std::distance(sv.begin(), sv.find(i));
return (ind == sv.size()) ? 0.0 : getElements()[ind];
#endif
}
double
CoinPackedVectorBase::oneNorm() const
{
double norm = 0.0;
const double *elements = getElements();
for (int i = getNumElements() - 1; i >= 0; --i) {
norm += fabs(elements[i]);
}
return norm;
}
void QLearning::learn(std::vector<unsigned int> &state_now, std::vector<unsigned int> &state_future, int &action_id, float &reward) {
// Get current qualities and experience
getElements(state_now);
float quality_now = q_vals_[action_id - 1];
unsigned int exp_now = exp_vals_[action_id - 1];
// Get future quality
getElements(state_future);
std::vector<float>::iterator quality_future = std::max_element(q_vals_.begin(), q_vals_.end());
// Exponentially decrease learning rate with experience [Unknown]
float alpha = this->alpha_max_/(float) exp(pow(exp_now, this->alpha_power_)/ this->alpha_denom_);
// Standard Q-learning update rule [Boutilier, 1999]
float quality_update = quality_now + alpha*(reward + (gamma_* *quality_future) - quality_now);
// Update tables
storeElements(state_now, quality_update, action_id);
}// end learn
int CoinPackedVectorBase::compare(const CoinPackedVectorBase &rhs) const
{
const int size = getNumElements();
int itmp = size - rhs.getNumElements();
if (itmp != 0) {
return itmp;
}
itmp = memcmp(getIndices(), rhs.getIndices(), size * sizeof(int));
if (itmp != 0) {
return itmp;
}
return memcmp(getElements(), rhs.getElements(), size * sizeof(double));
}
void Object::xform( bool beAllInstance )
{
Matrix4 const& trans = getLocalTransform();
MeshIterator iter = getElements();
for ( ; iter.haveMore() ; iter.next() )
{
MeshBase* mesh = iter.get()->getMesh();
iter.get()->getUnit().mesh = mesh->xform( trans , beAllInstance );
}
mLocalTrans.setIdentity();
}
void Object::updateBoundSphere()
{
mBoundSphere.center.setValue(0,0,0);
mBoundSphere.radius = 0;
MeshIterator iter = getElements();
for( ; iter.haveMore() ; iter.next() )
{
MeshBase* mesh = iter.get()->getMesh();
BoundSphere sphere;
mesh->calcBoundSphere( sphere );
mBoundSphere.merge( sphere );
}
}
TEST(MeshLib, ElementStatus)
{
const unsigned width (100);
const unsigned elements_per_side (20);
auto const mesh = std::unique_ptr<MeshLib::Mesh>{
MeshLib::MeshGenerator::generateRegularQuadMesh(width, elements_per_side)};
auto* const material_id_properties =
mesh->getProperties().createNewPropertyVector<int>(
"MaterialIDs", MeshLib::MeshItemType::Cell);
ASSERT_NE(nullptr, material_id_properties);
material_id_properties->resize(mesh->getNumberOfElements());
const std::vector<MeshLib::Element*> elements (mesh->getElements());
for (unsigned i=0; i<elements_per_side; ++i)
{
for (unsigned j=0; j<elements_per_side; ++j)
(*material_id_properties)[elements[i*elements_per_side + j]->getID()] = i;
}
{
// all elements and nodes active
MeshLib::ElementStatus status(mesh.get());
ASSERT_EQ (elements.size(), status.getNumberOfActiveElements());
ASSERT_EQ (mesh->getNumberOfNodes(), status.getNumberOfActiveNodes());
}
{
// set material 1 to false
std::vector<int> inactiveMat{1};
MeshLib::ElementStatus status(mesh.get(), inactiveMat);
ASSERT_EQ (elements.size()-elements_per_side, status.getNumberOfActiveElements());
}
{
// set material 0 and 1 to false
std::vector<int> inactiveMat{0, 1};
MeshLib::ElementStatus status(mesh.get(), inactiveMat);
ASSERT_EQ (elements.size()-(2*elements_per_side), status.getNumberOfActiveElements());
// active elements
auto &active_elements (status.getActiveElements());
ASSERT_EQ (active_elements.size(), status.getNumberOfActiveElements());
// active nodes
auto& active_nodes (status.getActiveNodes());
ASSERT_EQ (active_nodes.size(), status.getNumberOfActiveNodes());
}
}
double *
CoinPackedVectorBase::denseVector(int denseSize) const
{
if (getMaxIndex() >= denseSize)
throw CoinError("Dense vector size is less than max index",
"denseVector", "CoinPackedVectorBase");
double * dv = new double[denseSize];
CoinFillN(dv, denseSize, 0.0);
const int s = getNumElements();
const int * inds = getIndices();
const double * elems = getElements();
for (int i = 0; i < s; ++i)
dv[inds[i]] = elems[i];
return dv;
}
void writeConstantConstructor( std::stringstream& out, EGlslSymbolType t, TPrecision prec, TIntermConstant *c, GlslStruct *structure = 0 )
{
unsigned n_elems = getElements(t);
bool construct = n_elems > 1 || structure != 0;
if (construct) {
writeType (out, t, structure, EbpUndefined);
out << "(";
}
if (structure) {
// compound type
unsigned n_members = structure->memberCount();
for (unsigned i = 0; i != n_members; ++i) {
const GlslStruct::member &m = structure->getMember(i);
if (construct && i > 0)
out << ", ";
writeConstantConstructor (out, m.type, m.precision, c);
}
} else {
// simple type
unsigned n_constants = c->getCount();
for (unsigned i = 0; i != n_elems; ++i) {
unsigned v = Min(i, n_constants - 1);
if (construct && i > 0)
out << ", ";
switch (c->getBasicType()) {
case EbtBool:
out << (c->toBool(v) ? "true" : "false");
break;
case EbtInt:
out << c->toInt(v);
break;
case EbtFloat:
GlslSymbol::writeFloat(out, c->toFloat(v));
break;
default:
assert(0);
}
}
}
if (construct)
out << ")";
}
ColumnPtr FunctionArrayIntersect::castRemoveNullable(const ColumnPtr & column, const DataTypePtr & data_type) const
{
if (auto column_nullable = checkAndGetColumn<ColumnNullable>(column.get()))
{
auto nullable_type = checkAndGetDataType<DataTypeNullable>(data_type.get());
const auto & nested = column_nullable->getNestedColumnPtr();
if (nullable_type)
{
auto casted_column = castRemoveNullable(nested, nullable_type->getNestedType());
return ColumnNullable::create(casted_column, column_nullable->getNullMapColumnPtr());
}
return castRemoveNullable(nested, data_type);
}
else if (auto column_array = checkAndGetColumn<ColumnArray>(column.get()))
{
auto array_type = checkAndGetDataType<DataTypeArray>(data_type.get());
if (!array_type)
throw Exception{"Cannot cast array column to column with type "
+ data_type->getName() + " in function " + getName(), ErrorCodes::LOGICAL_ERROR};
auto casted_column = castRemoveNullable(column_array->getDataPtr(), array_type->getNestedType());
return ColumnArray::create(casted_column, column_array->getOffsetsPtr());
}
else if (auto column_tuple = checkAndGetColumn<ColumnTuple>(column.get()))
{
auto tuple_type = checkAndGetDataType<DataTypeTuple>(data_type.get());
if (!tuple_type)
throw Exception{"Cannot cast tuple column to type "
+ data_type->getName() + " in function " + getName(), ErrorCodes::LOGICAL_ERROR};
auto columns_number = column_tuple->getColumns().size();
Columns columns(columns_number);
const auto & types = tuple_type->getElements();
for (auto i : ext::range(0, columns_number))
{
columns[i] = castRemoveNullable(column_tuple->getColumnPtr(i), types[i]);
}
return ColumnTuple::create(columns);
}
return column;
}
void SmokeGenerator::_animate(int timerInterval)
{
static int remainingIntervals = 0;
static int i = 0;
if (remainingIntervals <= 0) {
vector<Element*>& elements = getElements();
Smoke* smoke = (Smoke*) elements[i];
smoke->setVisible(true);
smoke->setX(_sourceElement->x());
smoke->setY(_sourceElement->y());
smoke->setZ(_sourceElement->z());
smoke->setScaleWidth(1.0);
smoke->setScaleHeight(1.0);
smoke->setAlpha(1.0);
i = (i + 1) % _smokeNumber;
remainingIntervals = 45;
}
remainingIntervals--;
CompositeElement::_animate(timerInterval);
}
void CubeDimension::checkElements(PServer server, PDatabase database)
{
ElementsType elements = getElements(PUser(), false);
for (ElementsType::iterator i = elements.begin(); i != elements.end(); ++i) {
PCube cube = database->lookupCubeByName((*i)->getName(getElemNamesVector()), true);
if (!cube || (cube->getType() != NORMALTYPE && cube->getType() != GPUTYPE)) {
deleteElement(server, database, *i, PUser(), false, 0, false);
}
}
vector<CPCube> cubes = database->getCubes(PUser());
for (vector<CPCube>::iterator i = cubes.begin(); i != cubes.end(); ++i) {
if ((*i)->getType() == NORMALTYPE || (*i)->getType() == GPUTYPE) {
Element* element = lookupElementByName((*i)->getName(), false);
if (!element) {
addElement(server, database, NO_IDENTIFIER, (*i)->getName(), Element::STRING, PUser(), false);
}
}
}
}
double
CoinPackedVectorBase::normSquare() const
{
return std::inner_product(getElements(), getElements() + getNumElements(),
getElements(), 0.0);
}
std::vector<int> CRSSparsity::getElements(bool row_major) const{
std::vector<int> loc;
getElements(loc,row_major);
return loc;
}
const double *getObjectiveElements() {return getElements(this->getObjStart());}
const double *getRowElements(int irow){
if (this->has_matrix_)
return getElements(this->getMatStart()+irow-this->rowbeg_);
else
return NULL;
}
double
CoinPackedVectorBase::sum() const
{
return std::accumulate(getElements(), getElements() + getNumElements(), 0.0);
}
RESULT YandexNarodRVFSDriver::sync()
{
RESULT res = eERROR_GENERAL;
SettingStorage* settings = WebMounter::getSettingStorage();
QString pluginStoragePath = settings->getAppStoragePath() + QString(QDir::separator()) + m_pluginName;
QFileInfo fInfo(pluginStoragePath);
unsigned int uNotDownloaded = 0;
PluginSettings plSettings;
settings->getData(plSettings, m_pluginName);
m_driverMutex.lock();
if(m_state != eSyncStopping)
{
updateState(0, RemoteDriver::eSync);
}
m_driverMutex.unlock();
QList<VFSElement> elements;
VFSElement elem = VFSElement(VFSElement::DIRECTORY
, fInfo.absoluteFilePath()
, "ROOT"
, ""
, ""
, ""
, ROOT_ID
, ROOT_ID
, ""
, m_pluginName);
elements.append(elem);
res = getElements(elements);
if(!res)
{
QDir qDir;
QFile qFile;
uNotDownloaded = elements.count();
VFSCache* vfsCache = WebMounter::getCache();
VFSCache::iterator iter = vfsCache->begin();
for(iter; iter != vfsCache->end(); ++iter)
{
if(iter->getPluginName() == m_pluginName)
{
bool found = false;
int count = elements.count();
// Try to find element in new data
for(int i=0; i<count; i++)
{
if(iter->getId() == elements[i].getId())
{
found = true;
if(iter != elements[i])
{
if(iter->getType() == VFSElement::DIRECTORY)
{
qDir.rename(iter->getPath(), elements[i].getPath());
}
break;
}
elements.removeAt(i);
break;
}
}
// Element has been deleted
if(!found)
{
VFSCache::iterator iter1 = iter--;
vfsCache->erase(iter1);
}
}
}
{ LOCK(m_driverMutex);
if(m_state != eSyncStopping)
{
updateState(30, RemoteDriver::eSync);
}
}
// Add newly created elements
for(int i=0; i<elements.count(); i++)
{
vfsCache->insert(elements[i]);
}
{ LOCK(m_driverMutex);
if(m_state != eSyncStopping)
{
updateState(40, RemoteDriver::eSync);
}
}
QString rootPath = WebMounter::getSettingStorage()->getAppStoragePath() + QString(QDir::separator()) + m_pluginName;
QFileInfo fInfo(rootPath);
syncCacheWithFileSystem(fInfo.absoluteFilePath());
{ LOCK(m_driverMutex);
if(m_state != eSyncStopping)
{
updateState(50, RemoteDriver::eSync);
}
}
if(plSettings.m_fullSync)
{
res = downloadFiles();
}
}
if(res != eNO_ERROR)
{
stopPlugin();
notifyUser(Ui::Notification::eCRITICAL, tr("Error"), tr("Sync failed !\n"));
//updateState(100, RemoteDriver::eNotConnected);
}
else
{
m_driverMutex.lock();
if(m_state != eSyncStopping)
{
updateState(100, eConnected);
}
m_driverMutex.unlock();
}
return res;
}
RESULT YandexNarodRVFSDriver::uploadFile(const QString& path, const QString& title, const QString& /*Id*/, const QString& parentId)
{
QString xmlResp;
QString id = ROOT_ID;
QFileInfo fInfo(path);
RESULT err = m_httpConnector->uploadFile(path, title, parentId, xmlResp);
unsigned int retryUploadCounter = 0;
while(err != eNO_ERROR && retryUploadCounter < MAX_UPLOAD_RETRY)
{
err = m_httpConnector->uploadFile(path, title, parentId, xmlResp);
retryUploadCounter++;
}
VFSElement elem;
if(!err && xmlResp != "")
{
id = RegExp::getByPattern("\"fids\": \"(.*)\"", xmlResp);
if(id != "")
{
// Trying to get new element from server to retrieve the data-token
QList<VFSElement> elements;
err = getElements(elements);
if(err == eNO_ERROR)
{
int i=0;
for(i=0; i<elements.count(); i++)
{
if(elements[i].getId() == id)
break;
}
QString hash = RegExp::getByPattern("\"hash\": \"(.*)\",", xmlResp);
VFSCache* vfsCache = WebMounter::getCache();
elem = VFSElement(VFSElement::FILE
, fInfo.absoluteFilePath()
, title
, ""
, (i<elements.count() ? elements[i].getEditMediaUrl() : "")
, "http://narod.ru/disk/" + hash + "/" + fInfo.fileName() + ".html"
, id
, parentId
, ""
, m_pluginName);
vfsCache->insert(elem);
QFile::Permissions permissions = QFile::permissions(elem.getPath());
permissions &= ~(QFile::WriteGroup|QFile::WriteOwner|QFile::WriteUser|QFile::WriteOther);
QFile::setPermissions(elem.getPath(), permissions);
}
}
}
else
{
notifyUser(Ui::Notification::eCRITICAL
, tr("Error")
, tr("File upload failed (") + elem.getName() + QString(")"));
}
WebMounter::getProxy()->fileUploaded(fInfo.absoluteFilePath(), err);
return err;
}
