public void TestRoundtrip()
{
Molecule molecule = new Molecule();
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddSingleBond(0, 1);
molecule.AddSingleBond(0, 3);
molecule.AddSingleBond(1, 2);
molecule.AddSingleBond(2, 3);
AtomSignature atomSignature = new AtomSignature(molecule, 0);
string signatureString = atomSignature.ToCanonicalString();
ColoredTree tree = AtomSignature.Parse(signatureString);
MoleculeBuilder builder = new MoleculeBuilder();
Molecule builtMolecule = builder.FromTree(tree);
Assert.AreEqual(molecule.ToString(), builtMolecule.ToString());
// test that this can be done more than once
builtMolecule = builder.FromTree(tree);
Assert.AreEqual(molecule.ToString(), builtMolecule.ToString());
}
public void TestColoredTreeCreation()
{
string signatureString = "[C]([C]([C,1])[C]([C,1]))";
ColoredTree tree = AtomSignature.Parse(signatureString);
Assert.AreEqual(signatureString, tree.ToString());
}
public IAtomContainer Reconstruct(string signature)
{
ColoredTree tree = AbstractVertexSignature.Parse(signature);
MoleculeFromSignatureBuilder builder = new MoleculeFromSignatureBuilder(CDK.Builder);
builder.MakeFromColoredTree(tree);
return(builder.GetAtomContainer());
}
/// <summary>
/// Builder for molecules (rather, for atom containers) from signature
/// strings.
/// </summary>
/// <param name="signatureString">the signature string to use</param>
/// <param name="coBuilder"><see cref="IChemObjectBuilder"/> to build the returned atom container from</param>
/// <returns>an atom container</returns>
public static IAtomContainer FromSignatureString(string signatureString, IChemObjectBuilder coBuilder)
{
ColoredTree tree = AtomSignature.Parse(signatureString);
MoleculeFromSignatureBuilder builder = new MoleculeFromSignatureBuilder(coBuilder);
builder.MakeFromColoredTree(tree);
return(builder.GetAtomContainer());
}
private void Run(Song media)
{
ColoredTree <string, string> decisionTree = (_rebuild || !File.Exists(Paths.DecisionTree)) ? UpdateTree() : DeserializeTree(Paths.DecisionTree);
LearningDoneEventArgs e = new LearningDoneEventArgs(this.Predict(decisionTree, media));
e.Media = media;
OnLearningDone(e);
}
public void TestOddCycleReadin()
{
string signatureString = "[C]([C]([C,2]([C,1]))[C]([C,1]))";
ColoredTree tree = AtomSignature.Parse(signatureString);
Assert.AreEqual(signatureString, tree.ToString());
Molecule molecule = new MoleculeBuilder().FromTree(tree);
Assert.AreEqual(5, molecule.GetAtomCount());
Assert.AreEqual(5, molecule.GetBondCount());
}
// XXX DOES NOT YET WORK - reconstructed graph may be isomorphic,
// but not automorphic
public void Reconstruct(SimpleGraph graph)
{
SimpleGraphSignature signature = new SimpleGraphSignature(graph);
foreach (var symmetryClass in signature.GetSymmetryClasses())
{
string signatureString = symmetryClass.GetSignatureString();
ColoredTree tree = AbstractVertexSignature.Parse(signatureString);
SimpleGraphBuilder builder = new SimpleGraphBuilder();
SimpleGraph reconstruction = builder.FromTree(tree);
Assert.AreEqual(reconstruction.ToString(), graph.ToString());
}
}
private ColoredTree <string, string> UpdateTree()
{
ID3Learning id3 = new ID3Learning();
id3.Initialize(learning.DataCell);
ColoredTree <string, string> decisionTree = id3.Run(learning.Dataset, learning.Target);
this.SerializeTree(decisionTree);
this.OnTreeUpdated();
return(decisionTree);
}
public void TestColoredTreeRoundtrip()
{
string signatureString = "[.]([.]([.,0])[.]([.,0]))";
ColoredTree tree = SimpleVertexSignature.Parse(signatureString);
Assert.AreEqual(signatureString, tree.ToString());
SimpleGraphBuilder builder = new SimpleGraphBuilder();
SimpleGraph graph = builder.FromTree(tree);
SimpleGraphSignature graphSignature = new SimpleGraphSignature(graph);
string canonicalString = graphSignature.ToCanonicalString();
Assert.AreEqual(signatureString, canonicalString);
}
public void TestCage()
{
string signatureString = "[C]([C]([C,2]([C]([C,3][C,4]))[C]([C,5]" +
"[C,3]([C,6]([C,1]))))[C]([C]([C,7][C]" +
"([C,1][C,8]))[C,5]([C,8]([C,6])))[C]([C,2]" +
"[C,7]([C,4]([C,1]))))";
ColoredTree tree = AtomSignature.Parse(signatureString);
Assert.AreEqual(signatureString, tree.ToString());
Molecule molecule = new MoleculeBuilder().FromTree(tree);
Assert.AreEqual(16, molecule.GetAtomCount());
Assert.AreEqual(24, molecule.GetBondCount());
}
public EdgeColoredGraph FromTree(ColoredTree tree)
{
base.MakeFromColoredTree(tree);
return(this.graph);
}
private Int32 Parse(ColoredTree <string, string> .Vertex vertex)
{
return(vertex.Data == "True" ? 1 : (vertex.Data == "False") ? 0 : -1);
}
public Int32 Predict <V>(ColoredTree <string, string> tree, V media)
where V : class, IMedia
{
if (media == null)
{
return(-1);
}
if (typeof(V) != typeof(Song))
{
return(-1);
}
ColoredTree <string, string> .Vertex vertex = tree.Root;
Song song = media as Song;
while (true)
{
Attribute attribute = Utility.GetEnumValueFromString <Attribute>(vertex.Data);
ColoredGraph <string, string> .Edge edge = null;
if (attribute == Attribute.Tempo)
{
edge = tree.FindEdges(vertex, EdgeEnds.Start).Where(e => int.Parse(e.Data) - tempoSample < song.EchoNest.Tempo && song.EchoNest.Tempo < int.Parse(e.Data) + tempoSample).FirstOrDefault();
}
else if (attribute == Attribute.Danceability)
{
edge = tree.FindEdges(vertex, EdgeEnds.Start).Where(e => e.Data == song.EchoNest.Danceability.ToString()).FirstOrDefault();
}
else if (attribute == Attribute.Energy)
{
edge = tree.FindEdges(vertex, EdgeEnds.Start).Where(e => double.Parse(e.Data) - energySample < song.EchoNest.Energy && song.EchoNest.Energy < double.Parse(e.Data) + energySample).FirstOrDefault();
}
else if (attribute == Attribute.Key)
{
edge = tree.FindEdges(vertex, EdgeEnds.Start).Where(e => e.Data == song.EchoNest.Key.ToString()).FirstOrDefault();
}
if (edge == null)
{
break;
}
vertex = edge.End;
if (vertex == null)
{
break;
}
int leaf = Parse(vertex);
if (leaf != -1)
{
return(leaf);
}
}
return(-1);
}
public Molecule FromTree(ColoredTree tree)
{
base.MakeFromColoredTree(tree);
return(this.Molecule);
}
private void SerializeTree(ColoredTree <string, string> decisionTree)
{
decisionTree.Serialize(Paths.DecisionTree);
}
private int Predict(ColoredTree <string, string> decisionTree, Song media)
{
Song song = SharedData.Database.Song.Where(m => m.Name == media.Name).FirstOrDefault();
return(learning.Predict <Song>(decisionTree, song));
}
