void updateQRZ(Matrix& X, UpperTriangularMatrix& U)
{
REPORT
Tracer et("updateQRZ");
int n = X.Nrows(); int s = X.Ncols();
if (s != U.Ncols())
Throw(ProgramException("Incompatible dimensions",X,U));
if (n == 0 || s == 0) return;
Real* xi0 = X.Store(); Real* u0 = U.Store(); Real* u;
RowVector V(s); Real* v0 = V.Store(); Real* v; V = 0.0;
int j, k; int J = s; int i = s;
while (i--)
{
Real* xj0 = xi0; Real* xi = xi0; k = n;
if (k) for (;;)
{
v = v0; Real Xi = *xi; Real* xj = xj0;
j = J; while(j--) *v++ += Xi * *xj++;
if (!(--k)) break;
xi += s; xj0 += s;
}
Real r = *u0;
Real sum = sqrt(*v0 + square(r));
if (sum == 0.0)
{
REPORT
u = u0; v = v0;
j = J; while(j--) { *u++ = 0.0; *v++ = 0.0; }
xj0 = xi0++; k = n;
if (k) for (;;)
{
*xj0 = 0.0;
if (!(--k)) break;
xj0 += s;
}
u0 += J--;
}
else
{
Real frs = fabs(r) + sum;
Real a0 = sqrt(frs / sum); Real alpha = a0 / frs;
if (r <= 0) { REPORT alpha = -alpha; *u0 = sum; }
else { REPORT *u0 = -sum; }
j = J - 1; v = v0 + 1; u = u0 + 1;
while (j--)
{ *v = a0 * *u + alpha * *v; *u -= a0 * *v; ++v; ++u; }
xj0 = xi0; xi = xi0++; k = n;
if (k) for (;;)
{
v = v0 + 1; Real Xi = *xi; Real* xj = xj0;
Xi *= alpha; *xj++ = Xi;
j = J - 1; while(j--) *xj++ -= *v++ * Xi;
if (!(--k)) break;
xi += s; xj0 += s;
}
j = J; v = v0;
while (j--) *v++ = 0.0;
u0 += J--;
}
}
}
bool MET::isGood() const {
return et() > 20;
}
int main(int argc, char *agrv[]) {
google::ParseCommandLineFlags(&argc, &agrv, true);
hal::MatrixIOBus bus;
if (!bus.Init()) return false;
if (!bus.IsDirectBus()) {
std::cerr << "Kernel Modules has been loaded. Use ALSA implementation "
<< std::endl;
return false;
}
int sampling_rate = FLAGS_sampling_frequency;
int seconds_to_record = FLAGS_duration;
// Microhone Array Configuration
hal::MicrophoneArray mics;
mics.Setup(&bus);
mics.SetSamplingRate(sampling_rate);
if (FLAGS_gain > 0) mics.SetGain(FLAGS_gain);
mics.ShowConfiguration();
std::cout << "Duration : " << seconds_to_record << "s" << std::endl;
// Microphone Core Init
hal::MicrophoneCore mic_core(mics);
mic_core.Setup(&bus);
mic_core.SelectFIRCoeff(&FIR_bandpass[0]);
int16_t buffer[mics.Channels() + 1]
[mics.SamplingRate() + mics.NumberOfSamples()];
mics.CalculateDelays(0, 0, 1000, 320 * 1000);
std::ofstream os[mics.Channels() + 1];
for (uint16_t c = 0; c < mics.Channels() + 1; c++) {
std::string filename = "mic_" + std::to_string(mics.SamplingRate()) +
"_s16le_channel_" + std::to_string(c) + ".raw";
os[c].open(filename, std::ofstream::binary);
}
std::thread et(
[seconds_to_record](hal::MatrixIOBus *bus) {
hal::Everloop everloop;
everloop.Setup(bus);
hal::EverloopImage image(bus->MatrixLeds());
for (auto &led : image.leds) led.red = 10;
everloop.Write(&image);
int sleep = int(1000.0 * seconds_to_record / image.leds.size());
for (auto &led : image.leds) {
led.red = 0;
led.green = 10;
everloop.Write(&image);
std::this_thread::sleep_for(std::chrono::milliseconds(sleep));
}
},
&bus);
uint32_t samples = 0;
for (int s = 0; s < seconds_to_record; s++) {
for (;;) {
mics.Read(); /* Reading 8-mics buffer from de FPGA */
/* buffering */
for (uint32_t s = 0; s < mics.NumberOfSamples(); s++) {
for (uint16_t c = 0; c < mics.Channels(); c++) { /* mics.Channels()=8 */
buffer[c][samples] = mics.At(s, c);
}
buffer[mics.Channels()][samples] = mics.Beam(s);
samples++;
}
/* write to file */
if (samples >= mics.SamplingRate()) {
for (uint16_t c = 0; c < mics.Channels() + 1; c++) {
os[c].write((const char *)buffer[c], samples * sizeof(int16_t));
}
samples = 0;
break;
}
}
}
et.join();
return 0;
}
void NetworkConfig::_fromDictionary(const Dictionary &d)
{
static const std::string zero("0");
static const std::string one("1");
// NOTE: d.get(name) throws if not found, d.get(name,default) returns default
memset(_etWhitelist,0,sizeof(_etWhitelist));
std::vector<std::string> ets(Utils::split(d.get(ZT_NETWORKCONFIG_DICT_KEY_ALLOWED_ETHERNET_TYPES).c_str(),",","",""));
for(std::vector<std::string>::const_iterator et(ets.begin());et!=ets.end();++et) {
unsigned int tmp = Utils::hexStrToUInt(et->c_str()) & 0xffff;
_etWhitelist[tmp >> 3] |= (1 << (tmp & 7));
}
_nwid = Utils::hexStrToU64(d.get(ZT_NETWORKCONFIG_DICT_KEY_NETWORK_ID).c_str());
if (!_nwid)
throw std::invalid_argument("configuration contains zero network ID");
_timestamp = Utils::hexStrToU64(d.get(ZT_NETWORKCONFIG_DICT_KEY_TIMESTAMP).c_str());
_issuedTo = Address(d.get(ZT_NETWORKCONFIG_DICT_KEY_ISSUED_TO));
_multicastPrefixBits = Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_MULTICAST_PREFIX_BITS,zero).c_str());
_multicastDepth = Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_MULTICAST_DEPTH,zero).c_str());
_allowPassiveBridging = (Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_ALLOW_PASSIVE_BRIDGING,zero).c_str()) != 0);
_private = (Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_PRIVATE,one).c_str()) != 0);
_enableBroadcast = (Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_ENABLE_BROADCAST,one).c_str()) != 0);
_name = d.get(ZT_NETWORKCONFIG_DICT_KEY_NAME);
_description = d.get(ZT_NETWORKCONFIG_DICT_KEY_DESC,std::string());
if (!_multicastPrefixBits)
_multicastPrefixBits = ZT_DEFAULT_MULTICAST_PREFIX_BITS;
if (!_multicastDepth)
_multicastDepth = ZT_DEFAULT_MULTICAST_DEPTH;
std::string ipAddrs(d.get(ZT_NETWORKCONFIG_DICT_KEY_IPV4_STATIC,std::string()));
std::string v6s(d.get(ZT_NETWORKCONFIG_DICT_KEY_IPV6_STATIC,std::string()));
if (v6s.length()) {
if (ipAddrs.length())
ipAddrs.push_back(',');
ipAddrs.append(v6s);
}
std::vector<std::string> ipAddrs2(Utils::split(ipAddrs.c_str(),",","",""));
for(std::vector<std::string>::const_iterator ipstr(ipAddrs2.begin());ipstr!=ipAddrs2.end();++ipstr) {
InetAddress addr(*ipstr);
switch(addr.type()) {
case InetAddress::TYPE_IPV4:
if ((!addr.netmaskBits())||(addr.netmaskBits() > 32))
throw std::invalid_argument("static IP address fields contain one or more invalid IP/netmask entries");
break;
case InetAddress::TYPE_IPV6:
if ((!addr.netmaskBits())||(addr.netmaskBits() > 128))
throw std::invalid_argument("static IP address fields contain one or more invalid IP/netmask entries");
break;
default:
throw std::invalid_argument("static IP address fields contain one or more invalid IP/netmask entries");
}
_staticIps.insert(addr);
}
std::vector<std::string> ab(Utils::split(d.get(ZT_NETWORKCONFIG_DICT_KEY_ACTIVE_BRIDGES,"").c_str(),",","",""));
for(std::vector<std::string>::const_iterator a(ab.begin());a!=ab.end();++a) {
if (a->length() == ZT_ADDRESS_LENGTH_HEX) {
Address tmp(*a);
if (!tmp.isReserved())
_activeBridges.insert(tmp);
}
}
Dictionary mr(d.get(ZT_NETWORKCONFIG_DICT_KEY_MULTICAST_RATES,std::string()));
for(Dictionary::const_iterator i(mr.begin());i!=mr.end();++i) {
std::vector<std::string> params(Utils::split(i->second.c_str(),",","",""));
if (params.size() >= 3)
_multicastRates[MulticastGroup(i->first)] = MulticastRate(Utils::hexStrToUInt(params[0].c_str()),Utils::hexStrToUInt(params[1].c_str()),Utils::hexStrToUInt(params[2].c_str()));
}
_com.fromString(d.get(ZT_NETWORKCONFIG_DICT_KEY_CERTIFICATE_OF_MEMBERSHIP,std::string()));
}
Real OneDimSolve::Solve(Real Y, Real X, Real Dev, int Lim)
{
enum Loop { start, captured1, captured2, binary, finish };
Tracer et("OneDimSolve::Solve");
lim=Lim; Captured = false;
if (Dev==0.0) Throw(SolutionException("Dev is zero"));
L=0; C=1; U=2; vpol=1; hpol=1; y[C]=0.0; y[U]=0.0;
if (Dev<0.0) { hpol=-1; Dev = -Dev; }
YY=Y; // target value
x[L] = X; // initial trial value
if (!function.IsValid(X))
Throw(SolutionException("Starting value is invalid"));
Loop TheLoop = start;
for (;;)
{
switch (TheLoop)
{
case start:
LookAt(L); if (Finish) { TheLoop = finish; break; }
if (y[L]>0.0) VFlip(); // so Y[L] < 0
x[U] = X + Dev * hpol;
if (!function.maxXinf && x[U] > function.maxX)
x[U] = (function.maxX + X) / 2.0;
if (!function.minXinf && x[U] < function.minX)
x[U] = (function.minX + X) / 2.0;
LookAt(U); if (Finish) { TheLoop = finish; break; }
if (y[U] > 0.0) { TheLoop = captured1; Captured = true; break; }
if (y[U] == y[L])
Throw(SolutionException("Function is flat"));
if (y[U] < y[L]) HFlip(); // Change direction
State(L,U,C);
for (i=0; i<20; i++)
{
// cout << "Searching for crossing point\n";
// Have L C then crossing point, Y[L]<Y[C]<0
x[U] = x[C] + Dev * hpol;
if (!function.maxXinf && x[U] > function.maxX)
x[U] = (function.maxX + x[C]) / 2.0;
if (!function.minXinf && x[U] < function.minX)
x[U] = (function.minX + x[C]) / 2.0;
LookAt(U); if (Finish) { TheLoop = finish; break; }
if (y[U] > 0) { TheLoop = captured2; Captured = true; break; }
if (y[U] < y[C])
Throw(SolutionException("Function is not monotone"));
Dev *= 2.0;
State(C,U,L);
}
if (TheLoop != start ) break;
Throw(SolutionException("Can't locate a crossing point"));
case captured1:
// cout << "Captured - 1\n";
// We have 2 points L and U with crossing between them
Linear(L,C,U); // linear interpolation
// - result to C
LookAt(C); if (Finish) { TheLoop = finish; break; }
if (y[C] > 0.0) Flip(); // Want y[C] < 0
if (y[C] < 0.5*y[L]) { State(C,L,U); TheLoop = binary; break; }
case captured2:
// cout << "Captured - 2\n";
// We have L,C before crossing, U after crossing
Quadratic(L,C,U); // quad interpolation
// - result to L
State(C,L,U);
if ((x[C] - x[L])*hpol <= 0.0 || (x[C] - x[U])*hpol >= 0.0)
{ TheLoop = captured1; break; }
LookAt(C); if (Finish) { TheLoop = finish; break; }
// cout << "Through first stage\n";
if (y[C] > 0.0) Flip();
if (y[C] > 0.5*y[L]) { TheLoop = captured2; break; }
else { State(C,L,U); TheLoop = captured1; break; }
case binary:
// We have L, U around crossing - do binary search
// cout << "Binary\n";
for (i=3; i; i--)
{
x[C] = 0.5*(x[L]+x[U]);
LookAt(C); if (Finish) { TheLoop = finish; break; }
if (y[C]>0.0) State(L,U,C); else State(C,L,U);
}
if (TheLoop != binary) break;
TheLoop = captured1; break;
case finish:
return x[Last];
}
}
}
int main (int argc, char * const argv[]) {
clock_t clock_start = clock();
int option_char;
char* jdb;
char* block;
bool blocked = false;
bool snp = false;
int seed = -1;
int method = -1;
bool log = false;
int nbTree = 1;
int k = 1;
int inc = 0;
int nmin = 1;
int intc = 1;
bool startend = true;
bool startendlsts = true;
std::string acfile = "";
std::string lsfile = "";
std::string tsfile = "";
std::string gcfile = "";
while ((option_char = getopt(argc, argv, "x?m:j:b:r:sl:t:k:i:a:g:v:fn:c:e")) != -1) {
switch (option_char) {
case 'e': startend = false; break;
case 'x': startendlsts = false; break;
case 'b': block = optarg; blocked = true; break;
case 'a': acfile = optarg; break;
case 'v': tsfile = optarg; break;
case 'l': lsfile = optarg; break;
case 'g': gcfile = optarg; break;
case 'j': jdb = optarg; break;
case 's': snp = true; break;
case 'r': seed = atoi(optarg); break;
case 'm': method = atoi(optarg); break;
case 't': nbTree = atoi(optarg); break;
case 'k': k = atoi(optarg); break;
case 'i': inc = atoi(optarg); break;
case 'n': nmin = atoi(optarg); break;
case 'c': intc = atoi(optarg); break;
case 'f': log = true; break;
case '?': printHelp(); return -1 ; break;
default: printHelp(); return -1 ; break;
}
}
//return 0;
if (seed>-1)
srand(seed);
else
srand((unsigned int) time(NULL));
// OUTPUT FILES
char prefix[256];
sprintf(prefix, "%s_k%d_m%d_t%d_ic%d_nmin%d",jdb,k,method,nbTree,intc,nmin);
Logs l(prefix,inc);
// DATABASE INPUT
JavaDB db(jdb);
if (blocked) {
if (startend)
db.readBlockStartEnd(block);
else
db.readBlock(block);
l.main("BLOCK FILE:"); l.main(block); l.main("\n");
}
if (snp) {
db.setType(SNP);
l.main("SNP DB MODE : ON\n");
}
if (log)
db.print(l.main());
// LEARNING, TEST SETS AND CANDIDATE ATTRIBUTES SETTINGS
std::vector<SETREP> ls;
if (lsfile == "")
ls = db.selectAll();
else {
if (startendlsts)
ls = Sampler::readStartEndSet(lsfile);
else
ls = Sampler::readSet(lsfile);
l.main("LEARNING SET FILE:"); l.main(lsfile.c_str()); l.main("\n");
}
std::vector<SETREP> ts;
if (tsfile == "")
ts = db.selectAll();
else {
if (startendlsts)
ts = Sampler::readStartEndSet(tsfile);
else
ts = Sampler::readSet(tsfile);
l.main("TEST SET FILE:"); l.main(tsfile.c_str()); l.main("\n");
}
std::vector<unsigned int> attcand;
if (acfile == "")
attcand = db.selectAllAtt();
else {
attcand = Sampler::readStartEndSet(acfile);
l.main("CANDIDATE ATT. FILE:"); l.main(acfile.c_str()); l.main("\n");
}
std::vector<unsigned int> groupcand;
if (blocked) {
if (gcfile == "")
groupcand = db.selectAllGroup();
else {
groupcand = Sampler::readStartEndSet(gcfile);
l.main("CANDIDATE ATT. FILE:"); l.main(gcfile.c_str()); l.main("\n");
}
}
Result result(&db);
std::vector<float> vim(db.getNbAtt(),0.0);
switch (method) {
case 0: {
fprintf(stderr,"CLASSIC TREE\n");
ClassicTree ct(&db,nmin);
ct.setLS(&ls);
ct.setTS(&ts);
ct.setAttCand(&attcand);
ct.print(l.main());
fprintf(l.main(),"Learning Time : %f sec\n", ct.learn()/CLOCKS_PER_SEC);
result = ct.test();
fprintf(l.main(),"Error rate : %f %%\n", result.getErrorRate());
fprintf(stderr,"Error rate : %f %%\n", result.getErrorRate());
result.printProb(l.roc());
//ct.computeVimp();
//ct.printVimp(l.varimp());
ct.computeVimp(vim,ls);
ct.printVimp(vim,l.varimp());
fprintf(l.dot(),"digraph G {\n");
ct.dotit(l.dot());
fprintf(l.dot(),"}\n");
l.flush();
break;
} case 1: {
fprintf(stderr,"RANDOM FOREST\n");
RandomForest rf(&db,nbTree,k,nmin);
rf.setLS(&ls);
rf.setTS(&ts);
rf.setAttCand(&attcand);
rf.print(l.main());
rf.setTreeInfo(l.tree());
fprintf(l.main(),"Learning Time : %f sec\n", rf.learn()/CLOCKS_PER_SEC);
result = rf.test();
fprintf(l.main(),"Error rate : %f %%\n", result.getErrorRate());
fprintf(stderr,"Error rate : %f %%\n", result.getErrorRate());
result.printProb(l.roc());
rf.computeVimp(vim,ls);
rf.printVimp(vim,l.varimp());
rf.dotit(l.dot(),10);
l.flush();
break;
} case 2: {
fprintf(stderr,"EXTRATREES\n");
ExtraTrees et(&db,nbTree,k,nmin);
et.setLS(&ls);
et.setTS(&ts);
et.setAttCand(&attcand);
et.print(l.main());
et.setTreeInfo(l.tree());
fprintf(l.main(),"Learning Time : %f sec\n", et.learn()/CLOCKS_PER_SEC);
result = et.test();
fprintf(l.main(),"Error rate : %f %%\n", result.getErrorRate());
fprintf(stderr,"Error rate : %f %%\n", result.getErrorRate());
result.printProb(l.roc());
et.computeVimp(vim,ls);
et.printVimp(vim,l.varimp());
et.dotit(l.dot(),10);
l.flush();
break;
} case 3: {
fprintf(stderr,"RANDOM TT FOREST\n");
RandomTTForest rttf(&db,nbTree,k,nmin);
rttf.setKint(0);
rttf.setLS(&ls);
rttf.setTS(&ts);
rttf.setAttCand(&attcand);
rttf.setGroupCand(groupcand);
rttf.setInternalComp(intc);
rttf.print(l.main());
rttf.setTreeInfo(l.tree());
fprintf(l.main(),"Learning Time : %f sec\n", rttf.learn()/CLOCKS_PER_SEC);
result = rttf.test();
fprintf(l.main(),"Error rate : %f %%\n", result.getErrorRate());
fprintf(stderr,"Error rate : %f %%\n", result.getErrorRate());
result.printProb(l.roc());
std::vector<float> gim(db.getNbGroup(),0.0);
rttf.computeGroupVimp(gim,ls);
rttf.printGroupVimp(gim,l.groupimp());
rttf.computeVimp(vim,ls);
rttf.printVimp(vim, l.varimp());
rttf.dotit(l.dot(),10);
l.flush();
break;
} case 4: {
fprintf(stderr,"EXTRATTREES\n");
ExtraTTrees ett(&db,nbTree,k,nmin);
ett.setKint(0);
ett.setLS(&ls);
ett.setTS(&ts);
ett.setAttCand(&attcand);
ett.setGroupCand(groupcand);
ett.setInternalComp(intc);
ett.print(l.main());
fprintf(l.main(),"Learning Time : %f sec\n", ett.learn()/CLOCKS_PER_SEC);
result = ett.test();
fprintf(l.main(),"Error rate : %f %%\n", result.getErrorRate());
fprintf(stderr,"Error rate : %f %%\n", result.getErrorRate());
result.printProb(l.roc());
std::vector<float> gim(db.getNbGroup(),0.0);
ett.computeGroupVimp(gim,ls);
ett.printGroupVimp(gim,l.groupimp());
ett.computeVimp(vim,ls);
ett.printVimp(vim,l.varimp());
l.flush();
break;
} case 5: { // WIP...
fprintf(stderr,"RANDOM TT STUMP\n");
RandomTTForest rttf(&db,nbTree,k,nmin);
rttf.setKint(0);
rttf.setLS(&ls);
rttf.setTS(&ts);
rttf.setTreeType(RANDOMTTSTUMP);
rttf.setAttCand(&attcand);
rttf.setGroupCand(groupcand);
rttf.setInternalComp(intc);
rttf.print(l.main());
fprintf(l.main(),"Learning Time : %f sec\n", rttf.learn()/CLOCKS_PER_SEC);
result = rttf.test();
fprintf(l.main(),"Error rate : %f %%\n", result.getErrorRate());
fprintf(stderr,"Error rate : %f %%\n", result.getErrorRate());
result.printProb(l.roc());
rttf.computeVimp();
rttf.printVimp(l.varimp());
rttf.computeGroupVimp();
rttf.printGroupVimp(l.groupimp());
l.flush();
break;
} case 6: { // WIP...
fprintf(stderr,"EXTRATTSTUMP\n");
ExtraTTrees ett(&db,nbTree,k,nmin);
ett.setKint(0);
ett.setLS(&ls);
ett.setTS(&ts);
ett.setTreeType(EXTRATTSTUMP);
ett.setAttCand(&attcand);
ett.setGroupCand(groupcand);
ett.setInternalComp(intc);
ett.print(l.main());
fprintf(l.main(),"Learning Time : %f sec\n", ett.learn()/CLOCKS_PER_SEC);
result = ett.test();
fprintf(l.main(),"Error rate : %f %%\n", result.getErrorRate());
fprintf(stderr,"Error rate : %f %%\n", result.getErrorRate());
result.printProb(l.roc());
ett.computeVimp();
ett.printVimp(l.varimp());
ett.computeGroupVimp();
ett.printGroupVimp(l.groupimp());
l.flush();
break;
} default: break;
}
fprintf(l.main(),"Overall Time : %f sec\n",(clock()-clock_start) / (double) CLOCKS_PER_SEC);
fprintf(l.main(),"Program terminated...\n");
fprintf(stdout,"Program terminated...\n");
return 0;
}
int main( int argc , char * argv[] ) {
std::cout << "算术" << std::endl;
int a = 10 , b = 20;
int ret;
std::plus<int>add;
ret = add(a,b);
std::cout << ret << std::endl;
std::minus<int> min;
ret = min(b,a);
std::cout << ret << std::endl;
std::multiplies<int> mp;
ret = mp(a,b);
std::cout << ret << std::endl;
std::divides<int> divi;
ret = divi(a,b);
std::cout << ret << std::endl;
std::modulus<int> mod;
ret = mod(a,b);
std::cout << ret << std::endl;
std::negate<int> neg;
ret = neg(a);
std::cout << ret << std::endl;
std::cout << "关系" <<std::endl;
int a2 = 10 , b2 = 20;
int ret2;
std::equal_to<int> et;
ret2 = et(a,b);
std::cout << ret2 <<std::endl;
std::not_equal_to<int> net;
ret2 = net(a,b);
std::cout << ret2 << std::endl;
std::greater<int>gt;
ret2 = gt(b,a);
std::cout << ret2 << std::endl;
std::greater_equal<int> gte;
ret2 = gte(a,b);
std::cout << ret2 <<std::endl;
std::less<int> ls;
ret2 = ls(a,b);
std::cout << ret2 << std::endl;
std::less_equal<int> lel;
ret2 = lel(a,b);
std::cout << ret2 << std::endl;
std::cout << "逻辑" << std::endl;
int ret3;
std::logical_and<int> la;
ret3 = la(a,b);
std::cout << ret3 <<std::endl;
std::logical_or<int> lo;
ret3 = lo(a,b);
std::cout << ret3 << std::endl;
std::logical_not<int>ln;
ret3 = ln(b);
std::cout << ret3 <<std::endl;
return EXIT_SUCCESS;
}
/**
* GetPointInfo builds the PvlGroup containing all the important
* information derived from the Camera.
*
* @return PvlGroup* Data taken directly from the Camera and
* drived from Camera information. Ownership passed.
*/
PvlGroup * CameraPointInfo::GetPointInfo() {
CheckConditions();
Brick b(3,3,1,currentCube->PixelType());
int intSamp = (int)(camera->Sample() + 0.5);
int intLine = (int)(camera->Line() + 0.5);
b.SetBasePosition(intSamp, intLine, 1);
currentCube->Read(b);
double pB[3], spB[3], sB[3];
string utc;
double ssplat, ssplon, sslat, sslon, pwlon, oglat;
// Create group with ground position
PvlGroup * gp = new PvlGroup("GroundPoint");
{
gp->AddKeyword(PvlKeyword("Filename",currentCube->Filename()));
gp->AddKeyword(PvlKeyword("Sample",camera->Sample()));
gp->AddKeyword(PvlKeyword("Line",camera->Line()));
gp->AddKeyword(PvlKeyword("PixelValue",PixelToString(b[0])));
gp->AddKeyword(PvlKeyword("RightAscension",camera->RightAscension()));
gp->AddKeyword(PvlKeyword("Declination",camera->Declination()));
gp->AddKeyword(PvlKeyword("PlanetocentricLatitude",
camera->UniversalLatitude()));
// Convert lat to planetographic
double radii[3];
camera->Radii(radii);
oglat = Isis::Projection::ToPlanetographic(camera->UniversalLatitude(),
radii[0],radii[2]);
gp->AddKeyword(PvlKeyword("PlanetographicLatitude",oglat));
gp->AddKeyword(PvlKeyword("PositiveEast360Longitude",
camera->UniversalLongitude()));
//Convert lon to -180 - 180 range
gp->AddKeyword(PvlKeyword("PositiveEast180Longitude",
Isis::Projection::To180Domain(
camera->UniversalLongitude())));
//Convert lon to positive west
pwlon = Isis::Projection::ToPositiveWest(camera->UniversalLongitude(),
360);
gp->AddKeyword(PvlKeyword("PositiveWest360Longitude",pwlon));
//Convert pwlon to -180 - 180 range
gp->AddKeyword(PvlKeyword("PositiveWest180Longitude",
Isis::Projection::To180Domain(pwlon)));
camera->Coordinate(pB);
PvlKeyword coord("BodyFixedCoordinate");
coord.AddValue(pB[0],"km");
coord.AddValue(pB[1],"km");
coord.AddValue(pB[2],"km");
gp->AddKeyword(coord);
gp->AddKeyword(PvlKeyword("LocalRadius",camera->LocalRadius(),"m"));
gp->AddKeyword(PvlKeyword("SampleResolution",camera->SampleResolution(),"m"));
gp->AddKeyword(PvlKeyword("LineResolution",camera->LineResolution(),"m"));
camera->InstrumentPosition(spB);
PvlKeyword spcoord("SpacecraftPosition");
spcoord.AddValue(spB[0],"km");
spcoord.AddValue(spB[1],"km");
spcoord.AddValue(spB[2],"km");
spcoord.AddComment("Spacecraft Information");
gp->AddKeyword(spcoord);
gp->AddKeyword(PvlKeyword("SpacecraftAzimuth",camera->SpacecraftAzimuth()));
gp->AddKeyword(PvlKeyword("SlantDistance",camera->SlantDistance(),"km"));
gp->AddKeyword(PvlKeyword("TargetCenterDistance",camera->TargetCenterDistance(),"km"));
camera->SubSpacecraftPoint(ssplat,ssplon);
gp->AddKeyword(PvlKeyword("SubSpacecraftLatitude",ssplat));
gp->AddKeyword(PvlKeyword("SubSpacecraftLongitude",ssplon));
gp->AddKeyword(PvlKeyword("SpacecraftAltitude",camera->SpacecraftAltitude(),"km"));
gp->AddKeyword(PvlKeyword("OffNadirAngle",camera->OffNadirAngle()));
double subspcgrdaz;
subspcgrdaz = camera->GroundAzimuth(camera->UniversalLatitude(),camera->UniversalLongitude(),
ssplat,ssplon);
gp->AddKeyword(PvlKeyword("SubSpacecraftGroundAzimuth",subspcgrdaz));
camera->SunPosition(sB);
PvlKeyword scoord("SunPosition");
scoord.AddValue(sB[0],"km");
scoord.AddValue(sB[1],"km");
scoord.AddValue(sB[2],"km");
scoord.AddComment("Sun Information");
gp->AddKeyword(scoord);
gp->AddKeyword(PvlKeyword("SubSolarAzimuth",camera->SunAzimuth()));
gp->AddKeyword(PvlKeyword("SolarDistance",camera->SolarDistance(),"AU"));
camera->SubSolarPoint(sslat,sslon);
gp->AddKeyword(PvlKeyword("SubSolarLatitude",sslat));
gp->AddKeyword(PvlKeyword("SubSolarLongitude",sslon));
double subsolgrdaz;
subsolgrdaz = camera->GroundAzimuth(camera->UniversalLatitude(),camera->UniversalLongitude(),
sslat,sslon);
gp->AddKeyword(PvlKeyword("SubSolarGroundAzimuth",subsolgrdaz));
PvlKeyword phase("Phase",camera->PhaseAngle());
phase.AddComment("Illumination and Other");
gp->AddKeyword(phase);
gp->AddKeyword(PvlKeyword("Incidence",camera->IncidenceAngle()));
gp->AddKeyword(PvlKeyword("Emission",camera->EmissionAngle()));
gp->AddKeyword(PvlKeyword("NorthAzimuth",camera->NorthAzimuth()));
PvlKeyword et("EphemerisTime",camera->EphemerisTime(),"seconds");
et.AddComment("Time");
gp->AddKeyword(et);
iTime t(camera->EphemerisTime());
utc = t.UTC();
gp->AddKeyword(PvlKeyword("UTC",utc));
gp->AddKeyword(PvlKeyword("LocalSolarTime",camera->LocalSolarTime(),"hour"));
gp->AddKeyword(PvlKeyword("SolarLongitude",camera->SolarLongitude()));
}
return gp;
}
//void PieceAppearanceWidget::applyCurrentTemplate( QObject * tgt )
void PieceAppearanceWidget::applyCurrentTemplate( QGIPiece * tgt )
{
if( !tgt ) return;
typedef QList<QGraphicsItem*> QIL;
QIL li( impl->gv->scene()->selectedItems() );
impl->pc = 0;
// If there are multiple items selected, simply pick the first
// selected item which has an associated piece (the order has no
// meaning, however).
for( QIL::iterator it = li.begin();
li.end() != it;
++it )
{
QGIPiece * pvi = dynamic_cast<QGIPiece*>(*it);
if( pvi )
{
impl->pc = pvi;
}
}
if( ! impl->pc ) return;
/**
We want to keep certain properties intact:
pixmap: b/c the game client normally sets this
pos: we don't want to use the template's pos
dragDisabled: that property was developed to support
this class. The client will almost always expect
his pieces to be draggable.
*/
QVariant pix( tgt->property("pixmap") );
QVariant pos( tgt->property("pos") );
QVariant dragDisabled( tgt->property("dragDisabled") );
{
#if 0
QObject * src = impl->pc;
typedef QList<QByteArray> QL;
QL ql( src->dynamicPropertyNames() );
QL::const_iterator it( ql.begin() );
QL::const_iterator et( ql.end() );
for( ; et != it; ++it )
{
char const * key = it->constData();
if( !key || (*key == '_') ) continue; // Qt reserves the "_q_" prefix, so we'll elaborate on that.
tgt->setProperty( key, src->property(key) );
}
#else
S11nNode n;
impl->pc->serialize(n);
// Lame kludge to ensure that we don't throw
// here if tgt is a subclass of QGIType:
const QString cn1( S11nNodeTraits::class_name(n).c_str() );
const QString cn2( tgt->s11nClass() );
if( cn1 != cn2 )
{
S11nNodeTraits::class_name(n,cn2.toAscii().constData());
}
tgt->deserialize(n);
#endif
}
tgt->setProperty("pos", pos );
tgt->setProperty("pixmap", pix );
tgt->setProperty("dragDisabled", dragDisabled );
}
static void tred2(const SymmetricMatrix& A, DiagonalMatrix& D,
DiagonalMatrix& E, Matrix& Z)
{
Tracer et("Evalue(tred2)");
Real tol =
FloatingPointPrecision::Minimum()/FloatingPointPrecision::Epsilon();
int n = A.Nrows(); Z.ReSize(n,n); Z.Inject(A);
D.ReSize(n); E.ReSize(n);
Real* z = Z.Store(); int i;
for (i=n-1; i > 0; i--) // i=0 is excluded
{
Real f = Z.element(i,i-1); Real g = 0.0;
int k = i-1; Real* zik = z + i*n;
while (k--) g += square(*zik++);
Real h = g + square(f);
if (g <= tol) { E.element(i) = f; h = 0.0; }
else
{
g = sign(-sqrt(h), f); E.element(i) = g; h -= f*g;
Z.element(i,i-1) = f-g; f = 0.0;
Real* zji = z + i; Real* zij = z + i*n; Real* ej = E.Store();
int j;
for (j=0; j<i; j++)
{
*zji = (*zij++)/h; g = 0.0;
Real* zjk = z + j*n; zik = z + i*n;
k = j; while (k--) g += *zjk++ * (*zik++);
k = i-j; while (k--) { g += *zjk * (*zik++); zjk += n; }
*ej++ = g/h; f += g * (*zji); zji += n;
}
Real hh = f / (h + h); zij = z + i*n; ej = E.Store();
for (j=0; j<i; j++)
{
f = *zij++; g = *ej - hh * f; *ej++ = g;
Real* zjk = z + j*n; Real* zik = z + i*n;
Real* ek = E.Store(); k = j+1;
while (k--) *zjk++ -= ( f*(*ek++) + g*(*zik++) );
}
}
D.element(i) = h;
}
D.element(0) = 0.0; E.element(0) = 0.0;
for (i=0; i<n; i++)
{
if (D.element(i) != 0.0)
{
for (int j=0; j<i; j++)
{
Real g = 0.0;
Real* zik = z + i*n; Real* zkj = z + j;
int k = i; while (k--) { g += *zik++ * (*zkj); zkj += n; }
Real* zki = z + i; zkj = z + j;
k = i; while (k--) { *zkj -= g * (*zki); zkj += n; zki += n; }
}
}
Real* zij = z + i*n; Real* zji = z + i;
int j = i; while (j--) { *zij++ = 0.0; *zji = 0.0; zji += n; }
D.element(i) = *zij; *zij = 1.0;
}
}
static void tql2(DiagonalMatrix& D, DiagonalMatrix& E, Matrix& Z)
{
Tracer et("Evalue(tql2)");
Real eps = FloatingPointPrecision::Epsilon();
int n = D.Nrows(); Real* z = Z.Store(); int l;
for (l=1; l<n; l++) E.element(l-1) = E.element(l);
Real b = 0.0; Real f = 0.0; E.element(n-1) = 0.0;
for (l=0; l<n; l++)
{
int i,j;
Real& dl = D.element(l); Real& el = E.element(l);
Real h = eps * ( fabs(dl) + fabs(el) );
if (b < h) b = h;
int m;
for (m=l; m<n; m++) if (fabs(E.element(m)) <= b) break;
bool test = false;
for (j=0; j<30; j++)
{
if (m==l) { test = true; break; }
Real& dl1 = D.element(l+1);
Real g = dl; Real p = (dl1-g) / (2.0*el); Real r = sqrt(p*p + 1.0);
dl = el / (p < 0.0 ? p-r : p+r); Real h = g - dl; f += h;
Real* dlx = &dl1; i = n-l-1; while (i--) *dlx++ -= h;
p = D.element(m); Real c = 1.0; Real s = 0.0;
for (i=m-1; i>=l; i--)
{
Real ei = E.element(i); Real di = D.element(i);
Real& ei1 = E.element(i+1);
g = c * ei; h = c * p;
if ( fabs(p) >= fabs(ei))
{
c = ei / p; r = sqrt(c*c + 1.0);
ei1 = s*p*r; s = c/r; c = 1.0/r;
}
else
{
c = p / ei; r = sqrt(c*c + 1.0);
ei1 = s * ei * r; s = 1.0/r; c /= r;
}
p = c * di - s*g; D.element(i+1) = h + s * (c*g + s*di);
Real* zki = z + i; Real* zki1 = zki + 1; int k = n;
while (k--)
{
h = *zki1; *zki1 = s*(*zki) + c*h; *zki = c*(*zki) - s*h;
zki += n; zki1 += n;
}
}
el = s*p; dl = c*p;
if (fabs(el) <= b) { test = true; break; }
}
if (!test) Throw ( ConvergenceException(D) );
dl += f;
}
for (int i=0; i<n; i++)
{
int k = i; Real p = D.element(i);
for (int j=i+1; j<n; j++)
{ if (D.element(j) < p) { k = j; p = D.element(j); } }
if (k != i)
{
D.element(k) = D.element(i); D.element(i) = p; int j = n;
Real* zji = z + i; Real* zjk = z + k;
while (j--) { p = *zji; *zji = *zjk; *zjk = p; zji += n; zjk += n; }
}
}
}
/**
* Simplifie une formule.
* Cette fonction exprime les équivalences et implications de la formule en entrée avec les opérateurs ET, OU et NON.
* Elle ramène également toutes les négations de la formule au niveau des littéraux.
* @param form La formule à simplifier.
* @param negation Indique si l'élément parent était un NON. Vaut false par défaut.
* @return La formule simplifiée.
* @see formule
*/
formule* simplifie_formule(const formule *form, const bool negation) {
formule *form_out = NULL;
switch(form->op) {
case o_variable:
{
if(negation) {
form_out = non(var(*(form->nom)));
} else {
form_out = var(*(form->nom));
}
break;
}
case o_equivaut:
{
if(negation) {
form_out = ou(
et( simplifie_formule(form->arg1, true),
simplifie_formule(form->arg2)),
et( simplifie_formule(form->arg2, true),
simplifie_formule(form->arg1))
);
} else {
form_out = et(
ou( simplifie_formule(form->arg1, true),
simplifie_formule(form->arg2)),
ou( simplifie_formule(form->arg2, true),
simplifie_formule(form->arg1))
);
}
break;
}
case o_implique:
{
if(negation) {
form_out = et(simplifie_formule(form->arg1), simplifie_formule(form->arg2, true));
} else {
form_out = ou(simplifie_formule(form->arg1, true), simplifie_formule(form->arg2));
}
break;
}
case o_non:
{
form_out = simplifie_formule(form->arg, !negation);
break;
}
case o_ou:
{
if(negation) {
form_out = et(simplifie_formule(form->arg1, true), simplifie_formule(form->arg2, true));
} else {
form_out = ou(simplifie_formule(form->arg1), simplifie_formule(form->arg2));
}
break;
}
case o_et:
{
if(negation) {
form_out = ou(simplifie_formule(form->arg1, true), simplifie_formule(form->arg2, true));
} else {
form_out = et(simplifie_formule(form->arg1), simplifie_formule(form->arg2));
}
break;
}
}
return form_out;
}
void State::enforce_outflow(const OctFace& f, const _3Vec& X) {
switch (f) {
#ifdef USE_LZ
case XU:
if (vx(X) > 0.0) {
(*this)[sy_index] = X[0] * vy(X) * rho();
(*this)[sx_index] = X[1] * vy(X) * rho() / sqrt(X[0] * X[0] + X[1] * X[1]);
}
break;
case XL:
if (vx(X) < 0.0) {
(*this)[sy_index] = X[0] * vy(X) * rho();
(*this)[sx_index] = X[1] * vy(X) * rho() / sqrt(X[0] * X[0] + X[1] * X[1]);
}
break;
case YU:
if (vy(X) > 0.0) {
(*this)[sy_index] = -X[1] * vx(X) * rho();
(*this)[sx_index] = X[0] * vx(X) * rho() / sqrt(X[0] * X[0] + X[1] * X[1]);
}
break;
case YL:
if (vy(X) < 0.0) {
(*this)[sy_index] = -X[1] * vx(X) * rho();
(*this)[sx_index] = X[0] * vx(X) * rho() / sqrt(X[0] * X[0] + X[1] * X[1]);
}
break;
#else
case XU:
if (vx() > 0.0) {
set_et(et() - 0.5 * sx() * sx() / rho());
set_sx(0.0);
}
break;
case XL:
if (vx() < 0.0) {
set_et(et() - 0.5 * sx() * sx() / rho());
set_sx(0.0);
}
break;
case YU:
if (vy() > 0.0) {
set_et(et() - 0.5 * sy() * sy() / rho());
set_sy(0.0);
}
break;
case YL:
if (vy() < 0.0) {
set_et(et() - 0.5 * sy() * sy() / rho());
set_sy(0.0);
}
break;
#endif
case ZU:
if (sz() > 0.0) {
set_et(et() - 0.5 * sz() * sz() / rho());
set_sz(0.0);
}
break;
case ZL:
if (sz() < 0.0) {
set_et(et() - 0.5 * sz() * sz() / rho());
set_sz(0.0);
}
break;
}
}
void NetworkConfig::_fromDictionary(const Dictionary &d)
{
static const std::string zero("0");
static const std::string one("1");
// NOTE: d.get(name) throws if not found, d.get(name,default) returns default
_nwid = Utils::hexStrToU64(d.get(ZT_NETWORKCONFIG_DICT_KEY_NETWORK_ID).c_str());
if (!_nwid)
throw std::invalid_argument("configuration contains zero network ID");
_timestamp = Utils::hexStrToU64(d.get(ZT_NETWORKCONFIG_DICT_KEY_TIMESTAMP).c_str());
_revision = Utils::hexStrToU64(d.get(ZT_NETWORKCONFIG_DICT_KEY_REVISION,"1").c_str()); // older controllers don't send this, so default to 1
memset(_etWhitelist,0,sizeof(_etWhitelist));
std::vector<std::string> ets(Utils::split(d.get(ZT_NETWORKCONFIG_DICT_KEY_ALLOWED_ETHERNET_TYPES).c_str(),",","",""));
for(std::vector<std::string>::const_iterator et(ets.begin());et!=ets.end();++et) {
unsigned int tmp = Utils::hexStrToUInt(et->c_str()) & 0xffff;
_etWhitelist[tmp >> 3] |= (1 << (tmp & 7));
}
_issuedTo = Address(d.get(ZT_NETWORKCONFIG_DICT_KEY_ISSUED_TO));
_multicastLimit = Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_MULTICAST_LIMIT,zero).c_str());
if (_multicastLimit == 0) _multicastLimit = ZT_MULTICAST_DEFAULT_LIMIT;
_allowPassiveBridging = (Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_ALLOW_PASSIVE_BRIDGING,zero).c_str()) != 0);
_private = (Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_PRIVATE,one).c_str()) != 0);
_enableBroadcast = (Utils::hexStrToUInt(d.get(ZT_NETWORKCONFIG_DICT_KEY_ENABLE_BROADCAST,one).c_str()) != 0);
_name = d.get(ZT_NETWORKCONFIG_DICT_KEY_NAME);
if (_name.length() > ZT1_MAX_NETWORK_SHORT_NAME_LENGTH)
throw std::invalid_argument("network short name too long (max: 255 characters)");
_description = d.get(ZT_NETWORKCONFIG_DICT_KEY_DESC,std::string());
// In dictionary IPs are split into V4 and V6 addresses, but we don't really
// need that so merge them here.
std::string ipAddrs(d.get(ZT_NETWORKCONFIG_DICT_KEY_IPV4_STATIC,std::string()));
{
std::string v6s(d.get(ZT_NETWORKCONFIG_DICT_KEY_IPV6_STATIC,std::string()));
if (v6s.length()) {
if (ipAddrs.length())
ipAddrs.push_back(',');
ipAddrs.append(v6s);
}
}
std::vector<std::string> ipAddrsSplit(Utils::split(ipAddrs.c_str(),",","",""));
for(std::vector<std::string>::const_iterator ipstr(ipAddrsSplit.begin());ipstr!=ipAddrsSplit.end();++ipstr) {
InetAddress addr(*ipstr);
switch(addr.ss_family) {
case AF_INET:
if ((!addr.netmaskBits())||(addr.netmaskBits() > 32))
continue;
break;
case AF_INET6:
if ((!addr.netmaskBits())||(addr.netmaskBits() > 128))
continue;
break;
default: // ignore unrecognized address types or junk/empty fields
continue;
}
_staticIps.push_back(addr);
}
if (_staticIps.size() > ZT1_MAX_ZT_ASSIGNED_ADDRESSES)
throw std::invalid_argument("too many ZT-assigned IP addresses");
std::sort(_staticIps.begin(),_staticIps.end());
std::unique(_staticIps.begin(),_staticIps.end());
std::vector<std::string> activeBridgesSplit(Utils::split(d.get(ZT_NETWORKCONFIG_DICT_KEY_ACTIVE_BRIDGES,"").c_str(),",","",""));
for(std::vector<std::string>::const_iterator a(activeBridgesSplit.begin());a!=activeBridgesSplit.end();++a) {
if (a->length() == ZT_ADDRESS_LENGTH_HEX) { // ignore empty or garbage fields
Address tmp(*a);
if (!tmp.isReserved())
_activeBridges.push_back(tmp);
}
}
std::sort(_activeBridges.begin(),_activeBridges.end());
std::unique(_activeBridges.begin(),_activeBridges.end());
Dictionary multicastRateEntries(d.get(ZT_NETWORKCONFIG_DICT_KEY_MULTICAST_RATES,std::string()));
for(Dictionary::const_iterator i(multicastRateEntries.begin());i!=multicastRateEntries.end();++i) {
std::vector<std::string> params(Utils::split(i->second.c_str(),",","",""));
if (params.size() >= 3)
_multicastRates[MulticastGroup(i->first)] = MulticastRate(Utils::hexStrToUInt(params[0].c_str()),Utils::hexStrToUInt(params[1].c_str()),Utils::hexStrToUInt(params[2].c_str()));
}
std::vector<std::string> relaysSplit(Utils::split(d.get(ZT_NETWORKCONFIG_DICT_KEY_RELAYS,"").c_str(),",","",""));
for(std::vector<std::string>::const_iterator r(relaysSplit.begin());r!=relaysSplit.end();++r) {
std::size_t semi(r->find(';')); // address;ip/port,...
if (semi == ZT_ADDRESS_LENGTH_HEX) {
std::pair<Address,InetAddress> relay(
Address(r->substr(0,semi)),
((r->length() > (semi + 1)) ? InetAddress(r->substr(semi + 1)) : InetAddress()) );
if ((relay.first)&&(!relay.first.isReserved()))
_relays.push_back(relay);
}
}
std::sort(_relays.begin(),_relays.end());
std::unique(_relays.begin(),_relays.end());
_com.fromString(d.get(ZT_NETWORKCONFIG_DICT_KEY_CERTIFICATE_OF_MEMBERSHIP,std::string()));
}
void GSurface::createForwardDiffMatrices(){
Transformation es(_es), et(_et);
_DDx = (es * _cx * et).m();
_DDy = (es * _cy * et).m();
_DDz = (es * _cz * et).m();
}
void test_2d_compare()
{
P p1 = bg::make<P>(3, 1);
P p2 = bg::make<P>(3, 1);
P p3 = bg::make<P>(1, 3);
P p4 = bg::make<P>(5, 2);
P p5 = bg::make<P>(3, 2);
// Test in all dimensions
{
bg::equal_to<P> et;
bg::less<P> lt;
bg::greater<P> gt;
BOOST_CHECK_EQUAL(et(p1, p2), true);
BOOST_CHECK_EQUAL(et(p1, p3), false);
BOOST_CHECK_EQUAL(et(p1, p4), false);
BOOST_CHECK_EQUAL(et(p1, p5), false);
BOOST_CHECK_EQUAL(et(p3, p4), false);
BOOST_CHECK_EQUAL(lt(p1, p2), false);
BOOST_CHECK_EQUAL(lt(p1, p3), false);
BOOST_CHECK_EQUAL(lt(p1, p4), true);
BOOST_CHECK_EQUAL(lt(p1, p5), true);
BOOST_CHECK_EQUAL(lt(p3, p4), true);
BOOST_CHECK_EQUAL(gt(p1, p2), false);
BOOST_CHECK_EQUAL(gt(p1, p3), true);
BOOST_CHECK_EQUAL(gt(p1, p4), false);
BOOST_CHECK_EQUAL(gt(p1, p5), false);
BOOST_CHECK_EQUAL(gt(p3, p4), false);
}
// Test in dimension 0, X
{
bg::equal_to<P, 0> et;
bg::less<P, 0> lt;
bg::greater<P, 0> gt;
BOOST_CHECK_EQUAL(et(p1, p2), true);
BOOST_CHECK_EQUAL(et(p1, p3), false);
BOOST_CHECK_EQUAL(et(p1, p4), false);
BOOST_CHECK_EQUAL(et(p1, p5), true);
BOOST_CHECK_EQUAL(et(p3, p4), false);
BOOST_CHECK_EQUAL(lt(p1, p2), false);
BOOST_CHECK_EQUAL(lt(p1, p3), false);
BOOST_CHECK_EQUAL(lt(p1, p4), true);
BOOST_CHECK_EQUAL(lt(p1, p5), false);
BOOST_CHECK_EQUAL(lt(p3, p4), true);
BOOST_CHECK_EQUAL(gt(p1, p2), false);
BOOST_CHECK_EQUAL(gt(p1, p3), true);
BOOST_CHECK_EQUAL(gt(p1, p4), false);
BOOST_CHECK_EQUAL(gt(p1, p5), false);
BOOST_CHECK_EQUAL(gt(p3, p4), false);
}
// Test in dimension 1, Y
{
bg::equal_to<P, 1> et;
bg::less<P, 1> lt;
bg::greater<P, 1> gt;
BOOST_CHECK_EQUAL(et(p1, p2), true);
BOOST_CHECK_EQUAL(et(p1, p3), false);
BOOST_CHECK_EQUAL(et(p1, p4), false);
BOOST_CHECK_EQUAL(et(p1, p5), false);
BOOST_CHECK_EQUAL(et(p3, p4), false);
BOOST_CHECK_EQUAL(lt(p1, p2), false);
BOOST_CHECK_EQUAL(lt(p1, p3), true);
BOOST_CHECK_EQUAL(lt(p1, p4), true);
BOOST_CHECK_EQUAL(lt(p1, p5), true);
BOOST_CHECK_EQUAL(lt(p3, p4), false);
BOOST_CHECK_EQUAL(gt(p1, p2), false);
BOOST_CHECK_EQUAL(gt(p1, p3), false);
BOOST_CHECK_EQUAL(gt(p1, p4), false);
BOOST_CHECK_EQUAL(gt(p1, p5), false);
BOOST_CHECK_EQUAL(gt(p3, p4), true);
}
}
void Jacobi(const SymmetricMatrix& X, DiagonalMatrix& D, SymmetricMatrix& A,
Matrix& V, bool eivec)
{
Real epsilon = FloatingPointPrecision::Epsilon();
Tracer et("Jacobi");
REPORT
int n = X.Nrows(); DiagonalMatrix B(n), Z(n); D.resize(n); A = X;
if (eivec) { REPORT V.resize(n,n); D = 1.0; V = D; }
B << A; D = B; Z = 0.0; A.Inject(Z);
bool converged = false;
for (int i=1; i<=50; i++)
{
Real sm=0.0; Real* a = A.Store(); int p = A.Storage();
while (p--) sm += fabs(*a++); // have previously zeroed diags
if (sm==0.0) { REPORT converged = true; break; }
Real tresh = (i<4) ? 0.2 * sm / square(n) : 0.0; a = A.Store();
for (p = 0; p < n; p++)
{
Real* ap1 = a + (p*(p+1))/2;
Real& zp = Z.element(p); Real& dp = D.element(p);
for (int q = p+1; q < n; q++)
{
Real* ap = ap1; Real* aq = a + (q*(q+1))/2;
Real& zq = Z.element(q); Real& dq = D.element(q);
Real& apq = A.element(q,p);
Real g = 100 * fabs(apq); Real adp = fabs(dp); Real adq = fabs(dq);
if (i>4 && g < epsilon*adp && g < epsilon*adq) { REPORT apq = 0.0; }
else if (fabs(apq) > tresh)
{
REPORT
Real t; Real h = dq - dp; Real ah = fabs(h);
if (g < epsilon*ah) { REPORT t = apq / h; }
else
{
REPORT
Real theta = 0.5 * h / apq;
t = 1.0 / ( fabs(theta) + sqrt(1.0 + square(theta)) );
if (theta<0.0) { REPORT t = -t; }
}
Real c = 1.0 / sqrt(1.0 + square(t)); Real s = t * c;
Real tau = s / (1.0 + c); h = t * apq;
zp -= h; zq += h; dp -= h; dq += h; apq = 0.0;
int j = p;
while (j--)
{
g = *ap; h = *aq;
*ap++ = g-s*(h+g*tau); *aq++ = h+s*(g-h*tau);
}
int ip = p+1; j = q-ip; ap += ip++; aq++;
while (j--)
{
g = *ap; h = *aq;
*ap = g-s*(h+g*tau); *aq++ = h+s*(g-h*tau);
ap += ip++;
}
if (q < n-1) // last loop is non-empty
{
int iq = q+1; j = n-iq; ap += ip++; aq += iq++;
for (;;)
{
g = *ap; h = *aq;
*ap = g-s*(h+g*tau); *aq = h+s*(g-h*tau);
if (!(--j)) break;
ap += ip++; aq += iq++;
}
}
if (eivec)
{
REPORT
RectMatrixCol VP(V,p); RectMatrixCol VQ(V,q);
Rotate(VP, VQ, tau, s);
}
}
}
}
B = B + Z; D = B; Z = 0.0;
}
if (!converged) Throw(ConvergenceException(X));
if (eivec) SortSV(D, V, true);
else SortAscending(D);
}
int
main (int argc,
char **argv)
{
const char *options("hs:u:v");
bool qVerbose(false);
std::string saveFilename;
typedef std::vector<std::string> tStrings;
tStrings urls;
for (int c; (c = getopt(argc, argv, options)) != EOF;) {
switch (c) {
case 's': saveFilename = optarg; break;
case 'u': urls.push_back(optarg); break;
case 'v': qVerbose = !qVerbose; break;
default:
std::cerr << "Unrecognized option (" << ((char) optopt) << ")" << std::endl;
case 'h':
return usage(argv[0], options);
}
}
if (optind < argc) {
std::cerr << "Unprocessed command line arguments:";
for (int i(optind); i < argc; ++i) {
std::cerr << " '" << argv[i] << "'";
}
std::cerr << std::endl;
return usage(argv[0], options);
}
if (urls.empty()) { // Build from database
std::cerr << "urls from database not currently implemented!" << std::endl;
return 1;
}
for (tStrings::const_iterator it(urls.begin()), et(urls.end()); it != et; ++it) {
const std::string::size_type j(it->find(':'));
if (j == it->npos) {
std::cerr << "Malformed parser:URL field(" << *it << ")" << std::endl;
return 1;
}
const std::string parser(it->substr(0,j));
const std::string url(it->substr(j+1));
Curl curl(url, qVerbose); // Load the file
if (!curl) {
std::cerr << "Error fetching '" << url << "', " << curl.errmsg() << std::endl;
continue;
}
if (curl.responseCode() != 200) {
std::cerr << "Error fetching '" << url
<< "', response code " << curl.responseCode()
<< ", " << HTTP::statusMsg(curl.responseCode())
<< std::endl;
continue;
}
if (!saveFilename.empty()) {
std::ofstream os(saveFilename);
if (!os) {
std::cerr << "Error opening '" << saveFilename << "', " << strerror(errno) << std::endl;
return 1;
}
os << curl.str();
}
if (parser == "USGS0") {
ParserUSGS0 a(url, curl.str(), qVerbose);
} else if (parser == "USGS1") {
ParserUSGS1 a(url, curl.str(), qVerbose);
} else if (parser == "NOAA0") {
ParserNOAA0 a(url, curl.str(), qVerbose);
} else {
std::cerr << "Unrecongized parser '" << parser << "'" << std::endl;
continue;
}
}
return 0;
}
