From: Michael Orlitzky Date: Sun, 4 Sep 2011 00:11:02 +0000 (-0400) Subject: Move the Grid tests into the Grid module. X-Git-Tag: 0.0.1~167 X-Git-Url: https://gitweb.michael.orlitzky.com/?a=commitdiff_plain;h=bb8ee1121501e86c1971c83dd749da78f9b7abf5;p=spline3.git Move the Grid tests into the Grid module. --- diff --git a/src/Grid.hs b/src/Grid.hs index ba8ca20..2cf56ba 100644 --- a/src/Grid.hs +++ b/src/Grid.hs @@ -1,18 +1,35 @@ -- | The Grid module just contains the Grid type and two constructors -- for it. We hide the main Grid constructor because we don't want -- to allow instantiation of a grid with h <= 0. -module Grid +module Grid ( + grid_tests, + make_grid, + slow_tests, + zoom + ) where import Data.Array (Array, array, (!)) import qualified Data.Array.Repa as R -import Test.QuickCheck (Arbitrary(..), Gen, Positive(..)) +import Test.HUnit +import Test.Framework (Test, testGroup) +import Test.Framework.Providers.HUnit (testCase) +import Test.Framework.Providers.QuickCheck2 (testProperty) +import Test.QuickCheck (Arbitrary(..), Gen, Positive(..), choose) -import Cube (Cube(Cube), find_containing_tetrahedron) +import Assertions +import Comparisons +import Cube (Cube(Cube), + find_containing_tetrahedron, + tetrahedra, + tetrahedron0, + tetrahedron15) +import Examples import FunctionValues import Point (Point) import ScaleFactor -import Tetrahedron (polynomial) +import Tetrahedron (c, polynomial, v0, v1, v2, v3) +import ThreeDimensional import Values (Values3D, dims, empty3d, zoom_shape) @@ -44,11 +61,6 @@ make_grid grid_size values | otherwise = Grid grid_size values (cubes grid_size values) --- | Creates an empty grid with grid size 1. -empty_grid :: Grid -empty_grid = make_grid 1 empty3d - - -- | Returns a three-dimensional array of cubes centered on the grid -- points (h*i, h*j, h*k) with the appropriate 'FunctionValues'. cubes :: Double -> Values3D -> CubeGrid @@ -134,8 +146,8 @@ zoom_result g (sfx, sfy, sfz) (R.Z R.:. i R.:. j R.:. k) = j' = (fromIntegral j) / (fromIntegral sfy) - offset k' = (fromIntegral k) / (fromIntegral sfz) - offset p = (i', j', k') :: Point - c = find_containing_cube g p - t = find_containing_tetrahedron c p + cube = find_containing_cube g p + t = find_containing_tetrahedron cube p f = polynomial t @@ -148,3 +160,265 @@ zoom g scale_factor arr = function_values g (xsize, ysize, zsize) = dims arr transExtent = zoom_shape scale_factor + + + + +-- | Check all coefficients of tetrahedron0 belonging to the cube +-- centered on (1,1,1) with a grid constructed from the trilinear +-- values. See example one in the paper. +-- +-- We also verify that the four vertices on face0 of the cube are +-- in the correct location. +-- +trilinear_c0_t0_tests :: Test.Framework.Test +trilinear_c0_t0_tests = + testGroup "trilinear c0 t0" + [testGroup "coefficients" + [testCase "c0030 is correct" test_trilinear_c0030, + testCase "c0003 is correct" test_trilinear_c0003, + testCase "c0021 is correct" test_trilinear_c0021, + testCase "c0012 is correct" test_trilinear_c0012, + testCase "c0120 is correct" test_trilinear_c0120, + testCase "c0102 is correct" test_trilinear_c0102, + testCase "c0111 is correct" test_trilinear_c0111, + testCase "c0210 is correct" test_trilinear_c0210, + testCase "c0201 is correct" test_trilinear_c0201, + testCase "c0300 is correct" test_trilinear_c0300, + testCase "c1020 is correct" test_trilinear_c1020, + testCase "c1002 is correct" test_trilinear_c1002, + testCase "c1011 is correct" test_trilinear_c1011, + testCase "c1110 is correct" test_trilinear_c1110, + testCase "c1101 is correct" test_trilinear_c1101, + testCase "c1200 is correct" test_trilinear_c1200, + testCase "c2010 is correct" test_trilinear_c2010, + testCase "c2001 is correct" test_trilinear_c2001, + testCase "c2100 is correct" test_trilinear_c2100, + testCase "c3000 is correct" test_trilinear_c3000], + + testGroup "face0 vertices" + [testCase "v0 is correct" test_trilinear_f0_t0_v0, + testCase "v1 is correct" test_trilinear_f0_t0_v1, + testCase "v2 is correct" test_trilinear_f0_t0_v2, + testCase "v3 is correct" test_trilinear_f0_t0_v3] + ] + where + g = make_grid 1 trilinear + cube = cube_at g 1 1 1 + t = tetrahedron0 cube + + test_trilinear_c0030 :: Assertion + test_trilinear_c0030 = + assertAlmostEqual "c0030 is correct" (c t 0 0 3 0) (17/8) + + test_trilinear_c0003 :: Assertion + test_trilinear_c0003 = + assertAlmostEqual "c0003 is correct" (c t 0 0 0 3) (27/8) + + test_trilinear_c0021 :: Assertion + test_trilinear_c0021 = + assertAlmostEqual "c0021 is correct" (c t 0 0 2 1) (61/24) + + test_trilinear_c0012 :: Assertion + test_trilinear_c0012 = + assertAlmostEqual "c0012 is correct" (c t 0 0 1 2) (71/24) + + test_trilinear_c0120 :: Assertion + test_trilinear_c0120 = + assertAlmostEqual "c0120 is correct" (c t 0 1 2 0) (55/24) + + test_trilinear_c0102 :: Assertion + test_trilinear_c0102 = + assertAlmostEqual "c0102 is correct" (c t 0 1 0 2) (73/24) + + test_trilinear_c0111 :: Assertion + test_trilinear_c0111 = + assertAlmostEqual "c0111 is correct" (c t 0 1 1 1) (8/3) + + test_trilinear_c0210 :: Assertion + test_trilinear_c0210 = + assertAlmostEqual "c0210 is correct" (c t 0 2 1 0) (29/12) + + test_trilinear_c0201 :: Assertion + test_trilinear_c0201 = + assertAlmostEqual "c0201 is correct" (c t 0 2 0 1) (11/4) + + test_trilinear_c0300 :: Assertion + test_trilinear_c0300 = + assertAlmostEqual "c0300 is correct" (c t 0 3 0 0) (5/2) + + test_trilinear_c1020 :: Assertion + test_trilinear_c1020 = + assertAlmostEqual "c1020 is correct" (c t 1 0 2 0) (8/3) + + test_trilinear_c1002 :: Assertion + test_trilinear_c1002 = + assertAlmostEqual "c1002 is correct" (c t 1 0 0 2) (23/6) + + test_trilinear_c1011 :: Assertion + test_trilinear_c1011 = + assertAlmostEqual "c1011 is correct" (c t 1 0 1 1) (13/4) + + test_trilinear_c1110 :: Assertion + test_trilinear_c1110 = + assertAlmostEqual "c1110 is correct" (c t 1 1 1 0) (23/8) + + test_trilinear_c1101 :: Assertion + test_trilinear_c1101 = + assertAlmostEqual "c1101 is correct" (c t 1 1 0 1) (27/8) + + test_trilinear_c1200 :: Assertion + test_trilinear_c1200 = + assertAlmostEqual "c1200 is correct" (c t 1 2 0 0) 3 + + test_trilinear_c2010 :: Assertion + test_trilinear_c2010 = + assertAlmostEqual "c2010 is correct" (c t 2 0 1 0) (10/3) + + test_trilinear_c2001 :: Assertion + test_trilinear_c2001 = + assertAlmostEqual "c2001 is correct" (c t 2 0 0 1) 4 + + test_trilinear_c2100 :: Assertion + test_trilinear_c2100 = + assertAlmostEqual "c2100 is correct" (c t 2 1 0 0) (7/2) + + test_trilinear_c3000 :: Assertion + test_trilinear_c3000 = + assertAlmostEqual "c3000 is correct" (c t 3 0 0 0) 4 + + test_trilinear_f0_t0_v0 :: Assertion + test_trilinear_f0_t0_v0 = + assertEqual "v0 is correct" (v0 t) (1, 1, 1) + + test_trilinear_f0_t0_v1 :: Assertion + test_trilinear_f0_t0_v1 = + assertEqual "v1 is correct" (v1 t) (0.5, 1, 1) + + test_trilinear_f0_t0_v2 :: Assertion + test_trilinear_f0_t0_v2 = + assertEqual "v2 is correct" (v2 t) (0.5, 0.5, 1.5) + + test_trilinear_f0_t0_v3 :: Assertion + test_trilinear_f0_t0_v3 = + assertClose "v3 is correct" (v3 t) (0.5, 1.5, 1.5) + + +test_trilinear_reproduced :: Assertion +test_trilinear_reproduced = + assertTrue "trilinears are reproduced correctly" $ + and [p (i', j', k') ~= value_at trilinear i j k + | i <- [0..2], + j <- [0..2], + k <- [0..2], + t <- tetrahedra c0, + let p = polynomial t, + let i' = fromIntegral i, + let j' = fromIntegral j, + let k' = fromIntegral k] + where + g = make_grid 1 trilinear + c0 = cube_at g 1 1 1 + + +test_zeros_reproduced :: Assertion +test_zeros_reproduced = + assertTrue "the zero function is reproduced correctly" $ + and [p (i', j', k') ~= value_at zeros i j k + | i <- [0..2], + j <- [0..2], + k <- [0..2], + let i' = fromIntegral i, + let j' = fromIntegral j, + let k' = fromIntegral k] + where + g = make_grid 1 zeros + c0 = cube_at g 1 1 1 + t0 = tetrahedron0 c0 + p = polynomial t0 + + +-- | Make sure we can reproduce a 9x9x9 trilinear from the 3x3x3 one. +test_trilinear9x9x9_reproduced :: Assertion +test_trilinear9x9x9_reproduced = + assertTrue "trilinear 9x9x9 is reproduced correctly" $ + and [p (i', j', k') ~= value_at trilinear9x9x9 i j k + | i <- [0..8], + j <- [0..8], + k <- [0..8], + t <- tetrahedra c0, + let p = polynomial t, + let i' = (fromIntegral i) * 0.5, + let j' = (fromIntegral j) * 0.5, + let k' = (fromIntegral k) * 0.5] + where + g = make_grid 1 trilinear + c0 = cube_at g 1 1 1 + + +-- | The point 'p' in this test lies on the boundary of tetrahedra 12 and 15. +-- However, the 'contains_point' test fails due to some numerical innacuracy. +-- This bug should have been fixed by setting a positive tolerance level. +-- +-- Example from before the fix: +-- +-- > b0 (tetrahedron15 c) p +-- -3.4694469519536365e-18 +-- +test_tetrahedra_collision_sensitivity :: Assertion +test_tetrahedra_collision_sensitivity = + assertTrue "tetrahedron collision tests isn't too sensitive" $ + contains_point t15 p + where + g = make_grid 1 naturals_1d + cube = cube_at g 0 17 1 + p = (0, 16.75, 0.5) :: Point + t15 = tetrahedron15 cube + + +prop_cube_indices_never_go_out_of_bounds :: Grid -> Gen Bool +prop_cube_indices_never_go_out_of_bounds g = + do + let delta = Grid.h g + let coordmin = negate (delta/2) + + let (xsize, ysize, zsize) = dims $ function_values g + let xmax = delta*(fromIntegral xsize) - (delta/2) + let ymax = delta*(fromIntegral ysize) - (delta/2) + let zmax = delta*(fromIntegral zsize) - (delta/2) + + x <- choose (coordmin, xmax) + y <- choose (coordmin, ymax) + z <- choose (coordmin, zmax) + + let idx_x = calculate_containing_cube_coordinate g x + let idx_y = calculate_containing_cube_coordinate g y + let idx_z = calculate_containing_cube_coordinate g z + + return $ + idx_x >= 0 && + idx_x <= xsize - 1 && + idx_y >= 0 && + idx_y <= ysize - 1 && + idx_z >= 0 && + idx_z <= zsize - 1 + + + +grid_tests :: Test.Framework.Test +grid_tests = + testGroup "Grid Tests" [ + trilinear_c0_t0_tests, + testCase "tetrahedra collision test isn't too sensitive" + test_tetrahedra_collision_sensitivity, + testCase "trilinear reproduced" test_trilinear_reproduced, + testCase "zeros reproduced" test_zeros_reproduced ] + + +-- Do the slow tests last so we can stop paying attention. +slow_tests :: Test.Framework.Test +slow_tests = + testGroup "Slow Tests" [ + testProperty "cube indices within bounds" + prop_cube_indices_never_go_out_of_bounds, + testCase "trilinear9x9x9 reproduced" test_trilinear9x9x9_reproduced ] diff --git a/src/Tests/Grid.hs b/src/Tests/Grid.hs deleted file mode 100644 index a8bc685..0000000 --- a/src/Tests/Grid.hs +++ /dev/null @@ -1,260 +0,0 @@ -module Tests.Grid -where - -import Test.Framework (Test, testGroup) -import Test.Framework.Providers.HUnit (testCase) -import Test.HUnit -import Test.QuickCheck - - -import Assertions -import Comparisons -import Cube hiding (i, j, k) -import Examples -import FunctionValues (value_at) -import Grid -import Point (Point) -import Tetrahedron -import ThreeDimensional -import Values (dims) - - --- | Check all coefficients of tetrahedron0 belonging to the cube --- centered on (1,1,1) with a grid constructed from the trilinear --- values. See example one in the paper. --- --- We also verify that the four vertices on face0 of the cube are --- in the correct location. --- -trilinear_c0_t0_tests :: Test.Framework.Test -trilinear_c0_t0_tests = - testGroup "trilinear c0 t0" - [testGroup "coefficients" - [testCase "c0030 is correct" test_trilinear_c0030, - testCase "c0003 is correct" test_trilinear_c0003, - testCase "c0021 is correct" test_trilinear_c0021, - testCase "c0012 is correct" test_trilinear_c0012, - testCase "c0120 is correct" test_trilinear_c0120, - testCase "c0102 is correct" test_trilinear_c0102, - testCase "c0111 is correct" test_trilinear_c0111, - testCase "c0210 is correct" test_trilinear_c0210, - testCase "c0201 is correct" test_trilinear_c0201, - testCase "c0300 is correct" test_trilinear_c0300, - testCase "c1020 is correct" test_trilinear_c1020, - testCase "c1002 is correct" test_trilinear_c1002, - testCase "c1011 is correct" test_trilinear_c1011, - testCase "c1110 is correct" test_trilinear_c1110, - testCase "c1101 is correct" test_trilinear_c1101, - testCase "c1200 is correct" test_trilinear_c1200, - testCase "c2010 is correct" test_trilinear_c2010, - testCase "c2001 is correct" test_trilinear_c2001, - testCase "c2100 is correct" test_trilinear_c2100, - testCase "c3000 is correct" test_trilinear_c3000], - - testGroup "face0 vertices" - [testCase "v0 is correct" test_trilinear_f0_t0_v0, - testCase "v1 is correct" test_trilinear_f0_t0_v1, - testCase "v2 is correct" test_trilinear_f0_t0_v2, - testCase "v3 is correct" test_trilinear_f0_t0_v3] - ] - where - g = make_grid 1 trilinear - cube = cube_at g 1 1 1 - t = tetrahedron0 cube - - test_trilinear_c0030 :: Assertion - test_trilinear_c0030 = - assertAlmostEqual "c0030 is correct" (c t 0 0 3 0) (17/8) - - test_trilinear_c0003 :: Assertion - test_trilinear_c0003 = - assertAlmostEqual "c0003 is correct" (c t 0 0 0 3) (27/8) - - test_trilinear_c0021 :: Assertion - test_trilinear_c0021 = - assertAlmostEqual "c0021 is correct" (c t 0 0 2 1) (61/24) - - test_trilinear_c0012 :: Assertion - test_trilinear_c0012 = - assertAlmostEqual "c0012 is correct" (c t 0 0 1 2) (71/24) - - test_trilinear_c0120 :: Assertion - test_trilinear_c0120 = - assertAlmostEqual "c0120 is correct" (c t 0 1 2 0) (55/24) - - test_trilinear_c0102 :: Assertion - test_trilinear_c0102 = - assertAlmostEqual "c0102 is correct" (c t 0 1 0 2) (73/24) - - test_trilinear_c0111 :: Assertion - test_trilinear_c0111 = - assertAlmostEqual "c0111 is correct" (c t 0 1 1 1) (8/3) - - test_trilinear_c0210 :: Assertion - test_trilinear_c0210 = - assertAlmostEqual "c0210 is correct" (c t 0 2 1 0) (29/12) - - test_trilinear_c0201 :: Assertion - test_trilinear_c0201 = - assertAlmostEqual "c0201 is correct" (c t 0 2 0 1) (11/4) - - test_trilinear_c0300 :: Assertion - test_trilinear_c0300 = - assertAlmostEqual "c0300 is correct" (c t 0 3 0 0) (5/2) - - test_trilinear_c1020 :: Assertion - test_trilinear_c1020 = - assertAlmostEqual "c1020 is correct" (c t 1 0 2 0) (8/3) - - test_trilinear_c1002 :: Assertion - test_trilinear_c1002 = - assertAlmostEqual "c1002 is correct" (c t 1 0 0 2) (23/6) - - test_trilinear_c1011 :: Assertion - test_trilinear_c1011 = - assertAlmostEqual "c1011 is correct" (c t 1 0 1 1) (13/4) - - test_trilinear_c1110 :: Assertion - test_trilinear_c1110 = - assertAlmostEqual "c1110 is correct" (c t 1 1 1 0) (23/8) - - test_trilinear_c1101 :: Assertion - test_trilinear_c1101 = - assertAlmostEqual "c1101 is correct" (c t 1 1 0 1) (27/8) - - test_trilinear_c1200 :: Assertion - test_trilinear_c1200 = - assertAlmostEqual "c1200 is correct" (c t 1 2 0 0) 3 - - test_trilinear_c2010 :: Assertion - test_trilinear_c2010 = - assertAlmostEqual "c2010 is correct" (c t 2 0 1 0) (10/3) - - test_trilinear_c2001 :: Assertion - test_trilinear_c2001 = - assertAlmostEqual "c2001 is correct" (c t 2 0 0 1) 4 - - test_trilinear_c2100 :: Assertion - test_trilinear_c2100 = - assertAlmostEqual "c2100 is correct" (c t 2 1 0 0) (7/2) - - test_trilinear_c3000 :: Assertion - test_trilinear_c3000 = - assertAlmostEqual "c3000 is correct" (c t 3 0 0 0) 4 - - test_trilinear_f0_t0_v0 :: Assertion - test_trilinear_f0_t0_v0 = - assertEqual "v0 is correct" (v0 t) (1, 1, 1) - - test_trilinear_f0_t0_v1 :: Assertion - test_trilinear_f0_t0_v1 = - assertEqual "v1 is correct" (v1 t) (0.5, 1, 1) - - test_trilinear_f0_t0_v2 :: Assertion - test_trilinear_f0_t0_v2 = - assertEqual "v2 is correct" (v2 t) (0.5, 0.5, 1.5) - - test_trilinear_f0_t0_v3 :: Assertion - test_trilinear_f0_t0_v3 = - assertClose "v3 is correct" (v3 t) (0.5, 1.5, 1.5) - - -test_trilinear_reproduced :: Assertion -test_trilinear_reproduced = - assertTrue "trilinears are reproduced correctly" $ - and [p (i', j', k') ~= value_at trilinear i j k - | i <- [0..2], - j <- [0..2], - k <- [0..2], - t <- tetrahedra c0, - let p = polynomial t, - let i' = fromIntegral i, - let j' = fromIntegral j, - let k' = fromIntegral k] - where - g = make_grid 1 trilinear - c0 = cube_at g 1 1 1 - - -test_zeros_reproduced :: Assertion -test_zeros_reproduced = - assertTrue "the zero function is reproduced correctly" $ - and [p (i', j', k') ~= value_at zeros i j k - | i <- [0..2], - j <- [0..2], - k <- [0..2], - let i' = fromIntegral i, - let j' = fromIntegral j, - let k' = fromIntegral k] - where - g = make_grid 1 zeros - c0 = cube_at g 1 1 1 - t0 = tetrahedron0 c0 - p = polynomial t0 - - --- | Make sure we can reproduce a 9x9x9 trilinear from the 3x3x3 one. -test_trilinear9x9x9_reproduced :: Assertion -test_trilinear9x9x9_reproduced = - assertTrue "trilinear 9x9x9 is reproduced correctly" $ - and [p (i', j', k') ~= value_at trilinear9x9x9 i j k - | i <- [0..8], - j <- [0..8], - k <- [0..8], - t <- tetrahedra c0, - let p = polynomial t, - let i' = (fromIntegral i) * 0.5, - let j' = (fromIntegral j) * 0.5, - let k' = (fromIntegral k) * 0.5] - where - g = make_grid 1 trilinear - c0 = cube_at g 1 1 1 - - --- | The point 'p' in this test lies on the boundary of tetrahedra 12 and 15. --- However, the 'contains_point' test fails due to some numerical innacuracy. --- This bug should have been fixed by setting a positive tolerance level. --- --- Example from before the fix: --- --- > b0 (tetrahedron15 c) p --- -3.4694469519536365e-18 --- -test_tetrahedra_collision_sensitivity :: Assertion -test_tetrahedra_collision_sensitivity = - assertTrue "tetrahedron collision tests isn't too sensitive" $ - contains_point t15 p - where - g = make_grid 1 naturals_1d - c = cube_at g 0 17 1 - p = (0, 16.75, 0.5) :: Point - t15 = tetrahedron15 c - - -prop_cube_indices_never_go_out_of_bounds :: Grid -> Gen Bool -prop_cube_indices_never_go_out_of_bounds g = - do - let delta = Grid.h g - let coordmin = negate (delta/2) - - let (xsize, ysize, zsize) = dims $ function_values g - let xmax = delta*(fromIntegral xsize) - (delta/2) - let ymax = delta*(fromIntegral ysize) - (delta/2) - let zmax = delta*(fromIntegral zsize) - (delta/2) - - x <- choose (coordmin, xmax) - y <- choose (coordmin, ymax) - z <- choose (coordmin, zmax) - - let p = (x,y,z) :: Point - let idx_x = calculate_containing_cube_coordinate g x - let idx_y = calculate_containing_cube_coordinate g y - let idx_z = calculate_containing_cube_coordinate g z - - return $ - idx_x >= 0 && - idx_x <= xsize - 1 && - idx_y >= 0 && - idx_y <= ysize - 1 && - idx_z >= 0 && - idx_z <= zsize - 1 diff --git a/test/TestSuite.hs b/test/TestSuite.hs index 25057ef..6c4b4d9 100644 --- a/test/TestSuite.hs +++ b/test/TestSuite.hs @@ -11,9 +11,9 @@ import Test.QuickCheck (Testable ()) import Cardinal (cardinal_tests, cardinal_properties) import FunctionValues (function_values_tests, function_values_properties) +import Grid (grid_tests, slow_tests) import Misc (misc_tests, misc_properties) import Tests.Cube as TC -import Tests.Grid import Tests.Tetrahedron as TT main :: IO () @@ -27,14 +27,6 @@ tc = testCase -grid_tests :: Test.Framework.Test -grid_tests = - testGroup "Grid Tests" [ - trilinear_c0_t0_tests, - tc "tetrahedra collision test isn't too sensitive" - test_tetrahedra_collision_sensitivity, - tc "trilinear reproduced" test_trilinear_reproduced, - tc "zeros reproduced" test_zeros_reproduced ] tetrahedron_tests :: Test.Framework.Test @@ -162,14 +154,6 @@ tetrahedron_properties = $ prop_swapping_vertices_doesnt_affect_coefficients4 ] --- Do the slow tests last so we can stop paying attention. -slow_tests :: Test.Framework.Test -slow_tests = - testGroup "Slow Tests" [ - tp "cube indices within bounds" prop_cube_indices_never_go_out_of_bounds, - tc "trilinear9x9x9 reproduced" test_trilinear9x9x9_reproduced ] - - tests :: [Test.Framework.Test] tests = [ cardinal_tests, function_values_tests,