Пространство имён DataStructures

AttributeType.cs

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace CN2.Core.DataStructures

{

public enum Types

{

Boolean,

Integer,

Float,

String

}

 

/// <summary>

/// Представляет тип атрибута.

/// </summary>

[DebuggerDisplay("{ToString()}")]

public class AttributeType

{

protected string _name;

protected Types _types;

protected List<string> _values;

 

public string Name { get { return _name; } set { _name = value; } }

public Types Types { get { return _types; } set { _types = value; } }

public List<string> Values { get { return _values; } }

 

public AttributeType() { }

 

public AttributeType(string name, Types types)

{

_name = name;

_types = types;

_values = new List<string>();

}

 

public AttributeType(string name, Types types, IEnumerable<string> values)

{

_name = name;

_types = types;

_values = new List<string>();

foreach (var value in values)

{

bool retBool;

int retInt;

double retDouble;

 

if (_types == Types.Boolean && Boolean.TryParse(value, out retBool) ||

_types == Types.Integer && Int32.TryParse(value, out retInt) ||

_types == Types.Float && Double.TryParse(value, out retDouble) || _types == Types.String)

{

_values.Add(value);

}

else

{

throw new ArgumentException();

}

}

}

 

public AttributeType(AttributeType sample)

{

_name = sample.Name;

_types = sample.Types;

_values = sample.Values;

}

 

/// <summary>

/// Проверяет,

/// </summary>

/// <param name="value"></param>

/// <returns></returns>

private bool IsValid(string value)

{

switch (_types)

{

case Types.Boolean:

{

bool retBool;

return Boolean.TryParse(value, out retBool);

}

break;

 

case Types.Integer:

{

int retInt;

return Int32.TryParse(value, out retInt);

}

break;

 

case Types.Float:

{

double retFloat;

return Double.TryParse(value, out retFloat);

}

break;

 

case Types.String:

{

return!value.Equals(string.Empty);

}

break;

 

default:

{

return false;

}

break;

}

}

 

/// <summary>

/// Проверяет наличие значения среди множества значений типа атрибута.

/// </summary>

/// <param name="value">Проверяемое значние.</param>

/// <returns><c>true</c>, если среди значений типа атрибута есть проверяемое значение; иначе - <c>false</c>.</returns>

public bool HasValue(string value)

{

return IsValid(value) && _values.Contains(value);

}

 

/// <summary>

/// Добавляет

/// </summary>

/// <param name="value"></param>

public void Add(string value)

{

if (!HasValue(value))

{

_values.Add(value);

}

}

 

/// <summary>

/// Удаляет значение из множества значений типа атрибута.

/// </summary>

/// <param name="value">Удаляемое значение.</param>

public void Remove(string value)

{

_values.Remove(value);

}

 

/// <summary>

/// Производит сброс множества значений типа атрибута.

/// </summary>

public void Clear()

{

_values.Clear();

}

 

public bool IsValid()

{

if (_name.Equals(string.Empty) || _values.Count == 0)

{

return false;

}

foreach (var value in _values)

{

if (!IsValid(value))

{

return false;

}

}

return true;

}

 

/// <summary>

/// С УЧЁТОМ ПОРЯДКА!!!

/// </summary>

/// <param name="obj"></param>

/// <returns></returns>

public override bool Equals(object obj)

{

AttributeType otc = obj as AttributeType;

if (otc == null ||!_name.Equals(otc.Name) || _types!= otc.Types || _values.Count!= otc.Values.Count)

{

return false;

}

for (int i = 0; i < _values.Count; i++)

{

if (!_values[i].Equals(otc.Values[i]))

{

return false;

}

}

return true;

}

 

public override int GetHashCode()

{

throw new NotImplementedException ();

}

 

public override string ToString()

{

string values = string.Empty;

for (int i = 0; i < _values.Count; i++)

{

if (i == 0)

{

values += "(";

}

if (i == _values.Count - 1)

{

values += _values[i] + ")";

}

else

{

values += _values[i] + "; ";

}

}

return "Name = " + _name + " Type = " + _types + " Values = " + values;

}

}

}

AttributeValue.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace CN2.Core.DataStructures

