#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization;
using SemWeb;

namespace CedmaExporter {
  public static class Ontology {
    public static string CedmaNameSpace {
      get { return "http://www.heuristiclab.com/cedma/"; }
    }

    #region model attribute types
    /// <summary>
    /// Meta attribute to indicate potential attributes of models.
    /// </summary>
    public static Entity TypeModelAttribute {
      get { return new Entity(CedmaNameSpace + "TypeModelAttribute"); }
    }
    /// <summary>
    /// Meta attribute to indicate potential attributes of input variables.
    /// </summary>
    public static Entity TypeInputVariableAttribute {
      get { return new Entity(CedmaNameSpace + "TypeInputVariableAttribute"); }
    }
    /// <summary>
    /// Meta attribute to indicate potential attributes of problems (data sets).
    /// </summary>
    public static Entity TypeProblemAttribute {
      get { return new Entity(CedmaNameSpace + "TypeProblemAttribute"); }
    }
    /// <summary>
    /// Attribute value is ordinal, values can be sorted.
    /// Examples are quality measures or complexity measures.
    /// </summary>
    public static Entity TypeOrdinalAttribute {
      get { return new Entity(CedmaNameSpace + "TypeOrdinalAttribute"); }
    }
    /// <summary>
    /// Attribute value is categorical and thus can't be sorted.
    /// Examples is target-variable.
    /// </summary>
    public static Entity TypeCategoricalAttribute {
      get { return new Entity(CedmaNameSpace + "TypeCategoricalAttribute"); }
    }
    /// <summary>
    /// Attribute is a quality measure
    /// </summary>
    public static Entity TypeQualityAttribute {
      get { return new Entity(CedmaNameSpace + "TypeQualityAttribute"); }
    }
    /// <summary>
    /// Attribute is a complexity measure
    /// </summary>
    public static Entity TypeComplexityAttribute {
      get { return new Entity(CedmaNameSpace + "TypeComplexityAttribute"); }
    }
    #endregion

    #region meta-data predicates
    public static Entity Name {
      get { return new Entity(CedmaNameSpace + "Name"); }
    }
    /// <summary>
    /// Each entity can have a serialized XML representation that can be loaded in HL.
    /// </summary>
    public static Entity SerializedData {
      get { return new Entity(CedmaNameSpace + "SerializedData"); }
    }
    /// <summary>
    /// Link from data set to model.
    /// A data set can have multiple models.
    /// </summary>
    public static Entity HasModel {
      get { return new Entity(CedmaNameSpace + "Model"); }
    }
    /// <summary>
    /// Link from model to algorithm.
    /// An algorithm can generate multiple models, each model is generated by exactly one algorithm.
    /// </summary>
    public static Entity GeneratedBy {
      get { return new Entity(CedmaNameSpace + "GeneratedBy"); }
    }
    /// <summary>
    /// Link from model to input variable impact
    /// Each model can have multiple input variables and each of the input variables can have a different impact on the model.
    /// </summary>
    public static Entity HasInputVariable {
      get { return new Entity(CedmaNameSpace + "InputVariable"); }
    }
    #endregion

    #region types and type relations
    public static Entity InstanceOf {
      get { return new Entity(CedmaNameSpace + "InstanceOf"); }
    }
    public static Entity TypeDataSet {
      get { return new Entity(CedmaNameSpace + "DataSet"); }
    }
    public static Entity TypeAlgorithm {
      get { return new Entity(CedmaNameSpace + "Algorithm"); }
    }
    public static Entity TypeModel {
      get { return new Entity(CedmaNameSpace + "Model"); }
    }
    public static Entity TypeVariableImpact {
      get { return new Entity(CedmaNameSpace + "VariableImpact"); }
    }
    #endregion

