int main(int argc, char *argv[])
{
setIO("Peak");
read(n);read(m);read(Q);
for(int i = 1;i<=n;i++)
read(val[i]),sz[i] = 1,f[i] = i;
for(int i = 1;i<=m;i++)
read(b[i].C[0]),read(b[i].C[1]),read(b[i].C[2]);
sort(b+1,b+1+m);
for(int i = 1;i<=Q;i++)
read(c[i].C[0]),read(c[i].C[2]),read(c[i].C[1]),c[i].C[3]=i;
sort(c+1,c+1+Q);
int l = 1;
for(int i = 1;i<=Q;i++)
{
while(l <= m && b[l].C[2] <= c[i].C[2])
{
int x = b[l].C[0],y = b[l].C[1];
if(gf(x) != gf(y))
Union(x,y);
l++;
}
splay(c[i].C[0]);
ans[c[i].C[3]] = fkt(c[i].C[0],c[i].C[1]);
}
for(int i = 1;i<=Q;i++)
printf("%d\n",ans[i]);
closeIO();
return EXIT_SUCCESS;
}
TEST_F(TwoIndexGFTest,access)
{
alps::gf::matsubara_index omega; omega=4;
alps::gf::index sigma(1);
gf(omega, sigma)=std::complex<double>(3,4);
std::complex<double> x=gf(omega,sigma);
EXPECT_EQ(3, x.real());
EXPECT_EQ(4, x.imag());
}
TEST_F(ThreeIndexTestGF,access)
{
alps::gf::matsubara_index omega; omega=4;
alps::gf::momentum_index i; i=2;
alps::gf::index sigma(1);
gf(omega, i,sigma)=std::complex<double>(3,4);
std::complex<double> x=gf(omega,i,sigma);
EXPECT_EQ(3, x.real());
EXPECT_EQ(4, x.imag());
}
void Demo() {
const int nspins=2;
const int nfreq=10;
const double beta=5;
// Construct the meshes:
g::matsubara_positive_mesh m_mesh(beta, nfreq);
g::momentum_index_mesh k_mesh(generate_momentum_mesh());
g::index_mesh s_mesh(nspins);
// construct a GF using a pre-defined convenience type
g::omega_k_sigma_gf gf(m_mesh, k_mesh, s_mesh);
// initialize a GF to all-zeros
gf.initialize();
// Make indices:
g::matsubara_index omega;
omega=4;
g::momentum_index ii(2);
g::index sigma(0);
// Assign a GF element:
gf(omega,ii,sigma)=std::complex<double>(3,4);
// Density matrix as a double-valued GF
// on momentum and integer-index space:
typedef
g::two_index_gf<double, g::momentum_index_mesh, g::index_mesh>
density_matrix_type;
// Construct the object:
density_matrix_type denmat=density_matrix_type(k_mesh,s_mesh);
// prepare diagonal matrix
const double U=3.0;
denmat.initialize();
// loop over first mesh index:
for (g::momentum_index i=g::momentum_index(0);
i<denmat.mesh1().extent(); ++i) {
denmat(i,g::index(0))=0.5*U;
denmat(i,g::index(1))=0.5*U;
}
// construct a tailed GF using predefined convenience type:
g::omega_k_sigma_gf_with_tail gft(gf);
gft.set_tail(0, denmat); // set the tail
density_matrix_type gftail=gft.tail(0); // retrieve the tail
// access the tailed GF element
std::complex<double> x=gft(omega,ii,sigma);
}
virtual void go() {
release();
param *p = param::instance();
update_values(p);
Iso_rectangle_2 bbox = get_bbox(p);
std::string ndvi_file = p->get<boost::filesystem::path>("ndvi").string();
std::string dsm_file = p->get<boost::filesystem::path>("dsm" ).string();
clip_bbox(bbox,ndvi_file);
clip_bbox(bbox,dsm_file );
gradient_functor gf(p->get<double>("sigmaD"));
oriented_gradient_view grad_view(dsm_file, bbox, gf);
oriented_ndvi_view ndvi_view(ndvi_file, bbox);
m_confg_visitor->add_layer(ndvi_file);
m_confg_visitor->add_layer(dsm_file);
set_bbox(p,bbox);
wxPoint p0(wxCoord(bbox.min().x()),wxCoord(bbox.min().y()));
wxPoint p1(wxCoord(bbox.max().x()),wxCoord(bbox.max().y()));
m_confg_visitor->set_bbox(wxRect(p0,p1));
init_visitor (p,*m_visitor);
create_configuration(p,grad_view,ndvi_view,m_config);
create_sampler (p,m_sampler);
create_schedule (p,m_schedule);
create_end_test (p,m_end_test);
m_thread = new boost::thread(
simulated_annealing::optimize<configuration,sampler,schedule,end_test,visitor>,
boost::ref(*m_config), boost::ref(*m_sampler),
boost::ref(*m_schedule), boost::ref(*m_end_test),
boost::ref(*m_visitor) );
}
void object::test<7>()
{
GeomPtr geom;
try
{
// use FLOATING model
namespace ggm = geos::geom;
namespace gio = geos::io;
ggm::PrecisionModel pm(ggm::PrecisionModel::FLOATING);
ggm::GeometryFactory gf(&pm);
gio::WKTReader wktReader(&gf);
const std::string str = " POINT (0 0) ";
geom.reset(wktReader.read(str)); //HERE IT FAILS
geos::geom::CoordinateSequence *coords = geom->getCoordinates();
ensure_equals(coords->getDimension(), 2U);
ensure_distance(coords->getX(0), 0.0, 1e-12);
ensure_distance( coords->getY(0), 0.0, 1e-12);
delete coords;
}
catch (const geos::util::IllegalArgumentException& ex)
{
ensure( "Did get expected exception" );
ex.what();
}
catch (...)
{
ensure( !"Got unexpected exception" );
}
}
double pfijo(double x0, double es, double *ea, int imax, int *iter, int tabla)
{
double xr=x0, xrold;
if(tabla == 1)
{
printf ("\n\n| i | Raiz | ea | f(xr) | \n");
printf ("______________________________________________________\n");
}
*iter = 0;
do{
xrold = xr;
xr = gf(xrold);
*iter=*iter+1;
if(xr!=0)
{
*ea=fabs((xr-xrold)/xr)*100;
}
if ( tabla == 1 ) {
printf ("| %2d | %12.8f | %12.8f | %12.8f |\n", *iter, xr, *ea, f(xr) );
}
}while(es < *ea && *iter <= imax);
if ( tabla == 1 ) {
printf ("\n\nLa Raiz es %6.4lf en %d iteraciones\n",xr,*iter);
printf ("\n\nEl error relativo aproximado es %6.4lf\n",*ea);
return 0;
}
else
return xr;
}
TEST_F(TwoIndexGFTest,scaling)
{
alps::gf::matsubara_index omega; omega=4;
alps::gf::index sigma(1);
gf(omega,sigma)=std::complex<double>(3,4);
gf *= 2.;
std::complex<double> x=gf(omega,sigma);
EXPECT_NEAR(6, x.real(),1.e-10);
EXPECT_NEAR(8, x.imag(),1.e-10);
alps::gf::omega_sigma_gf gf1=gf/2;
std::complex<double> x1=gf1(omega,sigma);
EXPECT_NEAR(3, x1.real(),1.e-10);
EXPECT_NEAR(4, x1.imag(),1.e-10);
}
// ######################################################################
void IpcInputFrameSeries::
onSimEventClockTick(SimEventQueue& q, rutz::shared_ptr<SimEventClockTick>& e)
{
static int first_sim_event_clock = 1;
if(first_sim_event_clock)
{
Image< PixRGB<byte> > rgbimg(Dims(image_width, image_height), ZEROS);
GenericFrame gf(rgbimg);
rutz::shared_ptr<SimEventInputFrame>
ev(new SimEventInputFrame(this, gf, 0));
q.post(ev);
first_sim_event_clock = 0;
}
if(has_new_frame)
{
has_new_frame = 0;
if (frame.initialized())
{
rutz::shared_ptr<SimEventInputFrame>
ev(new SimEventInputFrame(this, frame, frame_counter));
q.post(ev);
}
}
}
GenericFrame convert_disparity_message_to_generic_frame(carmen_simple_stereo_disparity_message* message)
{
Image< PixRGB<byte> > rgbimg(Dims(image_width, image_height), ZEROS);
get_depth_map_from_disparity_map(message->disparity, temp_depth_map, camera_instance, 50.0);
for(int i = 0; i < (image_width * image_height); i++)
{
temp_disparity_map[i] = message->disparity[i];
if(i > (image_width * 170) && i < ( image_width * (image_height - 110)) && temp_depth_map[i] <= 12000)
{
//temp_depth_map[i] = 12000.0 - temp_depth_map[i];
rgbimg[i].p[0] = message->reference_image[3 * i];
rgbimg[i].p[1] = message->reference_image[3 * i + 1];
rgbimg[i].p[2] = message->reference_image[3 * i + 2];
}
else
{
temp_depth_map[i] = 0.0;
rgbimg[i].p[0] = message->reference_image[3 * i] = 0.0;
rgbimg[i].p[1] = message->reference_image[3 * i + 1] = 0.0;
rgbimg[i].p[2] = message->reference_image[3 * i + 2] = 0.0;
}
}
Image<unsigned short> depthimg(temp_depth_map, Dims(image_width, image_height));
GenericFrame gf(rgbimg, depthimg);
return gf;
}
int main(){
GraphFile gf("/tmp/");
gf.init(3,6,11);
printf("Total graphs: %llu\n", gf.get_total_graphs());
int pos;
while (1){
printf("Enter position: ");
scanf("%d", &pos);
if (pos == -1) break;
gf.seek_to(pos);
gf.get_y();
printf("Current position: %llu\n\n", gf.get_current_pos());
}
}
static inline
function_type build(cproc_type proc, const function_type &F )
{
const function_type G(proc);
composition gf(G,F);
return function_type(gf);
}
TEST_F(ThreeIndexTestGF,scaling)
{
alps::gf::momentum_index i; i=2;
alps::gf::index sigma(1);
alps::gf::matsubara_index omega; omega=4;
gf(omega,i,sigma)=std::complex<double>(3,4);
gf *= 2.;
std::complex<double> x=gf(omega,i,sigma);
EXPECT_NEAR(6, x.real(),1.e-10);
EXPECT_NEAR(8, x.imag(),1.e-10);
gf_type gf1=gf/2;
std::complex<double> x1=gf1(omega,i,sigma);
EXPECT_NEAR(3, x1.real(),1.e-10);
EXPECT_NEAR(4, x1.imag(),1.e-10);
}
//! Output stream operator for GFX
ostream &operator<<(ostream &os, const gfx &ingfx)
{
int terms=0;
for (int i=0; i<ingfx.degree+1; i++) {
if (ingfx.coeffs[i] != gf(ingfx.q,-1) ) {
if (terms != 0) os << " + ";
terms++;
if (ingfx.coeffs[i] == gf(ingfx.q,0) ) {// is the coefficient an one (=alpha^0=1)
os << "x^" << i;
} else {
os << ingfx.coeffs[i] << "*x^" << i;
}
}
}
if (terms == 0) os << "0";
return os;
}
int main(int argc, char *argv[])
{
setIO("sample");CLEAR(st,0xff);st[0] = 0;
int64 n=gi,m = gi,q=gi;s = gi;
for(int64 i = 1;i<=n;++i) a[i] = gi;
for(int64 i = 1,x,y,z;i<=m;++i) x = gi,y=gi,z = gi,add(x,y,z);
tot = n;sort(e+1,e+tote+1);
for(int64 i = 1,u,v;i<=tote;++i)
{
u = gf(e[i].u);v = gf(e[i].v);
if(u == v) continue;++tot;w[tot] = e[i].w;add2(u,tot);add2(tot,u);add2(v,tot);add2(tot,v);fa[u] = tot;fa[v] = tot;
}
qu[SIZE(qu)=1] = tot;
for(int64 i = 1,u;i<=SIZE(qu);++i)
TRA(x,u=qu[i])
{
int64 v = lk[x].v;f[v][0] = u;++SIZE(qu);qu[SIZE(qu)] = v;lk[x^1].f = 1;
}
int kruskal()
{
qsort(e+1,cntE,sizeof(e[0]),cmp);
memset(father,0,sizeof(father));
memset(apr,0,sizeof(apr));
int ans=0;
for(int i=1;i<=cntE;i++)
{
int fx = gf(e[i] .x);
int fy = gf(e[i] .y);
if(fx != fy)
{
ans += e[i] .len;
father[fx] = fy;
apr[e[i].x] = apr[e[i].y] = true;
}
}
return ans;
}
TEST_F(TwoIndexGFTest,init)
{
alps::gf::matsubara_index omega; omega=4;
alps::gf::index sigma(1);
gf.initialize();
std::complex<double> x=gf(omega,sigma);
EXPECT_EQ(0, x.real());
EXPECT_EQ(0, x.imag());
}
void UploadWindow::paint(Graphics& g)
{
g.fillAll(Colours::black);
Colour border = Colours::wheat;
juce::Rectangle<int> rc(0, 0, getWidth(), getHeight());
for (int i = 0; i < 4; i++)
{
g.setColour(i == 0 ? Colours::black : border);
g.drawRect(rc.getX(), rc.getY(), rc.getWidth(), rc.getHeight());
rc.reduce(1, 1);
border = border.brighter(0.4f);
}
ColourGradient gf(Colours::red, 0, getHeight()/2.0f, Colours::darkred, float(getWidth()), getHeight()/2.0f, false);
FillType ft(gf);
int cx = getWidth() / 2;
int cy = getHeight() / 2;
const float r = 12.0f;
for (int i = 3; i >= 0; i--)
{
if (i % 2 != 0)
g.setFillType(ft);
else
g.setColour(Colours::white);
g.fillEllipse(cx - (r * i), cy - (r * i), (r * i) * 2, (r * i) * 2);
}
g.setFillType(Colours::transparentWhite);
if (smugMug.isUploading())
{
int64 n = smugMug.getTotalbytesUploaded();
int64 d = smugMug.getTotalBytesToUpload();
double percent = (d == 0) ? 0 : (double(n)/double(d)*100);
GlyphArrangement glyphs;
glyphs.addLineOfText(Font(25.0f, Font::bold), String(percent, 1) + ("%"), 0, 0);
Path p;
glyphs.createPath(p);
juce::Rectangle<float> bounds = p.getBounds();
float cx = getWidth() / 2.0f - bounds.getWidth() / 2.0f - bounds.getX();
float cy = getHeight() / 2.0f - bounds.getHeight() / 2.0f - bounds.getY();
AffineTransform trans = AffineTransform::translation(cx, cy);
g.setColour(Colours::black);
g.fillPath(p, trans);
g.setColour(Colours::white);
g.strokePath(p, PathStrokeType(1), trans);
}
}
TEST_F(ThreeIndexTestGF,init)
{
alps::gf::matsubara_index omega; omega=4;
alps::gf::momentum_index i; i=2;
alps::gf::index sigma(1);
gf.initialize();
std::complex<double> x=gf(omega,i,sigma);
EXPECT_EQ(0, x.real());
EXPECT_EQ(0, x.imag());
}
static PyObject*
_gf(PyObject* self, PyObject* o)
{
double d = PyFloat_AsDouble(o);
K kobj = gf(d);
if (!kobj) {
PyErr_SetString(PyExc_RuntimeError, "gf returned NULL");
return NULL;
}
return _mk_K(kobj);
}
TEST_F(TwoIndexGFTest,Assign)
{
namespace g=alps::gf;
g::omega_sigma_gf other_gf(matsubara_mesh(beta, nfreq*2), g::index_mesh(nspins));
const g::matsubara_index omega(4);
const g::index sigma(0);
const std::complex<double> data(3,4);
gf(omega,sigma)=data;
gf2=gf;
EXPECT_EQ(data, gf2(omega,sigma));
EXPECT_THROW(other_gf=gf, std::invalid_argument);
// EXPECT_EQ(data, other_gf(omega,sigma));
}
int main() {
Transport::GraphFactory gf("/vagrant/dev/yooo/graph.txt-dump", false);
gf.setAll2();
const Transport::Graph * gr = gf.get();
cout << my_map.size() << endl;
return 0;
}
void gen_CLASS (node_t *root, int scopedepth)
{
currentClass = root->label;
for(int i = 0; i < root->n_children; i++) {
node_t *child = root->children[i];
if(child != NULL) {
child->generate(child, scopedepth);
}
}
currentClass = NULL;
gf(root, scopedepth);
}
bool Cartridge::load_file(const char *fn, uint8 *&data, unsigned &size, CompressionMode compression) const {
if(file::exists(fn) == false) return false;
Reader::Type filetype = Reader::Normal;
if(compression == CompressionInspect) filetype = Reader::detect(fn, true);
if(compression == CompressionAuto) filetype = Reader::detect(fn, snes.config.file.autodetect_type);
switch(filetype) { default:
case Reader::Normal: {
FileReader ff(fn);
if(!ff.ready()) return false;
size = ff.size();
data = ff.read();
} break;
#ifdef GZIP_SUPPORT
case Reader::GZIP: {
GZReader gf(fn);
if(!gf.ready()) return false;
size = gf.size();
data = gf.read();
} break;
case Reader::ZIP: {
ZipReader zf(fn);
if(!zf.ready()) return false;
size = zf.size();
data = zf.read();
} break;
#endif
#ifdef JMA_SUPPORT
case Reader::JMA: {
try {
JMAReader jf(fn);
size = jf.size();
data = jf.read();
} catch(JMA::jma_errors jma_error) {
return false;
}
} break;
#endif
}
return true;
}
TEST_F(GreensFunctionTailTest, TailSaveLoad)
{
typedef gfns::greenf<std::complex<double>, gfns::matsubara_mesh<gfns::mesh::POSITIVE_ONLY>, gfns::index_mesh> omega_sigma_gf;
typedef gfns::gf_tail<omega_sigma_gf, gfns::greenf<double, gfns::index_mesh> > omega_sigma_gf_with_tail;
typedef gfns::greenf<double, gfns::index_mesh> density_matrix_type;
density_matrix_type denmat = density_matrix_type(gfns::index_mesh(nspins));
omega_sigma_gf gf(gfns::matsubara_positive_mesh(beta,nfreq), alps::gf::index_mesh(nspins));
// prepare diagonal matrix
double U=3.0;
denmat.initialize();
denmat(gfns::index(0))=0.5*U;
denmat(gfns::index(1))=0.5*U;
// Attach a tail to the GF
int order=0;
omega_sigma_gf_with_tail gft(gf);
omega_sigma_gf_with_tail gft2(gft);
EXPECT_EQ(gfns::TAIL_NOT_SET,gft.min_tail_order());
EXPECT_EQ(gfns::TAIL_NOT_SET,gft.max_tail_order());
gft.set_tail(order, denmat);
EXPECT_EQ(0,gft.min_tail_order());
EXPECT_EQ(0,gft.max_tail_order());
EXPECT_EQ(0,(denmat - gft.tail(0)).norm());
{
alps::hdf5::archive oar("gf_2i_tailsaveload.h5","w");
gft(gfns::matsubara_index(4),gfns::index(1))=std::complex<double>(7., 3.);
oar["/gft"] << gft;
}
{
alps::hdf5::archive iar("gf_2i_tailsaveload.h5");
iar["/gft"] >> gft2;
}
EXPECT_EQ(gft2.tail().size(), gft.tail().size()) << "Tail size mismatch";
EXPECT_NEAR(0, (gft.tail(0)-gft2.tail(0)).norm(), 1E-8)<<"Tail loaded differs from tail stored";
EXPECT_EQ(7, gft2(gfns::matsubara_index(4), gfns::index(1)).real()) << "GF real part mismatch";
EXPECT_EQ(3, gft2(gfns::matsubara_index(4), gfns::index(1)).imag()) << "GF imag part mismatch";
}
main(int argc, char* argv[])
{
string ausgabe="./";
int NX=256;
int NY=256; //
double rpipe=0.02; // was 0.02
double rbeam=0.02; // 2*rms
double ne=5.0e12; // was 5.0e12 SPS 1.0e13 LHC
double dx=1.1*2.0*rpipe/(NX-1.0);
double dy=1.1*2.0*rpipe/(NY-1.0);
double rho0=qe*ne; // ion charge density (KV,dc)
// Timer
clock_t t1,t2;
float tf;
string data_dir=ausgabe;
data_dir=data_dir + "/";
Grid2D rho_xy(NX,NY,dx,dy,data_dir + "rho_xy.dat");
Grid2D pot_xy(NX,NY,dx,dy,data_dir + "pot_xy.dat");
init_rho(rho_xy,rho0,rbeam);
Greenfb gf(rho_xy,1.1*rpipe,rpipe*0.0); // !!!! 1.1
rho_xy.print();
t1=clock();
poisson_xy(rho_xy,gf);
t2=clock();
tf=(float)t2-(float)t1;
cout << "seconds:" << tf/CLOCKS_PER_SEC << endl;
pot_xy=rho_xy;
pot_xy.print();
}
void gen_FUNCTION ( node_t *root, int scopedepth )
{
function_symbol_t* entry = root->function_entry;
int len = strlen(entry->label);
char *temp = (char*) malloc(sizeof(char) * (len + 3));
temp[0] = 0;
strcat(temp, "_");
if(currentClass != NULL) {
strcat(temp, currentClass);
strcat(temp, "_");
}
strcat(temp, entry->label);
strcat(temp, ":");
instruction_add(STRING, STRDUP(temp), NULL, 0, 0);
gf(root,scopedepth);
}
TEST_F(ThreeIndexTestGF,Operators)
{
namespace g=alps::gf;
for (g::matsubara_index om=g::matsubara_index(0); om<gf.mesh1().extent(); ++om) {
for (g::momentum_index ii=g::momentum_index(0); ii<gf.mesh2().extent(); ++ii) {
for (g::index sig=g::index(0); sig<gf.mesh3().extent(); ++sig) {
std::complex<double> v1(1+om()+ii(), 1+sig());
std::complex<double> v2=1./v1;
gf(om,ii,sig)=v1;
gf2(om,ii,sig)=v2;
}
}
}
gf_type g_plus=gf+gf2;
gf_type g_minus=gf-gf2;
const double tol=1E-8;
for (g::matsubara_index om=g::matsubara_index(0); om<gf.mesh1().extent(); ++om) {
for (g::momentum_index ii=g::momentum_index(0); ii<gf.mesh2().extent(); ++ii) {
for (g::index sig=g::index(0); sig<gf.mesh3().extent(); ++sig) {
std::complex<double> v1(1+om()+ii(), 1+sig());
std::complex<double> v2=1./v1;
std::complex<double> r1=v1+v2;
std::complex<double> r2=v1-v2;
ASSERT_NEAR(r1.real(),g_plus(om,ii,sig).real(),tol);
ASSERT_NEAR(r1.imag(),g_plus(om,ii,sig).imag(),tol);
ASSERT_NEAR(r2.real(),g_minus(om,ii,sig).real(),tol);
ASSERT_NEAR(r2.imag(),g_minus(om,ii,sig).imag(),tol);
}
}
}
}
TEST_F(TwoIndexGFTest,saveload)
{
namespace g=alps::gf;
{
alps::hdf5::archive oar("gf.h5","w");
gf(g::matsubara_index(4), g::index(1))=std::complex<double>(7., 3.);
gf.save(oar,"/gf");
}
{
alps::hdf5::archive iar("gf.h5");
gf2.load(iar,"/gf");
}
EXPECT_EQ(7, gf2(g::matsubara_index(4), g::index(1)).real());
EXPECT_EQ(3, gf2(g::matsubara_index(4), g::index(1)).imag());
{
alps::hdf5::archive oar("gf.h5","rw");
oar["/gf/version/major"]<<7;
EXPECT_THROW(gf2.load(oar,"/gf"),std::runtime_error);
}
EXPECT_EQ(7, gf2(g::matsubara_index(4), g::index(1)).real());
EXPECT_EQ(3, gf2(g::matsubara_index(4), g::index(1)).imag());
}
virtual void SetUp() {
sockaddr_x sa;
int sock = Xsocket(AF_XIA, SOCK_STREAM, 0);
XreadLocalHostAddr(sock, ad, XID_LEN, hid, XID_LEN, fid, XID_LEN);
sprintf(fdag, FULL_DAG, ad, hid, SID);
Graph gf(fdag);
gf.fill_sockaddr(&sa);
XregisterName(FULL_NAME, &sa);
sprintf(hdag, HOST_DAG, ad, hid);
Graph gh(hdag);
gh.fill_sockaddr(&sa);
XregisterName(HOST_NAME, &sa);
Xclose(sock);
nad = new Node(ad);
nhid = new Node(hid);
nsid = new Node(SID);
ai = NULL;
}