{

/// <summary>

/// Представляет атрибут.

/// </summary>

public class AttributeValue: IExpressionMember

{

private AttributeType _type;

private string _value;

 

public AttributeType Type { get { return _type; } }

public string Value { get { return _value; } }

 

public AttributeValue(AttributeType type, string value)

{

if (type.HasValue(value))

{

_type = type;

_value = value;

}

else

{

throw new ArgumentException();

}

}

 

 

#region перегрузка object

 

public override bool Equals(object obj)

{

AttributeValue otc = obj as AttributeValue;

return otc!= null && (_type.Equals(otc.Type) && _value.Equals(otc.Value));

}

 

public override int GetHashCode()

{

throw new NotImplementedException ();

}

 

public override string ToString()

{

return "type=" + _type.Name + "; value=" + _value;

//return "Attribute type = [" + _type + "] Value = " + _value;

}

 

#endregion перегрузка object

 

#region реализация интерфейса IExpressionMember

 

public string GetValueString()

{

return "[" + _type.Name + " = " + _value + "]";

}

 

public bool IsCover(LearnableExample example)

{

foreach (var attribute in example.PredictiveAttributes)

{

if (_type.Equals(attribute.Type))

{

return _value.Equals(attribute.Value);

}

}

return false;

}

 

 

#endregion реализация интерфейса IExpressionMember

}

}

AttributeTypeSet.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Controls.Primitives;

 

namespace CN2.Core.DataStructures

{

/// <summary>

/// Представляет набор типов атрибутов.

/// </summary>

public class AttributeTypeSet

{

/// <summary>

/// Список типов предсказывающих атрибутов.

/// </summary>

private List<AttributeType> _predictiveAttributeTypeses;

/// <summary>

/// Тип решающего атрибута.

/// </summary>

private AttributeType _decisiveAttributeType;

 

/// <summary>

/// Возвращает список предсказывающих атрибутов.

/// </summary>

public List<AttributeType> PredictiveAttributeTypes { get { return _predictiveAttributeTypeses; } }

/// <summary>

/// Возвращает тип предсказывающего атрибута.

/// </summary>

public AttributeType DecisiveAttributeType { get { return _decisiveAttributeType; } }

 

public AttributeTypeSet(IEnumerable<AttributeType> predictiveAttributeTypes, AttributeType decisiveAttributeType)

{

_predictiveAttributeTypeses = new List<AttributeType>(predictiveAttributeTypes);

_decisiveAttributeType = decisiveAttributeType;

}

 

public List<AttributeType> GetAttributeTypes()

{

return new List<AttributeType>(_predictiveAttributeTypeses) {_decisiveAttributeType};

}

 

public bool IsValid()

{

if (!_decisiveAttributeType.IsValid())

{

return false;

}

foreach (var predictiveAttributeType in _predictiveAttributeTypeses)

{

if (!predictiveAttributeType.IsValid())

{

return false;

}

}

return true;

}

}

}

LearnableExample.cs

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Xml.Linq;

 

namespace CN2.Core.DataStructures

