Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
02/07/17 14:05:09 (8 years ago)
Author:
epitzer
Message:

#2727 completely replace basic array with array mapped trie in ValueTypeArray and descendants

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/PersistentDataStructures/HeuristicLab.Encodings.LinearLinkageEncoding/3.3/LinearLinkage.cs

    r14186 r14650  
    5454    /// <returns>An enumeration of all groups.</returns>
    5555    public IEnumerable<List<int>> GetGroups() {
    56       var len = array.Length;
     56      var len = historyArray.Length;
    5757      var remaining = new HashSet<int>(Enumerable.Range(0, len));
    5858      // iterate from lowest to highest index
    … …  
    6161        var group = new List<int> { i };
    6262        remaining.Remove(i);
    63         var next = array[i];
     63        var next = historyArray[i];
    6464        if (next != i) {
    6565          int prev;
    … …  
    6969              throw new ArgumentException("Array is malformed and does not represent a valid LLE forward encoding.");
    7070            prev = next;
    71             next = array[next];
     71            next = historyArray[next];
    7272          } while (next != prev);
    7373        }
    … …  
    104104    public IEnumerable<int> GetGroupForward(int index) {
    105105      yield return index;
    106       var next = array[index];
     106      var next = historyArray[index];
    107107      if (next == index) yield break;
    108108      int prev;
    … …  
    110110        yield return next;
    111111        prev = next;
    112         next = array[next];
     112        next = historyArray[next];
    113113      } while (next != prev);
    114114    }
    … …  
    130130    public IEnumerable<int> GetGroupBackward(int index) {
    131131      yield return index;
    132       var next = array[index];
     132      var next = historyArray[index];
    133133      // return preceding elements in group
    134134      for (var prev = index - 1; prev >= 0; prev--) {
    135         if (array[prev] != next) continue;
     135        if (historyArray[prev] != next) continue;
    136136        next = prev;
    137137        yield return next;
    … …  
    150150    /// be part of exactly one group.</param>
    151151    public void SetGroups(IEnumerable<IEnumerable<int>> grouping) {
    152       var len = array.Length;
     152      var len = historyArray.Length;
    153153      var remaining = new HashSet<int>(Enumerable.Range(0, len));
    154154      foreach (var group in grouping) {
    155155        var prev = -1;
    156156        foreach (var g in group.OrderBy(x => x)) {
    157           if (prev >= 0) array[prev] = g;
     157          if (prev >= 0) historyArray[prev] = g;
    158158          prev = g;
    159159          if (!remaining.Remove(prev))
    160160            throw new ArgumentException(string.Format("Element {0} is contained at least twice.", prev), "grouping");
    161161        }
    162         if (prev >= 0) array[prev] = prev;
     162        if (prev >= 0) historyArray[prev] = prev;
    163163      }
    164164      if (remaining.Count > 0)
    … …  
    175175    /// <returns>True if the encoding is valid.</returns>
    176176    public bool Validate() {
    177       var len = array.Length;
     177      var len = historyArray.Length;
    178178      var remaining = new HashSet<int>(Enumerable.Range(0, len));
    179179      for (var i = 0; i < len; i++) {
    180180        if (!remaining.Contains(i)) continue;
    181181        remaining.Remove(i);
    182         var next = array[i];
     182        var next = historyArray[i];
    183183        if (next == i) continue;
    184184        int prev;
    … …  
    186186          if (!remaining.Remove(next)) return false;
    187187          prev = next;
    188           next = array[next];
     188          next = historyArray[next];
    189189        } while (next != prev);
    190190      }
    … …  
    216216    public void LinearizeTreeStructures() {
    217217      // Step 1: Convert the array into LLE-e
    218       ToLLEeInplace(array);
     218      ToLLEeInplace(historyArray.ToArray());
    219219      // Step 2: For all groups linearize the links
    220       FromLLEe(array);
     220      FromLLEe(historyArray.ToArray());
    221221    }
    222222
    … …  
    234234    /// <returns>An integer array in LLE-e representation</returns>
    235235    public int[] ToLLEe() {
    236       var result = (int[])array.Clone();
     236      var result = (int[])historyArray.Clone();
    237237      ToLLEeInplace(result);
    238238      return result;
    … …  
    242242      var length = a.Length;
    243243      for (var i = length - 1; i >= 0; i--) {
    244         if (array[i] == i) a[i] = i;
     244        if (historyArray[i] == i) a[i] = i;
    245245        else a[i] = a[a[i]];
    246246      }
    … …  
    257257    /// <param name="llee">The LLE-e representation</param>
    258258    public void FromLLEe(int[] llee) {
    259       var length = array.Length;
     259      var length = historyArray.Length;
    260260      var groups = new Dictionary<int, int>();
    261261      for (var i = length - 1; i >= 0; i--) {
    262262        if (llee[i] == i) {
    263           array[i] = i;
     263          historyArray[i] = i;
    264264          groups[i] = i;
    265265        } else {
    266266          var g = llee[i];
    267           array[i] = groups[g];
     267          historyArray[i] = groups[g];
    268268          groups[g] = i;
    269269        }
Note: See TracChangeset for help on using the changeset viewer.