bool getentboundingbox(const extentity &e, ivec &o, ivec &r)
{
switch(e.type)
{
case ET_EMPTY:
return false;
case ET_MAPMODEL:
{
model *m = loadmapmodel(e.attrs[0]);
if(m)
{
vec center, radius;
mmboundbox(e, m, center, radius);
center.add(e.o);
radius.max(entselradius);
o = ivec(vec(center).sub(radius));
r = ivec(vec(center).add(radius).add(1));
break;
}
}
// invisible mapmodels use entselradius
default:
o = ivec(vec(e.o).sub(entselradius));
r = ivec(vec(e.o).add(entselradius+1));
break;
}
return true;
}
void pushCubeCorner(int x, int y, int z, int gridsize, int face, int corner, int direction)
{
if (!checkCubeCoords(x, y, z, gridsize))
{
logger::log(logger::ERROR, "Bad cube coordinates to pushCubeCorner: %d,%d,%d : %d\r\n", x, y, z, gridsize);
return;
}
assert(face >= 0 && face < 6);
assert(corner >= 0 && corner < 4);
selinfo sel;
sel.o = ivec(x, y, z);
sel.s = ivec(1, 1, 1);
sel.grid = gridsize;
sel.orient = face;
sel.corner = cornerTranslators[face][corner];
sel.cx = 0;
sel.cxs = 2;
sel.cy = 0;
sel.cys = 2;
mpeditface(direction, 2, sel, true);
}
void createCube(int x, int y, int z, int gridsize)
{
logger::log(logger::DEBUG, "createCube: %d,%d,%d -- %d\r\n", x, y, z, gridsize);
if (!checkCubeCoords(x, y, z, gridsize))
{
logger::log(logger::ERROR, "Bad cube coordinates to createCube: %d,%d,%d : %d\r\n", x, y, z, gridsize);
return;
}
// We simulate creating a cube by extruding from another, using mpeditface. This works even if there is no cube there to extrude from.
selinfo sel;
// We can either extrude from an imaginary cube from below, or from above. If there is room below, then extrude from there
if (z - gridsize >= 0)
{
sel.o = ivec(x, y, z - gridsize);
sel.orient = 5; // up
} else {
assert(z + gridsize < getworldsize());
sel.o = ivec(x, y, z + gridsize);
sel.orient = 4; // down
}
sel.s = ivec(1, 1, 1);
sel.grid = gridsize;
// Does it matter?
sel.corner = 1;
sel.cx = 0;
sel.cxs = 2;
sel.cy = 0;
sel.cys = 2;
mpeditface(-1, 1, sel, true);
}
void setCubeTexture(int x, int y, int z, int gridsize, int face, int texture)
{
if (!checkCubeCoords(x, y, z, gridsize))
{
logger::log(logger::ERROR, "Bad cube coordinates to setCubeTexture: %d,%d,%d : %d\r\n", x, y, z, gridsize);
return;
}
assert(face >= -1 && face < 6);
selinfo sel;
sel.o = ivec(x, y, z);
sel.s = ivec(1, 1, 1);
sel.grid = gridsize;
// Does it matter?
sel.orient = face != -1 ? face : 5;
sel.corner = 1;
sel.cx = 0;
sel.cxs = 2;
sel.cy = 0;
sel.cys = 2;
mpedittex(texture, face == -1, sel, true);
}
void setCubeColor(int x, int y, int z, int gridsize, float r, float g, float b)
{
if (!checkCubeCoords(x, y, z, gridsize))
{
logger::log(logger::ERROR, "Bad cube coordinates to setCubeMaterial: %d,%d,%d : %d\r\n", x, y, z, gridsize);
return;
}
selinfo sel;
sel.o = ivec(x, y, z);
sel.s = ivec(1, 1, 1);
sel.grid = gridsize;
// Does it matter?
sel.orient = 5;
sel.corner = 1;
sel.cx = 0;
sel.cxs = 2;
sel.cy = 0;
sel.cys = 2;
VSlot ds;
ds.changed = 1 << VSLOT_COLOR;
ds.colorscale = vec(
clamp(r, 0.0f, 1.0f),
clamp(g, 0.0f, 1.0f),
clamp(b, 0.0f, 1.0f)
);
mpeditvslot(ds, allfaces, sel, true);
}
void write_sparsebin(int nr, int nc, int **x, char *fname) //
{
int i, j, k, chk;
int NNZ = countNNZ(nr,nc,x);
int *col1 = ivec(NNZ);
int *col2 = ivec(NNZ);
int *col3 = ivec(NNZ);
FILE *fp = fopen(fname,"w"); assert(fp);
for (i = 0, k = 0; i < nr; i++)
for (j = 0; j < nc; j++)
if (x[i][j] > 0) {
col1[k] = i;
col2[k] = j;
col3[k] = x[i][j];
k++;
}
assert(k==NNZ);
fwrite(&nr, sizeof(int),1,fp);
fwrite(&nc, sizeof(int),1,fp);
fwrite(&NNZ,sizeof(int),1,fp);
chk = fwrite(col1,sizeof(int),NNZ,fp); assert(chk==NNZ);
chk = fwrite(col2,sizeof(int),NNZ,fp); assert(chk==NNZ);
chk = fwrite(col3,sizeof(int),NNZ,fp); assert(chk==NNZ);
fclose(fp);
free(col1);
free(col2);
free(col3);
}
void finalize()
{
center = vec(bbmin).add(bbmax).mul(0.5f);
radius = bbmin.dist(bbmax)/2;
cullmin = ivec(int(floor(bbmin.x)), int(floor(bbmin.y)), int(floor(bbmin.z)));
cullmax = ivec(int(ceil(bbmax.x)), int(ceil(bbmax.y)), int(ceil(bbmax.z)));
if(dbgpseed) spdlog::get("global")->debug("radius: {0}, maxfade: {1}", radius, maxfade);
}
void finalize()
{
center = vec(bbmin).add(bbmax).mul(0.5f);
radius = bbmin.dist(bbmax)/2;
bborigin = ivec(int(floor(bbmin.x)), int(floor(bbmin.y)), int(floor(bbmin.z)));
bbsize = ivec(int(ceil(bbmax.x)), int(ceil(bbmax.y)), int(ceil(bbmax.z))).sub(bborigin);
if(dbgpseed) conoutf(CON_DEBUG, "radius: %f, maxfade: %d", radius, maxfade);
}
void triPack2polygons(coOutputPort **packageOutPort, coDoPolygons **package,
trivec &triangles)
{
int tsize = triangles.size();
int num_coord = 3 * tsize;
f2ten coord = f2ten(3);
coord[0] = fvec(num_coord, 0.0);
coord[1] = fvec(num_coord, 0.0);
coord[2] = fvec(num_coord, 0.0);
int num_conn = num_coord;
ivec conn = ivec(num_conn);
int num_poly = tsize;
ivec poly = ivec(num_poly);
int i = 0;
for (; i < num_poly; i++)
{
poly[i] = 3 * i;
}
for (i = 0; i < num_conn; i++)
{
conn[i] = i;
}
for (i = 0; i < tsize; i++)
{
f2ten points = f2ten(2);
points[0] = fvec(3, 0.0);
points[1] = fvec(3, 0.0);
points = (triangles[i]).getC2d();
int j = 0;
for (; j < 3; j++)
{
coord[0][3 * i + j] = points[0][j];
coord[1][3 * i + j] = points[1][j];
}
}
//(*package)
(*package) = new coDoPolygons((*packageOutPort)->getObjName(), num_coord,
&coord[0][0], &coord[1][0], &coord[2][0],
num_conn, &conn[0],
num_poly, &poly[0]);
(*packageOutPort)->setCurrentObject(*package);
(*package)->addAttribute("vertexOrder", "2");
}
int main()
{
int ia[] = { 29,23,20,17,15,26,51,12,35,40,
74,16,54,21,44,62,10,41,65,71 };
vector< int, allocator > ivec( ia, ia+20 );
void (*pfi)( int ) = print_elements;
// place the two subsequences in sorted order
sort( &ia[0], &ia[10] );
sort( &ia[10], &ia[20] );
cout << "ia sorted into two sub-arrays: \n";
for_each( ia, ia+20, pfi ); cout << "\n\n";
inplace_merge( ia, ia+10, ia+20 );
cout << "ia inplace_merge:\n";
for_each( ia, ia+20, pfi ); cout << "\n\n";
sort( ivec.begin(), ivec.begin()+10, greater<int>() );
sort( ivec.begin()+10, ivec.end(), greater<int>() );
cout << "ivec sorted into two sub-vectors: \n";
for_each( ivec.begin(), ivec.end(), pfi ); cout << "\n\n";
inplace_merge( ivec.begin(), ivec.begin()+10,
ivec.end(), greater<int>() );
cout << "ivec inplace_merge:\n";
for_each( ivec.begin(), ivec.end(), pfi ); cout << endl;
}
void Ex9_26()
{
std::cout << "Exercise 9.26:" << std::endl;
int ia[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89};
std::vector<int> ivec(ia, ia + sizeof ia / sizeof ia[0]);
std::list<int> ilst(std::begin(ia), std::end(ia)); // C++11
auto it1 = ilst.begin();
while (it1 != ilst.end()) {
if (*it1 % 2 != 0) // odd
it1 = ilst.erase(it1);
else
++it1;
}
auto it2 = ivec.begin();
while (it2 != ivec.end()) {
if (*it2 % 2 == 0) // even
it2 = ivec.erase(it2);
else
++it2;
}
std::cout << "ivec: ";
for (auto it = ivec.cbegin(); it != ivec.cend(); ++it)
std::cout << *it << " ";
std::cout << "\nilst: ";
for (auto it = ilst.cbegin(); it != ilst.cend(); ++it)
std::cout << *it << " ";
std::cout << std::endl;
}
int main(int argc, char **argv) {
int ia[] = {0, 1, 1, 2, 3, 5, 8, 13, 21, 55, 89};
std::vector<int> ivec(ia, ia + 11);
std::list<int> lst(ia, ia + 11);
std::vector<int>::iterator iter_vec;
for (iter_vec = ivec.begin(); iter_vec != ivec.end(); ++iter_vec)
if (*iter_vec % 2 == 0) {
ivec.erase(iter_vec);
--iter_vec;
}
std::list<int>::iterator iter_list;
for (iter_list = lst.begin(); iter_list != lst.end(); ++iter_list)
if (*iter_list % 2 != 0) {
lst.erase(iter_list);
--iter_list;
}
iter_vec = ivec.begin();
while (iter_vec != ivec.end()) {
std::cout << *iter_vec << " ";
++iter_vec;
}
std::cout << std::endl;
iter_list = lst.begin();
while (iter_list != lst.end()) {
std::cout << *iter_list << " ";
++iter_list;
}
std::cout << std::endl;
}
main()
{
ivec(alltraps);
asm(STI);
while(1) asm(IDLE);
asm(HALT);
}
void TestHeap::testCase1() {
int ia[9] = {0,1,2,3,4,8,9,3,5};
Vector<int> ivec(ia, ia+9);
makeHeap(ivec.begin(), ivec.end());
for(int i=0; i<ivec.size(); ++i)
std::cout << ivec[i] << ' ';
// 9 5 8 3 4 0 2 3 1
std::cout << std::endl;
ivec.push_back(7);
pushHeap(ivec.begin(), ivec.end());
for(int i=0; i<ivec.size(); ++i)
std::cout << ivec[i] << ' ';
// 9 7 8 3 5 0 2 3 1 4
std::cout << std::endl;
popHeap(ivec.begin(), ivec.end());
std::cout << ivec.back() << std::endl;
// 9. return but no remove.
ivec.pop_back();
// remove last elem and no return
for(int i=0; i<ivec.size(); ++i)
std::cout << ivec[i] << ' ';
std::cout << std::endl;
// 8 7 4 3 5 0 2 3 1
sortHeap(ivec.begin(), ivec.end());
for(int i=0; i<ivec.size(); ++i)
std::cout << ivec[i] << ' ';
// 0 1 2 3 3 4 5 7 8
std::cout << std::endl;
std::cout << "case1 passed" << std::endl;
}
int main(int argc, char const *argv[])
{
int array[] = {0,1,2,3,4,5,6,7,8,9};
std::vector<int> ivec(array, array + 10);
int sum = std::accumulate(ivec.begin(), ivec.end(), 0);
std::cout << sum << std::endl;
return 0;
}
/*==========================================
* main
*========================================== */
int main(int argc, char* argv[])
{
int i, t, d, **dt, dtot;
//double alpha;
char **doc;
FILE *fp;
int *prob_t_given_d, *indx;
int T; // number of topics
int D; // number of docs
if (argc != 1) {
fprintf(stderr, "usage: %s\n", argv[0]);
exit(-1);
}
dt = read_sparse("Ndt.txt",&D,&T); assert(D>0); assert(T>0);
fp = fopen("docs.txt","r"); assert(fp);
doc = (char**)malloc(D*sizeof(char*)); assert(doc);
for (d = 0; d < D; d++) {
doc[d] = (char*)malloc(100*sizeof(char));
fscanf(fp,"%s",doc[d]);
}
fclose(fp);
prob_t_given_d = ivec(T);
indx = ivec(T);
for (d = 0; d < D; d++) {
printf("<%s> ", doc[d]);
dtot = 0;
for (t = 0; t < T; t++) { prob_t_given_d[t] = dt[d][t]; dtot += dt[d][t]; }
isort(T, prob_t_given_d, -1, indx);
for (i = 0; i < 4; i++) {
if ((1.0*dt[d][indx[i]])/dtot > 0.1)
printf("t%d ", indx[i]+1);
}
printf("\n");
}
return 0;
}
int main(int argc, char const *argv[])
{
int array[] = {0,1,2,3,1,2,3,1};
std::vector<int> ivec(array, array + 8);
std::vector<int>::iterator it = MostFrequently(ivec.begin(), ivec.end());
std::cout << *it << std::endl;
return 0;
}
int main()
{
// Sequence creation
std::vector<int> ilvec = initialize<int>();
std::vector<int> ivec(ilvec.cbegin(), ilvec.cend());
constexpr int arr_sz(11);
ilvec = initialize<int>(arr_sz);
std::array<int, arr_sz> ilarr({1,2,3,4,5,6,7,8,9,50,61});
ilvec = initialize<int>();
std::list<int> ilst(ilvec.cbegin(), ilvec.cend());
ilvec = initialize<int>();
std::forward_list<int> iflst(ilvec.cbegin(), ilvec.cend());
ilvec = initialize<int>();
std::deque<int> ideq(ilvec.cbegin(), ilvec.cend());
int iarr[]{1, 2, 3, 6, 5, 4, 3, 44, 5, 232, 45, 76, 654, 96, 687, 4, 65, 89,343, 23};
// Print
print(ivec, "ivec");
print(ilarr, "ilarr");
print(ilst, "ilst");
print(iflst, "iflst");
print(ideq, "ideq");
print(iarr, "iarr");
// Use algorithms
int val1 = 85, val2 = 54;
std::cout << "sum = " << std::accumulate(ivec.cbegin(), ivec.cend(), 0) << std::endl;
std::cout << "difference = " << std::accumulate(ideq.cbegin(), ideq.cend(), 10, diff<int>) << std::endl;
std::cout << "inner product = " << std::inner_product(ilarr.cbegin(), ilarr.cend(),ilst.cbegin(), 0) << std::endl;
std::cout << "custom inner product = " << std::inner_product(iflst.cbegin(), iflst.cend(), std::begin(iarr), 777, mod<int>, diff<int>) << std::endl;
std::vector<int> cpy(ilst.size()), cpy1(ivec.size());
std::partial_sum(ilst.cbegin(), ilst.cend(), cpy.begin());
print(cpy, "cpy");
std::partial_sum(ivec.cbegin(), ivec.cend(), cpy1.begin(), diff<int>);
print(cpy1, "cpy1");
std::vector<int> cpy2(arr_sz), cpy3(20);
std::adjacent_difference(ilarr.cbegin(), ilarr.cend(), cpy2.begin());
print(cpy2, "cpy2");
std::adjacent_difference(std::begin(iarr), std::end(iarr), cpy3.begin(), mod<int>);
print(cpy3, "cpy3");
print(iflst, "iflst");
std::iota(iflst.begin(), iflst.end(), val1);
print(iflst, "iflst");
return 0;
}
const glsl_type *
glsl_type::get_instance(unsigned base_type, unsigned rows, unsigned columns)
{
if (base_type == GLSL_TYPE_VOID)
return void_type;
if ((rows < 1) || (rows > 4) || (columns < 1) || (columns > 4))
return error_type;
/* Treat GLSL vectors as Nx1 matrices.
*/
if (columns == 1) {
switch (base_type) {
case GLSL_TYPE_UINT:
return uvec(rows);
case GLSL_TYPE_INT:
return ivec(rows);
case GLSL_TYPE_FLOAT:
return vec(rows);
case GLSL_TYPE_BOOL:
return bvec(rows);
default:
return error_type;
}
} else {
if ((base_type != GLSL_TYPE_FLOAT) || (rows == 1))
return error_type;
/* GLSL matrix types are named mat{COLUMNS}x{ROWS}. Only the following
* combinations are valid:
*
* 1 2 3 4
* 1
* 2 x x x
* 3 x x x
* 4 x x x
*/
#define IDX(c,r) (((c-1)*3) + (r-1))
switch (IDX(columns, rows)) {
case IDX(2,2): return mat2_type;
case IDX(2,3): return mat2x3_type;
case IDX(2,4): return mat2x4_type;
case IDX(3,2): return mat3x2_type;
case IDX(3,3): return mat3_type;
case IDX(3,4): return mat3x4_type;
case IDX(4,2): return mat4x2_type;
case IDX(4,3): return mat4x3_type;
case IDX(4,4): return mat4_type;
default: return error_type;
}
}
assert(!"Should not get here.");
return error_type;
}
vector<vector<int> > generate(int numRows) {
vector<vector<int> > tri;
for(int i=0; i<numRows; ++i) {
vector<int> ivec(i+1, 1);
for(int j=1; j<i; ++j)
ivec[j] = tri[i-1][j-1] + tri[i-1][j];
tri.push_back(ivec);
}
return tri;
}
VImage
VImage::composite( VImage other, VipsBlendMode mode, VOption *options )
{
VImage v[2] = { *this, other };
std::vector<VImage> ivec( v, v + VIPS_NUMBER( v ) );
int m[1] = { static_cast<int>( mode ) };
std::vector<int> mvec( m, m + VIPS_NUMBER( m ) );
return( composite( ivec, mvec, options ) );
}
//------------------------------------------------------------------------------
OrbitalEquation::OrbitalEquation(Config *cfg,
vector<bitset<BITS> > slaterDeterminants,
Interaction *V,
SingleParticleOperator *h):
cfg(cfg)
{
this->slaterDeterminants = slaterDeterminants;
this->V = V;
this->h = h;
try {
nParticles = cfg->lookup("system.nParticles");
nGrid = cfg->lookup("spatialDiscretization.nGrid");
nOrbitals = cfg->lookup("spatialDiscretization.nSpatialOrbitals");
} catch (const SettingNotFoundException &nfex) {
cerr << "OrbitalEquation::Error reading from config object." << endl;
exit(EXIT_FAILURE);
}
nSlaterDeterminants = slaterDeterminants.size();
invRho = cx_mat(nOrbitals, nOrbitals);
U = zeros<cx_mat>(nGrid, nOrbitals);
rightHandSide = zeros<cx_mat>(nGrid, nOrbitals);
// Q = cx_mat(nGrid, nGrid);
rho1 = zeros<cx_mat>(2*nOrbitals, 2*nOrbitals); // TMP
myRank = 0;
nNodes = 1;
#ifdef USE_MPI
// MPI-------------------------------------------
MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
MPI_Comm_size(MPI_COMM_WORLD, &nNodes);
#endif
sizeRij = ivec(nNodes);
int tot = nGrid*nOrbitals;
allRH = imat(nGrid, nOrbitals);
int node = 0;
int s = 0;
for (int j = 0; j < nOrbitals; j++) {
for (int i = 0; i < nGrid; i++) {
if (myRank == node){
myRij.push_back(pair<int, int>(i,j));
}
allRH(i,j) = node;
s++;
if(s >= BLOCK_SIZE(node, nNodes, tot)){
sizeRij(node) = BLOCK_SIZE(node, nNodes, tot);
s = 0;
node++;
}
}
}
}
void main() {
current = 0;
asm(CLI);
timeout(1000);
ivec(timetraps);
asm(STI);
while (current < 10) { }
halt(0);
}
int main(int argc, char const *argv[])
{
int array[] = {0,1,2,3,4,5,6,7,8,9};
std::vector<int> ivec(array, array + 10);
std::list<int> ilist(ivec.rbegin() + 3, ivec.rend() - 2);
for (std::list<int>::iterator it = ilist.begin(); it != ilist.end(); ++it)
{
std::cout << *it << std::endl;
}
return 0;
}
Triangles::Triangles()
{
id = 0;
packed = false;
nodes = ivec();
edges = i2ten();
coord = f2ten();
neighbours = i2ten();
vdata = f2ten();
c2d = f2ten();
}
void Triangles::setNodes(ivec n)
{
int size = n.size();
nodes = ivec(size);
for (int i = 0; i < size; i++)
{
nodes[i] = n[i];
}
return;
}
void isort(int n, int *x, int direction, int *indx) //
{
int i;
assert(direction*direction==1);
icomp_vec = ivec(n);
for (i = 0; i < n; i++) {
icomp_vec[i] = direction*x[i];
indx[i] = i;
}
qsort(indx,n,sizeof(int),icomp);
free(icomp_vec);
}
void test_mode() {
int_gen_t igen(-2, 2);
std::vector<int> ivec(10, 0);
std::for_each(begin(ivec), end(ivec),
[&](int& i) {
i = igen();
});
print_container<decltype(begin(ivec)), int>(begin(ivec), end(ivec));
auto mode = find_mode<decltype(begin(ivec)), int>(begin(ivec), end(ivec));
cout << "\nMode of this array: " << mode << endl;
}
int *dsort(int n, double *x) //
{
int *indx = ivec(n);
int i;
dcomp_vec = dvec(n);
for (i = 0; i < n; i++) {
dcomp_vec[i] = -x[i];
indx[i] = i;
}
qsort(indx,n,sizeof(int),dcomp);
free(dcomp_vec);
return indx;
}
int main(int argc, char const *argv[])
{
std::vector<int> ivec(9, 8);
std::vector<double> dvec(8, 9.9);
std::vector<char> cvec(7, 'h');
std::cout << count(ivec, 8) << std::endl;
std::cout << count(dvec, 9.9) << std::endl;
std::cout << count(cvec, 'h') << std::endl;
std::vector<std::string> svec(6, "hey");
std::cout << count(svec, std::string("hey")) << std::endl;
return 0;
}