{

/// <summary>

/// Представляет пример.

/// </summary>

[DebuggerDisplay("{ToString()}")]

public class LearnableExample

{

/// <summary>

/// Список предсказывающих атрибутов примера.

/// </summary>

protected List<AttributeValue> _predictiveAttributes;

/// <summary>

/// Решающий атрибут примера.

/// </summary>

protected AttributeValue _decisiveAttribute;

 

/// <summary>

/// Возвращает список предсказывающих атрибутов примера.

/// </summary>

public List<AttributeValue> PredictiveAttributes { get { return _predictiveAttributes; } /*set { _predictiveAttributes = value; }*/ }

/// <summary>

/// Возвращает решающий атрибут примера.

/// </summary>

public AttributeValue DecisiveAttribute { get { return _decisiveAttribute; } /*set { _decisiveAttribute = value; }*/ }

 

/// <summary>

/// Возвращает список всех атрибутов примера.

/// </summary>

public List<AttributeValue> AllAttributes { get { return new List<AttributeValue>(_predictiveAttributes) {_decisiveAttribute}; } }

 

public LearnableExample(IEnumerable<AttributeValue> attributes, AttributeValue decisiveAttribute)

{

_predictiveAttributes = new List<AttributeValue>(attributes);

_decisiveAttribute = decisiveAttribute;

}

 

public LearnableExample(LearnableExample sample)

{

_predictiveAttributes = new List<AttributeValue>(sample.PredictiveAttributes);

_decisiveAttribute = sample.DecisiveAttribute;

}

 

public override bool Equals(object obj)

{

LearnableExample otc = obj as LearnableExample;

return otc!= null && (_predictiveAttributes.Equals(otc.PredictiveAttributes) && _decisiveAttribute.Equals(otc.DecisiveAttribute));

}

 

public override int GetHashCode()

{

throw new NotImplementedException ();

}

 

public override string ToString()

{

string attributes = string.Empty;

for (int i = 0; i < _predictiveAttributes.Count; i ++)

{

if (i == 0)

{

attributes += "(";

}

if (i == _predictiveAttributes.Count - 1)

{

attributes += _predictiveAttributes[i] + ")";

}

else

{

attributes += _predictiveAttributes[i] + "; ";

}

}

return "Attributes = " + attributes + " Result = " + _decisiveAttribute;

}

 

public string GetString()

{

string example = "(";

for (int i = 0; i < _predictiveAttributes.Count; i++)

{

example += "[" + _predictiveAttributes[i].Type.Name + " = " + _predictiveAttributes[i].Value + "]; ";

}

example += " решающий атрибут: [" + _decisiveAttribute.Type.Name + " = " + _decisiveAttribute.Value + "])";

return example;

}

}

}

ArguedLearnableExample.cs

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Xml.Linq;

 

namespace CN2.Core.DataStructures

{

/// <summary>

/// Представляет аргументированный обучающий пример.

/// </summary>

[DebuggerDisplay("{ToString()")]

public class ArguedLearnableExample: LearnableExample

{

/// <summary>

/// Выражение "потому что" объекта аргументации примера.

/// </summary>

private Expression _becauseExpression;

/// <summary>

/// Выражение "несмотря на" объекта аргументации примера.

/// </summary>

private Expression _despiteExpression;

 

/// <summary>

/// Возвращает выражение "потому что" объекта аргументации примера.

/// </summary>

public Expression BecauseExpression { get { return _becauseExpression; } }

/// <summary>

/// Возвращает выражение "несмотря на" объекта аргументации примера.

/// </summary>

public Expression DespiteExpression { get { return _despiteExpression; } }

/// <summary>

/// Возвращает признак того, что объект аргументации примера имеет часть "несмотря на".

/// </summary>

public bool HasDespitePart { get { return _despiteExpression!= null; } }

 

public ArguedLearnableExample(IEnumerable<AttributeValue> attributes, AttributeValue decisiveAttribute,

Expression becauseExpression, Expression despiteExpression): base(attributes, decisiveAttribute)

{

_becauseExpression = becauseExpression;

_despiteExpression = despiteExpression;

}

 

public ArguedLearnableExample(ArguedLearnableExample sample): base(sample)

{

_becauseExpression = sample.BecauseExpression;

_despiteExpression = sample.DespiteExpression;

}

 

public override bool Equals(object obj)

{

ArguedLearnableExample otc = obj as ArguedLearnableExample;

return otc!= null &&

(base.Equals(otc) && _becauseExpression.Equals(otc.BecauseExpression) &&

(HasDespitePart && otc.HasDespitePart && _despiteExpression.Equals(otc.DespiteExpression)));

}

 

public override string ToString()

{

return base.ToString() + "; потому что: " + _becauseExpression + (HasDespitePart? string.Empty: "; несмотря на: " + _despiteExpression);

}

}

}

ExaminableExample.cs

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace CN2.Core.DataStructures

