anchor.diff:  
           !
           ! Line version
  +        ! (the 'eps' in the line definition helps the test to pass in both single and double precision,
  +        !  otherwise round-off can shift the results).
           !
  -        lx = [-1.0_dp ,  5.5_dp,  5.5_dp]
  -        ly = [3.5_dp  ,  3.5_dp, 11.5_dp]
  +        lx = [-1.0_dp ,  5.5_dp,  5.5_dp] + eps
  +        ly = [3.5_dp  ,  3.5_dp, 11.5_dp] - eps
           lz = lx + ly
           grid = 0.0_dp
           call burn_line_into_grid(lx, ly, lz, grid, lower_left, upper_right)
  -        expected_grid = 0.0
  +        expected_grid = 0.0_dp
           expected_grid(1:6,4) = [4.12500000_dp, 4.93750000_dp,  5.75000000_dp, 7.37500000_dp, 8.18750000_dp, 9.00000000_dp]
           expected_grid(6,5:10) = [9.88888931_dp, 10.7777777_dp, 11.6666670_dp, 13.4444447_dp, 14.3333330_dp, 15.2222223_dp]
           if(all(abs(grid - expected_grid) < 1.0e-05_dp)) then
  
positive.code:         real(dp) :: expected_grid(10,10)
          real(dp) :: lx(3), ly(3), lz(3)
          integer(ip) :: i
  
          lower_left = [0.0, 0.0]
          upper_right = [10.0, 10.0]
  
          x = [1.6_dp, 2.2_dp, 3.6_dp, 8.7_dp, 9.9_dp]
          y = [0.5_dp, 1.3_dp, 2.6_dp, 3.7_dp, 4.8_dp]
  
negative.code:             print*, 'FAIL'
          end if
  
          !print*, 'grid(1:6, 4): ', grid(1:6, 4)
          !print*, 'expected_grid(1:6, 4): ', expected_grid(1:6, 4) 
          !print*, 'grid(6, 5:10): ', grid(6, 5:10)
          !print*, 'expected_grid(6, 5:10): ', expected_grid(6, 5:10) 
  
      end subroutine
  
  end module
  