Esempio n. 1
0
File: js.c Progetto: ITikhonov/bb
void parse(int c) {
	printf("\x1b[01;31m%c:%c[%.*s]\x1b[00m",state,c,(int)(stack-b_stack),b_stack);
	switch(state) {
	case 'C':
		if(c=='I') { out1("arg"); }
		if(c=='{') { *stack++='('; state='X';  }
		break;
	case 'F':
		state='X';
		if(c=='=' && stack>b_stack && stack[-1]=='v') { out1("local"); }
		out1(c=='=' ? "ident" : "get");
	case 'P':
		if(c=='(') { *stack++='f'; *stack++='('; outo('('); break; }
	case 'X':
		if(c=='N') { out1("num"); }
		else if(c=='I') {
			int l=ident-b_ident;
			if(l==8&&memcmp("function",b_ident,ident-b_ident)==0) { state='C'; outn("def",closuren); outn("args",closuren); *fstack++=closuren++; }
			else if(l==3&&memcmp("var",b_ident,ident-b_ident)==0) { *stack++='v'; }
			else if(l==6&&memcmp("return",b_ident,ident-b_ident)==0) { *stack++='r'; }
			else { state='F'; } }
		else if(c==';') { unstack(0); outo(';'); }
		else if(c=='(') { *stack++='('; out1("com ("); }
		else if(c==')') { unstack(0); stack--; state='P'; }
		else if(c=='}') { unstack(0); stack--; outn("end",*(--fstack)); }
		else { unstack(c); *stack++=c; }
		break;
	default:
		goto abort;
	}
	return;

abort:	printf("\n Parse abort: char '%c' state '%c'\n",c,state);
	abort();
}
Esempio n. 2
0
 static I impl(I begin, I end, C pred, P proj, D len, Pair const p, concepts::ForwardIterator *fi)
 {
     // *begin is known to be false
     // len >= 1
     if(len == 1)
         return begin;
     if(len == 2)
     {
         I tmp = begin;
         if(invoke(pred, invoke(proj, *++tmp)))
         {
             ranges::iter_swap(begin, tmp);
             return tmp;
         }
         return begin;
     }
     if(len <= p.second)
     {   // The buffer is big enough to use
         // Move the falses into the temporary buffer, and the trues to the front of the line
         // Update begin to always point to the end of the trues
         auto tmpbuf = make_raw_buffer(p.first);
         auto buf = tmpbuf.begin();
         *buf = iter_move(begin);
         ++buf;
         auto res = partition_copy(make_move_iterator(next(begin)),
             make_move_sentinel(end), begin, buf, std::ref(pred), std::ref(proj));
         // All trues now at start of range, all falses in buffer
         // Move falses back into range, but don't mess up begin which points to first false
         ranges::move(p.first, res.out2().base().base(), res.out1());
         // h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
         return res.out1();
     }
     // Else not enough buffer, do in place
     // len >= 3
     D half = len / 2;  // half >= 2
     I middle = next(begin, half);
     // recurse on [begin, middle), *begin know to be false
     // F?????????????????
     // f       m         l
     I begin_false = stable_partition_fn::impl(begin, middle, pred, proj, half, p, fi);
     // TTTFFFFF??????????
     // f  ff   m         l
     // recurse on [middle, end], except increase middle until *(middle) is false, *end know to be true
     I m1 = middle;
     D len_half = len - half;
     while(invoke(pred, invoke(proj, *m1)))
     {
         if(++m1 == end)
             return ranges::rotate(begin_false, middle, end).begin();
         --len_half;
     }
     // TTTFFFFFTTTF??????
     // f  ff   m  m1     l
     I end_false = stable_partition_fn::impl(m1, end, pred, proj, len_half, p, fi);
     // TTTFFFFFTTTTTFFFFF
     // f  ff   m    sf   l
     return ranges::rotate(begin_false, middle, end_false).begin();
     // TTTTTTTTFFFFFFFFFF
     //         |
 }