{

/// <summary>

///

/// </summary>

[DebuggerDisplay("{ToString()}")]

public class ExaminableExample: LearnableExample

{

private AttributeValue _examinedAttribute;

 

public AttributeValue ExaminedAttribute

{

get { return _examinedAttribute; }

set { SetValue(value); }

}

 

public ExaminableExample(IEnumerable<AttributeValue> attributes, AttributeValue decisiveAttribute, AttributeValue value = null)

: base(attributes, decisiveAttribute)

{

SetValue(value);

}

 

public ExaminableExample(LearnableExample example, AttributeValue value = null): base(example)

{

SetValue(value);

}

 

public ExaminableExample(ExaminableExample sample): base(sample)

{

SetValue(sample.ExaminedAttribute);

}

 

private void SetValue(AttributeValue value)

{

if (value == null)

{

_examinedAttribute = null;

return;

}

 

if (_decisiveAttribute.Type.Equals(value.Type))

{

_examinedAttribute = value;

}

else

{

throw new ArgumentException("Тип не соответствует типу решающего атрибута.");

}

}

 

public override bool Equals(object obj)

{

ExaminableExample otc = obj as ExaminableExample;

return otc!= null && base.Equals(otc) && (_examinedAttribute.Equals(otc.ExaminedAttribute));

}

 

public override string ToString()

{

return base.ToString() + "; результат экзамена" + (_examinedAttribute == null? " не определён": (": " + _examinedAttribute.Value));

}

}

}

IExpressionMember.cs

namespace CN2.Core.DataStructures

{

public interface IExpressionMember

{

/// <summary>

/// Возвращает строковое представление члена выражения.

/// </summary>

/// <returns></returns>

string GetValueString();

 

/// <summary>

/// Проверяет, покрывает ли член выражения пример.

/// </summary>

/// <param name="value"></param>

/// <returns></returns>

bool IsCover(LearnableExample example);

}

}

Expression.cs

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Runtime.InteropServices;

 

namespace CN2.Core.DataStructures

{

/// <summary>

/// Определяет типы операций выражений.

/// </summary>

public enum Operation

{

/// <summary>

/// Коньюнкция. (conjunction)

/// </summary>

Con,

/// <summary>

/// Дизъюнкция. (disjunction)

/// </summary>

Dis,

/// <summary>

/// Отрицание.

/// </summary>

Neg

};

 

/// <summary>

/// Представляет логическое выражение.

/// </summary>

[DebuggerDisplay("{ToString()}")]

public class Expression: IExpressionMember

{

/// <summary>

/// Тип операции между элементами выражения.

/// </summary>

private Operation _operation;

/// <summary>

///

/// </summary>

private List<IExpressionMember> _members;

 

/// <summary>

/// Возвращает тип операции между элементами выражения.

/// </summary>

public Operation Operation { get { return _operation; } }

/// <summary>

///

/// </summary>

public List<IExpressionMember> Members { get { return _members; } }

 

public Expression(Operation operation)

{

_operation = operation;

_members = new List<IExpressionMember>();

}

 

public Expression(Operation operation, IExpressionMember member)

{

_operation = operation;

_members = new List<IExpressionMember>() {member};

}

 

public Expression(Operation operation, IEnumerable<IExpressionMember> members)

{

_operation = operation;

_members = new List<IExpressionMember>(members);

}

 

/// <summary>

/// Добавляет выражение в список выражений.

/// </summary>

/// <param name="member"></param>

public void AddMember(IExpressionMember member)

{

if (_operation == Operation.Neg)

{

throw new Exception("Unable to add an member.");

}

 

_members.Add(member);

}

 

#region перегрузка object

 

public override bool Equals(object obj)

{

Expression otc = obj as Expression;

if (otc == null || _operation!= otc.Operation || _members.Count!= otc.Members.Count)

{

return false;

}

for (int i = 0; i < _members.Count; i ++)

{

if (!otc.Members.Contains(_members[i]))

{

return false;

}

}

for (int i = 0; i < otc.Members.Count; i ++)

{

if (!_members.Contains(otc.Members[i]))

{

return false;

}

}

return true;

}

 

public override int GetHashCode()

{

throw new NotImplementedException ();

}

 

public override string ToString()

{

return GetValueString();

}

 

#endregion перегрузка object

 

#region реализация интерфейса IExpressionMember

 

public string GetValueString()

{

string op = string.Empty;

switch (_operation)

{

case Operation.Con:

{

op = " & ";

}

break;

 

case Operation.Dis:

{

op = " V ";

}

break;

 

case Operation.Neg:

{

if (_members.Count == 1)

{

return "! " + _members[0].GetValueString();

}

else

{

throw new Exception();

}

}

break;

 

default:

{

throw new NotImplementedException ();

}

break;

}

if (_members.Count == 0)

{

return "Operator: " + op + ". No members.";

}

string expr = string.Empty;

for (int i = 0; i < _members.Count; i++)

{

//bool isMemberExoression = (_members[i] as Expression) == null;

if (i == 0)

{

expr += "(";

}

if (i == _members.Count - 1)

{

expr += _members[i].GetValueString() + ")";

}

else

{

expr += _members[i].GetValueString() + op;

}

}

return expr;

}

 

public bool IsCover(LearnableExample example)

{

if (_members.Count == 0)

{

return true;

}

switch (_operation)

{

case Operation.Neg:

{

return!_members[0].IsCover(example);

}

break;

 

case Operation.Con:

{

foreach (var member in _members)

{

if (!member.IsCover(example))

{

return false;

}

}

return true;

}

break;

 

case Operation.Dis:

{

foreach (var member in _members)

{

if (member.IsCover(example))

{

return true;

}

return false;

}

}

break;

}

return false;

}

 

#endregion реализация интерфейса IExpressionMember

}

}

