# -*- coding: utf-8 -*-
#/***************************************************************************
# Irmt
# A QGIS plugin
# OpenQuake Integrated Risk Modelling Toolkit
# -------------------
# begin : 2013-10-24
# copyright : (C) 2014 by GEM Foundation
# email : devops@openquake.org
# ***************************************************************************/
#
# OpenQuake is free software: you can redistribute it and/or modify it
# under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# OpenQuake is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.
import unittest
from svir.calculations.transformation_algs import (
transform,
TRANSFORMATION_ALGS)
from PyQt4.QtCore import QPyNullVariant
[docs]class MissingValuesTestCase(unittest.TestCase):
[docs]class RankTestCase(unittest.TestCase):
[docs] def setUp(self):
self.alg = TRANSFORMATION_ALGS["RANK"]
self.input_list = [2, 0, 2, 1, 2, 3, 2]
[docs] def test_rank_direct_average(self):
rank_list, _ = self.alg(
self.input_list, variant_name="AVERAGE", inverse=False)
self.assertEqual(rank_list, [4.5, 1, 4.5, 2, 4.5, 7, 4.5])
[docs] def test_rank_direct_min(self):
rank_list, _ = self.alg(
self.input_list, variant_name="MIN", inverse=False)
self.assertEqual(rank_list, [3, 1, 3, 2, 3, 7, 3])
[docs] def test_rank_direct_max(self):
rank_list, _ = self.alg(
self.input_list, variant_name="MAX", inverse=False)
self.assertEqual(rank_list, [6, 1, 6, 2, 6, 7, 6])
[docs] def test_rank_direct_dense(self):
rank_list, _ = self.alg(
self.input_list, variant_name="DENSE", inverse=False)
self.assertEqual(rank_list, [3, 1, 3, 2, 3, 4, 3])
[docs] def test_rank_direct_ordinal(self):
rank_list, _ = self.alg(
self.input_list, variant_name="ORDINAL", inverse=False)
self.assertEqual(rank_list, [3, 1, 4, 2, 5, 7, 6])
[docs] def test_rank_inverse_average(self):
rank_list, _ = self.alg(
self.input_list, variant_name="AVERAGE", inverse=True)
self.assertEqual(rank_list, [3.5, 7, 3.5, 6, 3.5, 1, 3.5])
[docs] def test_rank_inverse_min(self):
rank_list, _ = self.alg(
self.input_list, variant_name="MIN", inverse=True)
self.assertEqual(rank_list, [2, 7, 2, 6, 2, 1, 2])
[docs] def test_rank_inverse_max(self):
rank_list, _ = self.alg(
self.input_list, variant_name="MAX", inverse=True)
self.assertEqual(rank_list, [5, 7, 5, 6, 5, 1, 5])
[docs] def test_rank_inverse_dense(self):
rank_list, _ = self.alg(
self.input_list, variant_name="DENSE", inverse=True)
self.assertEqual(rank_list, [2, 4, 2, 3, 2, 1, 2])
[docs] def test_rank_inverse_ordinal(self):
rank_list, _ = self.alg(
self.input_list, variant_name="ORDINAL", inverse=True)
self.assertEqual(rank_list, [2, 7, 3, 6, 4, 1, 5])
[docs]class MinMaxTestCase(unittest.TestCase):
[docs] def setUp(self):
self.alg = TRANSFORMATION_ALGS["MIN_MAX"]
self.input_list = [2, 0, 2, 1, 2, 3, 2]
[docs] def test_min_max_direct(self):
min_max_list, _ = self.alg(self.input_list, inverse=False)
self.assertEqual(min_max_list, [0.6666666666666666,
0.0,
0.6666666666666666,
0.3333333333333333,
0.6666666666666666,
1.0,
0.6666666666666666])
[docs] def test_min_max_inverse(self):
min_max_list, _ = self.alg(self.input_list, inverse=True)
self.assertEqual(min_max_list, [0.33333333333333337,
1.0,
0.33333333333333337,
0.6666666666666667,
0.33333333333333337,
0.0,
0.33333333333333337])
[docs]class ZScoreTestCase(unittest.TestCase):
[docs] def setUp(self):
self.alg = TRANSFORMATION_ALGS["Z_SCORE"]
self.input_list = [2, 0, 2, 1, 2, 3, 2]
[docs] def test_z_score_direct(self):
z_score_list, _ = self.alg(self.input_list, inverse=False)
expected_list = [0.3244428422615252,
-1.9466570535691505,
0.3244428422615252,
-0.81110710565381261,
0.3244428422615252,
1.459992790176863,
0.3244428422615252]
for i in range(len(self.input_list)):
self.assertAlmostEqual(z_score_list[i], expected_list[i], places=6)
[docs] def test_z_score_inverse(self):
z_score_list, _ = self.alg(self.input_list, inverse=True)
expected_list = [-4.2177569493998259,
-1.9466570535691505,
-4.2177569493998259,
-3.0822070014844885,
-4.2177569493998259,
-5.3533068973151643,
-4.2177569493998259]
for i in range(len(self.input_list)):
self.assertAlmostEqual(z_score_list[i], expected_list[i], places=6)
[docs]class Log10TestCase(unittest.TestCase):
[docs] def setUp(self):
self.alg = TRANSFORMATION_ALGS["LOG10"]
[docs] def test_log10_all_positive_values(self):
input_list = [101249,
94082,
94062,
158661,
174568]
log10_list, _ = self.alg(input_list)
expected_list = [5.005391,
4.973507,
4.973414,
5.200470,
5.241965]
for i in range(len(input_list)):
self.assertAlmostEqual(log10_list[i], expected_list[i], places=6)
[docs] def test_log10_with_negative_values(self):
input_list = [101249,
94082,
-94062,
-158661,
174568]
self.assertRaises(ValueError, self.alg, input_list)
[docs] def test_log10_incrementing_by_one_case_no_zeros_found(self):
input_list = [101249,
94082,
94062,
158661,
174568]
log10_list, _ = self.alg(
input_list, variant_name='INCREMENT BY ONE IF ZEROS ARE FOUND')
expected_list = [5.005391,
4.973507,
4.973414,
5.200470,
5.241965]
for i in range(len(input_list)):
self.assertAlmostEqual(log10_list[i], expected_list[i], places=6)
[docs] def test_log10_incrementing_by_one_case_zeros_found(self):
input_list = [101249,
94082,
0,
0,
174568]
log10_list, _ = self.alg(
input_list, variant_name='INCREMENT BY ONE IF ZEROS ARE FOUND')
expected_list = [5.005395,
4.973511,
0,
0,
5.241967]
for i in range(len(input_list)):
self.assertAlmostEqual(log10_list[i], expected_list[i], places=6)
[docs] def test_log10_with_zeros_unchanged(self):
input_list = [101249,
94082,
0,
0,
174568]
log10_list, _ = self.alg(
input_list, variant_name='IGNORE ZEROS')
expected_list = [5.005391,
4.973507,
QPyNullVariant(float),
QPyNullVariant(float),
5.241965]
for i in range(len(input_list)):
self.assertAlmostEqual(log10_list[i], expected_list[i], places=6)
[docs]class QuadraticTestCase(unittest.TestCase):
[docs] def setUp(self):
self.alg = TRANSFORMATION_ALGS["QUADRATIC"]
self.input_list = [80089,
83696,
249586,
121421,
120813]
[docs] def test_quadratic_direct_increasing(self):
quadratic_list, _ = self.alg(
self.input_list, variant_name="INCREASING", inverse=False)
expected_list = [0.102969,
0.112452,
1.000000,
0.236672,
0.234308]
for i in range(len(self.input_list)):
self.assertAlmostEqual(
quadratic_list[i], expected_list[i], places=4)
[docs] def test_quadratic_direct_decreasing(self):
quadratic_list, _ = self.alg(
self.input_list, variant_name="DECREASING", inverse=False)
expected_list = [0.461194,
0.441774,
0.000000,
0.263693,
0.266201]
for i in range(len(self.input_list)):
self.assertAlmostEqual(
quadratic_list[i], expected_list[i], places=4)
[docs] def test_quadratic_inverse_increasing(self):
quadratic_list, _ = self.alg(
self.input_list, variant_name="INCREASING", inverse=True)
expected_list = [0.897032,
0.887548,
0.000000,
0.763328,
0.765692]
for i in range(len(self.input_list)):
self.assertAlmostEqual(
quadratic_list[i], expected_list[i], places=4)
[docs] def test_quadratic_inverse_decreasing(self):
quadratic_list, _ = self.alg(
self.input_list, variant_name="DECREASING", inverse=True)
expected_list = [0.538806,
0.558266,
1.000000,
0.736307,
0.733799]
for i in range(len(self.input_list)):
self.assertAlmostEqual(
quadratic_list[i], expected_list[i], places=4)
[docs]class SigmoidTestCase(unittest.TestCase):
[docs] def setUp(self):
self.alg = TRANSFORMATION_ALGS["SIGMOID"]
[docs] def test_sigmoid_direct(self):
input_list = [-1,
0,
1,
-0.3,
0.3]
sigmoid_list, _ = self.alg(input_list)
expected_list = [0.268941421,
0.5,
0.7310585790,
0.425557483,
0.574442517]
for i in range(len(input_list)):
self.assertAlmostEqual(
sigmoid_list[i], expected_list[i], places=4)
[docs] def test_sigmoid_inverse(self):
input_list = [0.268941421,
0.5,
0.7310585790,
0.425557483,
0.574442517]
sigmoid_list, _ = self.alg(input_list, inverse=True)
expected_list = [-1,
0,
1,
-0.3,
0.3]
for i in range(len(input_list)):
self.assertAlmostEqual(
sigmoid_list[i], expected_list[i], places=4)
[docs] def test_sigmoid_inverse_zero_division(self):
input_list = [0.268941421,
0.5,
1,
0.425557483,
0.574442517]
sigmoid_list, invalid_input_values = self.alg(input_list, inverse=True)
expected_list = [-1,
0,
QPyNullVariant(float),
-0.3,
0.3]
self.assertEqual(invalid_input_values, [1])
for i in range(len(input_list)):
if expected_list[i] != QPyNullVariant(float):
self.assertAlmostEqual(
sigmoid_list[i], expected_list[i], places=4)
if __name__ == '__main__':
unittest.main()