Esempio n. 3
0
int ex2(struct parser* p)
{
    int label_1 = label_count++;
    int stop = 0;

    if (ex3(p)) {
        out3("BF", label_1);
    }
    else if (output(p)) {
    }
    else {
        stop = 1;
    }

    if (stop) return 0;

    while (!stop) {
        if (ex3(p)) {
            out1("BE");
        }
        else if (output(p)) {
        }
        else {
            stop = 1;
        }
    }

    generate_label(label_1);

    return 1;
}
Esempio n. 4
0
void System::saveCurrentProfile(std::vector<QString> interfaces, QString defaultPolicyIN, QString defaultPolicyOUT)
{
    //Writing the changes to the profile file
    QString pathString;
    QTextStream pathStream(&pathString);
    pathStream << this->systemPath << "/profiles/" << this->currentProfile->getName() << ".txt";
    QFile currentProfile(pathString);
    currentProfile.open(QIODevice::WriteOnly | QIODevice::Text);
    QTextStream out1(&currentProfile);
    out1 << this->currentProfile->getName() << "\n";
    out1 << defaultPolicyIN << "\n";
    out1 << defaultPolicyOUT << "\n";
    out1 << this->currentProfile->getCreationDate() << "\n";
    out1 << this->currentProfile->getSystemTime() << "\n";
    currentProfile.close();

    //Writing the changes of interfaces to the profile's interface file
    QString pathString2;
    QTextStream pathStream2(&pathString2);
    pathStream2 << this->systemPath << "/profiles/" << this->currentProfile->getName() << "-interfaces.txt";
    QFile currentProfileInterfaces(pathString2);
    currentProfileInterfaces.open(QIODevice::WriteOnly | QIODevice::Text);
    QTextStream out2(&currentProfileInterfaces);
    out2 << interfaces.size() << "\n";
    for (unsigned int i=0;i<interfaces.size();i++)
        out2 << interfaces.at(i) << "\n";
    currentProfileInterfaces.close();

    //Reload the currentProfile with the new changes
    this->updateProfileInfo(this->currentProfile->getName());
}
int TriangleSetTopologyContainer::getTriangleIndex(PointID v1, PointID v2, PointID v3)
{
    if(!hasTrianglesAroundVertex())
        createTrianglesAroundVertexArray();

    sofa::helper::vector<unsigned int> set1 = getTrianglesAroundVertex(v1);
    sofa::helper::vector<unsigned int> set2 = getTrianglesAroundVertex(v2);
    sofa::helper::vector<unsigned int> set3 = getTrianglesAroundVertex(v3);

    sort(set1.begin(), set1.end());
    sort(set2.begin(), set2.end());
    sort(set3.begin(), set3.end());

    // The destination vector must be large enough to contain the result.
    sofa::helper::vector<unsigned int> out1(set1.size()+set2.size());
    sofa::helper::vector<unsigned int>::iterator result1;
    result1 = std::set_intersection(set1.begin(),set1.end(),set2.begin(),set2.end(),out1.begin());
    out1.erase(result1,out1.end());

    sofa::helper::vector<unsigned int> out2(set3.size()+out1.size());
    sofa::helper::vector<unsigned int>::iterator result2;
    result2 = std::set_intersection(set3.begin(),set3.end(),out1.begin(),out1.end(),out2.begin());
    out2.erase(result2,out2.end());

#ifndef NDEBUG
    if(out2.size() > 1)
        sout << "Warning. [TriangleSetTopologyContainer::getTriangleIndex] more than one triangle found" << sendl;
#endif

    if (out2.size()==1)
        return (int) (out2[0]);
    else
        return -1;
}
// examples might be ".OUT('GN1')" or ".OUT(.LABEL *1)"?
// I think I have a typo or three:
// OUTPUT = ('.OUT' '('
// \$ OUT1 ')' / '.LABEL' .OUT('LB') OUT1) .OUT('OUT') .,
void output() {
  istoken(TOKEN_OUT);
  istoken(TOKEN_OPEN_PAREN);
  is_token(TOKEN_LABEL);
  emit(OP_LB);
  out1();
  emit(OP_OUT);
}
Esempio n. 7
0
int main() {
   auto string = QStringLiteral("FooBar");
   QByteArray block1, block2;
   QDataStream out1(&block1, QIODevice::WriteOnly), out2(&block2, QIODevice::WriteOnly);
   out1 << quint16(0) << string;
   operator<<(out2.operator<<(quint16(0)), string);
   Q_ASSERT(block1 == block2);
}
Esempio n. 8
0
void OptionsWindow::SaveAConfig(int step, bool nomesseage = true) {
	QSettings *GlobalSettings = new QSettings("/root/.WiFiHostapdAP/WiFi_Hostapd_AP.conf",QSettings::NativeFormat); // creating a new object
	// Функция сохраения конфигурационных файлов по маске
	// №1 - что сохраняем - 0 = только HOSTAPD; 1 - DNSMASQ
		QString temp;
		QDateTime TimeNow;
		QString dateUNIXNow;
	if(step == 0) {
		//  Save only HOSTAPD
		temp = getMaskToConfig(0);
		QFile::remove("/etc/hostapd/hostapd.conf");
		QFile hostapd_config("/etc/hostapd/hostapd.conf");
		hostapd_config.open(QIODevice::WriteOnly);
		QTextStream out(&hostapd_config);
		out << temp;
		hostapd_config.close();


		dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
		emit  toMainLog(QString("%1|%2|%3|%4").arg(tr("Options"), dateUNIXNow, tr("Hostapd config succesfully update."), QString("1")));

		// Hostapd
		if(!nomesseage) {
		QMessageBox msgBoxHostapd;
		msgBoxHostapd.setText(tr("The configuration file is updated"));
		msgBoxHostapd.setIcon(QMessageBox::Information);
		msgBoxHostapd.setInformativeText(tr("Hostapd Settings saved successfully. To enter into force, please restart the access point."));
		msgBoxHostapd.setStandardButtons(QMessageBox::Ok);
		msgBoxHostapd.setDefaultButton(QMessageBox::Ok);
		msgBoxHostapd.exec(); }
		temp.clear();
	} else {
		//  Сохраняемфайл DNSMASQ
		// 1
		temp = getMaskToConfig(1);
		QFile::remove("/etc/dnsmasq.conf");
		QFile firstDHCPConfig("/etc/dnsmasq.conf");
		firstDHCPConfig.open(QIODevice::WriteOnly);
		QTextStream out1(&firstDHCPConfig);
		out1 << temp;
		firstDHCPConfig.close();
		temp.clear();
		dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
		emit  toMainLog(QString("%1|%2|%3|%4").arg(tr("Options"), dateUNIXNow, tr("DNSMASQ config succesfully update."), QString("1")));

		// DHCP
		if(!nomesseage) {
		QMessageBox msgBoxDHCP;
		msgBoxDHCP.setText(tr("The configuration file is updated"));
		msgBoxDHCP.setIcon(QMessageBox::Information);
		msgBoxDHCP.setInformativeText(tr("DHCP Settings saved successfully. To enter into force, please restart the access point."));
		msgBoxDHCP.setStandardButtons(QMessageBox::Ok);
		msgBoxDHCP.setDefaultButton(QMessageBox::Ok);
		msgBoxDHCP.exec(); }
		temp.clear();
	}
	delete GlobalSettings;
}
Esempio n. 9
0
void OptionsWindow::SaveAConfig(int step, bool nomesseage = true) {
    QSettings *GlobalSettings = new QSettings("/root/.WiFiHostapdAP/WiFi_Hostapd_AP.conf",QSettings::NativeFormat); // создание нового объекта
    // Функция сохраения конфигурационных файлов по маске
    // №1 - что сохраняем - 0 = только HOSTAPD; 1 - DNSMASQ
    QString temp;
    QDateTime TimeNow;
    QString dateUNIXNow;
    if(step == 0) {
        //  Сохраняем только HOSTAPD
        temp = getMaskToConfig(0);
        QFile::remove("/etc/hostapd/hostapd.conf");
        QFile hostapd_config("/etc/hostapd/hostapd.conf");
        hostapd_config.open(QIODevice::WriteOnly);
        QTextStream out(&hostapd_config);
        out << temp;
        hostapd_config.close();


        dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
        emit  toMainLog(QString("%1|%2|%3|%4").arg(tr("Options"), dateUNIXNow, tr("Hostapd config succesfully update."), QString("1")));

        // Hostapd
        if(!nomesseage) {
            QMessageBox msgBoxHostapd;
            msgBoxHostapd.setText(tr("Конфигурационный файл обновлён"));
            msgBoxHostapd.setIcon(QMessageBox::Information);
            msgBoxHostapd.setInformativeText(tr("Настройки Hostapd успешно сохранены. Для вступления их в силу, пожалуйста, перезапустите точку доступа."));
            msgBoxHostapd.setStandardButtons(QMessageBox::Ok);
            msgBoxHostapd.setDefaultButton(QMessageBox::Ok);
            msgBoxHostapd.exec(); }
        temp.clear();
    } else {
        //  Сохраняемфайл DNSMASQ
        // 1
        temp = getMaskToConfig(1);
        QFile::remove("/etc/dnsmasq.conf");
        QFile firstDHCPConfig("/etc/dnsmasq.conf");
        firstDHCPConfig.open(QIODevice::WriteOnly);
        QTextStream out1(&firstDHCPConfig);
        out1 << temp;
        firstDHCPConfig.close();
        temp.clear();
        dateUNIXNow = QString::number(TimeNow.currentDateTime().toTime_t());
        emit  toMainLog(QString("%1|%2|%3|%4").arg(tr("Options"), dateUNIXNow, tr("DNSMASQ config succesfully update."), QString("1")));

        // DHCP
        if(!nomesseage) {
            QMessageBox msgBoxDHCP;
            msgBoxDHCP.setText(tr("Конфигурационный файл обновлён"));
            msgBoxDHCP.setIcon(QMessageBox::Information);
            msgBoxDHCP.setInformativeText(tr("Настройки DHCP успешно сохранены. Для вступления их в силу, пожалуйста, перезапустите точку доступа."));
            msgBoxDHCP.setStandardButtons(QMessageBox::Ok);
            msgBoxDHCP.setDefaultButton(QMessageBox::Ok);
            msgBoxDHCP.exec(); }
        temp.clear();
    }
    delete GlobalSettings;
}
Esempio n. 10
0
int ex3(struct parser* p)
{
    int label_1 = label_count++;

    whitespace(p);

    if (lstring(p, ".ID")) {
        out1("ID");
        return 1;
    }
    else if (lstring(p, ".NUMBER")) {
        out1("NUM");
        return 1;
    }
    else if (lstring(p, ".STRING")) {
        out1("SR");
        return 1;
    }
    else if (lstring(p, ".EMPTY")) {
        out1("SET");
        return 1;
    }
    else if (lstring(p, "(")) {
        ex1(p);
        lstring(p, ")");
        return 1;
    }
    else if (*(p->buf->begin) == '$') {
        p->buf->begin++;
        generate_label(label_1);
        ex3(p);
        out3("BT", label_1);
        out1("SET");
        return 1;
    }
    else if (identifier(p)) {
        out2("CLL", p->id);
        return 1;
    }
    else if (string(p)) {
        out2("TST", p->id);
        return 1;
    }
    return 0;
}
// test to run processing/example.py
TEST_F(SignalProcessingInterfaceTest, exampleTest) {
    android::String8 functionName("example");
    int nInputs = 8;
    int nOutputs = 4;
    bool inputTypes[8] = { true, true, true, true, false, false, false, false };
    bool outputTypes[4] = { true, true, false, false };

    android::sp<Buffer> in0(new Buffer(16, 16, true));
    char* data0 = in0->getData();
    for (size_t i = 0; i < in0->getSize(); i++) {
        data0[i] = i;
    }
    android::sp<Buffer> in1(new Buffer(16, 16, true));
    char* data1 = in1->getData();
    for (size_t i = 0; i < in1->getSize(); i++) {
        data1[i] = i;
    }
    android::sp<Buffer> in2(new Buffer(8, 8, false));
    char* data2 = in2->getData();
    for (size_t i = 0; i < in2->getSize(); i++) {
        data2[i] = i;
    }
    android::sp<Buffer> in3(new Buffer(8, 8, false));
    char* data3 = in3->getData();
    for (size_t i = 0; i < in3->getSize(); i++) {
        data3[i] = i;
    }
    TaskCase::Value in4((int64_t)100);
    TaskCase::Value in5((int64_t)100);
    TaskCase::Value in6(1.0f);
    TaskCase::Value in7(1.0f);
    void* inputs[8] = { &in0, &in1, &in2, &in3, &in4, &in5, &in6, &in7 };

    android::sp<Buffer> out0(new Buffer(16, 16, true));
    char* outdata0 = out0->getData();
    for (size_t i = 0; i < out0->getSize(); i++) {
        outdata0[i] = 0xaa;
    }
    android::sp<Buffer> out1(new Buffer(8, 8, false));
    char* outdata1 = out1->getData();
    for (size_t i = 0; i < out1->getSize(); i++) {
        outdata1[i] = 0xbb;
    }
    TaskCase::Value out2((int64_t)1000);
    TaskCase::Value out3(-1.0f);
    void *outputs[4] = { &out0, &out1, &out2, &out3 };

    ASSERT_TRUE(mSp->run( functionName,
            nInputs, inputTypes, inputs,
            nOutputs, outputTypes, outputs) == TaskGeneric::EResultOK);
    ASSERT_TRUE(*(in0.get()) == *(out0.get()));
    ASSERT_TRUE(*(in2.get()) == *(out1.get()));
    ASSERT_TRUE(in4 == out2);
    ASSERT_TRUE(in6 == out3);
}
Esempio n. 12
0
TEST(RealWordTest, OR)
{
  typedef NeuralNetwork<double, StepActivationFunction<double >> network;
  network nn;
  nn.setEntries(2);
  nn.setExits(1);
  nn.setLayersCount(1);
  nn.init();
  std::vector<double> in1(2);
  std::vector<double> in2(2);
  std::vector<double> in3(2);
  std::vector<double> in4(2);
  in1[0] = 0;
  in1[1] = 0;
  in2[0] = 1;
  in2[1] = 0;
  in3[0] = 0;
  in3[1] = 1;
  in4[0] = 1;
  in4[1] = 1;
  std::vector<double> out0(1);
  std::vector<double> out1(1);
  out0[0] = 0;
  out1[0] = 1;
  //uczenie
  for (int i = 0; i < 100; ++i)
  {
    nn.setInput(in1.begin(), in1.end());
    nn.calcOutput();
    nn.learn(out0.begin(), out0.end());
    nn.setInput(in2.begin(), in2.end());
    nn.calcOutput();
    nn.learn(out1.begin(), out1.end());
    nn.setInput(in3.begin(), in3.end());
    nn.calcOutput();
    nn.learn(out1.begin(), out1.end());
    nn.setInput(in4.begin(), in4.end());
    nn.calcOutput();
    nn.learn(out1.begin(), out1.end());
  }
  //test
  std::vector<double> out;
  nn.setInput(in1.begin(), in1.end());
  out = nn.calcOutput();
  ASSERT_EQ(out[0], 0);
  nn.setInput(in2.begin(), in2.end());
  out = nn.calcOutput();
  ASSERT_EQ(out[0], 1);
  nn.setInput(in3.begin(), in3.end());
  out = nn.calcOutput();
  ASSERT_EQ(out[0], 1);
  nn.setInput(in4.begin(), in4.end());
  out = nn.calcOutput();
  ASSERT_EQ(out[0], 1);
}
Esempio n. 13
0
int output(struct parser* p)
{
    if (lstring(p, ".OUT")) {
        lstring(p, "(");
        while (output1(p)) {}
        lstring(p, ")");
        out1("OUT");
    }
    else if (lstring(p, ".LABEL")) {
        out1("LB");
        output1(p);
        out1("OUT");
    }
    else {
        //out1("OUT");
        return 0;
    }

    return 1;
}
Esempio n. 14
0
int output1(struct parser* p)
{
    whitespace(p);

    if (lstring(p, "*1")) {
        out1("GN1");
        return 1;
    }
    else if (lstring(p, "*2")) {
        out1("GN2");
        return 1;
    }
    else if (lstring(p, "*")) {
        out1("CI");
        return 1;
    }
    else if (string(p)) {
        out2("CL", p->id);
        return 1;
    }
    return 0;
}
Esempio n. 15
0
int main ()
{
    BTree<int> t;
    t.insert (10,"");
    t.insert (20,"L");
    t.insert (8,"R");
    t.insert (17,"LL");
    t.insert (19,"RL");

    assert (t.sum () == 74);
    assert (t.countLeaves () == 2);
    BTree<int> t2 (t);

    assert (t == t2);
    assert (t.member(10));
    assert (!t.member(99));

    t.insert (99,"LR");
    assert (t.member(99));

    assert (!(t == t2));

    std::ofstream out1 ("tree1.hsl");
    t.printToHs (out1);
    out1.close ();

    std::ifstream in1 ("tree1.hsl");
    t2.readFromHs (in1);

    assert (t == t2);
    assert (!t.isBOT());

    BTree<int> bot;

    bot.insertBOT (10);
    bot.insertBOT (232);
    bot.insertBOT (577);
    bot.insertBOT (232);
    bot.insertBOT (878);
    bot.insertBOT (23);
    bot.insertBOT (68);
    bot.insertBOT (1);

    std::ofstream botf ("botf.dot");
    bot.printToDotty (botf);

    assert (bot.isBOT());


    return 0;
}
Esempio n. 16
0
void ThreadParse::run()
{
    QTextStream out1(&str);

    A2lLexer *lexer1 = new A2lLexer();
    lexer1->initialize();

    QStringList *errorList1 = new QStringList();
    A2lGrammar *gram = new A2lGrammar();
    nodeA2l1 = new A2LFILE(out1, 0, lexer1, errorList1, gram);
    nodeA2l1->name = (char*)"fileName";

    delete lexer1;
}
Esempio n. 17
0
int program(struct parser* p)
{
    lstring(p, ".SYNTAX");
    identifier(p);
    out2("ADR", p->id);

    while (st(p)) {}

    if (lstring(p, ".END")) {
        out1("END");
        return 1;
    }
    return 1;
}
Esempio n. 18
0
int main()
{
    using vector_type = hpx::partitioned_vector<double>;

    const std::size_t height = 16;
    const std::size_t width = 16;

    std::size_t local_height = 16;
    std::size_t local_width = 16;
    std::size_t local_leading_dimension = local_height;

    std::size_t raw_size = (height * width) * (local_height * local_width);

    auto layout =
        hpx::container_layout(height * width, hpx::find_all_localities());

    // Vector instantiations for test 1
    vector_type in1(raw_size, layout);
    vector_type out1(raw_size, layout);

    std::string in1_name("in1");
    std::string out1_name("out1");

    in1.register_as(hpx::launch::sync, in1_name);
    out1.register_as(hpx::launch::sync, out1_name);

    // Vector instantiations for test 2
    vector_type in2(raw_size, layout);
    vector_type out2(raw_size, layout);

    std::string in2_name("in2");
    std::string out2_name("out2");

    in2.register_as(hpx::launch::sync, in2_name);
    out2.register_as(hpx::launch::sync, out2_name);

    // Launch tests
    hpx::future<void> join1 = hpx::lcos::define_spmd_block("block1", 4,
        bulk_test_action(), height, width, local_height, local_width,
        local_leading_dimension, in1_name, out1_name);

    hpx::future<void> join2 = hpx::lcos::define_spmd_block("block2", 4,
        async_bulk_test_action(), height, width, local_height, local_width,
        local_leading_dimension, in2_name, out2_name);

    hpx::wait_all(join1, join2);

    return 0;
}
Esempio n. 19
0
int st(struct parser* p)
{
    if (!identifier(p)) {
        return 0;
    }

    label(p->id);

    character(p, '=');
    ex1(p);
    lstring(p, ".,");
    out1("R");

    return 1;
}
Esempio n. 20
0
int main(int, char **)
try
{
    DB::ReadBufferFromFileDescriptor in1(STDIN_FILENO);
    DB::WriteBufferFromFileDescriptor out1(STDOUT_FILENO);
    DB::AsynchronousWriteBuffer out2(out1);
    DB::CompressedWriteBuffer out3(out2);

    DB::copyData(in1, out3);

    return 0;
}
catch (const DB::Exception & e)
{
    std::cerr << e.what() << ", " << e.displayText() << std::endl;
    return 1;
}
DEF_TEST(UnflattenWithCustomFactory, r) {
    // Create and flatten the test flattenable
    SkBinaryWriteBuffer writeBuffer;
    sk_sp<SkFlattenable> flattenable1(new IntFlattenable(1, 2, 3, 4));
    writeBuffer.writeFlattenable(flattenable1.get());
    sk_sp<SkFlattenable> flattenable2(new IntFlattenable(2, 3, 4, 5));
    writeBuffer.writeFlattenable(flattenable2.get());
    sk_sp<SkFlattenable> flattenable3(new IntFlattenable(3, 4, 5, 6));
    writeBuffer.writeFlattenable(flattenable3.get());

    // Copy the contents of the write buffer into a read buffer
    sk_sp<SkData> data = SkData::MakeUninitialized(writeBuffer.bytesWritten());
    writeBuffer.writeToMemory(data->writable_data());
    SkReadBuffer readBuffer(data->data(), data->size());

    // Register a custom factory with the read buffer
    readBuffer.setCustomFactory(SkString("IntFlattenable"), &custom_create_proc);

    // Unflatten and verify the flattenables
    sk_sp<IntFlattenable> out1((IntFlattenable*) readBuffer.readFlattenable(
            SkFlattenable::kSkUnused_Type));
    REPORTER_ASSERT(r, out1);
    REPORTER_ASSERT(r, 2 == out1->a());
    REPORTER_ASSERT(r, 3 == out1->b());
    REPORTER_ASSERT(r, 4 == out1->c());
    REPORTER_ASSERT(r, 5 == out1->d());

    sk_sp<IntFlattenable> out2((IntFlattenable*) readBuffer.readFlattenable(
            SkFlattenable::kSkUnused_Type));
    REPORTER_ASSERT(r, out2);
    REPORTER_ASSERT(r, 3 == out2->a());
    REPORTER_ASSERT(r, 4 == out2->b());
    REPORTER_ASSERT(r, 5 == out2->c());
    REPORTER_ASSERT(r, 6 == out2->d());

    sk_sp<IntFlattenable> out3((IntFlattenable*) readBuffer.readFlattenable(
            SkFlattenable::kSkUnused_Type));
    REPORTER_ASSERT(r, out3);
    REPORTER_ASSERT(r, 4 == out3->a());
    REPORTER_ASSERT(r, 5 == out3->b());
    REPORTER_ASSERT(r, 6 == out3->c());
    REPORTER_ASSERT(r, 7 == out3->d());
}
Esempio n. 22
0
void diff_it(
  std::list<linet> &lines1,
  std::list<linet> &lines2)
{
  std::string tmp1_name=get_temporary_file("delta_diff1", "txt");
  std::string tmp2_name=get_temporary_file("delta_diff2", "txt");
  std::string tmp3_name=get_temporary_file("delta_diff3", "txt");

  {  
    std::ofstream out1(tmp1_name.c_str());
    std::ofstream out2(tmp2_name.c_str());
    
    for(std::list<linet>::const_iterator l_it=lines1.begin();
        l_it!=lines1.end(); l_it++)
      out1 << l_it->line << "\n";

    for(std::list<linet>::const_iterator l_it=lines2.begin();
        l_it!=lines2.end(); l_it++)
      out2 << l_it->line << "\n";
  }
  
  std::string cmdline="diff \""+tmp1_name+"\""+
                          " \""+tmp2_name+"\""+
                         "> \""+tmp3_name+"\"";
  
  int result=system(cmdline.c_str());

  // open output
  if(result>=0)
  {
    std::ifstream in(tmp3_name.c_str());
    std::string line;
    std::list<std::string> diff;
    while(std::getline(in, line)) diff.push_back(line);
    process_diff(lines1, lines2, diff);
  }
  
  // clean up
  unlink(tmp1_name.c_str());
  unlink(tmp2_name.c_str());
  unlink(tmp3_name.c_str());
}
Esempio n. 23
0
void out(FILE* fbin2,double average, int d, unsigned long n_tuples,int n, option_t *opt) {

	double *tscore;
	double* *keyvalue;//score index->index
	tscore = (double*)malloc(n_tuples * sizeof(double));
	keyvalue = (double**)malloc(n_tuples * sizeof(double*));
	int **readin;
	readin = (int**)malloc(n_tuples * sizeof(int*));
	for (int i = 0; i < n_tuples; i++)
		readin[i] = (int*)malloc((d + 5) * sizeof(int));
	for (int i = 0; i < n_tuples; i++) {
		char *buf;
		buf = (char*)malloc((d + 5) * sizeof(char));
		fgets(buf, d + 5, fbin2);
		analyse(buf, sizeof(buf), readin[i]);
		fscanf(fbin2, "%f", &tscore[i]);
		keyvalue[i] = &tscore[i];
		free(buf);
	}
	qsort((void*)keyvalue, n_tuples, sizeof(double*), cmp_1);
	//------------------------------------------------------------------------
	FILE* fout1 = fopen("out1.txt", "w");
	FILE* fout2 = fopen("out2.txt", "w");
	if (n == 0) { fclose(fout1); fclose(fout2); }
	//1---------------------------------------------------------------------
	out1(fout1, n,keyvalue,tscore,d,readin);
	fclose(fout1);
	//2--------------------------------------------------------------------------
	out2(fout2, n, keyvalue, tscore, d, readin,n_tuples);
	fclose(fout2);
	//3--------------------------------------------------------------------------
	FILE* fout3 = fopen("out3.txt", "w");
	out3(fout2, n, keyvalue, tscore, d, readin, n_tuples,opt);
	fclose(fout3);
	//4------------------------------------------------------------------------------
	FILE* fout4 = fopen("out4.txt", "w");
	out4(fout2, n, keyvalue, tscore, d, readin, n_tuples, opt);
	fclose(fout4);
	//
	free(tscore); free(readin); free(keyvalue);
}
Esempio n. 24
0
bool isUpdated(
    const InputFile &in,
    const std::string &outHeaderName,
    const std::string &outImplName)
{
    bool toret = false;

    InputFile out1( outHeaderName );
    InputFile out2( outImplName );

    if ( in.isOpen()
      && out1.isOpen()
      && out2.isOpen() )
    {
        toret = ( out1.getTimeStamp() >= in.getTimeStamp()
              &&  out2.getTimeStamp() >= in.getTimeStamp() )
        ;
    }

    return toret;
}
	int TetrahedronSetTopologyContainer::getTetrahedronIndex(PointID v1, PointID v2, PointID v3, PointID v4)
	{
		if(!hasTetrahedraAroundVertex())
			createTetrahedraAroundVertexArray();

		sofa::helper::vector<unsigned int> set1 = getTetrahedraAroundVertex(v1);
		sofa::helper::vector<unsigned int> set2 = getTetrahedraAroundVertex(v2);
		sofa::helper::vector<unsigned int> set3 = getTetrahedraAroundVertex(v3);
		sofa::helper::vector<unsigned int> set4 = getTetrahedraAroundVertex(v4);

		sort(set1.begin(), set1.end());
		sort(set2.begin(), set2.end());
		sort(set3.begin(), set3.end());
		sort(set4.begin(), set4.end());	

		// The destination vector must be large enough to contain the result.
		sofa::helper::vector<unsigned int> out1(set1.size()+set2.size());
		sofa::helper::vector<unsigned int>::iterator result1;
		result1 = std::set_intersection(set1.begin(),set1.end(),set2.begin(),set2.end(),out1.begin());
		out1.erase(result1,out1.end());

		sofa::helper::vector<unsigned int> out2(set3.size()+out1.size());
		sofa::helper::vector<unsigned int>::iterator result2;
		result2 = std::set_intersection(set3.begin(),set3.end(),out1.begin(),out1.end(),out2.begin());
		out2.erase(result2,out2.end());

		sofa::helper::vector<unsigned int> out3(set4.size()+out2.size());
		sofa::helper::vector<unsigned int>::iterator result3;
		result3 = std::set_intersection(set4.begin(),set4.end(),out2.begin(),out2.end(),out3.begin());
		out3.erase(result3,out3.end());

		assert(out3.size()==0 || out3.size()==1);

		if (out3.size()==1)
			return (int) (out3[0]);
		else
			return -1;
	}
