Example #1
0
    def test_rank_min_a(self) -> None:

        a1 = rank_1d(np.array([0, 2, 3, 2]), 'min', start=1)
        self.assertEqual(a1.tolist(), [1, 2, 4, 2])
        a2 = rank_1d(np.array([0, 2, 3, 2]), 'min', start=0)
        self.assertEqual(a2.tolist(), [0, 1, 3, 1])

        a3 = rank_1d(np.array([0, 2, 3, 2]), 'min', ascending=False)
        self.assertEqual(a3.tolist(), [3, 1, 0, 1])
Example #2
0
    def test_rank_average_a(self) -> None:

        a1 = rank_1d(np.array([0, 2, 3, 2]), 'mean', ascending=True)
        self.assertEqual(a1.tolist(), [0.0, 1.5, 3.0, 1.5])

        a2 = rank_1d(np.array([0, 2, 3, 2]), 'mean', start=1)
        self.assertEqual(a2.tolist(), [1.0, 2.5, 4.0, 2.5])

        a3 = rank_1d(np.array([0, 2, 3, 2]), 'mean', start=1, ascending=False)
        self.assertEqual(a3.tolist(), [4.0, 2.5, 1.0, 2.5])
Example #3
0
    def test_rank_max_a(self) -> None:

        a1 = rank_1d(np.array([0, 2, 3, 2]), 'max', start=1)
        # import ipdb; ipdb.set_trace()

        self.assertEqual(a1.tolist(), [1, 3, 4, 3])
        a2 = rank_1d(np.array([0, 2, 3, 2]), 'max', start=0)
        self.assertEqual(a2.tolist(), [0, 2, 3, 2])

        a2 = rank_1d(np.array([0, 2, 3, 2]), 'max', ascending=False)
        self.assertEqual(a2.tolist(), [3, 2, 0, 2])
Example #4
0
    def test_rank_1d_ordinal(self, value: np.ndarray) -> None:
        a1 = rankdata(value, method='ordinal')
        a2 = rank_1d(value, method='ordinal', start=1)
        self.assertEqual(a1.tolist(), a2.tolist())

        if len(value):
            a3 = rank_1d(value, method='ordinal')
            self.assertEqual(a3.min(), 0)

            a4 = rank_1d(value, method='ordinal', ascending=False)
            self.assertEqual(a4.min(), 0)
Example #5
0
    def test_rank_1d_pair_a(self) -> None:
        self.assertEqual(
            rank_1d(np.array([0, 0]), 'mean').tolist(), [0.5, 0.5])

        self.assertEqual(rank_1d(np.array([0, 0]), 'min').tolist(), [0, 0])

        self.assertEqual(rank_1d(np.array([0, 0]), 'max').tolist(), [1, 1])

        self.assertEqual(rank_1d(np.array([0, 0]), 'dense').tolist(), [0, 0])

        self.assertEqual(rank_1d(np.array([0, 0]), 'ordinal').tolist(), [0, 1])
Example #6
0
    def test_rank_ordinal_a(self) -> None:
        self.assertEqual(
            rank_1d(np.array([3, 2, 6, 20]), RankMethod.ORDINAL).tolist(),
            [1, 0, 2, 3])

        self.assertEqual(
            rank_1d(np.array([3, 2, 6, 20]), RankMethod.ORDINAL,
                    start=1).tolist(), [2, 1, 3, 4])

        a2 = rank_1d(np.array([3, 2, 6, 20]),
                     RankMethod.ORDINAL,
                     ascending=False)
        self.assertEqual(a2.tolist(), [2, 3, 1, 0])
Example #7
0
    def test_rank_1d_min(self, value: np.ndarray) -> None:
        # cannot compare values with NaN as scipy uses quicksort
        if np.isnan(value).any():
            return
        a1 = rankdata(value, method='min')
        a2 = rank_1d(value, method='min', start=1)
        self.assertEqual(a1.tolist(), a2.tolist())

        if len(value):
            a3 = rank_1d(value, method='min')
            self.assertEqual(a3.min(), 0)

            a4 = rank_1d(value, method='min', ascending=False)
            self.assertEqual(a4.min(), 0)
Example #8
0
 def test_rank_1d_average(self, value: np.ndarray) -> None:
     # cannot compare values with NaN as scipy uses quicksort
     if np.isnan(value).any():
         return
     a1 = rankdata(value, method='average')
     a2 = rank_1d(value, method='mean', start=1)
     self.assertEqual(a1.tolist(), a2.tolist())
Example #9
0
 def test_rank_average_d(self) -> None:
     a1 = rank_1d(np.array([17, 10, 3, -4, 9, 3, -12, 18, 3, 0, 17]),
                  'mean',
                  start=1)
     self.assertEqual(
         a1.tolist(),
         [9.5, 8.0, 5.0, 2.0, 7.0, 5.0, 1.0, 11.0, 5.0, 3.0, 9.5])
