22Kernel::Logger logger(
"Acomp");
42void split(
const int A,
int &S,
int &V)
92 if (A.Units.size() != Units.size())
94 if (A.Comp.size() != Comp.size())
97 if (A.Intersect != Intersect && Units.size() + Comp.size() != 1)
102 if (!Units.empty()) {
103 std::vector<int>::const_iterator vc, xc;
104 xc = A.Units.begin();
105 for (vc = Units.begin(); vc != Units.end(); ++xc, ++vc)
115 return A.Comp == Comp;
134 const int TS = isSingle();
135 const int AS = A.isSingle();
139 if (!TS && Intersect != A.Intersect) {
141 return Intersect > 0;
145 std::vector<int>::const_iterator uc, ac;
146 ac = A.Units.begin();
148 for (; ac != A.Units.end() && uc != Units.end(); ++uc, ++ac)
152 if (ac != A.Units.end())
154 if (uc != Units.end())
158 std::vector<Acomp>::const_iterator ux, ax;
161 for (; ux != Comp.end() && ax != A.Comp.end(); ++ux, ++ax) {
165 return uc != Units.end();
206 std::vector<Acomp> Fparts;
207 std::vector<Acomp> Gparts;
211 std::vector<Acomp> Outparts;
212 std::vector<Acomp> NegParts;
216 std::for_each(Fparts.begin(), Fparts.end(), std::mem_fn(&
Acomp::Sort));
217 std::for_each(Gparts.begin(), Gparts.end(), std::mem_fn(&
Acomp::Sort));
220 std::sort(Gparts.begin(), Gparts.end());
221 std::sort(Fparts.begin(), Fparts.end());
224 std::vector<Acomp>::const_iterator fc, gc;
226 for (fc = Fparts.begin(); gc != Gparts.end() && fc != Fparts.end(); ++fc) {
227 while (gc != Gparts.end() && (*gc < *fc)) {
228 NegParts.emplace_back(*gc);
232 if (gc != Gparts.end() && *gc == *fc)
235 Outparts.emplace_back(*fc);
238 for (; gc != Gparts.end(); ++gc)
239 NegParts.emplace_back(*gc);
245 for (fc = Outparts.begin(); fc != Outparts.end(); ++fc)
250 std::vector<Acomp>::iterator negX;
251 for (negX = NegParts.begin(); negX != NegParts.end(); ++negX) {
268 return A.operator<(*this);
317 std::pair<int, int> Stype = AX.
size();
318 if (Stype.first + Stype.second == 0)
319 throw std::runtime_error(
"Pair Count wrong in AddComp");
323 std::vector<int>::const_iterator aup;
324 for (aup = AX.
Units.begin(); aup != AX.
Units.end(); ++aup) {
325 std::vector<int>::iterator ipt;
326 ipt = std::lower_bound(
Units.begin(),
Units.end(), *aup);
327 if (ipt ==
Units.end() || *ipt != *aup)
328 Units.insert(ipt, *aup);
330 std::vector<Acomp>::const_iterator acp;
331 for (acp = AX.
Comp.begin(); acp != AX.
Comp.end(); ++acp) {
332 std::vector<Acomp>::iterator cpt;
333 cpt = std::lower_bound(
Comp.begin(),
Comp.end(), *acp);
334 if (cpt ==
Comp.end() || (AX.
Units.end() != aup && *cpt != *aup))
335 Comp.insert(cpt, *acp);
340 std::vector<Acomp>::iterator cpt;
341 cpt = std::lower_bound(
Comp.begin(),
Comp.end(), AX);
342 if (cpt ==
Comp.end() || *cpt != AX)
343 Comp.insert(cpt, AX);
353 std::vector<int>::iterator ipt;
354 ipt = std::lower_bound(
Units.begin(),
Units.end(), Item);
355 if (ipt ==
Units.end() || *ipt != Item)
356 Units.insert(ipt, Item);
369 std::string Bexpress;
374 for (
unsigned int iu = 0; iu < Ln.length(); iu++) {
379 else if (Ln[iu] ==
'(')
389 logger.error() <<
"Error in string creation\n";
398 else if (isalpha(Ln[iu]) || Ln[iu] ==
'%') {
403 throw std::invalid_argument(
"Acomp::procIntersection error in line Ln\"" + Ln +
"\"");
407 numItem = (islower(Ln[iu])) ?
static_cast<int>(1 + Ln[iu] -
'a') :
static_cast<int>(27 + Ln[iu] -
'A');
410 if (iu < Ln.length() && Ln[iu] ==
'\'') {
443 if (blevel || bextra)
451 logger.error() <<
"Error in string \n";
456 }
else if (iu ==
'(') {
458 if (Express.length()) {
467 if (!Express.empty()) {
472 logger.error() <<
"Error in bracket ::\n";
492 if (!A.
Units.empty()) {
493 auto Ept =
Units.end();
500 std::vector<Acomp>::const_iterator vc;
501 for (vc = A.
Comp.begin(); vc != A.
Comp.end(); ++vc)
515 for (
int i = 0; i < static_cast<int>(BX.
Size()); i++) {
519 if (V >=
static_cast<int>(Index.size()))
520 throw std::runtime_error(
"Error with addUnit::Index");
521 Units.emplace_back(S * Index[i]);
548 std::vector<BnId>::const_iterator vc;
549 for (vc = A.begin(); vc != A.end(); ++vc) {
577 std::vector<BnId>::const_iterator vc;
578 for (vc = A.begin(); vc != A.end(); ++vc) {
602 std::sort(
Comp.begin(),
Comp.end());
614 std::map<int, int> LitSet;
634 std::map<int, int> litMap;
635 getAbsLiterals(litMap);
637 A.getAbsLiterals(litMap);
638 std::map<int, int> Base;
639 std::vector<int> keyNumbers;
641 std::map<int, int>::const_iterator mc;
642 for (mc = litMap.begin(); mc != litMap.end(); ++mc) {
644 keyNumbers.emplace_back(mc->first);
647 BnId State(Base.size(), 0);
650 if (isTrue(Base) != A.isTrue(Base))
661 return ((
Units.empty() &&
Comp.empty()) ? 1 : 0);
675 return (
Comp.empty()) ? 1 : 0;
677 std::vector<Acomp>::const_iterator cc;
678 for (cc =
Comp.begin(); cc !=
Comp.end(); ++cc)
679 if (cc->Intersect == 0 || !cc->isSimple())
696 return (
Comp.empty()) ? 1 : 0;
698 std::vector<Acomp>::const_iterator cc;
699 for (cc =
Comp.begin(); cc !=
Comp.end(); ++cc)
700 if (cc->Intersect == 1 || !cc->isSimple())
715 std::vector<int>::const_iterator uc;
716 std::map<int, int>::iterator mc;
718 for (uc = Units.begin(); uc != Units.end(); ++uc) {
720 mc = literalMap.find(V);
721 if (mc != literalMap.end())
724 literalMap.emplace(V, 1);
726 std::vector<Acomp>::const_iterator cc;
727 for (cc = Comp.begin(); cc != Comp.end(); ++cc)
728 cc->getAbsLiterals(literalMap);
740 std::vector<int>::const_iterator uc;
741 std::map<int, int>::iterator mc;
742 for (uc = Units.begin(); uc != Units.end(); ++uc) {
743 mc = literalMap.find(*uc);
744 if (mc != literalMap.end())
747 literalMap.emplace(*uc, 1);
749 std::vector<Acomp>::const_iterator cc;
750 for (cc = Comp.begin(); cc != Comp.end(); ++cc) {
751 cc->getLiterals(literalMap);
762 return (
Comp.empty() ? 1 : 0);
772 return (
Comp.size() +
Units.size() > 1 ? 0 : 1);
783 std::vector<Acomp>::iterator dx;
785 dx = std::unique(
Comp.begin(),
Comp.end());
786 cnt +=
static_cast<int>(std::distance(dx,
Comp.end()));
793 cnt +=
static_cast<int>(std::distance(ux,
Units.end()));
813 std::vector<BnId> Work;
814 std::vector<BnId> PIComp;
815 std::vector<BnId> Tmod;
817 std::vector<BnId>::iterator uend;
825 sort(Work.begin(), Work.end());
826 uend = unique(Work.begin(), Work.end());
827 Work.erase(uend, Work.end());
830 using std::placeholders::_1;
831 for_each(Work.begin(), Work.end(), std::bind(std::mem_fn(&
BnId::setPI), _1, 1));
836 std::vector<BnId>::iterator vc;
837 for (vc = Work.begin(); vc != Work.end(); ++vc) {
838 const int GrpIndex(vc->TrueCount() + 1);
839 for (
auto oc = vc + 1; oc != Work.end(); ++oc) {
840 const int OCnt = oc->TrueCount();
843 if (OCnt == GrpIndex) {
844 std::pair<int, BnId> cVal = vc->makeCombination(*oc);
847 Tmod.emplace_back(cVal.second);
856 for (vc = Work.begin(); vc != Work.end(); ++vc)
857 if (vc->PIstatus() == 1)
858 PIComp.emplace_back(*vc);
861 }
while (!Tmod.empty());
864 return makeEPI(DNFobj, PIComp);
882 std::vector<BnId> EPI;
886 std::vector<int> DNFactive(DNFobj.size());
887 std::vector<int> PIactive(PIform.size());
888 std::vector<int> DNFscore(DNFobj.size());
889 std::vector<int> PIscore(DNFobj.size());
892 for (
int pc = 0; pc !=
static_cast<int>(PIform.size()); pc++) {
895 for (
int ic = 0; ic !=
static_cast<int>(DNFobj.size()); ic++) {
897 for (
int pc = 0; pc !=
static_cast<int>(PIform.size()); pc++) {
898 if (PIform[pc].equivalent(DNFobj[ic])) {
903 if (DNFscore[ic] == 0) {
904 logger.error() <<
"PIForm:\n";
905 copy(PIform.begin(), PIform.end(), std::ostream_iterator<BnId>(logger.error(),
"\n"));
906 logger.error() <<
"Error with DNF / EPI determination at " << ic <<
'\n';
907 logger.error() <<
" Items " << DNFobj[ic] <<
'\n';
912 std::vector<int>::iterator dx, ddx;
913 std::vector<int>::iterator px;
918 for (dx = DNFactive.begin(); dx != DNFactive.end(); ++dx) {
919 if (*dx >= 0 && DNFscore[*dx] == 1)
921 for (px = PIactive.begin(); px != PIactive.end(); ++px) {
926 if (PIactive.end() == px)
929 EPI.emplace_back(PIform[*px]);
931 for (ddx = DNFactive.begin(); ddx != DNFactive.end(); ++ddx)
932 if (*ddx >= 0 && Grid[*px][*ddx])
935 PIactive.erase(px, px + 1);
939 using std::placeholders::_1;
940 DNFactive.erase(remove_if(DNFactive.begin(), DNFactive.end(), std::bind(std::less<int>(), _1, 0)), DNFactive.end());
950 for (px = PIactive.begin(); px != PIactive.end(); ++px) {
952 for (ddx = DNFactive.begin(); ddx != DNFactive.end(); ++ddx) {
960 const auto Dsize(
static_cast<int>(DNFactive.size()));
961 const auto Psize(
static_cast<int>(PIactive.size()));
964 for (
int Icount = 1; Icount < Psize; Icount++) {
971 for (di = 0; di < Dsize; di++)
973 for (vecI = 0; vecI < Icount; vecI++) {
974 if (Cmat[Index[vecI]][di])
982 for (
int iout = 0; iout < Icount; iout++) {
983 EPI.emplace_back(PIform[Index[iout]]);
988 }
while (!(++Index));
992 for (px = PIactive.begin(); px != PIactive.end(); ++px)
993 EPI.emplace_back(PIform[*px]);
1004 std::map<int, int> litMap;
1005 std::vector<int> keyNumbers;
1007 std::map<int, int>::const_iterator mc;
1008 for (mc = litMap.begin(); mc != litMap.end(); ++mc)
1009 keyNumbers.emplace_back(mc->first);
1027 std::map<int, int> litMap;
1028 std::map<int, int> Base;
1029 getAbsLiterals(litMap);
1035 std::map<int, int>::iterator mc;
1037 for (mc = litMap.begin(); mc != litMap.end(); ++mc) {
1038 Base[mc->first] = 1;
1039 keyNumbers.emplace_back(mc->first);
1043 BnId State(Base.size(), 0);
1047 DNFobj.emplace_back(State);
1061 std::vector<BnId> DNFobj;
1062 std::vector<int> keyNumbers;
1066 return static_cast<int>(DNFobj.size());
1078 std::vector<BnId> CNFobj;
1079 std::vector<int> keyNumbers;
1083 return static_cast<int>(CNFobj.size());
1100 Parts.reserve(Units.size() + Comp.size());
1101 for (
const auto &item : Units) {
1104 Parts.emplace_back(Aitem);
1106 std::copy(Comp.cbegin(), Comp.cend(), std::back_inserter(Parts));
1107 return static_cast<int>(Parts.size());
1110 std::vector<int> keyNumbers;
1111 std::vector<BnId> DNFobj;
1112 if (!getDNFobject(keyNumbers, DNFobj)) {
1113 if (makePI(DNFobj)) {
1114 for (
auto &
obj : DNFobj) {
1117 Parts.emplace_back(Aitem);
1120 return static_cast<int>(Parts.size());
1138 std::map<int, int> litMap;
1139 std::map<int, int> Base;
1140 getAbsLiterals(litMap);
1146 std::map<int, int>::iterator mc;
1149 for (mc = litMap.begin(); mc != litMap.end(); ++mc) {
1151 Base[mc->first] = 1;
1152 keyNumbers.emplace_back(mc->first);
1156 BnId State(Base.size(), 0);
1160 CNFobj.emplace_back(State);
1174 if (Units.empty() && Comp.empty())
1179 auto retJoin =
static_cast<int>(Units.size() + Comp.size());
1181 retJoin = 1 - Intersect;
1184 std::map<int, int>::const_iterator bv;
1185 std::vector<int>::const_iterator uc;
1187 for (uc = Units.begin(); uc != Units.end(); ++uc) {
1190 if (bv == Base.end())
1191 throw std::runtime_error(
"Base unit not found");
1192 int aimTruth = (S < 0) ? 1 - retJoin : retJoin;
1194 if (bv->second == aimTruth)
1198 std::vector<Acomp>::const_iterator cc;
1199 for (cc = Comp.begin(); cc != Comp.end(); ++cc)
1200 if (cc->isTrue(Base) == retJoin)
1216 return std::pair<Acomp, Acomp>(
Acomp(),
Acomp());
1218 std::map<int, int> Gmap;
1221 return std::pair<Acomp, Acomp>(
Acomp(),
Acomp());
1227 std::vector<Acomp> U;
1228 std::vector<Acomp> V;
1230 std::vector<Acomp>::const_iterator cc;
1232 std::vector<Acomp> Flist, Glist;
1234 return std::pair<Acomp, Acomp>(
Acomp(),
Acomp());
1236 for (cc = Flist.begin(); cc != Flist.end(); ++cc) {
1238 U.emplace_back(
Acomp(0));
1239 V.emplace_back(
Acomp(0));
1240 Acomp &Uitem = U.back();
1241 Acomp &Vitem = V.back();
1243 while ((cell = cc->itemN(itemCnt))) {
1244 if (Gmap.find(cell) != Gmap.end())
1261 for (cc = Glist.begin(); cc != Glist.end(); ++cc) {
1262 std::vector<Acomp>::const_iterator ux, vx;
1264 for (ux = U.begin(); ux != U.end() && vx != V.end(); ++vx, ++ux) {
1265 if (!vx->isNull() && ux->contains(*cc)) {
1274 Hpart.
Units.clear();
1283 return std::pair<Acomp, Acomp>(H, Rem);
1295 std::vector<int>::const_iterator vc, tc;
1297 for (vc = A.Units.begin(); vc != A.Units.end(); ++vc) {
1298 while (tc != Units.end() && *tc < *vc)
1300 if (tc == Units.end() || *tc != *vc)
1316 std::pair<int, int> Stype =
size();
1317 if (Stype.first + Stype.second == 0)
1318 throw std::runtime_error(
"Pair Count wrong");
1321 if (Stype.first == 0 && Stype.second == 1)
1326 if (!Lower->
Units.empty()) {
1330 if (!Lower->
Comp.empty()) {
1331 Comp.resize(Lower->
Comp.size() + 1);
1332 copy(Lower->
Comp.begin(), Lower->
Comp.end(),
Comp.begin() + 1);
1338 for (
unsigned int ix = 0; ix <
Comp.size(); ix++) {
1341 if (Stype.first + Stype.second == 0)
1342 throw std::runtime_error(
"Pair Count wrong");
1345 if (Stype.first + Stype.second == 1)
1347 if (Stype.first == 1)
1371 std::vector<Acomp>::iterator xc;
1372 for (xc =
Comp.begin(); xc !=
Comp.end(); ++xc)
1373 cnt += xc->joinDepth();
1393 std::string Ln =
Line;
1394 std::string::size_type sPos = Ln.find(
'#');
1397 while (sPos != std::string::npos && Ln[sPos + 1] ==
'(') {
1400 for (ePos =
static_cast<int>(sPos) + 2; bLevel > 0 && ePos < static_cast<int>(Ln.size()); ePos++) {
1401 if (Ln[ePos] ==
'(')
1403 else if (Ln[ePos] ==
')')
1407 throw std::invalid_argument(
"Acomp::setString error in line Ln\"" + Ln +
"\"");
1409 CM.
setString(Ln.substr(sPos + 2, ePos - sPos - 3));
1411 Ln.replace(sPos, ePos - sPos,
"(" + CM.
display() +
")");
1412 sPos = Ln.find(
'#');
1426 throw std::runtime_error(Ln);
1430 if (i ==
'+' && !blevel)
1434 throw std::runtime_error(Ln);
1449 return std::pair<int, int>(
static_cast<int>(
Units.size()),
static_cast<int>(
Comp.size()));
1459 if (Index >= 0 && Index <
static_cast<int>(Units.size()))
1460 return Units[Index];
1471 if (Index < 0 || Index >=
static_cast<int>(Comp.size()))
1473 return &Comp[Index];
1485 using std::placeholders::_1;
1486 transform(
Units.begin(),
Units.end(),
Units.begin(), std::bind(std::multiplies<int>(), _1, -1));
1500 for (
int i = 0; i < Indent; i++)
1502 OXF << ((Intersect == 1) ?
"Inter" :
"Union");
1503 OXF <<
" " << Units.size() <<
" " << Comp.size() <<
'\n';
1504 for (
int i = 0; i < Indent; i++)
1506 OXF << display() <<
'\n';
1507 std::vector<Acomp>::const_iterator vc;
1508 for (vc = Comp.begin(); vc != Comp.end(); ++vc) {
1509 vc->writeFull(OXF, Indent + 2);
1520 std::stringstream cx;
1521 std::vector<int>::const_iterator ic;
1523 for (ic =
Units.begin(); ic !=
Units.end(); ++ic) {
1526 split(*ic, sign, val);
1528 cx << static_cast<char>(
static_cast<int>(
'a') + (val - 1));
1530 cx << static_cast<char>(
static_cast<int>(
'A') + (val - 27));
1532 cx <<
"%" << val - 52;
1537 std::vector<Acomp>::const_iterator vc;
1538 for (vc =
Comp.begin(); vc !=
Comp.end(); ++vc) {
1541 cx <<
'(' << vc->display() <<
')';
1554 std::stringstream cx;
1555 std::vector<int>::const_iterator ic;
1557 for (ic = Units.begin(); ic != Units.end(); ++ic) {
1558 if (!Intersect && ic != Units.begin())
1560 split(*ic, sign, val);
1562 cx << static_cast<char>(
static_cast<int>(
'a') + (val - 1));
1564 cx << static_cast<char>(
static_cast<int>(
'A') + (val - 27));
1566 cx <<
"%" << val - 52;
1571 std::vector<Acomp>::const_iterator vc;
1572 for (vc = Comp.begin(); vc != Comp.end(); ++vc) {
1573 if (!Intersect && (vc != Comp.begin() || !Units.empty()))
1577 cx <<
"D" << dval <<
" " <<
'(' << vc->displayDepth(dval + 1) <<
')' <<
" " << dval <<
"E";
1579 cx <<
"D" << dval <<
" " << vc->displayDepth(dval + 1) <<
" " << dval <<
"E";
1593 const std::pair<size_t, size_t> RX = Grid.size();
1594 for (
size_t pc = 0; pc != PIform.size(); pc++) {
1595 logger.debug() << PIform[pc] <<
":";
1596 for (
size_t ic = 0; ic != RX.second; ic++)
1597 logger.debug() << ((Grid[pc][ic]) ?
" 1" :
" 0");
1598 logger.debug() <<
'\n';
const Kernel::DblMatrix & cm
double obj
the value of the quadratic function
Holds a state point in the decision tree.
std::string displayDepth(int const =0) const
Really pretty print statment of tree.
void writeFull(std::ostream &, int const =0) const
Full write out to determine state.
void assignDNF(const std::vector< int > &, const std::vector< BnId > &)
Assigns the Comp with the DNF.
int logicalEqual(const Acomp &) const
Test that the system that is logically the same:
void Sort()
Sort the Units+Comp items.
int removeEqComp()
Remove non-unique items.
std::vector< int > Units
Units in list.
int getDNFobject(std::vector< int > &, std::vector< BnId > &) const
Creates the DNF items (ie the binary list of true statements) It forms a sum of products.
int makeReadOnce()
Factorize into a read once function.
int isSingle() const
only one part
void processIntersection(const std::string &)
Helper function :: assumes that Ln has been checked for bracket consistency.
std::pair< int, int > size() const
get the size of the units and the Acomp sub-comp
int isDNF() const
is Units only in union
int isCNF() const
is Units only in intersections
void deleteComp()
delete all of the Comp list
void addComp(const Acomp &)
add a Component intelligently
int itemN(int const) const
returns an integer to Units (or zero)
void assignCNF(const std::vector< int > &, const std::vector< BnId > &)
Assigns the Comp with the DNF.
Acomp & operator+=(const Acomp &)
Operator + (union addition)
std::vector< int > getKeys() const
Get the key numbers in the system.
int copySimilar(const Acomp &)
Join two componenet of similar type.
int makeDNFobject()
Make the object into DNF form (Sum of Products)
const Acomp * itemC(int const) const
returns a pointer to Comp (or zero)
Acomp & operator*=(const Acomp &)
This carries out the intersection operation with A.
int makeEPI(std::vector< BnId > &, std::vector< BnId > &) const
Creates an essentual PI list (note: this is not unique).
void addUnitItem(int const)
add an Unit intellgently
int isSimple() const
true if only Units
int contains(const Acomp &) const
Checks the Units of A to see if they are in this->Units.
bool operator==(const Acomp &) const
Equals operator requires that the Units are equal and the Comp units are equal.
void getLiterals(std::map< int, int > &) const
Get literals (+/- different)
int joinDepth()
Search table to uplift objects.
int getCNFobject(std::vector< int > &, std::vector< BnId > &) const
Creates the CNF items (ie the binary list of false statements) It forms a sum of products.
Acomp(int const =0)
Standard Constructor.
void processUnion(const std::string &)
Helper function :: assumes that Ln has been checked for bracket consistency Units are sorted after th...
bool operator!=(const Acomp &) const
Complementary operator.
void getAbsLiterals(std::map< int, int > &) const
Get literals (positve)
bool operator<(const Acomp &) const
Comparitor operator:: Comparies the unit list (which is already sorted) part by part.
Acomp & operator-=(const Acomp &)
Operator - (removal) This operation can be carried out in many ways.
std::string display() const
Pretty print statment.
std::pair< Acomp, Acomp > algDiv(const Acomp &)
Carry out Algebric division.
int makePI(std::vector< BnId > &) const
Calculate Principal Components.
void complement()
Take complement of component.
int getDNFpart(std::vector< Acomp > &) const
get the DNF parts (as Acomp)
int isNull() const
is nothing in the comp.
int makeCNFobject()
Make the object into CNF form (Product of Sums)
int isTrue(const std::map< int, int > &) const
Determine if the rule is true.
void printImplicates(const std::vector< BnId > &, const Kernel::Matrix< int > &) const
Debug function to print out PI and Grid :
int Intersect
Union/Intersection (0,1)
void addUnit(const std::vector< int > &, const BnId &)
Adds a Binary state to the Component.
std::vector< Acomp > Comp
Components in list.
void setString(const std::string &)
Processes a line of type abc'+efg.
bool operator>(const Acomp &) const
Operator> takes first to last precidence.
void setPI(const int A)
PI accessor.
size_t Size() const
returns number of variables / size
void mapState(const std::vector< int > &, std::map< int, int > &) const
Sets the components within base with true/false.
Simple multilevel-cyclic counter.
void split(const int A, int &S, int &V)
Split a number into the sign and positive value.
MANTID_GEOMETRY_DLL bool operator==(const Group_const_sptr &lhs, const Group_const_sptr &rhs)
Equality operator for shared pointers.
MANTID_GEOMETRY_DLL std::ostream & operator<<(std::ostream &stream, const PointGroup &self)
Returns a streamed representation of the PointGroup object.
int convPartNum(const std::string &A, T &out)
Takes a character string and evaluates the first [typename T] object.
Helper class which provides the Collimation Length for SANS instruments.