anchor.diff:  
           final split = splitter.split(
             samples,
  -          splittingColumnRange,
  +          splittingColumnIdx,
             null,
             splittingValues,
           );
           expect(split.values, equals(<Matrix>[]));
  -        verify(nominalSplitter.split(samples, splittingColumnRange, splittingValues))
  -            .called(1);
  -      });
  -
  -      test('should throw an error if unappropriate range is given (left '
  -          'boundary is less than 0)', () {
  -        final samples = Matrix.fromList([
  -          [11, 22, 0, 0, 1, 30],
  -          [60, 23, 0, 0, 1, 20],
  -          [20, 25, 1, 0, 0, 10],
  -          [17, 66, 1, 0, 0, 70],
  -          [13, 99, 0, 1, 0, 30],
  -        ]);
  -        final splittingColumnRange = ZRange.closed(-2, 4);
  -        final splittingValues = [
  -          Vector.fromList([0, 0, 1]),
  -          Vector.fromList([0, 1, 0]),
  -        ];
  +        verify(nominalSplitter.split(samples, splittingColumnIdx,
  +            splittingValues)).called(1);
  +      });
  +
  +      test('should throw an error if negative splitting index is given', () {
  +        final samples = Matrix.fromList([
  +          [11, 22, 1, 30],
  +          [60, 23, 1, 20],
  +          [20, 25, 2, 10],
  +          [17, 66, 2, 70],
  +          [13, 99, 3, 30],
  +        ]);
  +        final splittingColumnIdx = -2;
  +        final splittingValues = [1, 3];
           final splitter = GreedySplitter(null, null, null);
           final actual = () => splitter.split(
             samples,
  -          splittingColumnRange,
  +          splittingColumnIdx,
             null,
             splittingValues,
           );
           expect(actual, throwsException);
         });
   
  -      test('should throw an error if unappropriate range is given (right '
  -          'boundary is greater than the observations columns number)', () {
  -        final samples = Matrix.fromList([
  -          [11, 22, 0, 0, 1, 30],
  -          [60, 23, 0, 0, 1, 20],
  -          [20, 25, 1, 0, 0, 10],
  -          [17, 66, 1, 0, 0, 70],
  -          [13, 99, 0, 1, 0, 30],
  -        ]);
  -        final splittingColumnRange = ZRange.closed(0, 10);
  -        final splittingValues = [
  -          Vector.fromList([0, 0, 1]),
  -          Vector.fromList([0, 1, 0]),
  -        ];
  +      test('should throw an error if splitting index is greater than the '
  +          'number of columns', () {
  +        final samples = Matrix.fromList([
  +          [11, 22, 1, 30],
  +          [60, 23, 1, 20],
  +          [20, 25, 2, 10],
  +          [17, 66, 2, 70],
  +          [13, 99, 3, 30],
  +        ]);
  +        final splittingColumnIdx = 10;
  +        final splittingValues = [1, 3];
           final selector = GreedySplitter(null, null, null);
           final actual = () => selector.split(
             samples,
  -          splittingColumnRange,
  +          splittingColumnIdx,
             null,
             splittingValues,
           );
  
positive.code: 
      group('(splitting by categorical values)', () {
        test('should create split, splitting the observations into parts by '
            'given column range', () {
          final samples = Matrix.fromList([
            [11, 22, 0, 0, 1, 30],
            [60, 23, 0, 0, 1, 20],
            [20, 25, 1, 0, 0, 10],
            [17, 66, 1, 0, 0, 70],
            [13, 99, 0, 1, 0, 30],
          ]);
          final splittingColumnRange = ZRange.closed(2, 4);
          final splittingValues = [
            Vector.fromList([0, 0, 1]),
            Vector.fromList([0, 1, 0]),
            Vector.fromList([1, 0, 0]),
          ];
          final mockedSplit = {
            DecisionTreeNodeMock(): Matrix.fromList([
              [11, 22, 0, 0, 1, 30],
              [60, 23, 0, 0, 1, 20],
            ]),
            DecisionTreeNodeMock(): Matrix.fromList([
              [13, 99, 0, 1, 0, 30],
            ]),
            DecisionTreeNodeMock(): Matrix.fromList([
              [20, 25, 1, 0, 0, 10],
              [17, 66, 1, 0, 0, 70],
            ]),
          };
          final splitter = createNominalSplitter(splittingValues, mockedSplit);
          final selector = GreedySplitter(null, null, splitter);
          final actualSplit = selector.split(
            samples,
            splittingColumnRange,
            null,
            splittingValues,
          );
  
negative.code:           [0.0, 10.0],
          ]);
  
          final targetIdx = 1;
  
          final bestSplittingValue = 4.5;
          final splittingColumnIdx = 0;
  
          final mockedWorstSplit = {
            DecisionTreeNodeMock(): Matrix.fromList([[12.0, 22.0]]),
  