anchor.diff:      upperEnd = _getUpperEnd13(values);
     }
   
  -  if (_isApproved(lowerEnd, resultsObj.confidence, values.length)) {
  -    resultsObj.lowerEnd = lowerEnd;
  +  if (_isApproved(lowerEnd, results.confidence, values.length)) {
  +    results.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;
  +    results.removedValues.add(values.removeAt(0)); //removed the first value
  +    results.lowerEnd = _calculateQTest(values, results).lowerEnd;
  +  }
  +
  +  if (_isApproved(upperEnd, results.confidence, values.length)) {
  +    results.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));
  -}
  -
  +    results.removedValues.add(values.removeLast()); //removed last values
  +    results.upperEnd = _calculateQTest(values, results).upperEnd;
  +  }
  +
  +  return results;
  +}
  +
  +/// A representation of a Q Test calculation result
   class DixonResults {
     double lowerEnd;
     double upperEnd;
     List<double> values;
  -  List<double> removedValues=[];
  +  List<double> removedValues = [];
     final Confidence _confidence;
   
     DixonResults(this._confidence, this.values);
   
  +  /// The enum representing the confidence used in calculation
     get confidence => _confidence;
   
  +  /// The length of [values] attribute
     get n => values.length;
   
  +  /// The Q constant from Dixon's table for the resulting n and given confidence
     get q => _getQ(confidence, n);
   }
   
  -// TODO: add docs+/// A representation of a Q Test error
  +class DixonException implements Exception {
  +  /// Message describing the Dixon error
  +  final String message;
  +
  +  /// Creates a new [DixonException] with optional message
  +  DixonException([this.message = ""]);
  +
  +  @override
  +  String toString() => "DixonException: $message";
  +}
  +
  +/// Returns a [DixonResults] object representing the result of Q test calculation
  +///
  +/// Throws a [DixonException] if 'n' is or got lower than 3 during
  +/// the calculation
  +DixonResults calculateQTest(List<double> values, Confidence confidence) {
  +  // Prepares values before calculation
  +  List<double> filteredValues = values.toSet().toList();
  +  filteredValues.sort();
  +
  +  return _calculateQTest(
  +      filteredValues, DixonResults(confidence, filteredValues));
  +}
  
positive.code: furnished to do so, subject to the following conditions:
  */
  
  enum Confidence { percent95, percent99 }
  
  //Limit values for 95% of confidence
  final Map<int, double> _qTable95 = {
    3: 0.970,
    4: 0.829,
  
negative.code:   30: 0.412
  };
  
  // The limit values for 99% of confidence
  final Map<int, double> _qTable99 = {
    3: 0.994,
    4: 0.926,
  