Changeset 17374


Ignore:
Timestamp:
12/06/19 14:39:00 (23 months ago)
Author:
dpiringe
Message:

#3026:

  • extended the BaseConverter class to set the type of the extracted value and removed the assignment of type in all other converters
  • fixed a bug in ConfigurableConverter -> now it correctly iterates through all items from an IEnumerable and calls the extract callback
  • MultiCheckedOperatorConverter:
    • deleted unnecessary code line
    • now adds operators to parameters (instead of operator list, because the operator list will get removed in a future commit)
    • does not set the path of its added items anymore
  • ParameterBaseConverter removed unnecessary code lines
  • deleted ParameterBaseConverter
  • reimplemented StorableConverter to test it again (still not really useable, because it bloats the template massively)
  • fixed a pathing bug in ValueParameterConverter (extended ValueRangeConverter, ValueTypeArrayConverter, ValueTypeMatrixConverter, ValueTypeValueConverter to archive this)
  • JCGenerator now only writes a single array with parameters (only FreeParameters) and saves a .hl File to test a new type of implementation of the whole JsonInterface
  • fixed a bug in JsonItem -> now it replaces the name in path of the item (not the whole path as it was before)
Location:
branches/3026_IntegrationIntoSymSpace
Files:
1 deleted
17 edited

Legend:

