Beispiel #1
0
bool GRect::intersect(GRect rect1, GRect rect2) {
	Segment s11(rect1.coord1.x, rect1.coord2.x);
	Segment s12(rect1.coord1.y, rect1.coord2.y);
	Segment s21(rect2.coord1.x, rect2.coord2.x);
	Segment s22(rect2.coord1.y, rect2.coord2.y);
	return  ( (Segment::intersect(s11, s21)) && (Segment::intersect(s12, s22)) );
}
int testExpr3(int errors) {

  std::string expr3 = op_OR + "(" + op_AND + "(3,4,5)," + op_AND + "(1,2)," + op_AND + "(4,1,6,5))";
  BLAccessPolicy pol3(expr3, 6);

  ShareTuple s11(1,0,"1:1");
  ShareTuple s12(2,0,"1:2");
  ShareTuple s13(3,0,"1:3");
  ShareTuple s14(4,0,"1:4");
  ShareTuple s15(5,0,"1:5");
  ShareTuple s21(1,0,"2:1");
  ShareTuple s22(2,0,"2:2");
  ShareTuple s23(3,0,"2:3");
  ShareTuple s31(1,0,"3:1");
  ShareTuple s32(2,0,"3:2");
  ShareTuple s33(3,0,"3:3");
  ShareTuple s34(4,0,"3:4");
  ShareTuple s35(5,0,"3:5");
  ShareTuple s36(6,0,"3:6");
  

  vector<ShareTuple> ex3TestA3A4A5;
  vector<ShareTuple> ex3TestB1B2;
  vector<ShareTuple> ex3TestC1C2C3C4C5C6;
  vector<ShareTuple> ex3TestA4C6C5B1;
  vector<ShareTuple> ex3TestA1A2B3B1C4B2;

  vector<ShareTuple> ex3WitnessA3A4A5;
  vector<ShareTuple> ex3WitnessB1B2;
  vector<ShareTuple> ex3WitnessC1C2C3C4C5C6;
  vector<ShareTuple> ex3WitnessA4C6C5B1;
  vector<ShareTuple> ex3WitnessA1A2B3B1C4B2;


  ex3TestA3A4A5.push_back(s13);
  ex3TestA3A4A5.push_back(s14);
  ex3TestA3A4A5.push_back(s15);

  ex3TestB1B2.push_back(s21);
  ex3TestB1B2.push_back(s22);

  ex3TestC1C2C3C4C5C6.push_back(s31);
  ex3TestC1C2C3C4C5C6.push_back(s32);
  ex3TestC1C2C3C4C5C6.push_back(s33);
  ex3TestC1C2C3C4C5C6.push_back(s34);
  ex3TestC1C2C3C4C5C6.push_back(s35);
  ex3TestC1C2C3C4C5C6.push_back(s36);

  ex3TestA4C6C5B1.push_back(s14);
  ex3TestA4C6C5B1.push_back(s36);
  ex3TestA4C6C5B1.push_back(s35);
  ex3TestA4C6C5B1.push_back(s21);

  ex3TestA1A2B3B1C4B2.push_back(s11);
  ex3TestA1A2B3B1C4B2.push_back(s12);
  ex3TestA1A2B3B1C4B2.push_back(s23);
  ex3TestA1A2B3B1C4B2.push_back(s21);
  ex3TestA1A2B3B1C4B2.push_back(s34);
  ex3TestA1A2B3B1C4B2.push_back(s22);


  ex3WitnessA3A4A5.push_back(s13);
  ex3WitnessA3A4A5.push_back(s14);
  ex3WitnessA3A4A5.push_back(s15);

  ex3WitnessB1B2.push_back(s21);
  ex3WitnessB1B2.push_back(s22);

  ex3WitnessC1C2C3C4C5C6.push_back(s34);
  ex3WitnessC1C2C3C4C5C6.push_back(s31);
  ex3WitnessC1C2C3C4C5C6.push_back(s36);
  ex3WitnessC1C2C3C4C5C6.push_back(s35);

  ex3WitnessA1A2B3B1C4B2.push_back(s21);
  ex3WitnessA1A2B3B1C4B2.push_back(s22);

  vector<vector<ShareTuple> > ex3TestRun;
  vector<vector<ShareTuple> > ex3WitnessRun;

  ex3TestRun.push_back(ex3TestA3A4A5);
  ex3TestRun.push_back(ex3TestB1B2);
  ex3TestRun.push_back(ex3TestC1C2C3C4C5C6);
  ex3TestRun.push_back(ex3TestA4C6C5B1);
  ex3TestRun.push_back(ex3TestA1A2B3B1C4B2);

  ex3WitnessRun.push_back(ex3WitnessA3A4A5);
  ex3WitnessRun.push_back(ex3WitnessB1B2);
  ex3WitnessRun.push_back(ex3WitnessC1C2C3C4C5C6);
  ex3WitnessRun.push_back(ex3WitnessA4C6C5B1);
  ex3WitnessRun.push_back(ex3WitnessA1A2B3B1C4B2);

  errors = testVectors(errors, ex3TestRun, ex3WitnessRun, pol3, expr3);

  return errors;
}
int testExpr2(int errors) {

  std::string expr2 = op_OR + "(" + op_AND + "(1,2)," + op_AND + "(3,4))";
  BLAccessPolicy pol2(expr2, 4);

  ShareTuple s11(1,0,"1:1");
  ShareTuple s12(2,0,"1:2");
  ShareTuple s13(3,0,"1:3");
  ShareTuple s22(2,0,"2:2");
  ShareTuple s23(3,0,"2:3");
  ShareTuple s24(4,0,"2:4");
  

  vector<ShareTuple> ex2TestA1;
  vector<ShareTuple> ex2TestA2;
  vector<ShareTuple> ex2TestA1A2;
  vector<ShareTuple> ex2TestB3B4;
  vector<ShareTuple> ex2TestB2B3B4;
  vector<ShareTuple> ex2TestA1B4A2;
  vector<ShareTuple> ex2TestA1B2B3B4;
  vector<ShareTuple> ex2TestA1A3B4B2;

  vector<ShareTuple> ex2WitnessA1;
  vector<ShareTuple> ex2WitnessA2;
  vector<ShareTuple> ex2WitnessA1A2;
  vector<ShareTuple> ex2WitnessB3B4;
  vector<ShareTuple> ex2WitnessB2B3B4;
  vector<ShareTuple> ex2WitnessA1B4A2;
  vector<ShareTuple> ex2WitnessA1B2B3B4;
  vector<ShareTuple> ex2WitnessA1A3B4B2;

  ex2TestA1.push_back(s11);
  ex2TestA2.push_back(s12);
  ex2TestA1A2.push_back(s11);
  ex2TestA1A2.push_back(s12);
  ex2TestB3B4.push_back(s23);
  ex2TestB3B4.push_back(s24);
  ex2TestB2B3B4.push_back(s22);
  ex2TestB2B3B4.push_back(s23);
  ex2TestB2B3B4.push_back(s24);
  ex2TestA1B4A2.push_back(s11);
  ex2TestA1B4A2.push_back(s24);
  ex2TestA1B4A2.push_back(s12);
  ex2TestA1B2B3B4.push_back(s11);
  ex2TestA1B2B3B4.push_back(s22);
  ex2TestA1B2B3B4.push_back(s23);
  ex2TestA1B2B3B4.push_back(s24);
  ex2TestA1A3B4B2.push_back(s11);
  ex2TestA1A3B4B2.push_back(s13);
  ex2TestA1A3B4B2.push_back(s24);
  ex2TestA1A3B4B2.push_back(s22);

  ex2WitnessA1A2.push_back(s11);
  ex2WitnessA1A2.push_back(s12);
  ex2WitnessB3B4.push_back(s23);
  ex2WitnessB3B4.push_back(s24);
  ex2WitnessB2B3B4.push_back(s23);
  ex2WitnessB2B3B4.push_back(s24);
  ex2WitnessA1B4A2.push_back(s11);
  ex2WitnessA1B4A2.push_back(s12);
  ex2WitnessA1B2B3B4.push_back(s23);
  ex2WitnessA1B2B3B4.push_back(s24);


  vector<vector<ShareTuple> > ex2TestRun;
  vector<vector<ShareTuple> > ex2WitnessRun;

  ex2TestRun.push_back(ex2TestA1);
  ex2TestRun.push_back(ex2TestA2);
  ex2TestRun.push_back(ex2TestA1A2);
  ex2TestRun.push_back(ex2TestB3B4);
  ex2TestRun.push_back(ex2TestB2B3B4);
  ex2TestRun.push_back(ex2TestA1B4A2);
  ex2TestRun.push_back(ex2TestA1B2B3B4);
  ex2TestRun.push_back(ex2TestA1A3B4B2);

  ex2WitnessRun.push_back(ex2WitnessA1);
  ex2WitnessRun.push_back(ex2WitnessA2);
  ex2WitnessRun.push_back(ex2WitnessA1A2);
  ex2WitnessRun.push_back(ex2WitnessB3B4);
  ex2WitnessRun.push_back(ex2WitnessB2B3B4);
  ex2WitnessRun.push_back(ex2WitnessA1B4A2);
  ex2WitnessRun.push_back(ex2WitnessA1B2B3B4);
  ex2WitnessRun.push_back(ex2WitnessA1A3B4B2);

  errors = testVectors(errors, ex2TestRun, ex2WitnessRun, pol2, expr2);

  return errors;
}
int
SMatrix::createFormula(void) {
  bool *AVector;
  bool *BVector;
  int FormA, FormB, FormC, FormD;
  int count0, count1, count2, count3;
  int ChangeA, ChangeB;
  std::complex<double> A,B,C,D;
  int Row, Column;
  std::complex<double> Null_(0.0,0.0);
  std::complex<double> One_(1.0,0.0);

  if (FormulaExists_) return Formula.List.count();

  fillMatrix(500e6);

#ifdef DEBUG_
  std::cout << print();
#endif

  count0=count1=count2=count3=0;

  AVector = (bool*) calloc(MatrixDimension_, sizeof(bool));
  BVector = (bool*) calloc(MatrixDimension_, sizeof(bool));
  for (int i=0; i<MatrixDimension_; i++) {
   *(AVector+i)=false;
   *(BVector+i)=false;
  }

  qHeapSort( ChopUp.List);
#ifdef DEBUG_
  std::cout << ChopUp.print() << std::endl;
  std::cout << "MatrixDimension: " << MatrixDimension_ << std::endl;
#endif

  QValueList<ChopUpElement>::Iterator it;
  for ( it = ChopUp.List.begin(); it != ChopUp.List.end(); it++ ) {
    ChangeA = (*it).a()-1;
    ChangeB = (*it).b()-1;
    FormD = MatrixDimension_*ChangeB + ChangeA;
    D = *(SMatrix_+FormD);
    Row=0;
    while (Row < MatrixDimension_) {
     while ( ( (*(BVector+Row)) && (Row<MatrixDimension_) ) || (Row==ChangeB) ) Row++;
     if (Row<MatrixDimension_) {
      FormB=MatrixDimension_*Row+ChangeA;
      B = *(SMatrix_+FormB);
      if (B != Null_) {
       Column=0;
       while (Column < MatrixDimension_) {
        while ( ( (*(AVector+Column)) && (Column<MatrixDimension_) ) || (Column==ChangeA) ) Column++;
        if (Column<MatrixDimension_) {
         FormC = MatrixDimension_*ChangeB + Column;
         C = *(SMatrix_+FormC);
         if (C != Null_) {
          FormA = MatrixDimension_*Row + Column;
          A = *(SMatrix_ + FormA);
#ifdef DEBUG_
          std::cout << "*** Start of ChangeA: "<< ChangeA << " ChangeB: " << ChangeB << "\n";
          std::cout << "  A before: " << A << " <" << FormA << ">\n";
          std::cout << "  B: "<<B<<" <"<<FormB<<">\n";
          std::cout << "  C: "<<C<<" <"<<FormC<<">\n";
          std::cout << "  D: "<<D<<" <"<<FormD<<">\n";
          std::cout << "  Row: "<<Row<<" Column: "<<Column<<"\n";
#endif
          if ((A==Null_)&&(D==Null_)) {
           Formula.List.push_back(FormulaElement(0, FormA, FormB, FormC, FormD));
           A = B*C;
           count0++;
#ifdef DEBUG_
           std::cout << "  Formula 0: A=B*C\n";
#endif
          } else
          if ((A!=Null_)&&(D==Null_)) {
           Formula.List.push_back(FormulaElement(1, FormA, FormB, FormC, FormD));
           A += B*C;
           count1++;
#ifdef DEBUG_
           std::cout << "  Formula 1: A=A+B*C\n";
#endif
          } else
          if ((A==Null_)&&(D!=Null_)) {
           Formula.List.push_back(FormulaElement(2, FormA, FormB, FormC, FormD));
           A = B*C/(One_-D);
           count2++;
#ifdef DEBUG_
           std::cout << "  Formula 2: A=B*C/(1-D)\n";
#endif
          } else
          if ((A!=Null_)&&(D!=Null_)) {
           Formula.List.push_back(FormulaElement(3, FormA, FormB, FormC, FormD));
           A += B*C/(One_-D);
           count3++;
#ifdef DEBUG_
           std::cout << "  Formula 3: A=A+B*C/(1-D)\n";
#endif
          }
          *(SMatrix_+FormA)=A;
#ifdef DEBUG_
          std::cout << "  A after: " << A << "<" << FormA << ">\n";
#endif
         }
        }
        Column++;
       }
      }
     }
     Row++;
    }
    *(BVector+ChangeB)=true;
    *(AVector+ChangeA)=true;
  }

  FormulaExists_=true;

#ifdef DEBUG_
  std::cout << S11_ << " " << S12_ << " " << S21_ << " " << S22_ << std::endl;
  std::cout << count0 << " " << count1 << " " << count2 << " " << count3 << " (" <<
               count0+count1+count2+count3 << ")" << std::endl;
  std::cout << "S11: " << s11() << "\n";
  std::cout << "S12: " << s12() << "\n";
  std::cout << "S21: " << s21() << "\n";
  std::cout << "S22: " << s22() << "\n";
  std::cout << print();
#endif

  return Formula.List.count();
}