static double lobatto_fn_1(double x) { return l1(x); }
/**
* The block index used by find_block_by_height.
*/
const std::shared_ptr<block_index> & block_index_fbbh_last() const
{
std::lock_guard<std::mutex> l1(mutex_);
return m_block_index_fbbh_last;
}
/**
* Sets the main wallet.
* @param val The wallet.
*/
void set_wallet_main(const std::shared_ptr<wallet> & val)
{
std::lock_guard<std::mutex> l1(mutex_);
m_wallet_main = val;
}
/**
* The best block height.
*/
const std::int32_t & best_block_height() const
{
std::lock_guard<std::mutex> l1(mutex_);
return m_best_block_height;
}
/**
* Sets the hash of the best chain.
*/
void set_hash_best_chain(const sha256 & value)
{
std::lock_guard<std::mutex> l1(mutex_);
m_hash_best_chain = value;
}
static double refmap_hex_dz_f7(double x, double y, double z) { return l0(x) * l1(y) * dl1(z); }
int main(int argc,
char ** argv)
{
QApplication app(argc, argv);
MaliitKeyboard::Dashboard *dashboard = new MaliitKeyboard::Dashboard;
dashboard->show();
MaliitKeyboard::Renderer renderer;
// renderer.setSurfaceFactory(dashboard);
dashboard->setRenderer(&renderer);
MaliitKeyboard::Glass glass;
// glass.setWindow(renderer.viewport());
// One layout updater can only manage one layout. If more layouts need to
// be managed, then more layout updaters are required.
MaliitKeyboard::LayoutUpdater lu0;
MaliitKeyboard::SharedLayout l0(new MaliitKeyboard::Layout);
l0->setAlignment(MaliitKeyboard::Layout::Bottom);
l0->setScreenSize(dashboard->size());
MaliitKeyboard::Font font;
font.setColor(QByteArray("#ddd"));
font.setSize(20);
MaliitKeyboard::WordRibbon ribbon;
MaliitKeyboard::Area area;
area.setBackground(QByteArray("key-background.png"));
area.setBackgroundBorders(QMargins(10, 10, 10, 10));
area.setSize(QSize(856, 40));
ribbon.setArea(area);
l0->setWordRibbon(ribbon);
renderer.addLayout(l0);
glass.addLayout(l0);
lu0.setLayout(l0);
MaliitKeyboard::SharedLayout l1(new MaliitKeyboard::Layout);
l1->setAlignment(MaliitKeyboard::Layout::Top);
l1->setScreenSize(dashboard->size());
renderer.addLayout(l1);
glass.addLayout(l1);
MaliitKeyboard::LayoutUpdater lu1;
lu1.setLayout(l1);
MaliitKeyboard::Logic::WordEngine word_engine;
DefaultFeedback feedback;
MaliitKeyboard::Setup::connectAll(&glass, &lu0, &renderer, dashboard->editor(), &word_engine, &feedback);
MaliitKeyboard::Setup::connectGlassToLayoutUpdater(&glass, &lu1);
MaliitKeyboard::Setup::connectLayoutUpdaterToRenderer(&lu1, &renderer);
QObject::connect(&glass, SIGNAL(keyboardClosed()),
dashboard, SLOT(onHide()));
QObject::connect(dashboard, SIGNAL(orientationChanged(Layout::Orientation)),
&lu0, SLOT(setOrientation(Layout::Orientation)));
QObject::connect(dashboard, SIGNAL(orientationChanged(Layout::Orientation)),
&lu1, SLOT(setOrientation(Layout::Orientation)));
QObject::connect(&glass, SIGNAL(keyboardClosed()),
dashboard, SIGNAL(keyboardClosed()));
QObject::connect(dashboard, SIGNAL(keyboardClosed()),
&lu0, SLOT(resetOnKeyboardClosed()));
QObject::connect(dashboard, SIGNAL(keyboardClosed()),
&lu1, SLOT(resetOnKeyboardClosed()));
QObject::connect(dashboard, SIGNAL(keyboardClosed()),
&renderer, SLOT(hide()));
QObject::connect(dashboard, SIGNAL(keyboardClosed()),
dashboard, SLOT(onHide()));
// Allow to specify keyboard id via command line:
QString keyboard_id("en_gb");
bool found_keyboard_id = false;
Q_FOREACH (const QString &arg, QApplication::arguments()) {
if (found_keyboard_id && not arg.isEmpty()) {
keyboard_id = arg;
}
if (arg == "--id" || arg == "-id") {
found_keyboard_id = true;
}
}
lu0.setActiveKeyboardId(keyboard_id);
lu1.setActiveKeyboardId("toolbar");
renderer.show();
return app.exec();
}
/**
* The allowed addresses.
*/
std::set<std::string> & allowed_addresses_rpc()
{
std::lock_guard<std::mutex> l1(mutex_);
return m_allowed_addresses_rpc;
}
/**
* The banned addresses.
*/
std::map<std::string, std::time_t> & banned_addresses()
{
std::lock_guard<std::mutex> l1(mutex_);
return m_banned_addresses;
}
static double doLineDetection(cv::Mat img) {
const float MAX_ANGLE = 1.5;
const float GRADIENT_MATCH_ERROR = 0.3; //1 radian error margin
const float CIRC_RADIUS = 1;
const int CANNY_KERNEL_SIZE = 3;
//apply a Canny filter so we get edges of lines
cv::Mat cannyImg = img;
//cv::Canny(img, cannyImg, 50, 200, CANNY_KERNEL_SIZE);
#ifdef DEBUG
cv::imshow("canny", cannyImg);
#endif
std::vector<cv::Vec4i> lines;
HoughLinesP(cannyImg, lines, RESOLUTION_PX, RESOLUTION_DEG, MIN_THRESHOLD, MIN_LINE_LENGTH, MAX_LINE_GAP);
#ifdef DEBUG
cv::Mat debugImg;
cv::cvtColor(cannyImg, debugImg, CV_GRAY2RGB);
//draw all the lines and display
for( size_t i = 0; i < lines.size(); i++ ) {
cv::Vec4i l = lines[i];
cv::line(debugImg, cv::Point(l[0], l[1]), cv::Point(l[2], l[3]), cv::Scalar(0,0,255), 3, CV_AA);
}
unsigned char lineColour = 0;
#endif
//calculate the angles of the lines
std::vector<double> angles;
std::vector<cv::Vec4i> goodLines;
for(size_t i =0; i < lines.size(); i++) {
const cv::Vec4i l = lines[i];
//gradient is (y1-y2)/(x1-x2)
double angle = gradient(l);
#ifdef DEBUG
ROS_INFO("%f gradient", angle);
#endif
if (fabs(angle) < MAX_ANGLE) {
angles.push_back(angle);
goodLines.push_back(l);
#ifdef DEBUG
lineColour+=5;
cv::line(debugImg, cv::Point(l[0], l[1]), cv::Point(l[2], l[3]), cv::Scalar(lineColour,255,0), 3, CV_AA);
#endif
}
}
#ifdef DEBUG
cv::imshow("lines", debugImg);
ROS_INFO("Next img");
#endif
if(angles.size() > 0) {
std::vector<double> chosenAngles;
for(int i = 0; i < angles.size(); ++i) {
for(int j = 0; j < angles.size(); ++j) {
if(fabs(angles[i] - angles[j]) < GRADIENT_MATCH_ERROR) {
bool found = false;
cv::Vec4i goodLine;
//there are four possible lines, we want the one with the matching gradient (if it exists)
for(int k = 0; k < 2; ++k) {
for(int m = 0; m < 2; ++m) {
cv::Vec4i l1(goodLines[i][k*2], goodLines[i][(k*2)+1], goodLines[j][m*2], goodLines[j][(m*2)+1]);
if(fabs(angles[i] - gradient(l1)) < GRADIENT_MATCH_ERROR) {
found = true;
goodLine = l1;
break;
}
}
}
if(!found) {
ROS_INFO("Line not valid");
} else {
//check if the line passes through the center (ish)
//use the shortest distance from point to line formula
//http://math.stackexchange.com/questions/275529/check-if-line-intersects-with-circles-perimeter
const int centerY = cannyImg.size().height/2;
const int centerX = cannyImg.size().height/2;
const int numerator = fabs(
(goodLine[2] - goodLine[0])*centerX +
(goodLine[1] - goodLine[3])*centerY +
(goodLine[0] - goodLine[2])*goodLine[1] +
(goodLine[3] - goodLine[1])*goodLine[0]
);
const int denominator = sqrt(
pow(goodLine[2] - goodLine[0], 2) +
pow(goodLine[1] - goodLine[3], 2)
);
if((numerator/denominator) <= CIRC_RADIUS) {
chosenAngles.push_back(gradient(goodLine));
ROS_INFO("Good line found m: %f, x1: %d, y1 %d, x2 %d, y2 %d", angles[i], goodLine[0], goodLine[1], goodLine[2], goodLine[3]);
#ifdef DEBUG
cv::line(debugImg, cv::Point(goodLine[0], goodLine[1]), cv::Point(goodLine[2], goodLine[3]), cv::Scalar(255,0,0), 3, CV_AA);
#endif
}
}
}
#ifdef DEBUG
cv::imshow("good lines", debugImg);
#endif
}
}
#ifdef DEBUG_WAIT
cv::waitKey();
#endif
if(chosenAngles.size() > 0) {
double minGradient = chosenAngles[0];
for(int i = 0; i < chosenAngles.size(); ++i) {
if(fabs(minGradient) > fabs(chosenAngles[i]) ){
minGradient = chosenAngles[i];
}
}
return minGradient;
} else {
ROS_ERROR("No Good lines found");
return std::numeric_limits<double>::infinity() * -1;
}
} else {
#ifdef DEBUG_WAIT
cv::waitKey();
#endif
ROS_ERROR("No lines found");
return std::numeric_limits<double>::infinity();
}
}
void doJob(BlockScope *scope) override {
try {
auto visitor =
(DepthFirstVisitor<When, OptVisitor>*) m_context;
{
Lock ldep(BlockScope::s_depsMutex);
Lock lstate(BlockScope::s_jobStateMutex);
always_assert(scope->getMark() == BlockScope::MarkReady);
if (scope->getNumDepsToWaitFor()) {
scope->setMark(BlockScope::MarkWaiting);
return;
}
scope->setMark(BlockScope::MarkProcessing);
}
scope->setForceRerun(false);
// creates on demand
AnalysisResult::s_changedScopesMapThreadLocal->clear();
int useKinds = visitor->visitScope(BlockScopeRawPtr(scope));
assert(useKinds >= 0);
{
Lock l2(BlockScope::s_depsMutex);
Lock l1(BlockScope::s_jobStateMutex);
assert(scope->getMark() == BlockScope::MarkProcessing);
assert(scope->getNumDepsToWaitFor() == 0);
// re-enqueue changed scopes, regardless of rescheduling exception.
// this is because we might have made changes to other scopes which we
// do not undo, so we need to announce their updates
for (const auto& local : *AnalysisResult::s_changedScopesMapThreadLocal) {
for (const auto& pf : local.first->getOrderedUsers()) {
if ((pf->second & GetPhaseInterestMask<When>()) &&
(pf->second & local.second)) {
int m = pf->first->getMark();
switch (m) {
case BlockScope::MarkWaiting:
case BlockScope::MarkReady:
; // no-op
break;
case BlockScope::MarkProcessing:
pf->first->setForceRerun(true);
break;
case BlockScope::MarkProcessed:
if (visitor->activateScope(pf->first)) {
visitor->enqueue(pf->first);
}
break;
default: assert(false);
}
}
}
}
AnalysisResult::s_changedScopesMapThreadLocal.destroy();
useKinds |= scope->rescheduleFlags();
scope->setRescheduleFlags(0);
for (const auto& pf : scope->getOrderedUsers()) {
if (pf->second & GetPhaseInterestMask<When>()) {
int m = pf->first->getMark();
if (pf->second & useKinds && m == BlockScope::MarkProcessed) {
bool ready = visitor->activateScope(pf->first);
always_assert(!ready);
m = BlockScope::MarkWaiting;
}
if (m == BlockScope::MarkWaiting || m == BlockScope::MarkReady) {
int nd = pf->first->getNumDepsToWaitFor();
always_assert(nd >= 1);
if (!pf->first->decNumDepsToWaitFor() &&
m == BlockScope::MarkWaiting) {
pf->first->setMark(BlockScope::MarkReady);
visitor->enqueue(pf->first);
}
} else if (pf->second & useKinds &&
m == BlockScope::MarkProcessing) {
// This is conservative: If we have a user who is currently
// processing (yes, this can potentially happen if we add a
// user *after* the initial dep graph has been formed), then we
// have no guarantee that the scope read this scope's updates
// in its entirety. Thus, we must force it to run again in
// order to be able to observe all the updates.
always_assert(pf->first->getNumDepsToWaitFor() == 0);
pf->first->setForceRerun(true);
}
}
}
scope->setMark(BlockScope::MarkProcessed);
if (scope->forceRerun()) {
if (visitor->activateScope(BlockScopeRawPtr(scope))) {
visitor->enqueue(BlockScopeRawPtr(scope));
}
} else {
for (const auto& p : scope->getDeps()) {
if (*p.second & GetPhaseInterestMask<When>()) {
if (p.first->getMark() == BlockScope::MarkProcessing) {
bool ready = visitor->activateScope(BlockScopeRawPtr(scope));
always_assert(!ready);
break;
}
}
}
}
}
} catch (Exception &e) {
Logger::Error("%s", e.getMessage().c_str());
}
}
int test()
{
#ifdef CH_USE_HDF5
int error;
HDF5Handle testFile;
CH_assert(!testFile.isOpen());
error = testFile.open("data.h5", HDF5Handle::CREATE);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "File creation failed "<<error<<endl;
return error;
}
CH_assert(testFile.isOpen());
Box domain(IntVect::Zero, 20*IntVect::Unit);
DisjointBoxLayout plan1, plan2;
{
IntVectSet tags;
IntVect center = 10*IntVect::Unit;
setCircleTags(tags, 6, 1, center); //circle/sphere
buildDisjointBoxLayout(plan1, tags, domain);
tags.makeEmpty();
setCircleTags(tags, 5, 2, center);
buildDisjointBoxLayout(plan2, tags, domain);
}
if ( verbose )
{
pout() << "plan1: " << procID() << "...." << plan1 << endl;
pout() << "plan2: " << procID() << "...." << plan2 << endl;
}
//test LayoutData<Real> specialization
LayoutData<Real> specialReal(plan1);
LayoutData<Moment> vlPlan(plan1);
LevelData<BaseFab<int> > level1(plan1, 3, IntVect::Unit);
LevelData<BaseFab<int> > level2;
level2.define(level1);
level2.define(plan2, 1);
for (DataIterator i(level2.dataIterator()); i.ok(); ++i)
{
level2[i()].setVal(2);
}
level1.apply(values::setVal1);
level2.apply(values::setVal2);
HDF5HeaderData set1;
Real dx=0.004;
Box b1(IntVect(D_DECL6(1,2,1,1,2,1)), IntVect(D_DECL6(4,4,4,4,4,4)));
Box b2(IntVect(D_DECL6(5,2,1,5,2,1)), IntVect(D_DECL6(12,4,4,12,4,4)));
int currentStep = 2332;
set1.m_string["name"] = "set1";
set1.m_real["dx"] = dx;
set1.m_int["currentStep"] = currentStep;
set1.m_intvect["some intvect or other"] = b1.smallEnd();
set1.m_box["b1"] = b1;
set1.m_box["b2"] = b2;
testFile.setGroupToLevel(1);
error = write(testFile, plan1);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "box write failed "<<error<<endl;
return error;
}
error = write(testFile, level1, "level1 state vector");
if (error != 0)
{
if ( verbose )
pout() << indent2 << "BoxLayoutData 1 write failed "<<error<<endl;
return error;
}
testFile.setGroupToLevel(2);
error = write(testFile, plan2);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "box2 write failed "<<error<<endl;
return error;
}
error = write(testFile, level2, "level2 state vector");
if (error != 0)
{
if ( verbose )
pout() << indent2 << "BoxLayoutData 2 write failed "<<error<<endl;
return error;
}
LevelData<FArrayBox> state(plan2, 3);
state.apply(values::setVal3);
testFile.setGroupToLevel(0);
set1.writeToFile(testFile);
error = write(testFile, plan2);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "box2 write failed "<<error<<endl;
return error;
}
testFile.setGroup("/");
error = writeLevel(testFile, 0, state, 2, 1, 0.001, b2, 2);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "BoxLayoutData 2 write failed "<<error<<endl;
return error;
}
set1.writeToFile(testFile);
set1.writeToFile(testFile);
testFile.close();
CH_assert(!testFile.isOpen());
// test the utility functions ReadUGHDF5 and WriteUGHDF5
WriteUGHDF5("UGIO.hdf5", plan2, state, domain);
ReadUGHDF5("UGIO.hdf5", plan2, state, domain);
//========================================================================
//
// now, read this data back in
//
//========================================================================
BoxLayoutData<BaseFab<int> > readlevel1, readlevel2;
error = testFile.open("data.h5", HDF5Handle::OPEN_RDONLY);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "File open failed "<<error<<endl;
return error;
}
testFile.setGroupToLevel(2);
Vector<Box> boxes;
error = read(testFile, boxes);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "box read failed "<<error<<endl;
return error;
}
boxes.sort();
Vector<int> assign;
error = LoadBalance(assign, boxes);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "BoxLayout LoadBalance failed "<<error<<endl;
return error;
}
BoxLayout readplan2(boxes, assign);
readplan2.close();
error = read(testFile, readlevel2, "level2 state vector", readplan2);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "BoxLayoutData<BaseFab<int>> read failed "<<error<<endl;
return error;
}
testFile.setGroupToLevel(1);
error = read(testFile, boxes);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "box read failed "<<error<<endl;
return error;
}
error = LoadBalance(assign, boxes);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "BoxLayout LoadBalance failed "<<error<<endl;
return error;
}
BoxLayout readplan1(boxes, assign);
readplan1.close();
if ( verbose )
{
pout() << "readplan1: " << procID() << "...." << readplan1 << endl;
pout() << "readplan2: " << procID() << "...." << readplan2 << endl;
}
error = read(testFile, readlevel1, "level1 state vector", readplan1);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "BoxLayoutData<BaseFab<int>> read failed "<<error<<endl;
return error;
}
if ( verbose )
pout() << plan1<<readplan1<<endl;
// real test of IO, make sure the data is the same coming and going
DataIterator l1 = level1.dataIterator();
DataIterator rl1 = readlevel1.dataIterator();
DataIterator l2 = level2.dataIterator();
DataIterator rl2 = readlevel2.dataIterator();
if (level1.boxLayout().size() != readlevel1.boxLayout().size())
{
if ( verbose )
pout() << indent2 << "level1.size() != readl1.size() read failed "<<error<<endl;
return 1;
}
if (level2.boxLayout().size() != readlevel2.boxLayout().size())
{
if ( verbose )
pout() << indent2 << "level2.size() != readl2.size() read failed "<<error<<endl;
return 1;
}
// we can assume that BoxLayout IO is tested in HDF5boxIO
BaseFab<int>* before, *after;
for (; l1.ok(); ++l1, ++rl1)
{
before = &(level1[l1()]); after = &(readlevel1[rl1()]);
for (int c=0; c<before->nComp(); ++c)
{
for (BoxIterator it(level1.box(l1())); it.ok(); ++it)
{
if ((*before)(it(), c) != (*after)(it(), c))
{
if ( verbose )
pout() << indent2 << "l1 != readl1 read failed "<<error<<endl;
return 2;
}
}
}
}
for (; l2.ok(); ++l2, ++rl2)
{
before = &(level2[l2()]); after = &(readlevel2[rl2()]);
for (int c=0; c<before->nComp(); ++c)
{
for (BoxIterator it(level2.box(l2())); it.ok(); ++it)
{
if ((*before)(it(), c) != (*after)(it(), c))
{
if ( verbose )
pout() << indent2 << "level2 != readlevel2 read failed "<<error<<endl;
return 3;
}
}
}
}
LevelData<FArrayBox> readState;
Real dt, time;
int refRatio;
testFile.setGroup("/");
error = readLevel(testFile, 0, readState, dx, dt, time, b2, refRatio);
if (error != 0)
{
if ( verbose )
pout() << indent2 << "readLevel failed "<<error<<endl;
return error;
}
#ifndef CH_MPI
// OK, now try to read one FArrayBox at a time
// problem with DataIterator and running the out-of-core in parallel, so
// have to think about that for now BVS.
FArrayBox readFAB;
Interval interval(1,2);
testFile.setGroup("/");
int index=0;
for (DataIterator dit(state.dataIterator()); dit.ok(); ++index,++dit)
{
FArrayBox& fab = state[dit()];
readFArrayBox(testFile, readFAB, 0, index, interval);
for (BoxIterator it(state.box(dit())) ; it.ok() ; ++it)
{
if (readFAB(it(), 0) != fab(it(), 1))
{
if ( verbose )
pout() << indent2 << "state != after for out-of-core "<<error<<endl;
return 3;
}
}
}
#endif
testFile.close();
CH_assert(!testFile.isOpen());
#endif // CH_USE_HDF5
return 0;
}
int main (int, char**)
{
UnitTest t (1208);
std::vector <std::pair <std::string, Lexer::Type>> tokens;
std::string token;
Lexer::Type type;
// Feed in some attributes and types, so that the Lexer knows what a DOM
// reference is.
Lexer::attributes["due"] = "date";
Lexer::attributes["tags"] = "string";
Lexer::attributes["description"] = "string";
// White space detection.
t.notok (Lexer::isWhitespace (0x0041), "U+0041 (A) ! isWhitespace");
t.ok (Lexer::isWhitespace (0x0020), "U+0020 isWhitespace");
t.ok (Lexer::isWhitespace (0x0009), "U+0009 isWhitespace");
t.ok (Lexer::isWhitespace (0x000A), "U+000A isWhitespace");
t.ok (Lexer::isWhitespace (0x000B), "U+000B isWhitespace");
t.ok (Lexer::isWhitespace (0x000C), "U+000C isWhitespace");
t.ok (Lexer::isWhitespace (0x000D), "U+000D isWhitespace");
t.ok (Lexer::isWhitespace (0x0085), "U+0085 isWhitespace");
t.ok (Lexer::isWhitespace (0x00A0), "U+00A0 isWhitespace");
t.ok (Lexer::isWhitespace (0x1680), "U+1680 isWhitespace"); // 10
t.ok (Lexer::isWhitespace (0x180E), "U+180E isWhitespace");
t.ok (Lexer::isWhitespace (0x2000), "U+2000 isWhitespace");
t.ok (Lexer::isWhitespace (0x2001), "U+2001 isWhitespace");
t.ok (Lexer::isWhitespace (0x2002), "U+2002 isWhitespace");
t.ok (Lexer::isWhitespace (0x2003), "U+2003 isWhitespace");
t.ok (Lexer::isWhitespace (0x2004), "U+2004 isWhitespace");
t.ok (Lexer::isWhitespace (0x2005), "U+2005 isWhitespace");
t.ok (Lexer::isWhitespace (0x2006), "U+2006 isWhitespace");
t.ok (Lexer::isWhitespace (0x2007), "U+2007 isWhitespace");
t.ok (Lexer::isWhitespace (0x2008), "U+2008 isWhitespace"); // 20
t.ok (Lexer::isWhitespace (0x2009), "U+2009 isWhitespace");
t.ok (Lexer::isWhitespace (0x200A), "U+200A isWhitespace");
t.ok (Lexer::isWhitespace (0x2028), "U+2028 isWhitespace");
t.ok (Lexer::isWhitespace (0x2029), "U+2029 isWhitespace");
t.ok (Lexer::isWhitespace (0x202F), "U+202F isWhitespace");
t.ok (Lexer::isWhitespace (0x205F), "U+205F isWhitespace");
t.ok (Lexer::isWhitespace (0x3000), "U+3000 isWhitespace");
// static bool Lexer::isBoundary (int, int);
t.ok (Lexer::isBoundary (' ', 'a'), "' ' --> 'a' = isBoundary");
t.ok (Lexer::isBoundary ('a', ' '), "'a' --> ' ' = isBoundary");
t.ok (Lexer::isBoundary (' ', '+'), "' ' --> '+' = isBoundary");
t.ok (Lexer::isBoundary (' ', ','), "' ' --> ',' = isBoundary");
t.notok (Lexer::isBoundary ('3', '4'), "'3' --> '4' = isBoundary");
t.ok (Lexer::isBoundary ('(', '('), "'(' --> '(' = isBoundary");
t.notok (Lexer::isBoundary ('r', 'd'), "'r' --> 'd' = isBoundary");
// static bool Lexer::wasQuoted (const std::string&);
t.notok (Lexer::wasQuoted (""), "'' --> !wasQuoted");
t.notok (Lexer::wasQuoted ("foo"), "'foo' --> !wasQuoted");
t.ok (Lexer::wasQuoted ("a b"), "'a b' --> wasQuoted");
t.ok (Lexer::wasQuoted ("(a)"), "'(a)' --> wasQuoted");
// static bool Lexer::dequote (std::string&, const std::string& quotes = "'\"");
token = "foo";
Lexer::dequote (token);
t.is (token, "foo", "dequote foo --> foo");
token = "'foo'";
Lexer::dequote (token);
t.is (token, "foo", "dequote 'foo' --> foo");
token = "'o\\'clock'";
Lexer::dequote (token);
t.is (token, "o\\'clock", "dequote 'o\\'clock' --> o\\'clock");
token = "abba";
Lexer::dequote (token, "a");
t.is (token, "bb", "dequote 'abba' (a) --> bb");
// Should result in no tokens.
Lexer l0 ("");
t.notok (l0.token (token, type), "'' --> no tokens");
// Should result in no tokens.
Lexer l1 (" \t ");
t.notok (l1.token (token, type), "' \\t ' --> no tokens");
// \u20ac = Euro symbol.
Lexer l2 (" one 'two \\'three\\''+456-(1.3*2 - 0x12) 1.2e-3.4 foo.bar and '\\u20ac'");
tokens.clear ();
while (l2.token (token, type))
{
std::cout << "# «" << token << "» " << Lexer::typeName (type) << "\n";
tokens.push_back (std::pair <std::string, Lexer::Type> (token, type));
}
t.is (tokens[0].first, "one", "tokens[0] = 'one'"); // 30
t.is (Lexer::typeName (tokens[0].second), "identifier", "tokens[0] = identifier");
t.is (tokens[1].first, "'two 'three''", "tokens[1] = 'two 'three''");
t.is (Lexer::typeName (tokens[1].second), "string", "tokens[1] = string");
t.is (tokens[2].first, "+", "tokens[2] = '+'");
t.is (Lexer::typeName (tokens[2].second), "op", "tokens[2] = op");
t.is (tokens[3].first, "456", "tokens[3] = '456'");
t.is (Lexer::typeName (tokens[3].second), "number", "tokens[3] = number");
t.is (tokens[4].first, "-", "tokens[4] = '-'");
t.is (Lexer::typeName (tokens[4].second), "op", "tokens[4] = op");
t.is (tokens[5].first, "(", "tokens[5] = '('"); // 40
t.is (Lexer::typeName (tokens[5].second), "op", "tokens[5] = op");
t.is (tokens[6].first, "1.3", "tokens[6] = '1.3'");
t.is (Lexer::typeName (tokens[6].second), "number", "tokens[6] = number");
t.is (tokens[7].first, "*", "tokens[7] = '*'");
t.is (Lexer::typeName (tokens[7].second), "op", "tokens[7] = op");
t.is (tokens[8].first, "2", "tokens[8] = '2'");
t.is (Lexer::typeName (tokens[8].second), "number", "tokens[8] = number");
t.is (tokens[9].first, "-", "tokens[9] = '-'");
t.is (Lexer::typeName (tokens[9].second), "op", "tokens[9] = op");
t.is (tokens[10].first, "0x12", "tokens[10] = '0x12'"); // 50
t.is (Lexer::typeName (tokens[10].second), "hex", "tokens[10] = hex");
t.is (tokens[11].first, ")", "tokens[11] = ')'");
t.is (Lexer::typeName (tokens[11].second), "op", "tokens[11] = op");
t.is (tokens[12].first, "1.2e-3.4", "tokens[12] = '1.2e-3.4'");
t.is (Lexer::typeName (tokens[12].second), "number", "tokens[12] = number");
t.is (tokens[13].first, "foo.bar", "tokens[13] = 'foo.bar'");
t.is (Lexer::typeName (tokens[13].second), "identifier", "tokens[13] = identifier");
t.is (tokens[14].first, "and", "tokens[14] = 'and'"); // 60
t.is (Lexer::typeName (tokens[14].second), "op", "tokens[14] = op");
t.is (tokens[15].first, "'€'", "tokens[15] = \\u20ac --> ''€''");
t.is (Lexer::typeName (tokens[15].second), "string", "tokens[15] = string");
// Test for numbers that are no longer ISO-8601 dates.
Lexer l3 ("1 12 123 1234 12345 123456 1234567");
tokens.clear ();
while (l3.token (token, type))
{
std::cout << "# «" << token << "» " << Lexer::typeName (type) << "\n";
tokens.push_back (std::pair <std::string, Lexer::Type> (token, type));
}
t.is ((int)tokens.size (), 7, "7 tokens");
t.is (tokens[0].first, "1", "tokens[0] == '1'");
t.is ((int) tokens[0].second, (int) Lexer::Type::number, "tokens[0] == Type::number");
t.is (tokens[1].first, "12", "tokens[1] == '12'");
t.is ((int) tokens[1].second, (int) Lexer::Type::number, "tokens[1] == Type::date");
t.is (tokens[2].first, "123", "tokens[2] == '123'");
t.is ((int) tokens[2].second, (int) Lexer::Type::number, "tokens[2] == Type::number"); // 70
t.is (tokens[3].first, "1234", "tokens[3] == '1234'");
t.is ((int) tokens[3].second, (int) Lexer::Type::number, "tokens[3] == Type::date");
t.is (tokens[4].first, "12345", "tokens[4] == '12345'");
t.is ((int) tokens[4].second, (int) Lexer::Type::number, "tokens[4] == Type::number");
t.is (tokens[5].first, "123456", "tokens[5] == '123456'");
t.is ((int) tokens[5].second, (int) Lexer::Type::number, "tokens[5] == Type::date");
t.is (tokens[6].first, "1234567", "tokens[6] == '1234567'");
t.is ((int) tokens[6].second, (int) Lexer::Type::number, "tokens[6] == Type::number");
// void split (std::vector<std::string>&, const std::string&);
std::string unsplit = " ( A or B ) ";
std::vector <std::string> items;
items = Lexer::split (unsplit);
t.is (items.size (), (size_t) 5, "split ' ( A or B ) '");
t.is (items[0], "(", "split ' ( A or B ) ' -> [0] '('");
t.is (items[1], "A", "split ' ( A or B ) ' -> [1] 'A'");
t.is (items[2], "or", "split ' ( A or B ) ' -> [2] 'or'");
t.is (items[3], "B", "split ' ( A or B ) ' -> [3] 'B'");
t.is (items[4], ")", "split ' ( A or B ) ' -> [4] ')'");
// Test simple mode with contrived tokens that ordinarily split.
unsplit = " +-* a+b 12.3e4 'c d'";
items = Lexer::split (unsplit);
t.is (items.size (), (size_t) 8, "split ' +-* a+b 12.3e4 'c d''");
t.is (items[0], "+", "split ' +-* a+b 12.3e4 'c d'' -> [0] '+'");
t.is (items[1], "-", "split ' +-* a+b 12.3e4 'c d'' -> [1] '-'");
t.is (items[2], "*", "split ' +-* a+b 12.3e4 'c d'' -> [2] '*'");
t.is (items[3], "a", "split ' +-* a+b 12.3e4 'c d'' -> [3] 'a'");
t.is (items[4], "+", "split ' +-* a+b 12.3e4 'c d'' -> [4] '+'");
t.is (items[5], "b", "split ' +-* a+b 12.3e4 'c d'' -> [5] 'b'");
t.is (items[6], "12.3e4", "split ' +-* a+b 12.3e4 'c d'' -> [6] '12.3e4'");
t.is (items[7], "'c d'", "split ' +-* a+b 12.3e4 'c d'' -> [7] ''c d''");
// static bool decomposePair (const std::string&, std::string&, std::string&, std::string&, std::string&);
// 2 * 4 * 2 * 5 = 80 tests.
std::string outName, outMod, outValue, outSep;
for (auto& name : {"name"})
{
for (auto& mod : {"", "mod"})
{
for (auto& sep : {":", "=", "::", ":="})
{
for (auto& value : {"", "value", "a:b", "a::b", "a=b", "a:=b"})
{
std::string input = std::string ("name") + (strlen (mod) ? "." : "") + mod + sep + value;
t.ok (Lexer::decomposePair (input, outName, outMod, outSep, outValue), "decomposePair '" + input + "' --> true");
t.is (name, outName, " '" + input + "' --> name '" + name + "'");
t.is (mod, outMod, " '" + input + "' --> mod '" + mod + "'");
t.is (value, outValue, " '" + input + "' --> value '" + value + "'");
t.is (sep, outSep, " '" + input + "' --> sep '" + sep + "'");
}
}
}
}
// static bool readWord (const std::string&, const std::string&, std::string::size_type&, std::string&);
std::string::size_type cursor = 0;
std::string word;
t.ok (Lexer::readWord ("'one two'", "'\"", cursor, word), "readWord ''one two'' --> true");
t.is (word, "'one two'", " word '" + word + "'");
t.is ((int)cursor, 9, " cursor");
// Unterminated quoted string is invalid.
cursor = 0;
t.notok (Lexer::readWord ("'one", "'\"", cursor, word), "readWord ''one' --> false");
// static bool readWord (const std::string&, std::string::size_type&, std::string&);
cursor = 0;
t.ok (Lexer::readWord ("input", cursor, word), "readWord 'input' --> true");
t.is (word, "input", " word '" + word + "'");
t.is ((int)cursor, 5, " cursor");
cursor = 0;
t.ok (Lexer::readWord ("one\\ two", cursor, word), "readWord 'one\\ two' --> true");
t.is (word, "one two", " word '" + word + "'");
t.is ((int)cursor, 8, " cursor");
cursor = 0;
t.ok (Lexer::readWord ("\\u20A43", cursor, word), "readWord '\\u20A43' --> true");
t.is (word, "₤3", " word '" + word + "'");
t.is ((int)cursor, 7, " cursor");
cursor = 0;
t.ok (Lexer::readWord ("U+20AC4", cursor, word), "readWord '\\u20AC4' --> true");
t.is (word, "€4", " word '" + word + "'");
t.is ((int)cursor, 7, " cursor");
std::string text = "one 'two' three\\ four";
cursor = 0;
t.ok (Lexer::readWord (text, cursor, word), "readWord \"one 'two' three\\ four\" --> true");
t.is (word, "one", " word '" + word + "'");
cursor++;
t.ok (Lexer::readWord (text, cursor, word), "readWord \"one 'two' three\\ four\" --> true");
t.is (word, "'two'", " word '" + word + "'");
cursor++;
t.ok (Lexer::readWord (text, cursor, word), "readWord \"one 'two' three\\ four\" --> true");
t.is (word, "three four", " word '" + word + "'");
text = "one ";
cursor = 0;
t.ok (Lexer::readWord (text, cursor, word), "readWord \"one \" --> true");
t.is (word, "one", " word '" + word + "'");
// bool isLiteral (const std::string&, bool, bool);
Lexer l4 ("one.two");
t.notok (l4.isLiteral("zero", false, false), "isLiteral 'one.two' --> false");
t.ok (l4.isLiteral("one", false, false), "isLiteral 'one.two' --> 'one'");
t.ok (l4.isLiteral(".", false, false), "isLiteral 'one.two' --> '.'");
t.ok (l4.isLiteral("two", false, true), "isLiteral 'one.two' --> 'two'");
Lexer l5 ("wonder");
t.notok (l5.isLiteral ("wonderful", false, false), "isLiteral 'wonderful' != 'wonder' without abbreviation");
t.ok (l5.isLiteral ("wonderful", true, false), "isLiteral 'wonderful' == 'wonder' with abbreviation");
// bool isOneOf (const std::string&, bool, bool);
Lexer l6 ("Grumpy.");
std::vector <std::string> dwarves = {"Sneezy", "Doc", "Bashful", "Grumpy", "Happy", "Sleepy", "Dopey"};
t.notok (l6.isOneOf (dwarves, false, true), "isOneof ('Grumpy', true) --> false");
t.ok (l6.isOneOf (dwarves, false, false), "isOneOf ('Grumpy', false) --> true");
// static std::string::size_type commonLength (const std::string&, const std::string&);
t.is ((int)Lexer::commonLength ("", ""), 0, "commonLength '' : '' --> 0");
t.is ((int)Lexer::commonLength ("a", "a"), 1, "commonLength 'a' : 'a' --> 1");
t.is ((int)Lexer::commonLength ("abcde", "abcde"), 5, "commonLength 'abcde' : 'abcde' --> 5");
t.is ((int)Lexer::commonLength ("abc", ""), 0, "commonLength 'abc' : '' --> 0");
t.is ((int)Lexer::commonLength ("abc", "def"), 0, "commonLength 'abc' : 'def' --> 0");
t.is ((int)Lexer::commonLength ("foobar", "foo"), 3, "commonLength 'foobar' : 'foo' --> 3");
t.is ((int)Lexer::commonLength ("foo", "foobar"), 3, "commonLength 'foo' : 'foobar' --> 3");
// static std::string::size_type commonLength (const std::string&, std::string::size_type, const std::string&, std::string::size_type);
t.is ((int)Lexer::commonLength ("wonder", 0, "prowonderbread", 3), 6, "'wonder'+0 : 'prowonderbread'+3 --> 6");
// Test all Lexer types.
#define NO {"",Lexer::Type::word}
struct
{
const char* input;
struct
{
const char* token;
Lexer::Type type;
} results[5];
} lexerTests[] =
{
// Pattern
{ "/foo/", { { "/foo/", Lexer::Type::pattern }, NO, NO, NO, NO }, },
{ "/a\\/b/", { { "/a\\/b/", Lexer::Type::pattern }, NO, NO, NO, NO }, },
{ "/'/", { { "/'/", Lexer::Type::pattern }, NO, NO, NO, NO }, },
// Substitution
{ "/from/to/g", { { "/from/to/g", Lexer::Type::substitution }, NO, NO, NO, NO }, },
{ "/from/to/", { { "/from/to/", Lexer::Type::substitution }, NO, NO, NO, NO }, },
// Tag
{ "+tag", { { "+tag", Lexer::Type::tag }, NO, NO, NO, NO }, },
{ "-tag", { { "-tag", Lexer::Type::tag }, NO, NO, NO, NO }, },
{ "+@tag", { { "+@tag", Lexer::Type::tag }, NO, NO, NO, NO }, },
// Path
{ "/long/path/to/file.txt", { { "/long/path/to/file.txt", Lexer::Type::path }, NO, NO, NO, NO }, },
// Word
{ "1.foo.bar", { { "1.foo.bar", Lexer::Type::word }, NO, NO, NO, NO }, },
// Identifier
{ "foo", { { "foo", Lexer::Type::identifier }, NO, NO, NO, NO }, },
{ "Çirçös", { { "Çirçös", Lexer::Type::identifier }, NO, NO, NO, NO }, },
{ "☺", { { "☺", Lexer::Type::identifier }, NO, NO, NO, NO }, },
{ "name", { { "name", Lexer::Type::identifier }, NO, NO, NO, NO }, },
{ "f1", { { "f1", Lexer::Type::identifier }, NO, NO, NO, NO }, },
{ "foo.bar", { { "foo.bar", Lexer::Type::identifier }, NO, NO, NO, NO }, },
{ "a1a1a1a1_a1a1_a1a1_a1a1_a1a1a1a1a1a1", { { "a1a1a1a1_a1a1_a1a1_a1a1_a1a1a1a1a1a1", Lexer::Type::identifier }, NO, NO, NO, NO }, },
// Word that starts wih 'or', which is an operator, but should be ignored.
{ "ordinary", { { "ordinary", Lexer::Type::identifier }, NO, NO, NO, NO }, },
// DOM
{ "due", { { "due", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "123.tags", { { "123.tags", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "123.tags.PENDING", { { "123.tags.PENDING", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "123.description", { { "123.description", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "123.annotations.1.description", { { "123.annotations.1.description", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "123.annotations.1.entry", { { "123.annotations.1.entry", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "123.annotations.1.entry.year", { { "123.annotations.1.entry.year", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "a360fc44-315c-4366-b70c-ea7e7520b749.due", { { "a360fc44-315c-4366-b70c-ea7e7520b749.due", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "12345678-1234-1234-1234-123456789012.due", { { "12345678-1234-1234-1234-123456789012.due", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "system.os", { { "system.os", Lexer::Type::dom }, NO, NO, NO, NO }, },
{ "rc.foo", { { "rc.foo", Lexer::Type::dom }, NO, NO, NO, NO }, },
// URL
{ "http://tasktools.org", { { "http://tasktools.org", Lexer::Type::url }, NO, NO, NO, NO }, },
{ "https://bug.tasktools.org", { { "https://bug.tasktools.org", Lexer::Type::url }, NO, NO, NO, NO }, },
// String
{ "'one two'", { { "'one two'", Lexer::Type::string }, NO, NO, NO, NO }, },
{ "\"three\"", { { "\"three\"", Lexer::Type::string }, NO, NO, NO, NO }, },
{ "'\\''", { { "'''", Lexer::Type::string }, NO, NO, NO, NO }, },
{ "\"\\\"\"", { { "\"\"\"", Lexer::Type::string }, NO, NO, NO, NO }, },
{ "\"\tfoo\t\"", { { "\"\tfoo\t\"", Lexer::Type::string }, NO, NO, NO, NO }, },
{ "\"\\u20A43\"", { { "\"₤3\"", Lexer::Type::string }, NO, NO, NO, NO }, },
{ "\"U+20AC4\"", { { "\"€4\"", Lexer::Type::string }, NO, NO, NO, NO }, },
// Number
{ "1", { { "1", Lexer::Type::number }, NO, NO, NO, NO }, },
{ "3.14", { { "3.14", Lexer::Type::number }, NO, NO, NO, NO }, },
{ "6.02217e23", { { "6.02217e23", Lexer::Type::number }, NO, NO, NO, NO }, },
{ "1.2e-3.4", { { "1.2e-3.4", Lexer::Type::number }, NO, NO, NO, NO }, },
{ "0x2f", { { "0x2f", Lexer::Type::hex }, NO, NO, NO, NO }, },
// Set (1,2,4-7,9)
{ "1,2", { { "1,2", Lexer::Type::set }, NO, NO, NO, NO }, },
{ "1-2", { { "1-2", Lexer::Type::set }, NO, NO, NO, NO }, },
{ "1-2,4", { { "1-2,4", Lexer::Type::set }, NO, NO, NO, NO }, },
{ "1-2,4,6-8", { { "1-2,4,6-8", Lexer::Type::set }, NO, NO, NO, NO }, },
{ "1-2,4,6-8,10-12", { { "1-2,4,6-8,10-12", Lexer::Type::set }, NO, NO, NO, NO }, },
// Pair
{ "name:value", { { "name:value", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "name=value", { { "name=value", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "name:=value", { { "name:=value", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "name.mod:value", { { "name.mod:value", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "name.mod=value", { { "name.mod=value", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "name:", { { "name:", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "name=", { { "name=", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "name.mod:", { { "name.mod:", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "name.mod=", { { "name.mod=", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "pro:'P 1'", { { "pro:'P 1'", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "rc:x", { { "rc:x", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "rc.name:value", { { "rc.name:value", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "rc.name=value", { { "rc.name=value", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "rc.name:=value", { { "rc.name:=value", Lexer::Type::pair }, NO, NO, NO, NO }, },
{ "due:='eow - 2d'", { { "due:='eow - 2d'", Lexer::Type::pair }, NO, NO, NO, NO }, },
// Operator - complete set
{ "^", { { "^", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "!", { { "!", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "_neg_", { { "_neg_", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "_pos_", { { "_pos_", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "_hastag_", { { "_hastag_", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "_notag_", { { "_notag_", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "*", { { "*", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "/", { { "/", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "%", { { "%", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "+", { { "+", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "-", { { "-", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "<=", { { "<=", Lexer::Type::op }, NO, NO, NO, NO }, },
{ ">=", { { ">=", Lexer::Type::op }, NO, NO, NO, NO }, },
{ ">", { { ">", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "<", { { "<", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "=", { { "=", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "==", { { "==", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "!=", { { "!=", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "!==", { { "!==", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "~", { { "~", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "!~", { { "!~", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "and", { { "and", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "or", { { "or", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "xor", { { "xor", Lexer::Type::op }, NO, NO, NO, NO }, },
{ "(", { { "(", Lexer::Type::op }, NO, NO, NO, NO }, },
{ ")", { { ")", Lexer::Type::op }, NO, NO, NO, NO }, },
// UUID
{ "ffffffff-ffff-ffff-ffff-ffffffffffff", { { "ffffffff-ffff-ffff-ffff-ffffffffffff", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "00000000-0000-0000-0000-0000000", { { "00000000-0000-0000-0000-0000000", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "00000000-0000-0000-0000", { { "00000000-0000-0000-0000", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "00000000-0000-0000", { { "00000000-0000-0000", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "00000000-0000", { { "00000000-0000", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "00000000", { { "00000000", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "a360fc44-315c-4366-b70c-ea7e7520b749", { { "a360fc44-315c-4366-b70c-ea7e7520b749", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "a360fc44-315c-4366-b70c-ea7e752", { { "a360fc44-315c-4366-b70c-ea7e752", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "a360fc44-315c-4366-b70c", { { "a360fc44-315c-4366-b70c", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "a360fc44-315c-4366", { { "a360fc44-315c-4366", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "a360fc44-315c", { { "a360fc44-315c", Lexer::Type::uuid }, NO, NO, NO, NO }, },
{ "a360fc44", { { "a360fc44", Lexer::Type::uuid }, NO, NO, NO, NO }, },
// Date
{ "2015-W01", { { "2015-W01", Lexer::Type::date }, NO, NO, NO, NO }, },
{ "2015-02-17", { { "2015-02-17", Lexer::Type::date }, NO, NO, NO, NO }, },
{ "2013-11-29T22:58:00Z", { { "2013-11-29T22:58:00Z", Lexer::Type::date }, NO, NO, NO, NO }, },
{ "20131129T225800Z", { { "20131129T225800Z", Lexer::Type::date }, NO, NO, NO, NO }, },
{ "9th", { { "9th", Lexer::Type::date }, NO, NO, NO, NO }, },
{ "10th", { { "10th", Lexer::Type::date }, NO, NO, NO, NO }, },
{ "today", { { "today", Lexer::Type::date }, NO, NO, NO, NO }, },
// Duration
{ "year", { { "year", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "4weeks", { { "4weeks", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "PT23H", { { "PT23H", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "1second", { { "1second", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "1s", { { "1s", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "1minute", { { "1minute", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "2hour", { { "2hour", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "3 days", { { "3 days", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "4w", { { "4w", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "5mo", { { "5mo", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "6 years", { { "6 years", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "P1Y", { { "P1Y", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "PT1H", { { "PT1H", Lexer::Type::duration }, NO, NO, NO, NO }, },
{ "P1Y1M1DT1H1M1S", { { "P1Y1M1DT1H1M1S", Lexer::Type::duration }, NO, NO, NO, NO }, },
// Misc
{ "--", { { "--", Lexer::Type::separator }, NO, NO, NO, NO }, },
// Expression
// due:eom-2w
// due < eom + 1w + 1d
// ( /pattern/ or 8ad2e3db-914d-4832-b0e6-72fa04f6e331,3b6218f9-726a-44fc-aa63-889ff52be442 )
{ "(1+2)", { { "(", Lexer::Type::op },
{ "1", Lexer::Type::number },
{ "+", Lexer::Type::op },
{ "2", Lexer::Type::number },
{ ")", Lexer::Type::op }, }, },
{ "description~pattern", { { "description", Lexer::Type::dom },
{ "~", Lexer::Type::op },
{ "pattern", Lexer::Type::identifier }, NO, NO }, },
{ "(+tag)", { { "(", Lexer::Type::op },
{ "+tag", Lexer::Type::tag },
{ ")", Lexer::Type::op }, NO, NO }, },
{ "(name:value)", { { "(", Lexer::Type::op },
{ "name:value", Lexer::Type::pair },
{ ")", Lexer::Type::op }, NO, NO }, },
};
#define NUM_TESTS (sizeof (lexerTests) / sizeof (lexerTests[0]))
for (unsigned int i = 0; i < NUM_TESTS; i++)
{
// The isolated test puts the input string directly into the Lexer.
Lexer isolated (lexerTests[i].input);
for (int j = 0; j < 5; j++)
{
if (lexerTests[i].results[j].token[0])
{
// Isolated: "<token>"
t.ok (isolated.token (token, type), "Isolated Lexer::token(...) --> true");
t.is (token, lexerTests[i].results[j].token, " token --> " + token);
t.is ((int)type, (int)lexerTests[i].results[j].type, " type --> Lexer::Type::" + Lexer::typeToString (type));
}
}
// The embedded test surrounds the input string with a space.
Lexer embedded (std::string (" ") + lexerTests[i].input + " ");
for (int j = 0; j < 5; j++)
{
if (lexerTests[i].results[j].token[0])
{
// Embedded: "<token>"
t.ok (embedded.token (token, type), "Embedded Lexer::token(...) --> true");
t.is (token, lexerTests[i].results[j].token, " token --> " + token);
t.is ((int)type, (int)lexerTests[i].results[j].type, " type --> Lexer::Type::" + Lexer::typeToString (type));
}
}
}
return 0;
}
void TestBandMatrixArith_D1()
{
std::vector<tmv::BandMatrixView<T> > b;
std::vector<tmv::BandMatrixView<std::complex<T> > > cb;
MakeBandList(b,cb);
const int N = b[0].rowsize();
tmv::Matrix<T> a1(N,N);
for (int i=0; i<N; ++i) for (int j=0; j<N; ++j) a1(i,j) = T(3+i-5*j);
tmv::Matrix<std::complex<T> > ca1(N,N);
for (int i=0; i<N; ++i) for (int j=0; j<N; ++j)
ca1(i,j) = std::complex<T>(3+i-5*j,4-8*i-j);
tmv::UpperTriMatrix<T,tmv::NonUnitDiag|tmv::RowMajor> u1(a1);
tmv::UpperTriMatrix<std::complex<T>,tmv::NonUnitDiag|tmv::RowMajor> cu1(ca1);
tmv::UpperTriMatrixView<T> u1v = u1.view();
tmv::UpperTriMatrixView<std::complex<T> > cu1v = cu1.view();
tmv::UpperTriMatrix<T,tmv::NonUnitDiag> u1x = u1v;
tmv::UpperTriMatrix<std::complex<T>,tmv::NonUnitDiag> cu1x = cu1v;
#if (XTEST & 2)
tmv::UpperTriMatrix<T,tmv::UnitDiag|tmv::RowMajor> u2(a1);
tmv::UpperTriMatrix<T,tmv::NonUnitDiag|tmv::ColMajor> u3(a1);
tmv::UpperTriMatrix<T,tmv::UnitDiag|tmv::ColMajor> u4(a1);
tmv::LowerTriMatrix<T,tmv::NonUnitDiag|tmv::RowMajor> l1(a1);
tmv::LowerTriMatrix<T,tmv::UnitDiag|tmv::RowMajor> l2(a1);
tmv::LowerTriMatrix<T,tmv::NonUnitDiag|tmv::ColMajor> l3(a1);
tmv::LowerTriMatrix<T,tmv::UnitDiag|tmv::ColMajor> l4(a1);
tmv::UpperTriMatrix<std::complex<T>,tmv::UnitDiag|tmv::RowMajor> cu2(ca1);
tmv::UpperTriMatrix<std::complex<T>,tmv::NonUnitDiag|tmv::ColMajor> cu3(ca1);
tmv::UpperTriMatrix<std::complex<T>,tmv::UnitDiag|tmv::ColMajor> cu4(ca1);
tmv::LowerTriMatrix<std::complex<T>,tmv::NonUnitDiag|tmv::RowMajor> cl1(ca1);
tmv::LowerTriMatrix<std::complex<T>,tmv::UnitDiag|tmv::RowMajor> cl2(ca1);
tmv::LowerTriMatrix<std::complex<T>,tmv::NonUnitDiag|tmv::ColMajor> cl3(ca1);
tmv::LowerTriMatrix<std::complex<T>,tmv::UnitDiag|tmv::ColMajor> cl4(ca1);
tmv::UpperTriMatrixView<T> u2v = u2.view();
tmv::UpperTriMatrixView<T> u3v = u3.view();
tmv::UpperTriMatrixView<T> u4v = u4.view();
tmv::LowerTriMatrixView<T> l1v = l1.view();
tmv::LowerTriMatrixView<T> l2v = l2.view();
tmv::LowerTriMatrixView<T> l3v = l3.view();
tmv::LowerTriMatrixView<T> l4v = l4.view();
tmv::UpperTriMatrixView<std::complex<T> > cu2v = cu2.view();
tmv::UpperTriMatrixView<std::complex<T> > cu3v = cu3.view();
tmv::UpperTriMatrixView<std::complex<T> > cu4v = cu4.view();
tmv::LowerTriMatrixView<std::complex<T> > cl1v = cl1.view();
tmv::LowerTriMatrixView<std::complex<T> > cl2v = cl2.view();
tmv::LowerTriMatrixView<std::complex<T> > cl3v = cl3.view();
tmv::LowerTriMatrixView<std::complex<T> > cl4v = cl4.view();
#endif
for(size_t i=START;i<b.size();i++) {
if (showstartdone) {
std::cerr<<"Start loop "<<i<<std::endl;
std::cerr<<"bi = "<<b[i]<<std::endl;
}
tmv::BandMatrixView<T> bi = b[i];
tmv::BandMatrixView<std::complex<T> > cbi = cb[i];
TestMatrixArith4(bi,cbi,u1v,cu1v,"Band/UpperTri");
TestMatrixArith5(bi,cbi,u1v,cu1v,"Band/UpperTri");
TestMatrixArith6x(bi,cbi,u1v,cu1v,"Band/UpperTri");
#if (XTEST & 2)
TestMatrixArith4(bi,cbi,l1v,cl1v,"Band/LowerTri");
TestMatrixArith5(bi,cbi,l1v,cl1v,"Band/LowerTri");
TestMatrixArith6x(bi,cbi,l1v,cl1v,"Band/LowerTri");
TestMatrixArith4(bi,cbi,u2v,cu2v,"Band/UpperTri");
TestMatrixArith5(bi,cbi,u2v,cu2v,"Band/UpperTri");
TestMatrixArith6x(bi,cbi,u2v,cu2v,"Band/UpperTri");
TestMatrixArith4(bi,cbi,l2v,cl2v,"Band/LowerTri");
TestMatrixArith5(bi,cbi,l2v,cl2v,"Band/LowerTri");
TestMatrixArith6x(bi,cbi,l2v,cl2v,"Band/LowerTri");
TestMatrixArith4(bi,cbi,u3v,cu3v,"Band/UpperTri");
TestMatrixArith5(bi,cbi,u3v,cu3v,"Band/UpperTri");
TestMatrixArith6x(bi,cbi,u3v,cu3v,"Band/UpperTri");
TestMatrixArith4(bi,cbi,l3v,cl3v,"Band/LowerTri");
TestMatrixArith5(bi,cbi,l3v,cl3v,"Band/LowerTri");
TestMatrixArith6x(bi,cbi,l3v,cl3v,"Band/LowerTri");
TestMatrixArith4(bi,cbi,u4v,cu4v,"Band/UpperTri");
TestMatrixArith5(bi,cbi,u4v,cu4v,"Band/UpperTri");
TestMatrixArith6x(bi,cbi,u4v,cu4v,"Band/UpperTri");
TestMatrixArith4(bi,cbi,l4v,cl4v,"Band/LowerTri");
TestMatrixArith5(bi,cbi,l4v,cl4v,"Band/LowerTri");
TestMatrixArith6x(bi,cbi,l4v,cl4v,"Band/LowerTri");
#endif
}
}
static double refmap_hex_dy_f6(double x, double y, double z) { return l1(x) * dl1(y) * l1(z); }
int main()
{
try
{
symbol k("k"),q("q"),p("p"),p1("p1"),p2("p2"),p3("p3"),ms("ms"),l("l"),s("s"),m1s("m1s"),m2s("m2s"),m3s("m3s");
symbol l1("l1"),l2("l2"),l3("l3"),l4("l4"),t("t"),p4("p4"),p5("p5"),tp("tp"),v1("v1"),v2("v2"),l5("l5");
symbol k1("k1"),k2("k2"),k3("k3"),k4("k4"),k5("k5"),ms1("ms1"),ms2("ms2"),ms3("ms3"),ms4("ms4");
// oneloop box
// UFXmap l45 = UF(lst(k),lst(pow(k,2),pow(k+p1,2),pow(k+p1+p2,2),pow(k+p1+p2+p3,2)),lst(pow(p1,2)==0,pow(p2,2)==0));
// MBintegral root_int(l45,lst(1,1,1,1),1);
//two loop box bubble
// UFXmap l45 = UF(lst(k,l),lst(pow(k,2),pow(k+p1,2),pow(k+p1+p2,2),pow(l+p1+p2,2),pow(l+p1+p2+p3,2),pow(l,2),pow(k-l,2)),lst(pow(p1,2)==0,pow(p2,2)==0,pow(p3,2)==0));
//MBintegral root_int(l45,lst(1,1,1,1,1,1,1),2);
// B0
// UFXmap l45 = UF(lst(k),lst(ms-pow(k,2),ms-pow(-k,2)),lst(ms==1));
// MBintegral root_int(l45,lst(1,1),1);
// 2 loop sunrise
//UFXmap l45 = UF(lst(k,q),lst(ms-pow(k,2),ms-pow(-q-k,2),ms-pow(q,2)),lst(ms==1));
//MBintegral root_int(l45,lst(1,1,1),2);
//RoMB_planar box2loop(lst(k,l),lst(pow(k,2),pow(k+p1,2),pow(k+p1+p2,2),pow(l+p1+p2,2),pow(l+p1+p2+p3,2),pow(l,2),pow(k-l,2)),lst(pow(p1,2)==0,pow(p2,2)==0,pow(p3,2)==0),lst(1,1,1,1,1,1,1),2);
// RoMB_planar box1loop(lst(k),lst(pow(k,2),pow(k+p1,2)-ms,pow(k+p1+p2,2),pow(k+p1+p2+p3,2)),lst(pow(p1,2)==0,pow(p2,2)==0,pow(p3,2)==0,p1==0,p2==0,p3==0,ms==1),lst(1,1,1,1),1);
// RoMB_planar B0_1loop(lst(k),lst(pow(k,2)-ms,pow(p+k,2)-ms),lst(ms==0,pow(p,2)==1),lst(1,1),1);
// RoMB_planar C0_1loop(lst(k),lst(pow(k,2)-ms,pow(p1+k,2)-ms,pow(p1+p2+k,2)),lst(ms==1,pow(p1,2)==0,pow(p2,2)==0,p1*p2==50),lst(1,1,1),1);
//cout<<" new point "<<endl<<root_int.new_point()<<endl;
// cout<<" saved point "<<endl<<root_int.get_point()<<endl;
// MBcontinue(root_int);
//cout<<MB_lst(l45,lst(1,1,1,1),1).expand()<<endl;
// RoMB_loop_by_loop box2loop(lst(k,l),lst(pow(k,2),pow(k+p1,2),pow(k+p1+p2,2),pow(l+p1+p2,2),pow(l+p1+p2+p3,2),pow(l,2),pow(k-l,2)),lst(pow(p1,2)==0,pow(p2,2)==0,pow(p3,2)==0),lst(1,1,1,1,1,1,1));
// RoMB_loop_by_loop t2(lst(k,l), lst(pow(k,2),pow(p+k,2),pow(p+k+l,2),pow(l,2),pow(k+l,2)),lst(pow(p,2)==1),lst(1,1,1,1,1));
// works!!!
// RoMB_loop_by_loop sunset(lst(k,l), lst(pow(k,2)-1,pow(p-k-l,2)-4,pow(l,2)-5),lst(pow(p,2)==s),lst(1,1,1));
// RoMB_loop_by_loop sunset(lst(k,l), lst(pow(k,2)-m1s,pow(-k-l,2)-m2s,pow(l,2)-m3s),lst(pow(p,2)==s),lst(1,1,1));
// sunset.integrate(lst(m1s==1,m2s==1,m3s==1,s==0),0);
// bubble sunset 2=loop
// RoMB_loop_by_loop sunset_bub(lst(k,l), lst(-pow(k,2)+ms,-pow(-k-l,2)+ms,-pow(l,2)+ms),lst(pow(p,2)==0),lst(1,1,1));
// sunset_bub.integrate(lst(ms==1,m2s==1,m3s==1,s==0),1);
// bubble sunset 3=loop
// RoMB_loop_by_loop sunset_bub(lst(p,k,l), lst(-pow(p,2)+ms,-pow(k,2)+ms,-pow(l,2)+ms,-pow(-p-k-l,2)+ms),lst(pow(l3,2)==s),lst(1,1,1,1));
// sunset_bub.integrate(lst(ms==1,m2s==1,m3s==1,s==0),0);
// RoMB_loop_by_loop sunset_bub_d(lst(l1,l2,l3), lst(-pow(l1,2)+ms,-pow(l2,2)+ms,-pow(l3,2)+ms,-pow(l1+l2,2)+ms,-pow(l1+l2+l3,2)+ms),lst(pow(p,2)==s),lst(1,1,1,1,1));
// sunset_bub_d.integrate(lst(ms==1,m2s==1,m3s==1,s==0),-1);
// RoMB_loop_by_loop sunset_bub_e(lst(l1,l2,l3), lst(-pow(l1,2)+ms,-pow(l2,2)+ms,-pow(l3,2)+ms,-pow(l1-l2,2)+ms,-pow(l2-l3,2)+ms,-pow(l3-l1,2)+ms),lst(pow(p,2)==s),lst(1,1,1,1,1,1));
// sunset_bub_e.integrate_map(lst(ms==1,m2s==1,m3s==1,s==0),1);
//bubble 4-loop
// RoMB_loop_by_loop sunset_bub(lst(k,l1,l2,l3), lst(-pow(k,2)+ms,-pow(l2,2)+ms,-pow(l1,2)+ms,-pow(l3,2)+ms,-pow(k+l1+l2+l3,2)+ms),lst(pow(p,2)==s),lst(1,1,1,1,1));
// sunset_bub.integrate(lst(ms==1,m2s==1,m3s==1,s==0),0);
//bubble 5-loop
// RoMB_loop_by_loop sunset_bub5(lst(l3,k,l1,l2,l4), lst(-pow(l3,2)+ms,-pow(k,2)+ms,-pow(l1,2)+ms,-pow(l2,2)+ms,-pow(l4,2)+ms,-pow(k+l1+l2+l3+l4,2)+ms),lst(pow(p,2)==s),lst(1,1,1,1,1,1));
// sunset_bub5.integrate_map(lst(ms==1,m2s==1,m3s==1,s==0),3);
// RoMB_loop_by_loop sunset_bubC2(lst(l1,l2,l3,l4,l5), lst(-pow(l3,2)+ms,-pow(l5,2)+ms,-pow(l1,2)+ms,-pow(l2,2)+ms,-pow(l4,2)+ms,-pow(l5+l1+l2,2)+ms,-pow(l5+l3+l4,2)+ms),lst(pow(p,2)==s),lst(1,1,1,1,1,1,1));
// sunset_bubC2.integrate_map(lst(ms==1,m2s==1,m3s==1,s==0),0);
// RoMB_loop_by_loop sunset_bubC2(lst(l1,l2,l3,l4,l5), lst(-pow(l3,2)+ms,-pow(l5,2)+ms,-pow(l1,2)+ms,-pow(l2,2)+ms,-pow(l4,2)+ms,-pow(l3+l4+l5,2)+ms,-pow(l1+l2+l5+l3+l4,2)+ms),lst(pow(p,2)==s),lst(1,1,1,1,1,1,1));
// sunset_bubC2.integrate_map(lst(ms==1,m2s==1,m3s==1,s==0),0);
// RoMB_loop_by_loop sunset_bubC1(lst(l1,l2,l3,l4,l5), lst(-pow(l3,2)+ms,-pow(l5,2)+ms,-pow(l1,2)+ms,-pow(l2,2)+ms,-pow(l4,2)+ms,-pow(l2+l3+l4+l5,2)+ms,-pow(l1+l2+l5+l3+l4,2)+ms),lst(pow(p,2)==s),lst(1,1,1,1,1,1,1));
// sunset_bubC1.integrate_map(lst(ms==1,m2s==1,m3s==1,s==0),0);
/*
MEGA 5-LOOP BUBBLE with 12 propagators
*/
//RoMB_loop_by_loop l5p12(lst(k5,k2,k1,k4,k3),lst(-pow(k1,2)+ms,-pow(k2,2)+ms,-pow(k3,2)+ms,-pow(k4,2)+ms,-pow(k5,2)+ms,
//-pow(k1-k3,2)+ms,-pow(k1-k4,2)+ms,-pow(k3-k2,2)+ms,-pow(k2-k4,2)+ms,-pow(k5+k3-k1,2)+ms,-pow(k5+k3-k2,2)+ms,-pow(k5+k3-k4,2)+ms),lst(pow(p,2)==0),lst(1,1,1,1,1,1,1,1,1,1,1,1));
//l5p12.integrate(lst(ms==0),0);
//RoMB_loop_by_loop l5c1(lst(k2,k5,k3,k4,k1),lst(-pow(k3,2)+ms,-pow(k2,2)+ms,-pow(k1,2)+ms,-pow(k4,2)+ms,-pow(k5,2)+ms,
//-pow(k1+k3+k4,2)+ms,-pow(k2+k5-k3-k4,2)+ms),lst(pow(p,2)==0),lst(1,1,1,1,1,1,1));
//l5c1.integrate_map(lst(ms==1),0);
// RoMB_loop_by_loop t2loop(lst(k,l), lst(-pow(k,2)+ms,-pow(p+k,2)+ms,-pow(p+k+l,2)+ms,-pow(k+l,2)+ms,-pow(l,2)+ms),lst(pow(p,2)==s),lst(1,1,1,1,1));
// t2loop.integrate(lst(s==1,ms == 0),1);
/* RoMB_loop_by_loop bubble_five_loop(lst(k,l1,l2,l3,l4),
lst(pow(k,2)-ms,pow(l1,2)-ms,pow(l2,2)-ms,pow(l3,2)-ms,pow(l4,2)-ms,pow(k+l1,2)-ms,pow(k+l1+l2,2)-ms,pow(k+l1+l2+l3,2)-ms,pow(k+l1+l2+l3+l4,2)-ms,pow(k+l1+l2+l3,2)-ms,pow(k+l1+l2,2)-ms,pow(k+l1,2)-ms),
lst(ms==1),
lst(1,1,1,1,1,1,1,1,1,1,1,1));
*/
// works!!!
// RoMB_loop_by_loop B0_1loop_lbl(lst(k),lst(pow(k,2)-2-ms,pow(p+k,2)-ms),lst(ms==0,pow(p,2)==1),lst(2,1));
// RoMB_loop_by_loop B0_1loop_lbl(lst(k),lst(pow(k,2)-m1s,pow(p+k,2)-m2s),lst(pow(p,2)==s),lst(1,1));
// B0_1loop_lbl.integrate(lst(s==-1,m1s==1,m2s==1));
//MB works???
// RoMB_loop_by_loop C0_1loop_lbl(lst(k),lst(pow(k,2),pow(k+p1,2)-m1s,pow(k-p2,2)-m2s),lst(ms==1,pow(p1,2)==m1s,pow(p2,2)==m2s,p1*p2==(s-m1s-m2s)/2),lst(1,1,1));
// C0_1loop_lbl.integrate(lst(m1s==1,m2s==1,s==-100));
//MB works???
/*
RoMB_loop_by_loop box1loopm0(lst(k),lst(-pow(k,2),-pow(k+p1,2),-pow(k+p1+p2,2),-pow(k+p1+p2+p4,2)),
lst(pow(p1,2)==0,pow(p2,2)==0,pow(p4,2)==0,
p1*p2==-s/2,//
p1*p4==s/2+t/2,//
p2*p4==-t/2 //
),
lst(1,1,1,1),false);
box1loopm0.integrate_map(lst(s==3,t==1));
box1loopm0.integrate(lst(s==5,t==2));
*/
//MASIVE BOX LBL
RoMB_loop_by_loop box1loopm(lst(k),lst(-pow(k,2)+ms,-pow(k+p1,2)+ms,-pow(k+p1+p2,2)+ms,-pow(k+p1+p2+p4,2)+ms),
lst(pow(p1,2)==0,pow(p2,2)==0,pow(p4,2)==0,
p1*p2==s/2,//
p1*p4==-(s/2+t/2),//
p2*p4==t/2 //
),
lst(1,1,1,1),false);
box1loopm.integrate_map(lst(ms1==1,ms2==1,ms3==1,ms4==1,ms==1,s==-3,t==-1),3);
//triple box
/*
RoMB_loop_by_loop tribox1loopm(lst(k1,k2,k3),lst(-pow(k1,2)+ms,-pow(k1+p1,2),-pow(k1+p1+p2,2)+ms,
-pow(k1-k2,2),-pow(k2,2)+ms,-pow(k2+p1+p2,2)+ms,
-pow(k2-k3,2),-pow(k3,2)+ms,-pow(k3+p1+p2,2)+ms,
-pow(k3-p3,2)),
lst(pow(p1,2)==ms,pow(p2,2)==ms,pow(p3,2)==ms,pow(p4,2)==ms,
p1*p2==s/2-ms,//
p1*p3==t/2-ms,//
p2*p3==ms-(s+t)/2 //
),
lst(1,1,1,1,1,1,1,1,1,1),true);
tribox1loopm.integrate_map(lst(ms1==1,ms2==1,ms3==1,ms4==1,ms==1,s==-1/2,t==-3));
*/
//double box
/*
RoMB_loop_by_loop dobox1loopm(lst(k1,k2),lst(-pow(k1,2),-pow(k1+p1,2),-pow(k1+p1+p2,2),
-pow(k1-k2,2),-pow(k2,2),-pow(k2+p1+p2,2),
-pow(k2-p3,2)),
lst(pow(p1,2)==0,pow(p2,2)==0,pow(p3,2)==0,pow(p4,2)==0,
p1*p2==s/2-ms,//
p1*p3==t/2-ms,//
p2*p3==ms-(s+t)/2 //
),
lst(1,1,1,1,1,1,1),false);
dobox1loopm.integrate_map(lst(ms1==1,ms2==1,ms3==1,ms4==1,ms==1,s==-1/2,t==-3));
*/
/*
4-loop tadpole
*/
// RoMB_loop_by_loop tad4(lst(l1, l2, l3, l4),lst(pow(l1,2)- ms,pow(l2,2)- ms,pow(l3 ,2)- ms,pow(l4,2),pow(l1+l2+l3+l4,2)),lst(),lst(1,1,1,1,1));
// tad4.integrate(lst(ms == 1),-2);
/*
Pentagon
*/
/*
RoMB_loop_by_loop pent(lst(k1),lst(-pow(p1 + k1,2)+ ms,-pow(p1 + p5 + k1,2),
-pow(p1 + p5 + p4 + k1,2)+ ms,-pow(p1 + p5 + p4 + p3 + k1,2)+ ms,
-pow(k1,2)),
lst(
p1*p1 == ms, p2*p2 == ms, p3*p3 == 0, p4*p4 == ms, p5*p5 == ms,
p1*p2 == 1/2* (tp - 2* ms), p1*p3 == 1/2* (t - tp - v1),
p1*p4 == ms - 1/2* (s + t - v1), p1*p5 == 1/2* (s - 2* ms),
p2* p3 == 1/2* v1, p2* p4 == 1/2* (s - 2* ms - v1 - v2),
p2* p5 == ms - 1/2* (s + tp - v2), p3* p4 == 1/2* v2,
p3* p5 == 1/2* (tp - t - v2), p4* p5 == 1/2* (t - 2* ms)),
lst(1,1,1,1,1));
pent.integrate_map(lst(s==-2,t==-3,v2==-4,tp==-5,v1==-6,ms==1));
*/
/*
RoMB_loop_by_loop pent(lst(k1),lst(-pow(p1 + k1,2)+ ms,-pow(p1 + p5 + k1,2),
-pow(p1 + p5 + p4 + k1,2)+ ms,-pow(p1 + p5 + p4 + p3 + k1,2)+ ms,
-pow(k1,2)),
lst(
p1*p1 == ms,
p2*p2 == ms,
p3*p3 == 0,
p4*p4 == ms,
p5*p5 == ms,
p1*p2 == 1/2* (tp - 2* ms),
wild(1)*p1*p3 == wild(1)*1/2* (t - tp - v1),
wild(2)*p1*p4 == wild(2)*(ms - 1/2* (s + t - v1)),
wild(3)* p1*p5 == wild(3)*1/2* (s - 2* ms),
wild(4)*p2* p3 == wild(4)*1/2* v1,
wild(5)*p2* p4 == wild(5)*1/2* (s - 2* ms - v1 - v2),
wild(6)*p2* p5 ==wild(6)*( ms - 1/2* (s + tp - v2)),
wild(7)*p3* p4 == wild(7)*1/2* v2,
wild(8)*p3* p5 == wild(8)*1/2* (tp - t - v2),
wild()*p4* p5 == wild()*1/2* (t - 2* ms)),
lst(1,1,1,1,1));
pent.integrate_map(lst(s==-2,t==-3,v2==-4,tp==-5,v1==-6,ms==1));
*/
}
catch(std::exception &p)
{
std::cerr<<"******************************************************************"<<endl;
std::cerr<<" >>>ERROR: "<<p.what()<<endl;
std::cerr<<"******************************************************************"<<endl;
return 1;
}
return 0;
}
static double refmap_hex_dz_f1(double x, double y, double z) { return l1(x) * l0(y) * dl0(z); }
/**
* Calculates the intersection point(s) between two entities.
*
* @param onEntities true: only return intersection points which are
* on both entities.
* false: return all intersection points.
*
* @todo support more entities
*
* @return All intersections of the two entities. The tangent flag in
* RS_VectorSolutions is set if one intersection is a tangent point.
*/
RS_VectorSolutions RS_Information::getIntersection(RS_Entity* e1,
RS_Entity* e2, bool onEntities)
{
RS_VectorSolutions ret;
double tol = 1.0e-4;
if (e1==NULL || e2==NULL)
{
return ret;
}
// unsupported entities / entity combinations:
if ((e1->rtti()==RS2::EntityEllipse && e2->rtti()==RS2::EntityEllipse) ||
e1->rtti()==RS2::EntityText || e2->rtti()==RS2::EntityText ||
isDimension(e1->rtti()) || isDimension(e2->rtti()))
{
return ret;
}
// (only) one entity is an ellipse:
if (e1->rtti()==RS2::EntityEllipse || e2->rtti()==RS2::EntityEllipse)
{
if (e2->rtti()==RS2::EntityEllipse)
{
RS_Entity* tmp = e1;
e1 = e2;
e2 = tmp;
}
if (e2->rtti()==RS2::EntityLine)
{
RS_Ellipse* ellipse = (RS_Ellipse*)e1;
ret = getIntersectionLineEllipse((RS_Line*)e2, ellipse);
tol = 1.0e-1;
}
// ellipse / arc, ellipse / ellipse: not supported:
else
{
return ret;
}
}
else
{
RS_Entity* te1 = e1;
RS_Entity* te2 = e2;
// entity copies - so we only have to deal with lines and arcs
RS_Line l1(NULL,
RS_LineData(RS_Vector(0.0, 0.0), RS_Vector(0.0,0.0)));
RS_Line l2(NULL,
RS_LineData(RS_Vector(0.0, 0.0), RS_Vector(0.0,0.0)));
RS_Arc a1(NULL,
RS_ArcData(RS_Vector(0.0,0.0), 1.0, 0.0, 2*M_PI, false));
RS_Arc a2(NULL,
RS_ArcData(RS_Vector(0.0,0.0), 1.0, 0.0, 2*M_PI, false));
// convert construction lines to lines:
if (e1->rtti()==RS2::EntityConstructionLine)
{
RS_ConstructionLine* cl = (RS_ConstructionLine*)e1;
l1.setStartpoint(cl->getPoint1());
l1.setEndpoint(cl->getPoint2());
te1 = &l1;
}
if (e2->rtti()==RS2::EntityConstructionLine)
{
RS_ConstructionLine* cl = (RS_ConstructionLine*)e2;
l2.setStartpoint(cl->getPoint1());
l2.setEndpoint(cl->getPoint2());
te2 = &l2;
}
// convert circles to arcs:
if (e1->rtti()==RS2::EntityCircle)
{
RS_Circle* c = (RS_Circle*)e1;
RS_ArcData data(c->getCenter(), c->getRadius(), 0.0, 2*M_PI, false);
a1.setData(data);
te1 = &a1;
}
if (e2->rtti()==RS2::EntityCircle)
{
RS_Circle* c = (RS_Circle*)e2;
RS_ArcData data(c->getCenter(), c->getRadius(), 0.0, 2*M_PI, false);
a2.setData(data);
te2 = &a2;
}
// line / line:
//
//else
if (te1->rtti()==RS2::EntityLine &&
te2->rtti()==RS2::EntityLine)
{
RS_Line* line1 = (RS_Line*)te1;
RS_Line* line2 = (RS_Line*)te2;
ret = getIntersectionLineLine(line1, line2);
}
// line / arc:
//
else if (te1->rtti()==RS2::EntityLine &&
te2->rtti()==RS2::EntityArc)
{
RS_Line* line = (RS_Line*)te1;
RS_Arc* arc = (RS_Arc*)te2;
ret = getIntersectionLineArc(line, arc);
}
// arc / line:
//
else if (te1->rtti()==RS2::EntityArc &&
te2->rtti()==RS2::EntityLine)
{
RS_Arc* arc = (RS_Arc*)te1;
RS_Line* line = (RS_Line*)te2;
ret = getIntersectionLineArc(line, arc);
}
// arc / arc:
//
else if (te1->rtti()==RS2::EntityArc &&
te2->rtti()==RS2::EntityArc)
{
RS_Arc* arc1 = (RS_Arc*)te1;
RS_Arc* arc2 = (RS_Arc*)te2;
ret = getIntersectionArcArc(arc1, arc2);
}
else
{
RS_DEBUG->print("RS_Information::getIntersection:: Unsupported entity type.");
}
}
// Check all intersection points for being on entities:
//
if (onEntities==true)
{
if (!e1->isPointOnEntity(ret.get(0), tol) ||
!e2->isPointOnEntity(ret.get(0), tol))
{
ret.set(0, RS_Vector(false));
}
if (!e1->isPointOnEntity(ret.get(1), tol) ||
!e2->isPointOnEntity(ret.get(1), tol))
{
ret.set(1, RS_Vector(false));
}
if (!e1->isPointOnEntity(ret.get(2), tol) ||
!e2->isPointOnEntity(ret.get(2), tol))
{
ret.set(2, RS_Vector(false));
}
if (!e1->isPointOnEntity(ret.get(3), tol) ||
!e2->isPointOnEntity(ret.get(3), tol))
{
ret.set(3, RS_Vector(false));
}
}
int k=0;
for (int i=0; i<4; ++i)
{
if (ret.get(i).valid)
{
ret.set(k, ret.get(i));
k++;
}
}
for (int i=k; i<4; ++i)
{
ret.set(i, RS_Vector(false));
}
return ret;
}
void testCase15(){
tsL<int> l1(10, 0), l2(10, 1), l3(10, 0);
assert(l1 == l3);
assert(l1 != l2);
}
BOOL
vncServer::Authenticated(vncClientId clientid)
{
vncClientList::iterator i;
BOOL authok = TRUE;
// vnclog.Print(LL_INTINFO, VNCLOG("Lock2\n"));
omni_mutex_lock l1(m_desktopLock);
// vnclog.Print(LL_INTINFO, VNCLOG("Lock3\n"));
omni_mutex_lock l2(m_clientsLock);
// Search the unauthenticated client list
for (i = m_unauthClients.begin(); i != m_unauthClients.end(); i++)
{
// Is this the right client?
if ((*i) == clientid)
{
vncClient *client = GetClient(clientid);
// Yes, so remove the client and add it to the auth list
m_unauthClients.erase(i);
// Create the screen handler if necessary
if (m_desktop == NULL)
{
m_desktop = new vncDesktop();
if (m_desktop == NULL)
{
client->Kill();
authok = FALSE;
break;
}
if (!m_desktop->Init(this))
{
vnclog.Print(LL_INTINFO, VNCLOG("Desktop init failed, unlock in application mode ? \n"));
client->Kill();
authok = FALSE;
delete m_desktop;
m_desktop = NULL;
break;
}
}
// Tell the client about this new buffer
client->SetBuffer(&(m_desktop->m_buffer));
// Add the client to the auth list
m_authClients.push_back(clientid);
break;
}
}
// Notify anyone interested of this event
DoNotify(WM_SRV_CLIENT_AUTHENTICATED, 0, 0);
vnclog.Print(LL_INTINFO, VNCLOG("Authenticated() done\n"));
return authok;
}
/**
* Sets the best block height.
* @param value The value.
*/
void set_best_block_height(const std::int32_t & value)
{
std::lock_guard<std::mutex> l1(mutex_);
m_best_block_height = value;
}
// RemoveClient should ONLY EVER be used by the client to remove itself.
void
vncServer::RemoveClient(vncClientId clientid)
{
vncClientList::iterator i;
BOOL done = FALSE;
// vnclog.Print(LL_INTINFO, VNCLOG("Lock1\n"));
omni_mutex_lock l1(m_desktopLock);
// vnclog.Print(LL_INTINFO, VNCLOG("Lock3\n"));
{ omni_mutex_lock l2(m_clientsLock);
// Find the client in one of the two lists
for (i = m_unauthClients.begin(); i != m_unauthClients.end(); i++)
{
// Is this the right client?
if ((*i) == clientid)
{
vnclog.Print(LL_INTINFO, VNCLOG("removing unauthorised client\n"));
// Yes, so remove the client and kill it
m_unauthClients.erase(i);
m_clientmap[clientid] = NULL;
done = TRUE;
break;
}
}
if (!done)
{
for (i = m_authClients.begin(); i != m_authClients.end(); i++)
{
// Is this the right client?
if ((*i) == clientid)
{
vnclog.Print(LL_INTINFO, VNCLOG("removing authorised client\n"));
// Yes, so remove the client and kill it
m_authClients.erase(i);
m_clientmap[clientid] = NULL;
done = TRUE;
break;
}
}
}
// Signal that a client has quit
m_clientquitsig->signal();
} // Unlock the clientLock
// Are there any authorised clients connected?
if (m_authClients.empty() && (m_desktop != NULL))
{
vnclog.Print(LL_STATE, VNCLOG("deleting desktop server\n"));
// Are there locksettings set?
if (LockSettings() == 1)
{
// Yes - lock the machine on disconnect!
vncService::LockWorkstation();
} else if (LockSettings() > 1)
{
char username[UNLEN+1];
vncService::CurrentUser((char *)&username, sizeof(username));
if (strcmp(username, "") != 0)
{
// Yes - force a user logoff on disconnect!
if (!ExitWindowsEx(EWX_LOGOFF, 0))
vnclog.Print(LL_CONNERR, VNCLOG("client disconnect - failed to logoff user!\n"));
}
}
// Delete the screen server
delete m_desktop;
m_desktop = NULL;
vnclog.Print(LL_STATE, VNCLOG("desktop deleted\n"));
}
// Notify anyone interested of the change
DoNotify(WM_SRV_CLIENT_DISCONNECT, 0, 0);
vnclog.Print(LL_INTINFO, VNCLOG("RemoveClient() done\n"));
}
/**
* The block indexes.
*/
std::map<sha256, std::shared_ptr<block_index> > & block_indexes()
{
std::lock_guard<std::mutex> l1(mutex_);
return m_block_indexes;
}
static double refmap_hex_f3(double x, double y, double z) { return l0(x) * l1(y) * l0(z); }
/**
* The hash of the best chain.
*/
sha256 & hash_best_chain()
{
std::lock_guard<std::mutex> l1(mutex_);
return m_hash_best_chain;
}
static double refmap_hex_dx_f5(double x, double y, double z) { return dl1(x) * l0(y) * l1(z); }
/**
* The proofs of stake.
*/
std::map<sha256, sha256> & proofs_of_stake()
{
std::lock_guard<std::mutex> l1(mutex_);
return m_proofs_of_stake;
}
static double refmap_hex_dy_f4(double x, double y, double z) { return l0(x) * dl0(y) * l1(z); }
/**
* The (main) wallet.
*/
const std::shared_ptr<wallet> & wallet_main() const
{
std::lock_guard<std::mutex> l1(mutex_);
return m_wallet_main;
}
int main(int argc, char **argv)
{
static const char *defOutput = "a.out";
bool targetPlayer = false;
bool useLegacyAsc = false;
FILE *input = NULL;
FILE *output = NULL;
for(int i = 1; i < argc; i++)
{
std::string arg(argv[i]);
if(arg == "-o")
{
if(i >= argc - 1)
error("-o with no output file");
if(output)
error("Multiple output files specified");
if(!(output = fopen(argv[++i], "wb+")))
error("Failed to open %s for output", argv[i]);
}
else if(arg == "--")
{
if(input)
error("Multiple input files specified");
input = stdin;
}
else if(arg == "--target-player")
targetPlayer = true;
else if(arg == "--use-legacy-asc")
useLegacyAsc = true;
else
{
if(input)
error("Multiple input files specified: %s", argv[i]);
if(!(input = fopen(argv[i], "r")))
error("Failed to open %s for input", argv[i]);
}
}
if(!input)
input = stdin;
if(!output && !(output = fopen(defOutput, "wb+")))
error("Failed to open %s for output", defOutput);
std::string tmp1Path;
FILE *tmp1 = tmpfile(&tmp1Path, ".as");
if(!tmp1)
error("Couldn't create temp file 1");
Unlinker l1(tmp1Path);
std::string tmp2Path;
FILE *tmp2 = tmpfile(&tmp2Path, ".as");
if(!tmp2)
error("Couldn't create temp file 2");
Unlinker l2(tmp2Path);
FILE *cur = tmp1;
for(;;)
{
std::string line;
if(!readline(&line, input))
break;
if(line.at(0) == '#')
{
if(!line.compare(1, 8, "---SPLIT"))
{
if(cur == tmp2)
error("Multiple split directives encountered");
fclose(tmp1);
tmp1 = NULL;
cur = tmp2;
}
}
else
{
size_t len = line.length();
const char *data = line.data();
while(len)
{
int written = fwrite(data, 1, len, cur);
if(written <= 0)
error("Failed to write to output file");
len -= written;
data += written;
}
}
}
if(tmp1)
fclose(tmp1);
fclose(tmp2);
std::string outTmpPath;
FILE *outTmp = tmpfile(&outTmpPath, ".abc");
fclose(outTmp);
if(!outTmp)
error("Couldn't create temp file 2");
Unlinker l3(outTmpPath);
std::string libPath = SetFlasccSDKLocation("/../../");
libPath = unipath(libPath + "/usr/lib");
std::vector<std::string> jargs;
jargs.push_back("java");
jargs.push_back("-Xms512M");
jargs.push_back("-Xmx2048M");
jargs.push_back("-ea");
if(useLegacyAsc)
{
jargs.push_back("-classpath");
jargs.push_back(libPath + "/asc.jar");
jargs.push_back("macromedia.asc.embedding.ScriptCompiler");
}
else
{
jargs.push_back("-jar");
jargs.push_back(libPath + "/asc2.jar");
jargs.push_back("-merge");
jargs.push_back("-md");
}
jargs.push_back("-abcfuture");
jargs.push_back("-AS3");
jargs.push_back("-import");
jargs.push_back(libPath + "/builtin.abc");
jargs.push_back("-import");
if(targetPlayer)
jargs.push_back(libPath + "/playerglobal.abc");
else
jargs.push_back(libPath + "/shell_toplevel.abc");
jargs.push_back("-import");
jargs.push_back(libPath + "/BinaryData.abc");
jargs.push_back("-import");
jargs.push_back(libPath + "/Exit.abc");
jargs.push_back("-import");
jargs.push_back(libPath + "/LongJmp.abc");
jargs.push_back("-import");
jargs.push_back(libPath + "/ISpecialFile.abc");
jargs.push_back("-import");
jargs.push_back(libPath + "/IBackingStore.abc");
if(targetPlayer) {
jargs.push_back("-import");
jargs.push_back(libPath + "/InMemoryBackingStore.abc");
}
jargs.push_back("-import");
jargs.push_back(libPath + "/IVFS.abc");
jargs.push_back("-import");
jargs.push_back(libPath + "/CModule.abc");
if(useLegacyAsc) {
jargs.push_back(unipath(tmp1Path));
jargs.push_back(unipath(tmp2Path));
} else {
jargs.push_back(unipath(tmp2Path));
jargs.push_back(unipath(tmp1Path));
}
jargs.push_back("-outdir");
jargs.push_back(unipath(dirname(outTmpPath)));
std::string outNoExt = basename(outTmpPath);
outNoExt = outNoExt.substr(0, outNoExt.length() - 4); // trim the ".abc"! -- ugh!
jargs.push_back("-out");
jargs.push_back(outNoExt);
std::string cmdoutput;
if(runCmd(&cmdoutput, jargs))
error("Failed to execute compiler: %s", cmdoutput.c_str());
outTmp = fopen(outTmpPath.c_str(), "r");
for(;;)
{
char buf[CHUNK];
int nRead = fread(buf, 1, sizeof(buf), outTmp);
if(nRead < 0)
error("Failed to read from temporary output");
if(nRead == 0)
break;
if(nRead != fwrite(buf, 1, nRead, output))
error("Failed to write to final output");
}
fclose(output);
fclose(outTmp);
#ifdef _WIN32
DeleteFile(apptempdir);
#endif
return 0;
}