    #region attributes for models
    public static Entity TargetVariable {
      get { return new Entity(CedmaNameSpace + "TargetVariable"); }
    }
    public static Entity TrainingMeanSquaredError {
      get { return new Entity(CedmaNameSpace + "TrainingMeanSquaredError"); }
    }
    public static Entity ValidationMeanSquaredError {
      get { return new Entity(CedmaNameSpace + "ValidationMeanSquaredError"); }
    }
    public static Entity TestMeanSquaredError {
      get { return new Entity(CedmaNameSpace + "TestMeanSquaredError"); }
    }
    public static Entity TrainingMeanAbsolutePercentageError {
      get { return new Entity(CedmaNameSpace + "TrainingMeanAbsolutePercentageError"); }
    }
    public static Entity ValidationMeanAbsolutePercentageError {
      get { return new Entity(CedmaNameSpace + "ValidationMeanAbsolutePercentageError"); }
    }
    public static Entity TestMeanAbsolutePercentageError {
      get { return new Entity(CedmaNameSpace + "TestMeanAbsolutePercentageError"); }
    }
    public static Entity TrainingMeanAbsolutePercentageOfRangeError {
      get { return new Entity(CedmaNameSpace + "TrainingMeanAbsolutePercentageOfRangeError"); }
    }
    public static Entity ValidationMeanAbsolutePercentageOfRangeError {
      get { return new Entity(CedmaNameSpace + "ValidationMeanAbsolutePercentageOfRangeError"); }
    }
    public static Entity TestMeanAbsolutePercentageOfRangeError {
      get { return new Entity(CedmaNameSpace + "TestMeanAbsolutePercentageOfRangeError"); }
    }
    public static Entity TrainingCoefficientOfDetermination {
      get { return new Entity(CedmaNameSpace + "TrainingCoefficientOfDetermination"); }
    }
    public static Entity ValidationCoefficientOfDetermination {
      get { return new Entity(CedmaNameSpace + "ValidationCoefficientOfDetermination"); }
    }
    public static Entity TestCoefficientOfDetermination {
      get { return new Entity(CedmaNameSpace + "TestCoefficientOfDetermination"); }
    }
    public static Entity TrainingVarianceAccountedFor {
      get { return new Entity(CedmaNameSpace + "TrainingVarianceAccountedFor"); }
    }
    public static Entity ValidationVarianceAccountedFor {
      get { return new Entity(CedmaNameSpace + "ValidationVarianceAccountedFor"); }
    }
    public static Entity TestVarianceAccountedFor {
      get { return new Entity(CedmaNameSpace + "TestVarianceAccountedFor"); }
    }
    public static Entity TrainingAccuracy {
      get { return new Entity(CedmaNameSpace + "TrainingAccuracy"); }
    }
    public static Entity ValidationAccuracy {
      get { return new Entity(CedmaNameSpace + "ValidationAccuracy"); }
    }
    public static Entity TestAccuracy {
      get { return new Entity(CedmaNameSpace + "TestAccuracy"); }
    }
    public static Entity TrainingTheilsInequalityCoefficient {
      get { return new Entity(CedmaNameSpace + "TrainingTheilsInequalityCoefficient"); }
    }
    public static Entity ValidationTheilsInequalityCoefficient {
      get { return new Entity(CedmaNameSpace + "ValidationTheilsInequalityCoefficient"); }
    }
    public static Entity TestTheilsInequalityCoefficient {
      get { return new Entity(CedmaNameSpace + "TestTheilsInequalityCoefficient"); }
    }
    public static Entity TreeSize {
      get { return new Entity(CedmaNameSpace + "TreeSize"); }
    }
    public static Entity TreeHeight {
      get { return new Entity(CedmaNameSpace + "TreeHeight"); }
    }
    public static Entity EvaluatedSolutions {
      get { return new Entity(CedmaNameSpace + "EvaluatedSolutions"); }
    }
    #endregion
    #region attributes for input variables
    public static Entity EvaluationImpact {
      get { return new Entity(CedmaNameSpace + "EvaluationImpact"); }
    }
    public static Entity QualityImpact {
      get { return new Entity(CedmaNameSpace + "QualityImpact"); }
    }
    #endregion