ProductionRule.cs

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace CN2.Core.DataStructures

{

/// <summary>

/// Представляет продукционное правило.

/// </summary>

[DebuggerDisplay("{ToString()}")]

public class ProductionRule

{

private IExpressionMember _condition;

private AttributeValue _result;

 

public IExpressionMember Condition { get { return _condition; } }

public AttributeValue Result { get { return _result; } }

public bool IsDefault { get; set; }

 

public ProductionRule(IExpressionMember condition, AttributeValue result)

{

_condition = condition;

_result = result;

IsDefault = false;

}

 

public override bool Equals(object obj)

{

ProductionRule otc = obj as ProductionRule;

return otc!= null && (_condition.Equals(otc.Condition) && _result.Equals(otc.Result));

}

 

public override string ToString()

{

return "Если " + _condition.GetValueString() + ", то " + _result.GetValueString();

}

 

public string GetStringValue()

{

return (IsDefault? "Правило по умолчанию: ": ("Если: " + _condition.GetValueString() + ", то: ")) + _result.GetValueString();

}

}

}

Пространство имён UC

IValidatable.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace CN2.Core.DataStructures

{

public interface IValidatable

{

bool IsValid { get; }

}

}

SerializationData.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace CN2.UC

{

/// <summary>

/// Представляет данные, необходимые для сериализации и десериализации объектов.

/// </summary>

public class SerializationData

{

public const string SaveAttributeTypesFileDialogTitle = "Сохранение типов атрибутов";

public const string LoadAttributeTypesFileDialogTitle = "Загрузка типов атрибутов";

public const string SaveExamplesFileDialogTitle = "Сохранение примеров";

public const string LoadExamplesFileDialogTitle = "Загрузка примеров";

public const string FileDialogFilter = "XML документ (*.xml)|*.xml";

public const string SaveLogFileDialogTitle = "Сохранение журнала";

public const string LogFileDialogFilter = "Текстовый файл (*.txt)|*.txt";

 

public const string IsUse = "isUse";

 

#region наименования узлов и атрибутов элеменотов файла типов атрибутов

 

public const string AttributeTypesNode = "attrinuteTypes";

public const string AttributeTypeNode = "attributeType";

 

public const string AttributeTypeName = "name";

public const string AttrinuteTypeType = "type";

public const string AttributeTypeValues = "values";

 

#endregion наименования узлов и атрибутов элеменотов файла типов атрибутов

 

#region наименования узлов и атрибутов элементов файла примеров

 

public const string ExamplesNode = "examples";

public const string ExampleNode = "example";

public const string ExampleAttributeNode = "attribute";

 

public const string ExampleAttributeTypeName = "typeName";

public const string ExampleAttrinuteValue = "value";

public const string ExampleAttributeIsDecisive = "isDecisive";

public const string ExampleAttributeIsBecause = "isBecause";

public const string ExampleAttributeIsDespite = "isDespite";

 

#endregion наименования узлов и атрибутов элементов файла примеров

}

}