Relation Relation::project(vector<int>& index1) { Relation temp; Tuple tempTuplele; for(int i=0; i<index1.size(); i++) { temp.my_values.ADD(my_values.scheme_string(index1[i])); } for (set<Tuple>::iterator it = Tuple_Set.begin(); it != Tuple_Set.end(); ++it) { for(int i = 0; i < index1.size(); i++) { tempTuplele.push_back((*it)[index1[i]]); } temp.Tuple_Set.insert(tempTuplele); tempTuplele.clear(); } temp.my_name = my_name; return temp; }
void Relation::project(map<int, string>& variables) { set<Tuple> newTuples; Scheme newScheme; Tuple t; for (auto& v : variables){ newScheme.addAttribute(scheme.getAttributes().at(v.first)); } for (auto& tup : tuples){ for (auto& v : variables) { t.addAttValue(tup.at(v.first)); } if (variables.size() > 0){ newTuples.insert(t); t.clear(); } } tuples = newTuples; scheme = newScheme; setName("project"); }
template<class T> void Tuple<T>::join(Tuple<T>& t) { int old_sz = sz; reallocate(t.size()+size()); assert(alloc_sz >= sz); for(int i=0; i<t.sz; i++) data[i+old_sz] = t.data[i]; t.clear(); }
void Database::parseFacts() { Tuple tup; for (int i = 0; i < Facts.size(); i++){ if (relations.count(Facts[i].getData())){ setTupleAttributeValues(tup, i); relations[Facts[i].getData()].addTuple(tup); tup.clear(); } } }
void Join::execProject(const Tuple &left_tuple, const Tuple &right_tuple, Tuple &output_tuple) const { output_tuple.clear(); for (ColID i = 0; i < numOutputCols(); ++i) { if (selected_input_col_ids_[i] < left_child_->numOutputCols()) { output_tuple.push_back(left_tuple[selected_input_col_ids_[i]]); } else { output_tuple.push_back(right_tuple[selected_input_col_ids_[i] - left_child_->numOutputCols()]); } } }
void UniqueLinSolveAtom::retrieve(const Query& query, Answer& answer) throw (PluginError) { Tuple parms = query.getInputTuple(); std::string matrixPred = ""; std::string constantPred = ""; int argc = 2; char* argv[] = {"-linkname", "math -mathlink"}; //check number and type of arguments if (parms.size()!= 2) { throw PluginError("Wrong number of arguments"); } else { if(parms[0].isSymbol() && parms[1].isSymbol()) { matrixPred = parms[0].getString(); //std::cout << "Matrixpraedikat: " << matrixPred << std::endl; constantPred = parms[1].getString(); //std::cout << "Vektorpraedikat: " << vectorPred << std::endl; } else { throw PluginError("Wrong type of arguments"); } } //get complete Interpretation of given predicates in query AtomSet totalInt = query.getInterpretation(); AtomSet matrixInt; AtomSet constantInt; if (totalInt.empty()) { throw PluginError("Could not find any interpretion"); } else { // separate interpretation into facts of first predicate (matrix) totalInt.matchPredicate(matrixPred, matrixInt); // and into facts of second predicate (vector) totalInt.matchPredicate(constantPred, constantInt); } int mRows = 0; int mColumns = 0; int cRows = 0; int cColumns = 0; evaluateMatrix(matrixInt, mRows, mColumns); evaluateVector(constantInt, cRows, cColumns); if(mRows != cRows) throw PluginError("Coefficient matrix and target vector(s) or matrix do not have the same dimensions."); std::vector <std::vector <std::string> > matrix(mRows); for(int i = 0; i < mRows; i++) matrix[i].resize(mColumns); std::vector <std::vector <std::string> > constants(cRows); for (int i = 0; i < cRows; i++) constants[i].resize(cColumns); //write the values of the Atoms in the Interpretation into std::vectors for further processing convertMatrixToVector(matrixInt, mRows, mColumns, matrix); convertMatrixToVector(constantInt, cRows, cColumns, constants); //check if matrix and target vector or matrix are fully defined checkVector(matrix, mRows, mColumns, matrixPred); checkVector(constants, cRows, cColumns, constantPred); //convert matrix to MatrixRank-expression and calculate rank of coefficient matrix A std::string coeffMRankExpr = toMatrixRankExpr(matrix, mRows, mColumns); //std::cout << "MatrixRank expression: " << coeffMRankExpr << std::endl; int coeffMRank = calculateRank(argc, argv, coeffMRankExpr); //convert matrix A and target b to MatrixRank-expression and calculate rank //of extended coefficient matrix [A,b] std::string extendedMRankExpr = toMatrixRankExpr(matrix, mRows, mColumns, constants, cRows, cColumns); //std::cout << "Extended MatrixRank expression: " << extendedMRankExpr << std::endl; int extCoeffMRank = calculateRank(argc, argv, extendedMRankExpr); //compare calculated ranks and number of matrix colums, iff they are equal, //a unique solution for the matrix equation exists if ((coeffMRank == extCoeffMRank) && (coeffMRank == mColumns)) { std::string linSolExpr = toLinearSolveExpr(matrix, mRows, mColumns, constants, cRows, cColumns); std::vector <std::string> result; result = calculateSolution(argc, argv, linSolExpr); if(result.size() != mColumns*cColumns) throw PluginError("Wrong number of arguments in result vector"); Tuple out; int index = 0; //fill the result values with correct indices into Tuple out //and add all Tuples to Answer for (int r = 1; r <= mColumns; r++) { for(int c = 1; c<= cColumns; c++) { out.push_back(Term(r)); out.push_back(Term(c)); out.push_back(Term(result[index],true)); answer.addTuple(out); out.clear(); index++; } } } }