Example #10
0
    def test_rank_average_b(self) -> None:

        a1 = rank_1d(np.array([0, 2, 5, 2, 2, 2]), 'mean', ascending=True)
        self.assertEqual(a1.tolist(), [0.0, 2.5, 5.0, 2.5, 2.5, 2.5])

        a1 = rank_1d(np.array([0, 2, 5, 2, 2, 2]),
                     'mean',
                     ascending=True,
                     start=1)
        self.assertEqual(a1.tolist(), [1.0, 3.5, 6.0, 3.5, 3.5, 3.5])
        #scipy: [1.0, 3.5, 6.0, 3.5, 3.5, 3.5]

        # import ipdb; ipdb.set_trace()
        a2 = rank_1d(np.array([0, 2, 3, 2]), 'mean', start=1)
        self.assertEqual(a2.tolist(), [1.0, 2.5, 4.0, 2.5])

        a3 = rank_1d(np.array([0, 2, 3, 2]), 'mean', start=1, ascending=False)
        self.assertEqual(a3.tolist(), [4.0, 2.5, 1.0, 2.5])
Example #11
0
    def test_rank_1d_pair_b(self) -> None:
        self.assertEqual(
            rank_1d(np.array([0, 0, 1]), 'mean').tolist(), [0.5, 0.5, 2])
        self.assertEqual(rank_1d(np.array([0, 0, 1]), 'mean').dtype.kind, 'f')

        self.assertEqual(
            rank_1d(np.array([0, 0, 1]), 'min').tolist(), [0, 0, 2])
        self.assertEqual(rank_1d(np.array([0, 0, 1]), 'min').dtype.kind, 'i')

        self.assertEqual(
            rank_1d(np.array([0, 0, 1]), 'max').tolist(), [1, 1, 2])
        self.assertEqual(rank_1d(np.array([0, 0, 1]), 'max').dtype.kind, 'i')

        self.assertEqual(
            rank_1d(np.array([0, 0, 1]), 'dense').tolist(), [0, 0, 1])
        self.assertEqual(rank_1d(np.array([0, 0, 1]), 'dense').dtype.kind, 'i')

        self.assertEqual(
            rank_1d(np.array([0, 0, 1]), 'ordinal').tolist(), [0, 1, 2])
        self.assertEqual(
            rank_1d(np.array([0, 0, 1]), 'ordinal').dtype.kind, 'i')
Example #12
0
 def test_rank_method_a(self) -> None:
     with self.assertRaises(NotImplementedError):
         rank_1d(np.array([3, 2, 6, 20]), None)  #type: ignore
Example #13
0
 def test_rank_min_b(self) -> None:
     a1 = rank_1d(np.array([8, 15, 7, 2, 20, 4, 20, 7, 15, 15]),
                  'min',
                  start=1)
     self.assertEqual(a1.tolist(), [5, 6, 3, 1, 9, 2, 9, 3, 6, 6])
Example #14
0
 def test_rank_min_c(self) -> None:
     a1 = rank_1d(np.array([17, 10, 3, -4, 9, 3, -12, 18, 3, 0, 17]),
                  'min',
                  start=1)
     self.assertEqual(a1.tolist(), [9, 8, 4, 2, 7, 4, 1, 11, 4, 3, 9])
Example #15
0
 def test_rank_average_c(self) -> None:
     a1 = rank_1d(np.array([8, 15, 7, 2, 20, 4, 20, 7, 15, 15]),
                  'mean',
                  start=1)
     self.assertEqual(a1.tolist(),
                      [5.0, 7.0, 3.5, 1.0, 9.5, 2.0, 9.5, 3.5, 7.0, 7.0])
Example #16
0
 def test_rank_max_b(self) -> None:
     a1 = rank_1d(np.array([8, 15, 7, 2, 20, 4, 20, 7, 15, 15]),
                  'max',
                  start=1)
     self.assertEqual(a1.tolist(), [5, 8, 4, 1, 10, 2, 10, 4, 8, 8])
Example #17
0
 def test_rank_ordinal_d(self) -> None:
     a1 = rank_1d(np.array([17, 10, 3, -4, 9, 3, -12, 18, 3, 0, 17]),
                  'ordinal',
                  start=1)
     self.assertEqual(a1.tolist(), [9, 8, 4, 2, 7, 5, 1, 11, 6, 3, 10])
Example #18
0
 def test_rank_ordinal_c(self) -> None:
     a1 = rank_1d(np.array([8, 15, 7, 2, 20, 4, 20, 7, 15, 15]),
                  'ordinal',
                  start=1)
     self.assertEqual(a1.tolist(), [5, 6, 3, 1, 9, 2, 10, 4, 7, 8])
Example #19
0
 def test_rank_max_c(self) -> None:
     a1 = rank_1d(np.array([17, 10, 3, -4, 9, 3, -12, 18, 3, 0, 17]),
                  'max',
                  start=1)
     self.assertEqual(a1.tolist(), [10, 8, 6, 2, 7, 6, 1, 11, 6, 3, 10])
Example #20
0
 def test_rank_dense_c(self) -> None:
     a1 = rank_1d(np.array([17, 10, 3, -4, 9, 3, -12, 18, 3, 0, 17]),
                  'dense',
                  start=1)
     self.assertEqual(a1.tolist(), [7, 6, 4, 2, 5, 4, 1, 8, 4, 3, 7])
Example #21
0
 def test_rank_dense_b(self) -> None:
     a1 = rank_1d(np.array([8, 15, 7, 2, 20, 4, 20, 7, 15, 15]),
                  'dense',
                  start=1)
     self.assertEqual(a1.tolist(), [4, 5, 3, 1, 6, 2, 6, 3, 5, 5])