static void Load()
{
stopwatch.Restart();
truthTable = repository.Resolve(ModelPath).RootElements[0] as TruthTable;
stopwatch.Stop();
Report(BenchmarkPhase.Load);
}
public void TestSimplifiedTruthTableDNF(string formula)
{
BinaryTree tree = new BinaryTree(formula);
TruthTable table = new TruthTable(tree);
var dnf = table.GetDNF(table.SimplifiedTable);
if (table.GetHashCode(table.OriginalTable) != 0 && Convert.ToString(table.GetHashCode(table.OriginalTable), 2).Contains('0'))
{
BinaryTree treeFromDnf = new BinaryTree(dnf.PrefixFormat);
TruthTable tableFromDnf = new TruthTable(treeFromDnf);
Assert.AreEqual(table.GetHashCode(table.OriginalTable), tableFromDnf.GetHashCode(tableFromDnf.OriginalTable));
string formulaWithoutBrackets = treeFromDnf.PrintParsedFormula().Replace("(", "");
formulaWithoutBrackets = formulaWithoutBrackets.Replace(")", "");
formulaWithoutBrackets = formulaWithoutBrackets.Replace(" ", "");
string infixWithoutBrackets = dnf.InfixFormat.Replace("(", "");
infixWithoutBrackets = infixWithoutBrackets.Replace(")", "");
infixWithoutBrackets = infixWithoutBrackets.Replace(" ", "");
Assert.AreEqual(formulaWithoutBrackets, infixWithoutBrackets);
}
else
{
Assert.AreEqual(dnf.PrefixFormat, "");
string infixWithoutBrackets = dnf.InfixFormat.Replace("(", "");
infixWithoutBrackets = infixWithoutBrackets.Replace(")", "");
infixWithoutBrackets = infixWithoutBrackets.Replace(" ", "");
Assert.AreEqual(infixWithoutBrackets, "");
}
}
public void TestMethod1()
{
BuildKB KB = new BuildKB("apple.txt");
TruthTable TT = new TruthTable(KB.Implies, KB.Vars, KB.TrueVars, "apple");
Assert.IsTrue(TT.BuildTT() == "Yes 1", "Returns yes with 1 level for apple");
}
private static Operand GetExpr(TruthTable imm, EmitterContext context, Operand x, Operand y, Operand z)
{
return(imm switch
{
TruthTable.False => Const(0),
TruthTable.True => Const(-1),
TruthTable.In => x,
TruthTable.And2 => context.BitwiseAnd(x, y),
TruthTable.Or2 => context.BitwiseOr(x, y),
TruthTable.Xor2 => context.BitwiseExclusiveOr(x, y),
TruthTable.And3 => context.BitwiseAnd(x, context.BitwiseAnd(y, z)),
TruthTable.Or3 => context.BitwiseOr(x, context.BitwiseOr(y, z)),
TruthTable.XorAnd => context.BitwiseAnd(x, context.BitwiseExclusiveOr(y, z)),
TruthTable.XorOr => context.BitwiseOr(x, context.BitwiseExclusiveOr(y, z)),
TruthTable.OrAnd => context.BitwiseAnd(x, context.BitwiseOr(y, z)),
TruthTable.AndOr => context.BitwiseOr(x, context.BitwiseAnd(y, z)),
TruthTable.Onehot => context.BitwiseExclusiveOr(context.BitwiseOr(x, y), context.BitwiseOr(z, context.BitwiseAnd(x, y))),
TruthTable.Majority => context.BitwiseAnd(context.BitwiseOr(x, y), context.BitwiseOr(z, context.BitwiseAnd(x, y))),
TruthTable.InverseGamble => context.BitwiseOr(context.BitwiseExclusiveOr(x, y), context.BitwiseExclusiveOr(x, z)),
TruthTable.Dot => context.BitwiseAnd(context.BitwiseExclusiveOr(x, z), context.BitwiseOr(context.BitwiseNot(y), z)),
TruthTable.Mux => context.BitwiseOr(context.BitwiseAnd(x, y), context.BitwiseAnd(context.BitwiseNot(x), z)),
TruthTable.AndXor => context.BitwiseExclusiveOr(x, context.BitwiseAnd(y, z)),
TruthTable.OrXor => context.BitwiseExclusiveOr(x, context.BitwiseOr(y, z)),
TruthTable.Xor3 => context.BitwiseExclusiveOr(x, context.BitwiseExclusiveOr(y, z)),
_ => null
});
public void BuildExpressionTree_Should_Create_ExpressionTree_From_PrefixExpression(List <int> minterms)
{
GC.Collect();
Stopwatch s2 = Stopwatch.StartNew();
var externalLibraryResult = QuineMcCluskeySolver.QMC_Solve(minterms, new int[] { });
s2.Stop();
TruthTable table = TruthTableHelpers.GenerateTruthTable(minterms);
Stopwatch s1 = Stopwatch.StartNew();
var customLibraryResult = logic.ExpressionService.Common.QMC.QuineMcCluskey.SimplifyTable(table.Value);
s1.Stop();
TestContext.Out.WriteLine(s1.ElapsedTicks);
TestContext.Out.WriteLine(s2.ElapsedTicks);
var helperSet = new HashSet <string>();
foreach (var pr in customLibraryResult)
{
helperSet.Add(pr.RowData);
}
foreach (var item in externalLibraryResult)
{
helperSet.Should().Contain(item.ToString());
}
}
private static List <List <LogicState> > getRowsWithTrueOutput(TruthTable input)
{
/* picks the rows with output equal to true
* e.g.:
* 000|0
* 001|1
* 010|1
* would return
* 001|1
* 010|1
*/
List <List <LogicState> > output = new List <List <LogicState> >();
for (int i = 0; i < input.OutputStates.Count; i++)
{
if (input.OutputStates[i] == LogicState.True)
{
output.Add(input.InputStates[i].Clone());
}
}
return(output);
}
private PL_Base Solve(string statement, out TruthTable truthTable)
{
PL_Base PL_Statement;
try
{
switch (currentType)
{
case SystemType.PL:
PL_Statement = new PL(statement);
break;
case SystemType.PL_DASH1:
PL_Statement = new PL_Dash1(statement);
break;
case SystemType.PL_DASH2:
PL_Statement = new PL_Dash2(statement);
break;
default:
PL_Statement = new PL_Dash3(statement);
break;
}
PL_Statement.GenerateTruthTable();
truthTable = PL_Statement.TruthTable;
return(PL_Statement);
}
catch (MalFormedException)
{
throw;
}
}
// ((A + B)*C)
// ((A + (B*C)) + D)
// ABC*+D+
public Function(string function)
{
this.function = function;
postfix = toPostfix();
variables = identifyVariables();
truthTable = new TruthTable(variables, postfix);
}
public void TestSimplifiedTruthTableCreation(string formula, string expectedHashCode)
{
int hashCodeInBinary = Convert.ToInt32(expectedHashCode, 2);
BinaryTree tree = new BinaryTree(formula);
TruthTable table = new TruthTable(tree);
Assert.AreEqual(table.GetHashCode(table.SimplifiedTable), hashCodeInBinary);
}
public void CreateTruthTableTest()
{
BooleanExpression expression1 = new BooleanExpression("a'b'cd + a'bc'd");
TruthTable table1 = new TruthTable(expression1);
Console.WriteLine(table1.ToString());
Console.WriteLine(table1.MintermString());
}
public void TruthTableTest()
{
AbstractionSyntaxTree ast = new AbstractionSyntaxTree(">(=(&(p,q),a),b)");
TruthTable tb = new TruthTable(ast);
Assert.AreEqual(false, tb.isCalulated);
Assert.AreEqual(ast, tb.AST);
}
public void setUpLabel_isLabelValid()
{
//Arrange and Act
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Assert
Assert.AreEqual(truthTableObject.setUpLabel(), "a b | evaluation\n");
}
public void setUpLabel_is_not_Null()
{
//Arrange and Act
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Assert
Assert.IsNotNull(truthTableObject.setUpLabel());
}
public static double[,] test(TruthTable[,] truthTables)
{
int numberOfCategories = (int) Math.Sqrt(truthTables.Length);
var result = new double[numberOfCategories, numberOfCategories];
for(int i=0; i<numberOfCategories; i++)
for (int j = 0; j < numberOfCategories; j++)
result[i,j] = calcTestStatistic(truthTables[i, j].FalsePosetive, truthTables[i, j].FalseNegative);
return result;
}
public void Full_Truth_Table_fail()
{
FileInput input = new FileInput("./Semicomplicated_false.txt");
Model temp = new Model();
PropositionInterpreter test = new PropositionInterpreter(ref temp);
World MyWorld = new World(test.ParseProps(input.ReadFromFile()), temp.Length);
TruthTable solver = new TruthTable(temp, MyWorld);
Assert.AreEqual(solver.solve(), 0);
}
static void Main(string[] args)
{
var testTable = TruthTable.Create<bool, bool, bool, bool>
(b => b /*Column description*/ , b => b /* Column 2 */ , b => b, b => b, defaultValue: false)
.Row(false, false, false, false, false)
.Row(false, true, false, true, true)
.Row(true, true, true, false, false)
.Row(true, false, true, true, true);
var result = testTable.GetValue(false, true, false, true);
}
public void TruthTable_CalculateTruthTable_HashCodeBeEqualAsExpected(string prefixInput, string hexaHashCode)
{
//Arrange
var binaryTree = ParsingModule.Parse(prefixInput);
//Act
var truthTable = new TruthTable(binaryTree);
//Assert
Assert.Equal(truthTable.GetHexadecimalHashCode(), hexaHashCode);
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
private void setup()
{
model = new Model();
propintr = new PropositionInterpreter(ref model);
input = new FileInput(filePath);
MyWorld = new World(propintr.ParseProps(input.ReadFromFile()), model.Length);
Truthsolver = new TruthTable(model, MyWorld);
forwardsolver = new ForwardChain(model, MyWorld);
backwardsolver = new BackwardsChain(model, MyWorld);
strWriter = new StringWriter();
Console.SetOut(strWriter);
}
public void printTable_IsItValid()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var tableString = truthTableObject.printTable();
//Assert
Assert.AreEqual(tableString, "0 0 1\n0 1 1\n1 0 0\n1 1 1\n");
}
public void getList0and1_is_not_null()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var simplifiedtableString = truthTableObject.getList0and1();
//Assert
Assert.IsNotNull(simplifiedtableString);
}
public void NoOfDifferentSymbol_does_it_return_right_type()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var valueReturn = truthTableObject.NoOfDifferentSymbol("a", "b");
//Assert
Assert.IsInstanceOfType(valueReturn, typeof(int));
}
public void returnLabel_is_not_null()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var valueReturn = truthTableObject.returnLabel();
//Assert
Assert.IsNotNull(valueReturn);
}
public void simplifiedTableString_is_not_null()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var testString = truthTableObject.simplifiedTableString(truthTableObject.returnValuesEachLine());
//Assert
Assert.IsNotNull(testString);
}
public void getList0and1_is_it_valid()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var simplifiedtableString = truthTableObject.getList0and1();
//Assert
Assert.AreEqual(simplifiedtableString, "0 ⋆ 1\n⋆ 1 1\n");
}
public void printTable_is_not_null()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var tableString = truthTableObject.printTable();
//Assert
Assert.IsNotNull(tableString);
}
public void returnLogicResult_does_it_return_right_type()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var valueReturn = truthTableObject.returnLogicResult();
//Assert
Assert.IsInstanceOfType(valueReturn, typeof(List <int>));
}
// 初期化
public QuineMcCluskey (TruthTable table)
{
Source = table;
var trues = table.Columns.Where (x => x.Result);
var trueCount = trues.Count ();
trueCols = trues.Select((x, i) => {
var col = new QMColumn(x, trueCount);
col.Flags[i] = true;
return col;
}).ToArray ();
combined = new IEnumerable<IEnumerable<QMColumn>>[table.Columns[0].Size + 1];
}
public void returnHexHashCode_is_not_null()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var tableString = truthTableObject.printTable();
var hashCode = truthTableObject.returnHexHashCode();
//Assert
Assert.IsNotNull(hashCode);
}
/// <summary>
/// Brings up the truth table window and hooks into truth table events
/// </summary>
public void DisplayTruthTable()
{
TruthTable truthTable = new TruthTable(sketchPanel.Circuit);
truthTableWindow = new TruthTableWindow(truthTable.TruthTableHeader, truthTable.TruthTableOutputs, sketchPanel.Circuit.NumInputs);
truthTableWindow.Closed += new EventHandler(truthTableWindow_Closed);
truthTableWindow.Show();
truthTableWindow.SimulateRow += new RowHighlightEventHandler(truthTableWindow_SimulateRow);
truthTableWindow.Highlight += new HighlightEventHandler(truthTableWindow_HighlightLabel);
truthTableWindow.UnHighlight += new UnhighlightEventHandler(truthTableWindow_UnHighlightLabel);
truthTableWindow.RelabelStrokes += new RelabelStrokesEventHandler(truthTableWindow_RelabelStrokes);
}
internal static LogicalNetworEntity Create(
IEnumerable<LogicalNetworkGene> dominantGeneSequence,
GateTypeEvolutionMethod evolutionMethod,
TruthTable truthTableToSolve,
LogicGateTypes gateTypeRestrictions)
{
Contract.Requires(dominantGeneSequence != null);
Contract.Requires(truthTableToSolve != null);
Contract.Requires(gateTypeRestrictions != null);
var dna = new DNA<LogicalNetworkGene>(dominantGeneSequence.ToList());
return Create(dna, dna.Genes[0], evolutionMethod, truthTableToSolve, gateTypeRestrictions);
}
public void returnHexHashCode_isItValid()
{
//Arrange
var processObject = new ProcessLogicClass(">(a,b)");
var truthTableObject = new TruthTable(processObject);
//Act
var tableString = truthTableObject.printTable();
var hashCode = truthTableObject.returnHexHashCode();
//Assert
Assert.AreEqual(hashCode, "B");
}
private void btnGenerateTruthTable_Click(object sender, EventArgs e)
{
BuildTree();
//Create the truth table from the formula
myTruthTable = new TruthTable(myProcessing.Variables);
myProcessing.AssignRowValues(myTruthTable.GetRows());
//Display both truth tables and hash code
tbTruthTable.Text = myTruthTable.ToString();
tbSimplifiedTruthTable.Text = myTruthTable.SimplifiedTableToString();
tbHashCode.Text = myTruthTable.GetHashCodeTB();
}
public void TestBinHash()
{
//Arrange
Parser p = new Parser();
string input = ">(A,|(&(D,A),C))";
Node n = p.ParseExpression(input);
TruthTable truthTable = new TruthTable(new char[] { 'A', 'C', 'D' }, n);
//Act
string result = truthTable.BinHashValue;
//Assert
Assert.AreEqual("11101111", result);
}
internal static LogicalNetworEntity Create(
DNA<LogicalNetworkGene> dna,
IEnumerable<LogicalNetworkGene> dominantGeneSequence,
GateTypeEvolutionMethod evolutionMethod,
TruthTable truthTableToSolve,
LogicGateTypes gateTypeRestrictions)
{
Contract.Requires(dna != null);
Contract.Requires(dominantGeneSequence != null);
Contract.Requires(truthTableToSolve != null);
Contract.Requires(gateTypeRestrictions != null);
LogicalNetworkFactory factory;
if (evolutionMethod == GateTypeEvolutionMethod.Restrict)
{
factory = new LogicalNetworkFactory(truthTableToSolve.InputInterfaceLength, truthTableToSolve.OutputInterfaceLength, gateTypeRestrictions);
}
else // Evolve
{
factory = new LogicalNetworkFactory(truthTableToSolve.InputInterfaceLength, truthTableToSolve.OutputInterfaceLength);
}
var network = LogicalNetworkDNADecoder.CreateNetwork(factory, dominantGeneSequence);
int numOfNAGates = 0;
if (evolutionMethod == GateTypeEvolutionMethod.Evolve && gateTypeRestrictions != null)
{
foreach (var entry in network.EntryArray)
{
var gate = entry.NodeEntry.Node as LogicGate;
if (gate != null)
{
var type = new LogicGateType(gate.Operation, entry.UpperConnectionEntryArray.Length);
if (!gateTypeRestrictions.Contains(type)) numOfNAGates++;
}
}
}
int errors = new TruthTableComputation(network).ComputeError(truthTableToSolve);
return new LogicalNetworEntity(dna, network, errors, numOfNAGates);
}
private static void Begin()
{
/*
0 0 0 0 0
0 1 0 0 1
1 0 0 0 1
1 1 0 1 0
0 0 1 0 1
0 1 1 1 0
1 0 1 1 0
1 1 1 1 1
*/
var table = new TruthTable(
3, 2,
new[]
{
new TruthTableEntry(new[] { false, false, false }, new[] { false, false }),
new TruthTableEntry(new[] { false, true, false }, new[] { false, true }),
new TruthTableEntry(new[] { true, false, false }, new[] { false, true }),
new TruthTableEntry(new[] { true, true, false }, new[] { true, false }),
new TruthTableEntry(new[] { false, false, true }, new[] { false, true }),
new TruthTableEntry(new[] { false, true, true }, new[] { true, false }),
new TruthTableEntry(new[] { true, false, true }, new[] { true, false }),
new TruthTableEntry(new[] { true, true, true }, new[] { true, true }),
});
var restrict = new LogicGateTypes(new[] { LogicGateType.NAND(2), LogicGateType.NOT() });
var factory = new LNGAEntityFactory(table, restrict);
factory.MaxIndex = 20;
factory.ValidDNALenghtRange = IntRange.CreateInclusive(200, 250);
factory.CrossoverChunkSize = IntRange.CreateExclusive(1, factory.ValidDNALenghtRange.MaxValue);
factory.StoreParentSequences = false;
factory.GateTypeEvolutionMethod = GateTypeEvolutionMethod.Restrict;
factory.MutationParameters.MutationChunkSize = IntRange.CreateExclusive(1, factory.ValidDNALenghtRange.MaxValue);
factory.MutationParameters.PointMutationChance = 0.01;
factory.MutationParameters.DeletionMutationChance = 0.01;
factory.MutationParameters.DuplicationMutationChance = 0.01;
factory.MutationParameters.InsertionMutationChance = 0.01;
factory.MutationParameters.TranslocationMutationChance = 0.01;
factory.MutationParameters.InversionMutationChance = 0.01;
var epoch = new LogicalGAEpoch(factory, 50, 25);
epoch.NumberOfParentsRange = IntRange.CreateFixed(4);
epoch.OffspringMovingChance = 0.1;
epoch.BestSelectStdDev = 0.7;
epoch.WorstSelectStdDev = 0.01;
//var factory = new LNStatisticalEntityFactory(
// table,
// 180,
// 40,
// 10,
// 0.00,
// 0.25,
// GateTypeEvolutionMethod.Evolve,
// restrict);
//var epoch = new LogicalSAEpoch(factory, 50, 25, 5);
bool done = false;
LogicalNetworEntity best = null;
while (!done)
{
epoch.Step();
var cbest = (LogicalNetworEntity)epoch.BestEntity;
if (cbest != null)
{
if (best == null || cbest.CompareTo(best) < 0)
{
best = cbest;
Dump(epoch, best);
}
else if (epoch.CurrentIteration % 100 == 0)
{
Dump(epoch, best);
}
}
//if (Console.KeyAvailable)
//{
// Console.ReadKey();
// done = true;
//}
}
}
public static void Main (string[] args)
{
string line;
noCaption = args.Contains("-n");
while((line = Console.ReadLine ()) != null) {
var parser = Parser.Parse (line);
if (parser.Expression != null) {
var table = new TruthTable (parser.Parameters.Values.ToArray (), parser.Expression);
// 真理値表
if (args.Contains("-T")) {
caption ("[Truth Table]");
echo (table.ToString());
}
// 主加法標準形
if (args.Contains("-D")) {
caption ("[Disjunctive]");
echo (table.ToDisjunctiveCanonicalExpression ().ToSimpleString ());
}
// 主乗法標準形
if (args.Contains("-C")) {
caption ("[Conjunctive]");
echo (table.ToConjunctiveCanonicalExpression ().ToSimpleString ());
}
// 省力化
if (!args.Any (s => s.StartsWith("-q") || s.StartsWith("-c"))) {
Console.WriteLine ();
continue;
}
// QM法
var qmc = new QuineMcCluskey (table);
foreach (IEnumerable<TruthTableColumn> result in qmc.Compressed) {
var newTable = new TruthTable (table.Parameters, result);
// QM法 真理値
if (args.Contains("-qT")) {
caption ("[QM'ed Truth Table]");
echo (newTable.ToString ());
}
// QM法 主加法標準形
if (args.Contains("-qD")) {
caption ("[QM'ed Disjunctive]");
echo (newTable.ToDisjunctiveCanonicalExpression ().ToSimpleString ());
}
var checkTable = new TruthTable (table.Parameters, newTable.ToDisjunctiveCanonicalExpression ());
// 確認用 真理値表
if (args.Contains("-cT")) {
caption ("[Check Truth Table]");
echo (checkTable.ToString ());
}
// 確認用 主乗法標準形
if (args.Contains("-cC")) {
caption ("[Check Conjunctive]");
echo (checkTable.ToConjunctiveCanonicalExpression ().ToSimpleString ());
}
// 確認用 主加法標準形
if (args.Contains("-cD")) {
caption ("[Check Disjunctive]");
echo (checkTable.ToDisjunctiveCanonicalExpression ().ToSimpleString ());
}
}
Console.WriteLine ();
} else {
Console.Error.WriteLine("Parse Error.");
}
}
}
public void ValidateFormula_FormulaWithJustOneArgument_ValidFormula()
{
TruthTable table = new TruthTable("");
Assert.AreEqual(true, table.ValidateFormula("d"));
}
public void Arguments_NotCalculated_TableNotCalculatedExceptionThrown()
{
TruthTable table = new TruthTable("a.b");
Int32 hellhound = table.Arguments.Count;
}
public void ArgumentsValues_NotCalculated_TableNotCalculatedExceptionThrown()
{
TruthTable table = new TruthTable("a.b");
Int32 on = table.ArgumentsValues.Length;
}
public void ExpressionsValues_NotCalculated_TableNotCalculatedExceptionThrown()
{
TruthTable table = new TruthTable("a.b");
Int32 trail = table.ExpressionsValues.Count;
}