Esempio n. 26
0
server::worker::worker(environment const & env, io_state const & ios, definition_cache & cache, optional<std::string> const & base_dir):
    m_empty_snapshot(env, ios.get_options()),
    m_cache(cache),
    m_base_dir(base_dir),
    m_todo_line_num(0),
    m_todo_options(ios.get_options()),
    m_terminate(false),
    m_thread([=]() {
            io_state _ios(ios);
            while (!m_terminate) {
                file_ptr todo_file;
                unsigned todo_line_num = 0;
                options  todo_options;
                // wait for next task
                while (!m_terminate) {
                    unique_lock<mutex> lk(m_todo_mutex);
                    if (m_todo_file) {
                        todo_file    = m_todo_file;
                        todo_line_num = m_todo_line_num;
                        todo_options = m_todo_options;
                        break;
                    } else {
                        m_todo_cv.wait(lk);
                    }
                }
                // extract block of code and snapshot from todo_file
                reset_interrupt();
                bool worker_interrupted = false;
                if (m_terminate)
                    break;
                DIAG(std::cerr << "processing '" << todo_file->get_fname() << "'\n";)
                std::string block;
                unsigned    num_lines;
                snapshot    s;
                {
                    lean_assert(todo_file);
                    lock_guard<mutex> lk(todo_file->m_lines_mutex);
                    unsigned i = todo_file->find(todo_line_num);
                    todo_file->m_snapshots.resize(i);
                    s = i == 0 ? m_empty_snapshot : todo_file->m_snapshots[i-1];
                    if (direct_imports_have_changed(s.m_env))
                        s = m_empty_snapshot;
                    lean_assert(s.m_line > 0);
                    todo_file->m_info.start_from(s.m_line);
                    todo_file->m_info.save_environment_options(s.m_line, 0, s.m_env, s.m_options);
                    num_lines = todo_file->copy_to(block, s.m_line - 1);
                }
                if (m_terminate)
                    break;
                // parse block of code with respect to snapshot
                try {
                    std::istringstream strm(block);
                    #if defined(LEAN_SERVER_DIAGNOSTIC)
                    std::shared_ptr<output_channel> out1(new stderr_channel());
                    std::shared_ptr<output_channel> out2(new stderr_channel());
                    #else
                    std::shared_ptr<output_channel> out1(new string_output_channel());
                    std::shared_ptr<output_channel> out2(new string_output_channel());
                    #endif
                    io_state tmp_ios(_ios, out1, out2);
                    tmp_ios.set_options(join(s.m_options, _ios.get_options()));
                    bool use_exceptions  = false;
                    unsigned num_threads = 1;
                    parser p(s.m_env, tmp_ios, strm, todo_file->m_fname.c_str(), m_base_dir,
                        use_exceptions, num_threads,
                        &s, &todo_file->m_snapshots, &todo_file->m_info);
                    p.set_cache(&m_cache);
                    p();
                } catch (interrupted &) {
                    worker_interrupted = true;
                } catch (throwable & ex) {
                    DIAG(std::cerr << "worker exception: " << ex.what() << "\n";)
                }
                if (!m_terminate && !worker_interrupted) {
                    DIAG(std::cerr << "finished '" << todo_file->get_fname() << "'\n";)
                    unique_lock<mutex> lk(m_todo_mutex);
                    if (m_todo_file == todo_file && m_last_file == todo_file && m_todo_line_num == todo_line_num) {
                        m_todo_line_num = num_lines + 1;
                        m_todo_file    = nullptr;
                        m_todo_cv.notify_all();
                    }
                }
Esempio n. 27
0
TEST(RealWordTest, ORLinear)
{
  typedef NeuralNetwork<double, LinearActivationFunction<double >> network;
  network nn;
  nn.setEntries(2);
  nn.setExits(1);
  nn.setLayersCount(1);
  nn.init();
  std::vector<double> in1(2);
  std::vector<double> in2(2);
  std::vector<double> in3(2);
  std::vector<double> in4(2);
  in1[0] = 0;
  in1[1] = 0;
  in2[0] = 1;
  in2[1] = 0;
  in3[0] = 0;
  in3[1] = 1;
  in4[0] = 1;
  in4[1] = 1;
  std::vector<double> out0(1);
  std::vector<double> out1(1);
  out0[0] = 0;
  out1[0] = 1;
  //uczenie
  for (int i = 0; i < 1000; ++i)
  {
    std::vector<double> o;
    //   nn.printWages();
    nn.setInput(in1.begin(), in1.end());
    o = nn.calcOutput();
    //    for (auto d : o)
    //    {
    //      std::cout << d << " :answer 0 0 \n";
    //    }
    nn.learn(out0.begin(), out0.end());
    nn.setInput(in2.begin(), in2.end());
    o = nn.calcOutput();
    //    for (auto d : o)
    //    {
    //      std::cout << d << " :answer 1 0 \n";
    //    }
    nn.learn(out1.begin(), out1.end());
    nn.setInput(in3.begin(), in3.end());
    o = nn.calcOutput();
    //    for (auto d : o)
    //    {
    //      std::cout << d << " :answer 0 1 \n";
    //    }
    nn.learn(out1.begin(), out1.end());
    nn.setInput(in4.begin(), in4.end());
    o = nn.calcOutput();
    //    for (auto d : o)
    //    {
    //      std::cout << d << " :answer 1 1 \n";
    //    }
    nn.learn(out1.begin(), out1.end());
  }
  //  nn.printWages();
  //test
  std::vector<double> out;
  nn.setInput(in1.begin(), in1.end());
  out = nn.calcOutput();
  ASSERT_LT(out[0], 0.1);
  nn.setInput(in2.begin(), in2.end());
  out = nn.calcOutput();
  ASSERT_GT(out[0], 0.9);
  nn.setInput(in3.begin(), in3.end());
  out = nn.calcOutput();
  ASSERT_GT(out[0], 0.9);
  nn.setInput(in4.begin(), in4.end());
  out = nn.calcOutput();
  ASSERT_GT(out[0], 0.9);

}
Esempio n. 28
0
TEST(RealWordTest, XORLinear)
{
  typedef NeuralNetwork<double, LinearActivationFunction<double >> network;
  network nn;
  //nn.setActivationfunction(LinearActivationFunction<double>(10));
  nn.setEntries(2);
  nn.setExits(1);
  nn.setLayersCount(2);
  nn.setNeurons(1, 2);
  nn.init();
  std::vector<double> in1(2);
  std::vector<double> in2(2);
  std::vector<double> in3(2);
  std::vector<double> in4(2);
  in1[0] = 0;
  in1[1] = 0;
  in2[0] = 1;
  in2[1] = 0;
  in3[0] = 0;
  in3[1] = 1;
  in4[0] = 1;
  in4[1] = 1;
  std::vector<double> out0(1);
  std::vector<double> out1(1);
  out0[0] = 0;
  out1[0] = 1;
  //uczenie
  for (int i = 0; i < 1000; ++i)
  {
    std::vector<double> o(1);

    nn.setInput(in1.begin(), in1.end());
    o = nn.calcOutput();
    nn.learn(out0.begin(), out0.end());
    //
    //    std::cout << "Wynik0: " << o[0] << "\n";
    //    nn.printWages();

    nn.setInput(in2.begin(), in2.end());
    o = nn.calcOutput();
    nn.learn(out1.begin(), out1.end());
    //
    //    std::cout << "Wynik1: " << o[0] << "\n";
    //    nn.printWages();

    nn.setInput(in3.begin(), in3.end());
    o = nn.calcOutput();
    nn.learn(out1.begin(), out1.end());
    //
    //    std::cout << "Wynik1: " << o[0] << "\n";
    //    nn.printWages();

    nn.setInput(in4.begin(), in4.end());
    o = nn.calcOutput();
    nn.learn(out0.begin(), out0.end());
    //
    //    std::cout << "Wynik0: " << o[0] << "\n";
    //    nn.printWages();

  }
  //test
  std::vector<double> out;
  std::vector<double> o(4);
  nn.setInput(in1.begin(), in1.end());
  out = nn.calcOutput();
  o[0] = out[0];
  EXPECT_LT(out[0], 0.1);
  nn.setInput(in2.begin(), in2.end());
  out = nn.calcOutput();
  o[1] = out[0];
  EXPECT_GT(out[0], 0.9);
  nn.setInput(in3.begin(), in3.end());
  out = nn.calcOutput();
  o[2] = out[0];
  EXPECT_GT(out[0], 0.9);
  nn.setInput(in4.begin(), in4.end());
  out = nn.calcOutput();
  o[3] = out[0];
  EXPECT_LT(out[0], 0.1);

  //std::cout << o[0] << " " << o[1] << " " << o[2] << " " << o[3] << "\n";
}
Esempio n. 29
0
Sivia::Sivia(repere& R, struct sivia_struct *par) : R(R) {

    par->area = 0;

    // Create the function we want to apply SIVIA on.
    Variable x,y;
    double ei = par->ei;
    double xb=par->xb1,yb=par->yb1;
    Interval xbi=Interval(par->xb1-ei,par->xb1+ei),ybi=Interval(par->yb1-ei,par->yb1+ei);

    double arc = par->sonar_arc;

    double r = pow(par->sonar_radius,2);
    double th1 = par->th[0];
    double th2=th1+arc;
    double th21= par->th[1];
    double th22=th21 + arc;
    double th31= par->th[2];
    double th32=th31 + arc;
    double e=1;
    double epsilon = par->epsilon;

    double xin,yin;

    // First SONAR
    Function f(x,y,sqr(x-xbi)+sqr(y-ybi));

    NumConstraint c1(x,y,f(x,y)<=r+e);
    NumConstraint c2(x,y,f(x,y)>=e);
    NumConstraint c3(x,y,f(x,y)>r+e);
    NumConstraint c4(x,y,f(x,y)<e);


    double sign1,sign2;
    if(cos(th1)>0) sign1=1;
    else sign1=-1;
    if(cos(th2)<0) sign2=1;
    else sign2=-1;


    NumConstraint cth11(x,y,sign1*(y-ybi-((sin(th1))/(cos(th1)))*(x-xbi))<0);
    NumConstraint cth12(x,y,sign1*(y-ybi-((sin(th1))/(cos(th1)))*(x-xbi))>0);
    NumConstraint cth21(x,y,sign2*(y-ybi-((sin(th2))/(cos(th2)))*(x-xbi))<0);
    NumConstraint cth22(x,y,sign2*(y-ybi-((sin(th2))/(cos(th2)))*(x-xbi))>0);


//     Create contractors with respect to each
//     of the previous constraints.
    CtcFwdBwd out1(c1);
    CtcFwdBwd out2(c2);
    CtcFwdBwd in1(c3);
    CtcFwdBwd in2(c4);


    CtcFwdBwd outth1(cth12);
    CtcFwdBwd inth1(cth11);
    CtcFwdBwd inth2(cth21);
    CtcFwdBwd outth2(cth22);

//    CtcIn inside(f,Interval(-1,1));
//    CtcNotIn outside(f,Interval(-1,1));
    // Create a contractor that removes all the points
    // that do not satisfy either f(x,y)<=2 or f(x,y)>=0.
    // These points are "outside" of the solution set.
    CtcCompo outside1(out1,out2,outth1,outth2);

    // Create a contractor that removes all the points
    // that do not satisfy both f(x,y)>2 or f(x,y)<0.
    // These points are "inside" the solution set.
    CtcUnion inside11(in1,in2,inth1);
    CtcUnion inside1(inside11,inth2);


    // Second SONAR
    double xb2=par->xb2,yb2=par->yb2;
    Interval xb2i=Interval(par->xb2-ei,par->xb2+ei),yb2i=Interval(par->yb2-ei,par->yb2+ei);

    Function f2(x,y,sqr(x-xb2i)+sqr(y-yb2i));
    NumConstraint c21(x,y,f2(x,y)<=r+e);
    NumConstraint c22(x,y,f2(x,y)>=e);
    NumConstraint c23(x,y,f2(x,y)>r+e);
    NumConstraint c24(x,y,f2(x,y)<e);


    double sign21,sign22;
    if(cos(th21)>0) sign21=-1;
    else sign21=1;
    if(cos(th22)<0) sign22=1;
    else sign22=-1;


    NumConstraint cth211(x,y,sign21*(y-yb2i-((sin(th21))/(cos(th21)))*(x-xb2i))<0);
    NumConstraint cth212(x,y,sign21*(y-yb2i-((sin(th21))/(cos(th21)))*(x-xb2i))>0);
    NumConstraint cth221(x,y,sign22*(y-yb2i-((sin(th22))/(cos(th22)))*(x-xb2i))<0);
    NumConstraint cth222(x,y,sign22*(y-yb2i-((sin(th22))/(cos(th22)))*(x-xb2i))>0);

//     Create contractors with respect to each
//     of the previous constraints.
    CtcFwdBwd out21(c21);
    CtcFwdBwd out22(c22);
    CtcFwdBwd in21(c23);
    CtcFwdBwd in22(c24);


    CtcFwdBwd outth21(cth211);
    CtcFwdBwd inth21(cth212);
    CtcFwdBwd inth22(cth221);
    CtcFwdBwd outth22(cth222);

//    CtcIn inside(f,Interval(-1,1));
//    CtcNotIn outside(f,Interval(-1,1));
    // Create a contractor that removes all the points
    // that do not satisfy either f(x,y)<=2 or f(x,y)>=0.
    // These points are "outside" of the solution set.
    CtcCompo outside2(out21,out22,outth21,outth22);

    // Create a contractor that removes all the points
    // that do not satisfy both f(x,y)>2 or f(x,y)<0.
    // These points are "inside" the solution set.
    CtcUnion inside21(in21,in22,inth21);
    CtcUnion inside2(inside21,inth22);



    //Third SONAR

    double xb3=par->xb3,yb3=par->yb3;
    Interval xb3i=Interval(par->xb3-ei,par->xb3+ei),yb3i=Interval(par->yb3-ei,par->yb3+ei);

    Function f3(x,y,sqr(x-xb3i)+sqr(y-yb3i));
    NumConstraint c31(x,y,f3(x,y)<=r+e);
    NumConstraint c32(x,y,f3(x,y)>=e);
    NumConstraint c33(x,y,f3(x,y)>r+e);
    NumConstraint c34(x,y,f3(x,y)<e);


    double sign31,sign32;
    if(cos(th31)>0) sign31=-1;
    else sign31=1;
    if(cos(th32)<0) sign32=1;
    else sign32=-1;


    NumConstraint cth311(x,y,sign31*(y-yb3i-((sin(th31))/(cos(th31)))*(x-xb3i))<0);
    NumConstraint cth312(x,y,sign31*(y-yb3i-((sin(th31))/(cos(th31)))*(x-xb3i))>0);
    NumConstraint cth321(x,y,sign32*(y-yb3i-((sin(th32))/(cos(th32)))*(x-xb3i))<0);
    NumConstraint cth322(x,y,sign32*(y-yb3i-((sin(th32))/(cos(th32)))*(x-xb3i))>0);

//     Create contractors with respect to each
//     of the previous constraints.
    CtcFwdBwd out31(c31);
    CtcFwdBwd out32(c32);
    CtcFwdBwd in31(c33);
    CtcFwdBwd in32(c34);


    CtcFwdBwd outth31(cth311);
    CtcFwdBwd inth31(cth312);
    CtcFwdBwd inth32(cth321);
    CtcFwdBwd outth32(cth322);

//    CtcIn inside(f,Interval(-1,1));
//    CtcNotIn outside(f,Interval(-1,1));
    // Create a contractor that removes all the points
    // that do not satisfy either f(x,y)<=2 or f(x,y)>=0.
    // These points are "outside" of the solution set.
    CtcCompo outside3(out31,out32,outth31,outth32);

    // Create a contractor that removes all the points
    // that do not satisfy both f(x,y)>2 or f(x,y)<0.
    // These points are "inside" the solution set.
    CtcUnion inside31(in31,in32,inth31);
    CtcUnion inside3(inside31,inth32);

    //CtcQInter inter(inside,1);

    //Artifact MODELISATION

    double xa = par->xa;
    double ya = par->ya;

    double ra = par->ra;

    Function f_a(x,y,sqr(x-xa)+sqr(y-ya));

    NumConstraint ca1(x,y,f_a(x,y)<=sqr(ra));
    NumConstraint ca2(x,y,f_a(x,y)>=sqr(ra)-par->thick);
    NumConstraint ca3(x,y,f_a(x,y)>sqr(ra));
    NumConstraint ca4(x,y,f_a(x,y)<sqr(ra)-par->thick);

    CtcFwdBwd aout1(ca1);
    CtcFwdBwd aout2(ca2);
    CtcFwdBwd ain1(ca3);
    CtcFwdBwd ain2(ca4);

    CtcUnion ain(ain1,ain2);
    CtcCompo aout(aout1,aout2);


    //Robot MODELISATION

    double xr = par->xr; //robot position x
    double yr = par->yr; //robot position y

    double wr = par->wr; //robot width
    double lr = par->lr; //robot length
    double ep = par->thick;

    xr = par->xr - wr/2;
    NumConstraint inrx1(x,y,x>xr+ep);
    NumConstraint outrx1(x,y,x<xr+ep);
    NumConstraint inrx2(x,y,x<xr-ep);
    NumConstraint outrx2(x,y,x>xr-ep);
    NumConstraint inry1(x,y,y<yr-lr/2);
    NumConstraint outry1(x,y,y>yr-lr/2);
    NumConstraint inry2(x,y,y>yr+lr/2);
    NumConstraint outry2(x,y,y<yr+lr/2);

    CtcFwdBwd incrx1(inrx1);
    CtcFwdBwd incrx2(inrx2);
    CtcFwdBwd incry1(inry1);
    CtcFwdBwd incry2(inry2);

    CtcFwdBwd outcrx1(outrx1);
    CtcFwdBwd outcrx2(outrx2);
    CtcFwdBwd outcry1(outry1);
    CtcFwdBwd outcry2(outry2);

    CtcUnion inrtemp(incrx1,incrx2,incry1);
    CtcUnion inr1(inrtemp,incry2);
    CtcCompo outrtemp(outcrx1,outcrx2,outcry1);
    CtcCompo outr1(outrtemp,outcry2);

    //2nd rectangle
    xr = par->xr + wr/2;

    NumConstraint inrx21(x,y,x>xr+ep);
    NumConstraint outrx21(x,y,x<xr+ep);
    NumConstraint inrx22(x,y,x<xr-ep);
    NumConstraint outrx22(x,y,x>xr-ep);
    NumConstraint inry21(x,y,y<yr-lr/2);
    NumConstraint outry21(x,y,y>yr-lr/2);
    NumConstraint inry22(x,y,y>yr+lr/2);
    NumConstraint outry22(x,y,y<yr+lr/2);

    CtcFwdBwd incrx21(inrx21);
    CtcFwdBwd incrx22(inrx22);
    CtcFwdBwd incry21(inry21);
    CtcFwdBwd incry22(inry22);

    CtcFwdBwd outcrx21(outrx21);
    CtcFwdBwd outcrx22(outrx22);
    CtcFwdBwd outcry21(outry21);
    CtcFwdBwd outcry22(outry22);

    CtcUnion inrtemp2(incrx21,incrx22,incry21);
    CtcUnion inr2(inrtemp2,incry22);
    CtcCompo outrtemp2(outcrx21,outcrx22,outcry21);
    CtcCompo outr2(outrtemp2,outcry22);


    //3nd rectangle top rectangle
    yr=par->yr+par->lr/2;
    xr=par->xr;

    NumConstraint inrx31(x,y,x>xr+wr/2+ep);
    NumConstraint outrx31(x,y,x<xr+wr/2+ep);
    NumConstraint inrx32(x,y,x<xr-wr/2-ep);
    NumConstraint outrx32(x,y,x>xr-wr/2-ep);
    NumConstraint inry31(x,y,y<yr-ep);
    NumConstraint outry31(x,y,y>yr-ep);
    NumConstraint inry32(x,y,y>yr+ep);
    NumConstraint outry32(x,y,y<yr+ep);

    CtcFwdBwd incrx31(inrx31);
    CtcFwdBwd incrx32(inrx32);
    CtcFwdBwd incry31(inry31);
    CtcFwdBwd incry32(inry32);

    CtcFwdBwd outcrx31(outrx31);
    CtcFwdBwd outcrx32(outrx32);
    CtcFwdBwd outcry31(outry31);
    CtcFwdBwd outcry32(outry32);

    CtcUnion inrtemp3(incrx31,incrx32,incry31);
    CtcUnion inr3(inrtemp3,incry32);
    CtcCompo outrtemp3(outcrx31,outcrx32,outcry31);
    CtcCompo outr3(outrtemp3,outcry32);

    //4 rectangle bot

    yr=par->yr-par->lr/2;
    xr=par->xr;

    NumConstraint inrx41(x,y,x>xr+wr/2+ep);
    NumConstraint outrx41(x,y,x<xr+wr/2+ep);
    NumConstraint inrx42(x,y,x<xr-wr/2-ep);
    NumConstraint outrx42(x,y,x>xr-wr/2-ep);
    NumConstraint inry41(x,y,y<yr-ep);
    NumConstraint outry41(x,y,y>yr-ep);
    NumConstraint inry42(x,y,y>yr+ep);
    NumConstraint outry42(x,y,y<yr+ep);

    CtcFwdBwd incrx41(inrx41);
    CtcFwdBwd incrx42(inrx42);
    CtcFwdBwd incry41(inry41);
    CtcFwdBwd incry42(inry42);

    CtcFwdBwd outcrx41(outrx41);
    CtcFwdBwd outcrx42(outrx42);
    CtcFwdBwd outcry41(outry41);
    CtcFwdBwd outcry42(outry42);

    CtcUnion inrtemp4(incrx41,incrx42,incry41);
    CtcUnion inr4(inrtemp4,incry42);
    CtcCompo outrtemp4(outcrx41,outcrx42,outcry41);
    CtcCompo outr4(outrtemp4,outcry42);

    CtcCompo inrtp(inr1,inr2,inr3);
    CtcUnion outrtp(outr1,outr2,outr3);

    CtcCompo inr(inrtp,inr4);
    CtcUnion outr(outrtp,outr4);

    yr = par->yr;

    int maxq = 3; //nb of contractors
    int Qinter = 2;
    int ctcq = maxq - Qinter + 1; //nb for q-relaxed function of Ibex


    Array<Ctc> inside1r1(inside1,inr,ain);
    Array<Ctc> outside1r1(outside1,outr,aout);

    Array<Ctc> inside2r1(inside2,inr,ain);
    Array<Ctc> outside2r1(outside2,outr,aout);

    Array<Ctc> inside3r1(inside3,inr,ain);
    Array<Ctc> outside3r1(outside3,outr,aout);

    CtcQInter outside1r(outside1r1,Qinter);
    CtcQInter inside1r(inside1r1,ctcq);

    CtcQInter outside2r(outside2r1,Qinter);
    CtcQInter inside2r(inside2r1,ctcq);

    CtcQInter outside3r(outside3r1,Qinter);
    CtcQInter inside3r(inside3r1,ctcq);


    // Build the initial box.
    IntervalVector box(2);
    box[0]=Interval(-10,10);
    box[1]=Interval(-10,10);
    par->vin.clear();
    // Build the way boxes will be bisected.
    // "LargestFirst" means that the dimension bisected
    // is always the largest one.

    int nbox1=0;
    LargestFirst lf;
    IntervalVector viinside1(2);
    stack<IntervalVector> s;
    s.push(box);
    while (!s.empty()) {
        IntervalVector box=s.top();
        s.pop();
            contract_and_draw(inside1r,box,viinside1,1,par,nbox1,Qt::magenta,Qt::red);
            if (box.is_empty()) { continue; }

            contract_and_draw(outside1r,box,viinside1,0,par,nbox1,Qt::darkBlue,Qt::cyan);
            if (box.is_empty()) { continue; }

            if (box.max_diam()<epsilon) {
                R.DrawBox(box[0].lb(),box[0].ub(),box[1].lb(),box[1].ub(),QPen(Qt::yellow),QBrush(Qt::NoBrush));
            } else {
                pair<IntervalVector,IntervalVector> boxes=lf.bisect(box);
                s.push(boxes.first);
                s.push(boxes.second);
            }
    }

    if(par->isinside==1){
        robot_position_estimator(nbox1,par);
        par->isinside1=1;
        par->isinside=0;
        //cout<<"area1: "<<par->area<<endl;
    }

    IntervalVector box2(2);
    box2[0]=Interval(-10,10);
    box2[1]=Interval(-10,10);

    // Build the way boxes will be bisected.
    // "LargestFirst" means that the dimension bisected
    // is always the largest one.
    int nbox2=0;
    LargestFirst lf2;
    IntervalVector viinside2(2);
    stack<IntervalVector> s2;
    s2.push(box2);
    while (!s2.empty()) {
        IntervalVector box2=s2.top();
        s2.pop();
            contract_and_draw(inside2r,box2,viinside2,2,par,nbox2,Qt::magenta,Qt::red);
            if (box2.is_empty()) { continue; }

            contract_and_draw(outside2r,box2,viinside2,0,par,nbox2,Qt::darkBlue,Qt::cyan);
            if (box2.is_empty()) { continue; }

            if (box2.max_diam()<epsilon) {
                R.DrawBox(box2[0].lb(),box2[0].ub(),box2[1].lb(),box2[1].ub(),QPen(Qt::yellow),QBrush(Qt::NoBrush));
            } else {
                pair<IntervalVector,IntervalVector> boxes2=lf2.bisect(box2);
                s2.push(boxes2.first);
                s2.push(boxes2.second);
            }
    }
    if(par->isinside==1){
        robot_position_estimator(nbox2,par);
        par->isinside2=1;
        par->isinside=0;
        //cout<<"area2: "<<par->area<<endl;
    }
    IntervalVector box3(2);
    box3[0]=Interval(-10,10);
    box3[1]=Interval(-10,10);

    // Build the way boxes will be bisected.
    // "LargestFirst" means that the dimension bisected
    // is always the largest one.
    int nbox3=0;
    LargestFirst lf3;
    IntervalVector viinside3(2);
    stack<IntervalVector> s3;
    s3.push(box3);
    while (!s3.empty()) {
        IntervalVector box3=s3.top();
        s3.pop();
            contract_and_draw(inside3r,box3,viinside3,3,par,nbox3,Qt::magenta,Qt::red);
            if (box3.is_empty()) { continue; }

            contract_and_draw(outside3r,box3,viinside3,0,par,nbox3,Qt::darkBlue,Qt::cyan);
            if (box3.is_empty()) { continue; }

            if (box3.max_diam()<epsilon) {
                R.DrawBox(box3[0].lb(),box3[0].ub(),box3[1].lb(),box3[1].ub(),QPen(Qt::yellow),QBrush(Qt::NoBrush));
            } else {
                pair<IntervalVector,IntervalVector> boxes3=lf3.bisect(box3);
                s3.push(boxes3.first);
                s3.push(boxes3.second);
            }
    }
    if(par->isinside==1){
        robot_position_estimator(nbox3,par);
        par->isinside3=1;
        par->isinside=0;
        //cout<<"area3: "<<par->area<<endl;
    }
    par->state.clear();
    if (par->isinside1 ==1 || par->isinside2 ==1 || par->isinside3 ==1){
        double *aimth = new double[3];
        aimth[0] = get_angle(xb,yb,par->xin,par->yin)+M_PI ;
        aimth[1] = get_angle(xb2,yb2,par->xin,par->yin)+M_PI;
        aimth[2] = get_angle(xb3,yb3,par->xin,par->yin)+M_PI;

        R.DrawLine(xb,yb,xb+r*cos(aimth[0]),yb+r*sin(aimth[0]),QPen(Qt::red));
        R.DrawLine(xb2,yb2,xb2+r*cos(aimth[1]),yb2+r*sin(aimth[1]),QPen(Qt::red));
        R.DrawLine(xb3,yb3,xb3+r*cos(aimth[2]),yb3+r*sin(aimth[2]),QPen(Qt::red));

        par->state = std::string("found");
        double kp = par->kp;
        double u[3];

        for (int i=0;i<3;i++){
            u[i] =   -kp*atan(tan((par->th[i] - (aimth[i] - arc/2.0 ))/2));
            if(u[i]>par->sonar_speed) par->th[i] += par->sonar_speed;
            if(u[i]<-par->sonar_speed) par->th[i] += -par->sonar_speed;
            else par->th[i] += u[i];
        }
//        for (int i=0;i<3;i++){
//            u[i] =   atan(tan((par->th[i] - (aimth[i] - arc/2.0 ))/2));
//            par->th[i] -=u[i];
//        }
    }

    r = sqrt(r);
    //cout<<"th1"<<th1<<endl;
    R.DrawEllipse(xb,yb,par->ei,QPen(Qt::black),QBrush(Qt::NoBrush));
    R.DrawEllipse(xb2,yb2,par->ei,QPen(Qt::black),QBrush(Qt::NoBrush));
    R.DrawEllipse(xb3,yb3,par->ei,QPen(Qt::black),QBrush(Qt::NoBrush));

    R.DrawLine(xb,yb,xb+r*cos(th2),yb+r*sin(th2),QPen(Qt::green));
    R.DrawLine(xb2,yb2,xb2+r*cos(th22),yb2+r*sin(th22),QPen(Qt::green));
    R.DrawLine(xb3,yb3,xb3+r*cos(th32),yb3+r*sin(th32),QPen(Qt::green));

    R.DrawLine(xb,yb,xb+r*cos(th1),yb+r*sin(th1),QPen(Qt::green));
    R.DrawLine(xb2,yb2,xb2+r*cos(th21),yb2+r*sin(th21),QPen(Qt::green));
    R.DrawLine(xb3,yb3,xb3+r*cos(th31),yb3+r*sin(th31),QPen(Qt::green));

    R.DrawEllipse(par->xa,par->ya,par->ra,QPen(Qt::black),QBrush(Qt::NoBrush));

    R.DrawRobot(xr-wr/2,yr+lr/2,-3.14/2,wr,lr);
    R.Save("paving");

    par->vin.clear();
}
Esempio n. 30
0
int main()
{
  cout  << setiosflags(ios::uppercase);
  
  ofstream out1("Daten_Gauss.out");
  out1 << setiosflags(ios::uppercase);
  
  ofstream out("LIP.out");
  out << setiosflags(ios::uppercase);

  ofstream outs("Y2D.out");
  outs  << setiosflags(ios::uppercase);
  
  ofstream rout("REGLIP_Gauss.out");
  rout  << setiosflags(ios::uppercase);
  
  cout << "*** Imaginaerteilgleichung ***" << endl;
  cout << "*** Filter: Gauss ***" << endl;

  mp_init();
  cout << "*** Precision = " << mpipl << " ***" << endl;
  

  int M, N, MD;
  double xa, xb, x1, x2, xr1, xr2, h, step, step2, b1, dfactor, dpi;
  mp_real b, mpx1, mpx2, mpstep, mpx;

  dpi = 4.0 * atan(1.0);

  mp_real pi = mppic; // pi aus der Bibliothek !!!
  mp_real pi2 = pi * pi;
  static mp_real factor;


  cin >> b1;
  cin >> xa >> xb >> MD;
  cin >> x1 >> x2 >> M;  
  cin >> xr1 >> xr2 >> N ;
  
  cout << '\v';

  /* KERNELARRY ANFANG */

  mp_real* const mpregKern = new mp_real [M+1];
  b = mp_real(b1);
  mpx1 = mp_real(x1);
  mpx2 = mp_real(x2);

  mpstep = (mpx2 - mpx1)/mp_real(M);  
  
  /* Vorfaktor */
  factor = mp_real(2.0)*b/power(pi,mp_real(1.5));
  factor *= exp(mp_real(0.25) * pi2 * b * b);
  
  dfactor = 2.0 * (b1/pow(dpi,1.5)) * exp(b1*b1*dpi*dpi*.25);

  cout << "*** Begin: Init. Kernel *** " << endl;
    
  cout << "b1  = " << b1  << endl;
  cout << "b  = " <<  b ;
  cout << "x1  = " << x1 << endl;  /* Anfangs-/Endpunkt der Regularisierung */
  cout << "x2  = " << x2 << endl;
  cout << "M   = " << M  << endl; 
  cout << "h   = " << mpstep;
  cout << "factor = " << factor ;
  cout << "dfactor = " << dfactor << endl;

  for(int i = 0; i <= M; i++) 
    {
      mpx = mpx1 + i * mpstep;
      mpregKern[i] = mpregkerne2(mpx, b);
    }

  cout << "*** End: Init. Kernel *** " << endl;

  /* KERNELARRY ENDE */

  double x0, datlinpol, Error_splint, DataError, e2core;

  /* Index der Vektoren beginnt mit 1 und *nicht* mit 0 */
  
  double* y2d = dvector(1,MD);  /* 2.Ableitung der SPL-Funktion */
  double* data = dvector(1,MD); /* Datenvektor */
  double* x = dvector(1,MD);    /* x-Vektor */
  
  /* Datenarrays fuellen */

  h = (xb - xa)/(MD - 1);
  double rho = MD/(xb -xa);

  cout << '\v';
  cout << "*** Begin: Init. Data-Array ***" << endl;
  cout << "xa  = " << xa << endl;   /* Anfangs-/Endpunkte der Daten */
  cout << "xb  = " << xb << endl;
  cout << "MD  = " << MD  << endl;  /* Zahl der Datenpunkte */
  cout << "h   = " << h  << endl;
  cout << "rho = " << rho  << endl;
  x[1] = xa;
  data[1] = e2data(xa);

  for(int i = 2; i <= MD ; i++)
    {
      x[i] = xa + (i-1) * h;
      data[i] = e2data(x[i]);
    }

  x[MD] = xb;
  data[MD] = e2data(xb);
  
  cout << "*** End: Init. Data-Array ***" << endl;
  cout << '\v' ;

  /* Kontrollausgabe, Datenausgabe */
  for(int i = 1; i <= MD; i++)
    {
      DataError = fabs(data[i] - e2(x[i]))/fabs(e2(x[i]));
      DataError *= 100.0;
      out1 << i << '\t' << x[i] << '\t' << data[i] << '\t' << e2(x[i]) << '\t' << DataError << endl;
    }

  cout << "*** Begin: Interpol. *** " << endl;

  intlinear(x,data,MD,y2d);

  for(int i = 1; i <= MD; i++) outs << i << '\t'  << y2d[i] << endl;

  cout << "*** End:   Interpol. *** " << endl; 
  cout << '\v';

  
  
  for(int j = 0; j <= M; j++)
    {
      step = dble(mpstep);
      x0 = x1 + j * step;
      
      datlinpol = linint(x,data,y2d,MD,x0);
      e2core  = e2(x0);
      Error_splint = fabs(datlinpol - e2core)/fabs(e2core);
      Error_splint *= 100.0;
      
      out << x0 << '\t' <<  datlinpol << '\t' << e2core << '\t' << Error_splint << endl;
      
    }

  /* REGULARISIERUNG */
 
  double xi;

  mp_real mp_regsum, mpdata, mpError, mpreg;
  double regsum, Error, Reg;

  step2 = (xr2 - xr1)/N;

  cout <<"*** Begin: Regularisation ***" << endl;
  cout << "b1  = " << b1  << endl;
  cout << "b  = " <<  b ;
  cout << "x1 = " << xr1 << endl;
  cout << "x2 = " << xr2 << endl;
  cout << "N  = " << N  << endl;
  cout << "h  = " << step2 << endl;
  cout << '\v' ;

  for(int jj = 0; jj <= N; jj++)
  {
    mp_regsum = mp_real(0.0);
    x0 = xr1 + jj * step2;
    
    for(int j = 0; j <= M; j++)
      {
	xi = x1 + j * step;
	xi = x0 - xi;
	datlinpol = linint(x,data,y2d,MD,xi);
	mpdata = mp_real(datlinpol);
	mp_regsum += mpregKern[j] * mpdata;
	
      }
    mp_regsum *= mpstep;
    mp_regsum *= factor;

    mpreg = mpRegexakt(mp_real(x0),b);
    mpError = abs(mp_regsum - mpreg)/abs(mpreg);
    mpError *= mp_real(100.0);

    regsum = dble(mp_regsum);
    Error  = dble(mpError);
    Reg    = dble(mpreg);

    cout << x0 << endl;
    cout << mpreg << mp_regsum << mpError << endl;
    
    rout << x0 << '\t' << Reg << '\t' << regsum << '\t' << Error << '\t' << b1 << endl;
    
  }
  cout <<"*** End: Regularisation ***" << endl;
  
  free_dvector(y2d,1,MD);
  free_dvector(data,1,MD);
  free_dvector(x,1,MD);
  delete [] mpregKern;

  return 0;
}