Unmodified
Added
Removed
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/BaseConverter.cs

    r17371 r17374  
    2020    public JsonItem Extract(IItem value) {
    2121      JsonItem data = ExtractData(value);
    22       data.Name = String.IsNullOrEmpty(data.Name) ? value.ItemName : data.Name;
     22      data.Name = string.IsNullOrEmpty(data.Name) ? value.ItemName : data.Name;
     23      data.Type = string.IsNullOrEmpty(data.Type) ? value.GetType().AssemblyQualifiedName : data.Type;
    2324      return data;
    2425    }
     
    8788    protected object GetDefaultValue(Type t) => t.IsValueType ? Activator.CreateInstance(t) : null;
    8889
    89    
    90 
    9190    #endregion
    9291  }
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ConfigurableConverter.cs

    r17371 r17374  
    8181        if (!t.IsEqualTo(typeof(IEnumerable)))
    8282          throw new InvalidCastException($"Type {t.Name} is not an IEnumerable!");
    83         return extract(o,t);
     83        List<JsonItem> items = new List<JsonItem>();
     84        foreach(var x in (o as IEnumerable))
     85          items.AddRange(extract(x,x.GetType()));
     86        return items;
    8487      });
    8588
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/MultiCheckedOperatorConverter.cs

    r17353 r17374  
    1212      JsonItem data = base.ExtractData(value);
    1313
    14       data.Value = value.GetType().GetPrettyName(false);
    15       data.Operators = new List<JsonItem>();
     14      if(data.Parameters == null)
     15        data.Parameters = new List<JsonItem>();
    1616      dynamic val = value.Cast<dynamic>();
    1717      foreach (var op in val.Operators) {
    18         data.Operators.Add(new JsonItem() {
     18        data.Parameters.Add(new JsonItem() {
    1919          Name = op.Name,
    2020          Value = val.Operators.ItemChecked(op),
    21           Range = new object[] { false, true },
    22           Path = data.Path + "." + op.Name
     21          Range = new object[] { false, true }/*,
     22          Path = data.Path + "." + op.Name*/
    2323        });
    2424      }
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ParameterBaseConverter.cs

    r17284 r17374  
    1111      IParameter param = value.Cast<IParameter>();
    1212      JsonItem comp = ExtractData(param);
    13       //comp.Path = value.Cast<IParameter>().ActualValue?.ItemName;
    14       /*comp.Path = value.Cast<IParameter>().Name + "." + comp.Path;
    15       if(comp.ParameterizedItems != null) {
    16         foreach (var item in comp.ParameterizedItems) {
    17           item.Path = value.Cast<IParameter>().Name + "." + item.Path;
    18         }
    19       }*/
    2013      return comp;
    2114    }
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ParameterizedItemConverter.cs

    r17339 r17374  
    2020    public override JsonItem ExtractData(IItem value) {
    2121      JsonItem item = new JsonItem();
    22       item.Name = value.ItemName;
    23       item.Type = value.GetType().AssemblyQualifiedName;
     22      var parameterizedItem = value as IParameterizedItem;
    2423
    25       foreach (var param in value.Cast<IParameterizedItem>().Parameters) {
    26         JsonItem data = JsonItemConverter.Extract(param);
    27         data.Name = param.Name;
    28        
    29         if (item.Parameters == null)
    30           item.Parameters = new List<JsonItem>();
    31         item.Parameters.Add(data);
     24      foreach (var param in parameterizedItem.Parameters) {
     25        if(!param.Hidden) {
     26          JsonItem data = JsonItemConverter.Extract(param);
     27          //data.Name = param.Name;
     28
     29          if (item.Parameters == null)
     30            item.Parameters = new List<JsonItem>();
     31          item.Parameters.Add(data);
     32        }
    3233      }
    3334      return item;
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/StorableConverter.cs

    r17353 r17374  
    1414
    1515
    16   public class StorableConverter : BaseConverter {
    17     private const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
    18 
    19     private bool ContainsOnlyPrimitives(IEnumerable enumerable) {
     16  public class StorableConverter {
     17    private const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
     18
     19    //private IDictionary<Type, >
     20
     21
     22    private bool Filter(MemberInfo info) => info.Name != "ItemName" && info.Name != "ItemDescription" && info.Name != "name" && info.Name != "description";
     23
     24    private Stack<Tuple<JsonItem, object, Type, string>> stack = new Stack<Tuple<JsonItem, object, Type, string>>();
     25    private IDictionary<int, JsonItem> hashToObject = new Dictionary<int, JsonItem>();
     26
     27    public JsonItem ExtractHelper(object obj, Type type, string name = "") {
     28      JsonItem item = new JsonItem() {
     29        Parameters = new List<JsonItem>()
     30      };
     31
    2032     
    21       foreach (var i in enumerable) {
    22         if (!i.GetType().IsPrimitive) return false;
    23       }
    24       return true;
    25     }
    26 
    27     private void ExtractFromMemberInfo(MemberInfo info, object obj, JsonItem item) {
    28       string name = (obj is IItem) ? ((IItem)obj).ItemName : info.Name;
    29       if (StorableAttribute.IsStorable(info)) {
    30         object tmp = GetValue(info, obj);
    31         if (tmp is IItem)
    32           item.Parameters.Add(JsonItemConverter.Extract((IItem)tmp));
    33         else if (tmp is IDictionary) {
    34         }
    35         else if(tmp is IEnumerable) {
    36           IEnumerable c = (IEnumerable)tmp;
    37           List<object> objs = new List<object>();
    38           foreach (var i in c) {
    39             if (i is IItem)
    40               item.Parameters.Add(JsonItemConverter.Extract((IItem)i));
    41             else
    42               objs.Add(i);
     33
     34      item.Type = type.AssemblyQualifiedName;
     35
     36      if (obj != null && obj is IItem)
     37        item.Name = (obj as IItem).ItemName;
     38      else if (!string.IsNullOrEmpty(name))
     39        item.Name = name;
     40      else
     41        item.Name = type.Name;
     42
     43      hashToObject.Add(obj.GetHashCode(), item);
     44
     45      item.Path = item.Name;
     46
     47      if (obj == null) return item;
     48
     49      if (StorableTypeAttribute.IsStorableType(type)) {
     50        do {
     51          foreach (var property in type.GetProperties(flags)) {
     52            if (StorableAttribute.IsStorable(property) && Filter(property)) {
     53              object tmp = GetValue(property, obj);
     54              if (tmp != null && !hashToObject.ContainsKey(tmp.GetHashCode()))
     55                item.Parameters.Add(ExtractHelper(tmp, tmp != null ? tmp.GetType() : property.PropertyType, property.Name));
     56            }
    4357          }
    44           item.Value = objs;
    45         }
    46       }
    47     }
    48 
     58
     59          foreach (var field in type.GetFields(flags)) {
     60            if (StorableAttribute.IsStorable(field) && Filter(field)) {
     61              object tmp = GetValue(field, obj);
     62              if (tmp != null && !hashToObject.ContainsKey(tmp.GetHashCode()))
     63                item.Parameters.Add(ExtractHelper(tmp, tmp != null ? tmp.GetType() : field.FieldType, field.Name));
     64            }
     65          }
     66
     67          type = type.BaseType;
     68        } while (type != null);
     69      } else if (
     70          type.IsEqualTo(typeof(short))
     71          || type.IsEqualTo(typeof(int))
     72          || type.IsEqualTo(typeof(long))
     73          || type.IsEqualTo(typeof(ushort))
     74          || type.IsEqualTo(typeof(uint))
     75          || type.IsEqualTo(typeof(ulong))
     76          || type.IsEqualTo(typeof(float))
     77          || type.IsEqualTo(typeof(double))
     78          || type.IsEqualTo(typeof(bool))
     79      ) {
     80        item.Value = obj;
     81        item.Range = new object[] { GetMinValue(type), GetMaxValue(type) };
     82      } else if (type.IsEqualTo(typeof(IDictionary))) {
     83        if (obj != null) {
     84          foreach (DictionaryEntry i in (IDictionary)obj) {
     85            if (i.Key is string) {
     86              if (!hashToObject.ContainsKey(i.Value.GetHashCode()))
     87                item.Parameters.Add(ExtractHelper(i.Value, i.Value.GetType()));
     88            }
     89          }
     90        }
     91      } else if(type.IsEqualTo(typeof(IList))) {
     92        foreach (var i in (IList)obj) {
     93          if (!hashToObject.ContainsKey(i.GetHashCode()))
     94            item.Parameters.Add(ExtractHelper(i, i.GetType()));
     95        }
     96      } else if(type.IsEqualTo(typeof(KeyValuePair<,>))) {
     97        dynamic tmp = (dynamic)obj;
     98        object key = (object)tmp.Key;
     99        object value = (object)tmp.Value;
     100        if (!hashToObject.ContainsKey(key.GetHashCode()))
     101          item.Parameters.Add(ExtractHelper(key, key.GetType()));
     102
     103        if (!hashToObject.ContainsKey(value.GetHashCode()))
     104          item.Parameters.Add(ExtractHelper(value, value.GetType()));
     105
     106      } else if(type.IsEqualTo(typeof(string))) {
     107        item.Value = obj;
     108
     109      } else if(type.IsEqualTo(typeof(Array))) {
     110        foreach (var i in (Array)obj) {
     111          if (!hashToObject.ContainsKey(i.GetHashCode()))
     112            item.Parameters.Add(ExtractHelper(i, i.GetType()));
     113        }
     114      } else if(type.IsEqualTo(typeof(Tuple<,>))) {
     115        dynamic tmp = (dynamic)obj;
     116        object key = (object)tmp.Item1;
     117        object value = (object)tmp.Item2;
     118        if (!hashToObject.ContainsKey(key.GetHashCode()))
     119          item.Parameters.Add(ExtractHelper(key, key.GetType()));
     120
     121        if (!hashToObject.ContainsKey(value.GetHashCode()))
     122          item.Parameters.Add(ExtractHelper(value, value.GetType()));
     123
     124      } else if (type.IsEqualTo(typeof(IEnumerable))) {
     125        foreach (var i in (IEnumerable)obj) {
     126          if (!hashToObject.ContainsKey(i.GetHashCode()))
     127            item.Parameters.Add(ExtractHelper(i, i.GetType()));
     128        }
     129      }
     130
     131
     132      item.UpdatePath();
     133      return item;
     134    }
     135
     136    public JsonItem Extract(object obj) {
     137      return ExtractHelper(obj, obj.GetType());
     138    }
     139
     140    /*
    49141    public override JsonItem ExtractData(IItem value) {
    50142      Type type = value.GetType();
     
    74166      return item;
    75167    }
    76 
     168   
    77169    public override void InjectData(IItem item, JsonItem data) {
    78170      throw new NotImplementedException();
    79171    }
    80 
     172    */
    81173
    82174    private object GetValue(MemberInfo info, object obj) {
     
    88180        default: return null;
    89181      }
    90     }     
     182    }
     183
     184    private object GetMaxValue(Type t) {
     185      TypeCode typeCode = Type.GetTypeCode(t);
     186
     187      if (typeof(ValueType).IsEqualTo(typeof(PercentValue)))
     188        return 1.0d;
     189
     190      switch (typeCode) {
     191        case TypeCode.Int16: return Int16.MaxValue;
     192        case TypeCode.Int32: return Int32.MaxValue;
     193        case TypeCode.Int64: return Int64.MaxValue;
     194        case TypeCode.UInt16: return UInt16.MaxValue;
     195        case TypeCode.UInt32: return UInt32.MaxValue;
     196        case TypeCode.UInt64: return UInt64.MaxValue;
     197        case TypeCode.Single: return Single.MaxValue;
     198        case TypeCode.Double: return Double.MaxValue;
     199        case TypeCode.Decimal: return Decimal.MaxValue;
     200        case TypeCode.Byte: return Byte.MaxValue;
     201        case TypeCode.Boolean: return true;
     202        default: return GetDefaultValue(t);
     203      }
     204    }
     205
     206    private object GetMinValue(Type t) {
     207      TypeCode typeCode = Type.GetTypeCode(t);
     208
     209      if (typeof(ValueType).IsEqualTo(typeof(PercentValue)))
     210        return 0.0d;
     211
     212      switch (typeCode) {
     213        case TypeCode.Int16: return Int16.MinValue;
     214        case TypeCode.Int32: return Int32.MinValue;
     215        case TypeCode.Int64: return Int64.MinValue;
     216        case TypeCode.UInt16: return UInt16.MinValue;
     217        case TypeCode.UInt32: return UInt32.MinValue;
     218        case TypeCode.UInt64: return UInt64.MinValue;
     219        case TypeCode.Single: return Single.MinValue;
     220        case TypeCode.Double: return Double.MinValue;
     221        case TypeCode.Decimal: return Decimal.MinValue;
     222        case TypeCode.Byte: return Byte.MinValue;
     223        case TypeCode.Boolean: return false;
     224        default: return GetDefaultValue(t);
     225      }
     226    }
     227
     228    private object GetDefaultValue(Type t) => t.IsValueType ? Activator.CreateInstance(t) : null;
     229
    91230  }
    92231}
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueParameterConverter.cs

    r17342 r17374  
    1616
    1717    public override JsonItem ExtractData(IParameter value) {
    18       JsonItem data = null;
    19       if (value.ActualValue == null)
    20         data = new JsonItem();
    21       else
    22         data = JsonItemConverter.Extract(value.ActualValue);
    23       data.Name = value.Name;
     18      JsonItem data = new JsonItem() { Name = value.Name };
     19      if (value.ActualValue != null) {
     20        JsonItem tmp = JsonItemConverter.Extract(value.ActualValue);
     21        if(tmp.Name == "[OverridableParamName]") {
     22          tmp.Name = value.Name;
     23          data = tmp;
     24        }
     25        else
     26          data.AddParameter(tmp);
     27      }
    2428      return data;
    2529    }
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueRangeConverter.cs

    r17353 r17374  
    2424
    2525      return new JsonItem() {
     26        Name = "[OverridableParamName]",
    2627        Value = new object[] { tuple.Item1.Value, tuple.Item2.Value },
    2728        Range = new object[] { GetMinValue(tuple.Item1.Value.GetType()),
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueTypeArrayConverter.cs

    r17346 r17374  
    1818    public override JsonItem ExtractData(IItem value) =>
    1919      new JsonItem() {
     20        Name = "[OverridableParamName]",
    2021        Value = value.Cast<ArrayType>().CloneAsArray()
    2122      };
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueTypeMatrixConverter.cs

    r17342 r17374  
    1818    public override JsonItem ExtractData(IItem value) =>
    1919      new JsonItem() {
     20        Name = "[OverridableParamName]",
    2021        Value = value.Cast<MatrixType>().CloneAsMatrix()
    2122      };
     
    2728      var colInfo = matrix.GetType().GetProperty("Columns");
    2829      colInfo.SetValue(matrix, data.GetLength(1));
    29       //matrix.Cast<dynamic>().Columns = data.GetLength(1);
     30
    3031      for (int x = 0; x < data.GetLength(0); ++x) {
    3132        for (int y = 0; y < data.GetLength(1); ++y) {
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/Converters/ValueTypeValueConverter.cs

    r17353 r17374  
    1717    public override JsonItem ExtractData(IItem value) =>
    1818      new JsonItem() {
     19        Name = "[OverridableParamName]",
    1920        Value = value.Cast<ValueType>().Value,
    2021        Range = new object[] { GetMinValue(typeof(T)), GetMaxValue(typeof(T)) }
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/HeuristicLab.JsonInterface.csproj

    r17371 r17374  
    6666    <Compile Include="Converters\ConfigurableConverter.cs" />
    6767    <Compile Include="Converters\ItemCollectionConverter.cs" />
    68     <Compile Include="Converters\ParameterConverter.cs" />
    6968    <Compile Include="Converters\PrimitiveConverter.cs" />
     69    <Compile Include="Converters\RegressionProblemDataConverter.cs" />
    7070    <Compile Include="Converters\StorableConverter.cs" />
    7171    <Compile Include="Converters\ValueLookupParameterConverter.cs" />
     
    129129      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
    130130    </ProjectReference>
     131    <ProjectReference Include="..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
     132      <Project>{df87c13e-a889-46ff-8153-66dcaa8c5674}</Project>
     133      <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
     134    </ProjectReference>
     135    <ProjectReference Include="..\HeuristicLab.Problems.Instances.DataAnalysis\3.3\HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj">
     136      <Project>{94c7714e-29d4-4d6d-b213-2c18d627ab75}</Project>
     137      <Name>HeuristicLab.Problems.Instances.DataAnalysis-3.3</Name>
     138    </ProjectReference>
    131139    <ProjectReference Include="..\HeuristicLab.SequentialEngine\3.3\HeuristicLab.SequentialEngine-3.3.csproj">
    132140      <Project>{DC3D7072-7999-4719-B65D-3997744D5DC1}</Project>
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/JCGenerator.cs

    r17354 r17374  
    88using Newtonsoft.Json;
    99using Newtonsoft.Json.Linq;
     10using HEAL.Attic;
    1011
    1112namespace HeuristicLab.JsonInterface {
     
    2728        JsonItems = new JArray()
    2829      };
     30
     31      ProtoBufSerializer serializer = new ProtoBufSerializer();
     32      serializer.Serialize(algorithm, @"C:\Workspace\template.hl");
     33     
    2934
    3035      // 1.1. extract JsonItem, save the name in the metadata section of the
     
    6166    private static void PopulateJsonItems(JsonItem item, GenData genData) {
    6267      if (item.Parameters != null) {
     68        foreach (var p in item.Parameters) {
     69          PopulateJsonItems(p, genData);
     70        }
     71      }else if (item.Value != null || item.Range != null /*|| item.ActualName != null*/) {
     72        genData.JsonItems.Add(Serialize(item, genData));
     73      }
     74      /*
     75      if (item.Parameters != null) {
    6376        if (item.Range == null)
    6477          genData.JsonItems.Add(Serialize(item, genData));
     
    6679          if (p.IsParameterizedItem)
    6780            PopulateJsonItems(p, genData);
    68       }
     81      }*/
    6982    }
    7083
    7184    private static JObject Serialize(JsonItem item, GenData genData) {
    7285      JObject obj = JObject.FromObject(item, Settings());
    73       obj[Constants.StaticParameters] = obj[nameof(JsonItem.Parameters)];
    74       obj[Constants.FreeParameters] = obj[nameof(JsonItem.Parameters)];
     86      //obj[Constants.StaticParameters] = obj[nameof(JsonItem.Parameters)];
     87      //obj[Constants.FreeParameters] = obj[nameof(JsonItem.Parameters)];
    7588
    76       obj.Property(nameof(JsonItem.Parameters))?.Remove();
    77       RefactorFreeParameters(obj, genData);
    78       RefactorStaticParameters(obj, genData);
     89      //obj.Property(nameof(JsonItem.Parameters))?.Remove();
     90      //RefactorFreeParameters(obj, genData);
     91      //RefactorStaticParameters(obj, genData);
    7992
    80       obj.Property(nameof(JsonItem.Value))?.Remove();
     93      //obj.Property(nameof(JsonItem.Value))?.Remove();
    8194      obj.Property(nameof(JsonItem.Type))?.Remove();
    8295
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/JsonItem.cs

    r17371 r17374  
    11using System;
     2using System.Collections;
    23using System.Collections.Generic;
    34using System.IO;
     
    2425      get => name;
    2526      set {
    26         name = value;
    27         Path = Name;
    28         UpdatePath();
     27        if(Name != value) {
     28          string oldName = Name;
     29          name = value;
     30          if (Path != null) {
     31            var parts = Path.Split('.');
     32            for (int i = 0; i < parts.Length; ++i)
     33              if (parts[i] == oldName)
     34                parts[i] = Name;
     35
     36            Path = string.Join(".", parts);
     37          } else
     38            Path = Name;
     39         
     40          UpdatePath();
     41        }
    2942      }
    3043    }
     
    7588
    7689    #region Public Methods
     90    public void AddParameter(JsonItem item) {
     91      if (Parameters == null)
     92        Parameters = new List<JsonItem>();
     93      Parameters.Add(item);
     94      item.Path = $"{Path}.{item.Name}";
     95      item.UpdatePath();
     96    }
     97
    7798    public void UpdatePath() {
    7899      if (Parameters != null)
     
    103124    }
    104125
    105     private bool IsInRange() => IsInRangeList() ||
    106       (Value.GetType().IsArray && ((object[])Value).All(x => IsInNumericRange(x))) ||
    107       (!Value.GetType().IsArray && IsInNumericRange(Value));
    108 
    109     private bool IsInRangeList() {
     126    private bool IsInRange() {
     127      bool b1 = true, b2 = true;
     128      if (Value is IEnumerable && !(Value is string)) {
     129        foreach (var x in (IEnumerable)Value) {
     130          b1 = b1 ? IsInRangeList(x) : b1;
     131          b2 = b2 ? IsInNumericRange(x) : b2;
     132        }
     133      }
     134      else {
     135        b1 = IsInRangeList(Value);
     136        b2 = IsInNumericRange(Value);
     137      }
     138
     139      return b1 || b2;
     140    }
     141
     142    private bool IsInRangeList(object value) {
    110143      foreach (var x in Range)
    111         if (x.Equals(Value)) return true;
     144        if (x.Equals(value)) return true;
    112145      return false;
    113146    }
    114147
    115148    private bool IsInNumericRange(object value) =>
    116       IsInNumericRange<long>(value)
     149      IsInNumericRange<ulong>(value)
     150      || IsInNumericRange<uint>(value)
     151      || IsInNumericRange<ushort>(value)
     152      || IsInNumericRange<long>(value)
    117153      || IsInNumericRange<int>(value)
    118154      || IsInNumericRange<short>(value)
    119155      || IsInNumericRange<byte>(value)
    120156      || IsInNumericRange<float>(value)
    121       || IsInNumericRange<double>(value);
     157      || IsInNumericRange<double>(value)
     158      || (value is float && float.IsNaN((float)value))
     159      || (value is double && double.IsNaN((double)value));
    122160
    123161    private bool IsInNumericRange<T>(object value) where T : IComparable {
    124162      object min = Range.First(), max = Range.Last();
    125       return value != null && min != null && max != null && value is T && min is T && max is T &&
    126             (((T)min).CompareTo(value) == -1 || ((T)min).CompareTo(value) == 0) &&
    127             (((T)max).CompareTo(value) == 1 || ((T)max).CompareTo(value) == 0);
     163      return
     164        value != null && min != null && max != null && value is T && min is T && max is T &&
     165        (((T)min).CompareTo(value) == -1 || ((T)min).CompareTo(value) == 0) &&
     166        (((T)max).CompareTo(value) == 1 || ((T)max).CompareTo(value) == 0);
    128167    }
    129168
  • branches/3026_IntegrationIntoSymSpace/HeuristicLab.JsonInterface/JsonItemConverter.cs

    r17371 r17374  
    8181        return best.Converter;
    8282      }
    83 
    84       Type t = Mapper.StaticCache.GetType(new Guid("25137f88-66b9-48d7-a2bd-60190082e044"));
    85 
    86      
    87 
    8883      return new DummyConverter();
    8984    }
     
    121116
    122117      Register(typeof(EnumValue<>), new EnumTypeConverter(), 1);
    123 
    124       Register<IParameter>(new ParameterConverter(), 1);
    125 
     118     
    126119      Register<IValueParameter>(new ValueParameterConverter(), 2);
    127120      Register<IParameterizedItem>(new ParameterizedItemConverter(), 2);
     
    131124      Register(typeof(IConstrainedValueParameter<>), new ConstrainedValueParameterConverter(), 3);
    132125      Register(typeof(ICheckedMultiOperator<>), new MultiCheckedOperatorConverter(), 3);
    133 
    134       //ApplicationManager.Manager
    135       // "25137f88-66b9-48d7-a2bd-60190082e044"
    136       //new Guid("25137f88-66b9-48d7-a2bd-60190082e044")
     126     
     127      Register("EE612297-B1AF-42D2-BF21-AF9A2D42791C", new RegressionProblemDataConverter(), 20);
     128
    137129      // ISymbol
    138 
     130      /*
    139131      Register("25137f88-66b9-48d7-a2bd-60190082e044",
    140132        new ConfigurableConverter()
     
    144136        .Primitive("MaximumArity", ElementType.Property, 10),
    145137        5);
     138      */
     139      // SymbolicRegressionProblem
     140      /*
     141      Register("7DDCF683-96FC-4F70-BF4F-FE3A0B0DE6E0",
     142        new ConfigurableConverter()
     143        .
     144        10);
     145      */
    146146
    147147      // Dataset
     148      /*
    148149      Register("49F4D145-50D7-4497-8D8A-D190CD556CC8",
    149         new ConfigurableConverter() //TODO: set guid to enable inheritance?
    150         /*.PrimitiveEnumerable("VariableNames", ElementType.Property)
    151         .PrimitiveEnumerable("DoubleVariables", ElementType.Property)
    152         .PrimitiveEnumerable("StringVariables", ElementType.Property)
    153         .PrimitiveEnumerable("DateTimeVariables", ElementType.Property)*/
     150        new ConfigurableConverter() //TODO: set guid to enable "inheritance"?
    154151        .PrimitiveEnumerable("storableData", ElementType.Field, new double[,] { }),
    155152        5);
    156 
     153      */
     154      // ItemCollection<>
     155      /*
     156      Register("0BD4F01E-2D52-4E41-AEF8-611F10856D90",
     157        new ConfigurableConverter()
     158        .This((o, t) => {
     159          dynamic itemList = o as dynamic;
     160          IList<JsonItem> jsonItems = new List<JsonItem>();
     161          foreach (var obj in itemList) {
     162            IItem item = obj as IItem;
     163            jsonItems.Add(Extract(item));
     164          }
     165          return jsonItems;
     166        }),
     167        5);
     168      */
     169      // IItemList<>
     170      /*
     171      Register("466747d2-6a73-495b-ac68-7b0199d0f830",
     172        new ConfigurableConverter()
     173        .This((o, t) => {
     174          dynamic itemList = o as dynamic;
     175          IList<JsonItem> jsonItems = new List<JsonItem>();
     176          foreach (var obj in itemList) {
     177            IItem item = obj as IItem;
     178            jsonItems.Add(Extract(item));
     179          }
     180          return jsonItems;
     181        }),
     182        6);
     183      */
    157184      // ICheckedItemList<>
     185      /*
    158186      Register("ba4a82ca-92eb-47a1-95a7-f41f6ef470f4",
    159187        new ConfigurableConverter()
     
    181209          return jsonItems;
    182210        }),
    183         5);
     211        6);
     212      */
     213      //ISymbolicExpressionGrammar - "1f6afcbe-b309-44e2-8d35-2d33eaeb9649"
     214      //ISymbolicExpressionGrammarBase - "119f5e94-bc7d-42fc-a48b-ac0230115ef2"
     215      /*
     216      Register("119f5e94-bc7d-42fc-a48b-ac0230115ef2",
     217        new ConfigurableConverter()
     218        .Enumerable("Symbols", ElementType.Property, (o,t) => new JsonItem[] { Extract(o as IItem) }),
     219        10);
     220      */
    184221    }
    185222  }
  • branches/3026_IntegrationIntoSymSpace/Heuristiclab.ConfigStarter/Heuristiclab.ConfigStarter.csproj

    r17371 r17374  
    113113      <Name>HeuristicLab.Problems.TravelingSalesman-3.3</Name>
    114114    </ProjectReference>
     115    <ProjectReference Include="..\HeuristicLab.SequentialEngine\3.3\HeuristicLab.SequentialEngine-3.3.csproj">
     116      <Project>{dc3d7072-7999-4719-b65d-3997744d5dc1}</Project>
     117      <Name>HeuristicLab.SequentialEngine-3.3</Name>
     118    </ProjectReference>
    115119  </ItemGroup>
    116120  <ItemGroup>
  • branches/3026_IntegrationIntoSymSpace/Heuristiclab.ConfigStarter/Program.cs

    r17371 r17374  
    1212using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
    1313using HeuristicLab.PluginInfrastructure.Manager;
     14using HeuristicLab.SequentialEngine;
     15using System.Threading;
    1416
    1517namespace Heuristiclab.ConfigStarter {
    1618  public class Program {
     19
     20    private static string Reduce(string str) =>
     21      str
     22      .Replace(" ", "")
     23      .Replace("-", "")
     24      .Replace("`", "")
     25      .Replace(".", "")
     26      .Replace("<", "")
     27      .Replace(">", "")
     28      .Replace("(", "_")
     29      .Replace(")", "_");
     30
     31    private static void Visualize(JsonItem item, StringBuilder sb) {
     32      sb.Append($"  {item.GetHashCode()} [label=\"{item.Name}\"];\n");
     33      foreach (var i in item.Parameters) {
     34        sb.Append($"  {item.GetHashCode()} -> {i.GetHashCode()};\n");
     35      }
     36      foreach(var i in item.Parameters) {
     37        Visualize(i, sb);
     38      }
     39    }
     40
    1741    public static void Main(string[] args) {
    1842
     
    3256
    3357      GeneticAlgorithm alg = new GeneticAlgorithm();
     58      alg.MaximumGenerations.Value = 10000;
    3459      TravelingSalesmanProblem tsp = new TravelingSalesmanProblem();
    3560      tsp.Coordinates[0, 0] = 123;
     61
    3662
    3763
     
    4066      alg.Problem = prop;
    4167
     68      alg.Engine = new SequentialEngine();
     69      Task t = alg.StartAsync();
     70      Thread.Sleep(1000);
     71      alg.Stop();
     72
     73      StorableConverter storableConverter = new StorableConverter();
     74      JsonItem item = storableConverter.Extract(alg);
     75
     76      StringBuilder sb = new StringBuilder();
     77
     78      //Visualize(item, sb);
     79
     80      //File.WriteAllText(@"C:\Workspace\item.gv", $"digraph G {{\n{sb.ToString()}}}");
     81
     82
     83      //Console.WriteLine(alg);
    4284      File.WriteAllText(@"C:\Workspace\Template.json", JCGenerator.GenerateTemplate(alg));
    4385
Note: See TracChangeset for help on using the changeset viewer.