anchor.diff:  
   //lower end functions
   double _getLowerEnd3_7(List<double> values) {
  -  return (values[1] - values[0]) / (values[values.length - 1] - values[0]);
  +  return (values[1] - values.first) / (values.last - values.first);
   }
   
   double _getLowerEnd8_12(List<double> values) {
  -  return (values[1] - values[0]) / (values[values.length - 2] - values[0]);
  +  return (values[1] - values.first) /
  +      (values[values.length - 2] - values.first);
   }
   
   double _getLowerEnd13(List<double> values) {
  -  return (values[2] - values[0]) / (values[values.length - 3] - values[0]);
  +  return (values[2] - values.first) /
  +      (values[values.length - 3] - values.first);
   }
   
   //Upper end functions
   double _getUpperEnd3_7(List<double> values) {
  -  return (values[values.length - 1] - values[values.length - 2]) /
  -      (values[values.length - 1] - values[0]);
  +  return (values.last - values[values.length - 2]) /
  +      (values.last - values.first);
   }
   
   double _getUpperEnd8_12(List<double> values) {
  -  return (values[values.length - 1] - values[values.length - 2]) /
  -      (values[values.length - 1] - values[1]);
  +  return (values.last - values[values.length - 2]) / (values.last - values[1]);
   }
   
   double _getUpperEnd13(List<double> values) {
  -  return (values[values.length - 1] - values[values.length - 3]) /
  -      (values[values.length - 1] - values[2]);
  -}
  -
  -DixonResults _recursiveCalc(List<double> values, DixonResults resultsObj) {
  +  return (values.last - values[values.length - 3]) / (values.last - values[2]);
  +}
  +
  +DixonResults _calculateQTest(List<double> values, DixonResults results) {
     double lowerEnd = 0.0;
     double upperEnd = 0.0;
   
     if (values.length < 3) {
  -    throw "'n' is lower than 3";
  +    throw DixonException("n is lower than 3");
     } else if (values.length <= 7) {
       lowerEnd = _getLowerEnd3_7(values);
       upperEnd = _getUpperEnd3_7(values);
  
positive.code:     upperEnd = _getUpperEnd13(values);
    }
  
    if (_isApproved(lowerEnd, resultsObj.confidence, values.length)) {
      resultsObj.lowerEnd = lowerEnd;
    } else {
      resultsObj.removedValues.add(values.removeAt(0)); //removed the first value
      resultsObj.lowerEnd = _recursiveCalc(values, resultsObj).lowerEnd;
    }
  
    if (_isApproved(upperEnd, resultsObj.confidence, values.length)) {
      resultsObj.upperEnd = upperEnd;
    } else {
      resultsObj.removedValues.add(values.removeLast()); //removed last values
      resultsObj.upperEnd = _recursiveCalc(values, resultsObj).upperEnd;
    }
  
    return resultsObj;
  }
  
  DixonResults calc(List<double> values, Confidence confidence) {
    List<double> filteredValues = values.toSet().toList();
    filteredValues.sort();
  
    return _recursiveCalc(
        filteredValues, DixonResults(confidence, filteredValues));
  }
  
  class DixonResults {
    double lowerEnd;
    double upperEnd;
    List<double> values;
    List<double> removedValues=[];
    final Confidence _confidence;
  
    DixonResults(this._confidence, this.values);
  
    get confidence => _confidence;
  
    get n => values.length;
  
    get q => _getQ(confidence, n);
  }
  
  // TODO: add docs
negative.code:   30: 0.412
  };
  
  // The limit values for 99% of confidence
  final Map<int, double> _qTable99 = {
    3: 0.994,
    4: 0.926,
  