    public static ICollection<Statement> InitialStatements {
      get {
        return new List<Statement> {
          new Statement(TargetVariable, InstanceOf, TypeCategoricalAttribute),
          new Statement(TargetVariable, InstanceOf, TypeModelAttribute),
          
          new Statement(TrainingMeanSquaredError, InstanceOf, TypeOrdinalAttribute),
          new Statement(TrainingMeanSquaredError, InstanceOf, TypeQualityAttribute),
          new Statement(TrainingMeanSquaredError, InstanceOf, TypeModelAttribute),
          
          new Statement(ValidationMeanSquaredError, InstanceOf, TypeOrdinalAttribute),
          new Statement(ValidationMeanSquaredError, InstanceOf, TypeQualityAttribute),
          new Statement(ValidationMeanSquaredError, InstanceOf, TypeModelAttribute),

          new Statement(TestMeanSquaredError, InstanceOf, TypeOrdinalAttribute),
          new Statement(TestMeanSquaredError, InstanceOf, TypeQualityAttribute),
          new Statement(TestMeanSquaredError, InstanceOf, TypeModelAttribute),
          
          new Statement(TrainingMeanAbsolutePercentageError, InstanceOf, TypeOrdinalAttribute),
          new Statement(TrainingMeanAbsolutePercentageError, InstanceOf, TypeQualityAttribute),
          new Statement(TrainingMeanAbsolutePercentageError, InstanceOf, TypeModelAttribute),
          
          new Statement(ValidationMeanAbsolutePercentageError, InstanceOf, TypeOrdinalAttribute),
          new Statement(ValidationMeanAbsolutePercentageError, InstanceOf, TypeQualityAttribute),
          new Statement(ValidationMeanAbsolutePercentageError, InstanceOf, TypeModelAttribute),
          
          new Statement(TestMeanAbsolutePercentageError, InstanceOf, TypeOrdinalAttribute),
          new Statement(TestMeanAbsolutePercentageError, InstanceOf, TypeQualityAttribute),
          new Statement(TestMeanAbsolutePercentageError, InstanceOf, TypeModelAttribute),
          
          new Statement(TrainingMeanAbsolutePercentageOfRangeError, InstanceOf, TypeOrdinalAttribute),
          new Statement(TrainingMeanAbsolutePercentageOfRangeError, InstanceOf, TypeQualityAttribute),
          new Statement(TrainingMeanAbsolutePercentageOfRangeError, InstanceOf, TypeModelAttribute),
          
          new Statement(ValidationMeanAbsolutePercentageOfRangeError, InstanceOf, TypeOrdinalAttribute),
          new Statement(ValidationMeanAbsolutePercentageOfRangeError, InstanceOf, TypeQualityAttribute),
          new Statement(ValidationMeanAbsolutePercentageOfRangeError, InstanceOf, TypeModelAttribute),
          
          new Statement(TestMeanAbsolutePercentageOfRangeError, InstanceOf, TypeOrdinalAttribute),
          new Statement(TestMeanAbsolutePercentageOfRangeError, InstanceOf, TypeQualityAttribute),
          new Statement(TestMeanAbsolutePercentageOfRangeError, InstanceOf, TypeModelAttribute),
          
          new Statement(TrainingCoefficientOfDetermination, InstanceOf, TypeOrdinalAttribute),
          new Statement(TrainingCoefficientOfDetermination, InstanceOf, TypeQualityAttribute),
          new Statement(TrainingCoefficientOfDetermination, InstanceOf, TypeModelAttribute),
          
          new Statement(ValidationCoefficientOfDetermination, InstanceOf, TypeOrdinalAttribute),
          new Statement(ValidationCoefficientOfDetermination, InstanceOf, TypeQualityAttribute),
          new Statement(ValidationCoefficientOfDetermination, InstanceOf, TypeModelAttribute),
          
          new Statement(TestCoefficientOfDetermination, InstanceOf, TypeOrdinalAttribute),
          new Statement(TestCoefficientOfDetermination, InstanceOf, TypeQualityAttribute),
          new Statement(TestCoefficientOfDetermination, InstanceOf, TypeModelAttribute),
          
          new Statement(TrainingVarianceAccountedFor, InstanceOf, TypeOrdinalAttribute),
          new Statement(TrainingVarianceAccountedFor, InstanceOf, TypeQualityAttribute),
          new Statement(TrainingVarianceAccountedFor, InstanceOf, TypeModelAttribute),
          
          new Statement(ValidationVarianceAccountedFor, InstanceOf, TypeOrdinalAttribute),
          new Statement(ValidationVarianceAccountedFor, InstanceOf, TypeQualityAttribute),
          new Statement(ValidationVarianceAccountedFor, InstanceOf, TypeModelAttribute),
          
          new Statement(TestVarianceAccountedFor, InstanceOf, TypeOrdinalAttribute),
          new Statement(TestVarianceAccountedFor, InstanceOf, TypeQualityAttribute),
          new Statement(TestVarianceAccountedFor, InstanceOf, TypeModelAttribute),
          
          new Statement(TrainingAccuracy, InstanceOf, TypeOrdinalAttribute),
          new Statement(TrainingAccuracy, InstanceOf, TypeQualityAttribute),
          new Statement(TrainingAccuracy, InstanceOf, TypeModelAttribute),
          
          new Statement(ValidationAccuracy, InstanceOf, TypeOrdinalAttribute),
          new Statement(ValidationAccuracy, InstanceOf, TypeQualityAttribute),
          new Statement(ValidationAccuracy, InstanceOf, TypeModelAttribute),

          new Statement(TestAccuracy, InstanceOf, TypeOrdinalAttribute),
          new Statement(TestAccuracy, InstanceOf, TypeQualityAttribute),
          new Statement(TestAccuracy, InstanceOf, TypeModelAttribute),
          
          new Statement(TrainingTheilsInequalityCoefficient, InstanceOf, TypeOrdinalAttribute),
          new Statement(TrainingTheilsInequalityCoefficient, InstanceOf, TypeQualityAttribute),
          new Statement(TrainingTheilsInequalityCoefficient, InstanceOf, TypeModelAttribute),
          
          new Statement(ValidationTheilsInequalityCoefficient, InstanceOf, TypeOrdinalAttribute),
          new Statement(ValidationTheilsInequalityCoefficient, InstanceOf, TypeQualityAttribute),
          new Statement(ValidationTheilsInequalityCoefficient, InstanceOf, TypeModelAttribute),
          
          new Statement(TestTheilsInequalityCoefficient, InstanceOf, TypeOrdinalAttribute),
          new Statement(TestTheilsInequalityCoefficient, InstanceOf, TypeQualityAttribute),
          new Statement(TestTheilsInequalityCoefficient, InstanceOf, TypeModelAttribute),

          new Statement(TreeSize, InstanceOf, TypeOrdinalAttribute),
          new Statement(TreeSize, InstanceOf, TypeComplexityAttribute),
          new Statement(TreeSize, InstanceOf, TypeModelAttribute),
          
          new Statement(TreeHeight, InstanceOf, TypeOrdinalAttribute),
          new Statement(TreeHeight, InstanceOf, TypeComplexityAttribute),
          new Statement(TreeHeight, InstanceOf, TypeModelAttribute),
          
          new Statement(EvaluatedSolutions, InstanceOf, TypeOrdinalAttribute),
          new Statement(EvaluatedSolutions, InstanceOf, TypeModelAttribute),

          new Statement(Name, InstanceOf, TypeCategoricalAttribute),
          new Statement(Name, InstanceOf, TypeModelAttribute),
          new Statement(Name, InstanceOf, TypeProblemAttribute),
          new Statement(Name, InstanceOf, TypeInputVariableAttribute),
          
          new Statement(QualityImpact, InstanceOf, TypeOrdinalAttribute),
          new Statement(QualityImpact, InstanceOf, TypeInputVariableAttribute),

          new Statement(EvaluationImpact, InstanceOf, TypeOrdinalAttribute),
          new Statement(EvaluationImpact, InstanceOf, TypeInputVariableAttribute)
        };
      }
    }


    /// <summary>
    /// Wildcard entity for filtering.
    /// </summary>
    public static Entity AnyEntity {
      get { return new Entity(null); }
    }
  }
}