public IStringBuilder Append(IStringBuilder builder)
{
if (builder == null)
return this;
_builder.Append(builder.ToString());
return this;
}
public override string getProof()
{
IStringBuilder sb = TextFactory.CreateStringBuilder();
ICollection <Literal> nLits = toProve.getNegativeLiterals();
for (int i = 0; i < toProve.getNumberNegativeLiterals(); ++i)
{
sb.Append(nLits.Get(i).getAtomicSentence());
if (i != (toProve.getNumberNegativeLiterals() - 1))
{
sb.Append(" AND ");
}
}
if (toProve.getNumberNegativeLiterals() > 0)
{
sb.Append(" => ");
}
sb.Append(toProve.getPositiveLiterals().Get(0));
return(sb.ToString());
}
/**
* Returns the string representation of this plan
*
* @return a string representation of this plan.
*/
public override string ToString()
{
IStringBuilder s = TextFactory.CreateStringBuilder();
s.Append("[");
int count = 0;
int size = this.Size();
foreach (object step in this)
{
s.Append(step);
if (count < size - 1)
{
s.Append(", ");
}
count++;
}
s.Append("]");
return(s.ToString());
}
public override string ToString()
{
if (null == toString)
{
IStringBuilder sb = TextFactory.CreateStringBuilder();
sb.Append("<");
for (int i = 0; i < values.Length; ++i)
{
if (i > 0)
{
sb.Append(", ");
}
sb.Append(values[i]);
}
sb.Append(">");
toString = sb.ToString();
}
return(toString);
}
public override string ToString()
{
IStringBuilder output = TextFactory.CreateStringBuilder();
foreach (string lh in lhs)
{
output.Append(lh);
}
output.Append(" -> ");
foreach (string rh in rhs)
{
output.Append(rh);
}
output.Append(" ").Append(PROB.ToString());
return(output.ToString());
}
public string getBoardPic()
{
IStringBuilder builder = TextFactory.CreateStringBuilder();
for (int row = 0; (row < getSize()); row++)
{ // row
for (int col = 0; (col < getSize()); col++)
{ // col
if (queenExistsAt(col, row))
{
builder.Append(" Q ");
}
else
{
builder.Append(" - ");
}
}
builder.Append("\n");
}
return(builder.ToString());
}
public override string ToString()
{
IStringBuilder builder = TextFactory.CreateStringBuilder();
for (int row = 0; row < getSize(); row++)
{ // rows
for (int col = 0; col < getSize(); col++)
{ // columns
if (queenExistsAt(col, row))
{
builder.Append('Q');
}
else
{
builder.Append('-');
}
}
builder.Append("\n");
}
return(builder.ToString());
}
public override string ToString()
{
IStringBuilder sb = TextFactory.CreateStringBuilder();
sb.Append('[');
bool first = true;
foreach (var item in this)
{
if (first)
{
first = false;
}
else
{
sb.Append(", ");
}
sb.Append(item.ToString());
}
sb.Append(']');
return(sb.ToString());
}
void IAssetManager.AddWebsiteAssets(IElement element)
{
var elementName = ElementName(element);
if (elementName == null)
{
return;
}
var hashSet = _elementsAddedToWebsite;
lock (hashSet) if (!hashSet.Add(elementName))
{
return;
}
GetStaticAssets(element, AssetType.Style, _websiteStylesBuilder);
GetStaticAssets(element, AssetType.Script, _websiteFunctionsBuilder);
_websiteStyles = _websiteStylesBuilder.ToString();
_websiteFunctions = _websiteFunctionsBuilder.ToString();
}
public override string ToString()
{
IStringBuilder sb = TextFactory.CreateStringBuilder();
sb.Append('[');
sb.Append(attributeName);
sb.Append("=[");
bool first = true;
foreach (string value in attributePossibleValues)
{
if (!first)
{
sb.Append(", ");
}
sb.Append(value);
first = false;
}
sb.Append("]]");
return(sb.ToString());
}
public override string ToString()
{
ICollection <Sentence> sentences = getSentences();
if (sentences.Size() == 0)
{
return("");
}
else
{
bool first = true;
IStringBuilder sb = TextFactory.CreateStringBuilder();
foreach (Sentence s in sentences)
{
if (!first)
{
sb.Append("\n");
}
sb.Append(s.ToString());
first = false;
}
return(sb.ToString());
}
}
public override string ToString()
{
if (cachedStringRep == null)
{
IStringBuilder sb = TextFactory.CreateStringBuilder();
bool first = true;
sb.Append("{");
foreach (Literal l in literals)
{
if (first)
{
first = false;
}
else
{
sb.Append(", ");
}
sb.Append(l);
}
sb.Append("}");
cachedStringRep = sb.ToString();
}
return(cachedStringRep);
}
/**
* Utility method for outputting InferenceResults in a formatted textual
* representation.
*
* @param ir
* an InferenceResult
* @return a string representation of the InferenceResult.
*/
public static string printInferenceResult(InferenceResult ir)
{
IStringBuilder sb = TextFactory.CreateStringBuilder();
sb.Append("InferenceResult.isTrue=" + ir.isTrue());
sb.Append("\n");
sb.Append("InferenceResult.isPossiblyFalse=" + ir.isPossiblyFalse());
sb.Append("\n");
sb.Append("InferenceResult.isUnknownDueToTimeout=" + ir.isUnknownDueToTimeout());
sb.Append("\n");
sb.Append("InferenceResult.isPartialResultDueToTimeout=" + ir.isPartialResultDueToTimeout());
sb.Append("\n");
sb.Append("InferenceResult.#Proofs=" + ir.getProofs().Size());
sb.Append("\n");
int proofNo = 0;
foreach (Proof p in ir.getProofs())
{
proofNo++;
sb.Append("InferenceResult.Proof#" + proofNo + "=\n" + ProofPrinter.printProof(p));
}
return(sb.ToString());
}
public override string ToString()
{
IStringBuilder output = TextFactory.CreateStringBuilder();
output.Append("Variables: ");
foreach (var var in vars)
{
output.Append(var).Append(", ");
}
output.Append('\n');
output.Append("Terminals: ");
foreach (var terminal in terminals)
{
output.Append(terminal).Append(", ");
}
output.Append('\n');
foreach (var rule in rules)
{
output.Append(rule.ToString()).Append('\n');
}
return(output.ToString());
}
public override string ToString()
{
return(_buffer.ToString());
}
public override string ToString(int depth, IStringBuilder buf)
{
buf.Append(Util.ntimes("\t", depth + 1));
buf.Append("DECISION -> " + value + "\n");
return(buf.ToString());
}
public ClauseEqualityIdentityConstructor(ICollection <Literal> literals, LiteralsSorter sorter)
{
clauseVarCounts = new int[literals.Size()];
foreach (Literal l in literals)
{
if (l.isNegativeLiteral())
{
identity.Append("~");
}
identity.Append(l.getAtomicSentence().getSymbolicName());
identity.Append("(");
bool firstTerm = true;
foreach (Term t in l.getAtomicSentence().getArgs())
{
if (firstTerm)
{
firstTerm = false;
}
else
{
identity.Append(",");
}
t.accept(this, null);
}
identity.Append(")");
currentLiteral++;
}
int min, max;
min = max = 0;
for (int i = 0; i < literals.Size(); ++i)
{
int incITo = i;
int next = i + 1;
max += clauseVarCounts[i];
while (next < literals.Size())
{
if (0 != sorter.Compare(literals.Get(i), literals.Get(next)))
{
break;
}
max += clauseVarCounts[next];
incITo = next; // Need to skip to the end of the range
next++;
}
// This indicates two or more literals are identical
// except for variable naming (note: identical
// same name would be removed as are working
// with sets so don't need to worry about this).
if ((next - i) > 1)
{
// Need to check each variable
// and if it has a position within the
// current min/max range then need
// to include its alternative
// sort order positions as well
foreach (string key in varPositions.GetKeys())
{
ICollection <int> positions = varPositions.Get(key);
ICollection <int> additPositions = CollectionFactory.CreateQueue <int>();
// Add then subtract for all possible
// positions in range
foreach (int pos in positions)
{
if (pos >= min && pos < max)
{
int pPos = pos;
int nPos = pos;
for (int candSlot = i; candSlot < (next - 1); candSlot++)
{
pPos += clauseVarCounts[i];
if (pPos >= min && pPos < max)
{
if (!positions.Contains(pPos) &&
!additPositions.Contains(pPos))
{
additPositions.Add(pPos);
}
}
nPos -= clauseVarCounts[i];
if (nPos >= min && nPos < max)
{
if (!positions.Contains(nPos) &&
!additPositions.Contains(nPos))
{
additPositions.Add(nPos);
}
}
}
}
}
positions.AddAll(additPositions);
}
}
min = max;
i = incITo;
}
// Determine the maxWidth
int maxWidth = 1;
while (noVarPositions >= 10)
{
noVarPositions = noVarPositions / 10;
maxWidth++;
}
// Sort the individual position lists
// And then add their string representations
// together
ICollection <string> varOffsets = CollectionFactory.CreateQueue <string>();
foreach (string key in varPositions.GetKeys())
{
ICollection <int> positions = varPositions.Get(key);
positions.Sort(new List <int> .Comparer());
IStringBuilder sb = TextFactory.CreateStringBuilder();
foreach (int pos in positions)
{
string posStr = pos.ToString();
int posStrLen = posStr.Length;
int padLen = maxWidth - posStrLen;
for (int i = 0; i < padLen; ++i)
{
sb.Append('0');
}
sb.Append(posStr);
}
varOffsets.Add(sb.ToString());
}
varOffsets.Sort(new List <string> .Comparer());
for (int i = 0; i < varOffsets.Size(); ++i)
{
identity.Append(varOffsets.Get(i));
if (i < (varOffsets.Size() - 1))
{
identity.Append(",");
}
}
}
public string getIdentity()
{
return(identity.ToString());
}
