def test_boolean_vertex_value_is_a_numpy_array() -> None: ndarray = np.array([[True, True], [False, True]]) vertex = Const(ndarray) value = vertex.get_value() assert type(value) == np.ndarray assert value.dtype == np.bool_ assert (value == ndarray).all()
def test_int_vertex_value_is_a_numpy_array() -> None: ndarray = np.array([[1, 2], [3, 4]]) vertex = Const(ndarray) value = vertex.get_value() assert type(value) == np.ndarray assert value.dtype == np.int64 or value.dtype == np.int32 assert (value == ndarray).all()
def test_float_vertex_value_is_a_numpy_array() -> None: ndarray = np.array([[1., 2.], [3., 4.]]) vertex = Const(ndarray) value = vertex.get_value() assert type(value) == np.ndarray assert value.dtype == np.float64 assert (value == ndarray).all()
def test_const_takes_ndarray(arr: List[List[primitive_types]], expected_java_class: str) -> None: ndarray = np.array(arr) v = Const(ndarray) assert_java_class(v, expected_java_class) assert np.array_equal(v.get_value(), ndarray)
def test_scalar_vertex_value_is_a_numpy_array() -> None: scalar = 1. vertex = Const(scalar) value = vertex.get_value() assert type(value) == numpy_types assert value.shape == () assert value.dtype == float assert value == scalar
def test_simple_binary_op_description() -> None: two = Const(2.0) three = Const(3.0) three.set_label("Three") pred1 = two >= three assert create_description(pred1) == "This Vertex = Const(2.0) >= Three"
def test_const_takes_ndarray_of_rank_one() -> None: ndarray = np.array([1, 2]) v = Const(ndarray) assert ndarray.shape == (2, ) assert v.get_value().shape == (2, ) assert np.array_equal(v.get_value().flatten(), ndarray.flatten())
def test_const_takes_panda_dataframe(data: List[List[primitive_types]], expected_java_class: str) -> None: dataframe = pd.DataFrame(columns=['A', 'B'], data=data) v = Const(dataframe) assert_java_class(v, expected_java_class) vertex_value = v.get_value() dataframe_value = dataframe.values assert np.array_equal(vertex_value, dataframe_value)
def test_simple_if_vertex_description_created_correctly() -> None: predicate = Const(False) three = Const(3.0) four = Const(4.0) three.set_label("Three") four.set_label("Four") result = If(predicate, three, four) assert create_description( result) == "This Vertex = Const(false) ? Three : Four"
def test_const_takes_panda_series(data: List[primitive_types], expected_java_class: str) -> None: series = pd.Series(data) v = Const(series) assert_java_class(v, expected_java_class) vertex_value = v.get_value() series_value = series.values assert len(vertex_value) == len(series_value) assert vertex_value.shape == (2, ) assert series_value.shape == (2, ) assert np.array_equal(vertex_value.flatten(), series_value.flatten())
def test_const_does_not_take_generic(generic) -> None: with pytest.raises( NotImplementedError, match= r"Argument t must be either an ndarray or an instance of numbers.Number. Was given {} instead" .format(type(generic))): Const(generic)
def test_can_do_compound_operations() -> None: v1 = Const(np.array([[2., 3.], [5., 7.]])) v2 = np.array([[11., 13.], [17., 19.]]) v3 = 23. result = v1 * v2 - v2 / v1 + v3 * v2 assert (result.get_value() == np.array([[269.5, 333.6666666666667], [472.6, 567.2857142857142]])).all()
def test_can_pass_vertex_to_vertex(jvm_view: JVMView) -> None: mu = Gaussian(0., 1.) gaussian = Vertex(jvm_view.GaussianVertex, "gaussian", mu, Const(1.)) sample = gaussian.sample() assert type(sample) == numpy_types assert sample.shape == () assert sample.dtype == float
def test_const_does_not_take_generic_ndarray(generic) -> None: ndarray = np.array([[generic]]) with pytest.raises( NotImplementedError, match= r"Generic types in an ndarray are not supported. Was given object" ): Const(ndarray)
def test_const_does_not_take_generic(generic) -> None: with pytest.raises(NotImplementedError) as excinfo: Const(generic) assert str( excinfo.value ) == "Argument t must be either an ndarray or an instance of numbers.Number. Was given {} instead".format( type(generic))
def test_const_does_not_take_generic_ndarray(generic) -> None: ndarray = np.array([[generic]]) with pytest.raises(NotImplementedError) as excinfo: Const(ndarray) assert str( excinfo.value ) == "Generic types in an ndarray are not supported. Was given object"
def test_can_do_abs() -> None: v = Const(np.array([[2., -3.], [-5., 7.]])) expected = np.array([[2., 3.], [5., 7.]]) result = abs(v) assert isinstance(result, Vertex) assert (result.get_value() == expected).all()
def test_proxy_vertices_are_correctly_typed() -> None: initial_state: Optional[Dict[str, vertex_constructor_param_types]] = { "double_vertex": Const(1.0), "int_vertex": Const(1), "bool_vertex": Const(True) } def factory(sequence_item: SequenceItem): previous_double_vertex = sequence_item.add_double_proxy_for( "double_vertex") assert previous_double_vertex._class == "DoubleProxyVertex" assert type(previous_double_vertex) == Double previous_int_vertex = sequence_item.add_integer_proxy_for("int_vertex") assert previous_int_vertex._class == "IntegerProxyVertex" assert type(previous_int_vertex) == Integer previous_bool_vertex = sequence_item.add_boolean_proxy_for( "bool_vertex") assert previous_bool_vertex._class == "BooleanProxyVertex" assert type(previous_bool_vertex) == Boolean double_vertex = previous_int_vertex + 1.0 double_vertex.set_label("double_vertex") sequence_item.add(double_vertex) assert double_vertex._class == "AdditionVertex" assert type(double_vertex) == Double int_vertex = previous_int_vertex + 1 int_vertex.set_label("int_vertex") sequence_item.add(int_vertex) assert int_vertex._class == "AdditionVertex" assert type(int_vertex) == Integer bool_vertex = previous_bool_vertex == True bool_vertex.set_label("bool_vertex") sequence_item.add(bool_vertex) assert bool_vertex._class == "EqualsVertex" assert type(bool_vertex) == Boolean sequence = Sequence(count=5, factories=factory, initial_state=initial_state)
def test_can_do_ceil() -> None: v = Const(np.array([[4.4, 4.5, 5.5, 6.6], [-4.4, -4.5, -5.5, -6.6]])) expected = np.array([[5., 5., 6., 7.], [-4., -4., -5., -6.]]) result = math.ceil(v) assert isinstance(result, Vertex) assert ( result. # type: ignore # see https://stackoverflow.com/questions/53483596/type-annotations-for-floor-and-ceil get_value() == expected).all()
def test_can_do_round() -> None: v = Const(np.array([[4.4, 4.5, 5.5, 6.6], [-4.4, -4.5, -5.5, -6.6]])) expected = np.array([[4., 5., 6., 7.], [-4., -5., -6., -7.]]) result = round(v) assert isinstance(result, Vertex) assert ( result . # type: ignore # see https://stackoverflow.com/questions/53481887/looking-for-a-working-example-of-supportsround get_value() == expected).all()
def add_time(current): rho_v = Const(rho) (xt, yt, zt) = current x_tplus1 = xt * Const(1. - time_step * sigma) + (yt * Const(time_step * sigma)) y_tplus1 = yt * Const(1. - time_step) + (xt * (rho_v - zt) * Const(time_step)) z_tplus1 = zt * Const(1. - time_step * beta) + (xt * yt * Const(time_step)) return (x_tplus1, y_tplus1, z_tplus1)
def factory(sequence_item): x = sequence_item.add_double_proxy_for(x_label) x_out = x * Const(2.0) x_out.set_label(x_label) sequence_item.add(x_out)
def test_const_takes_num(num: Union[primitive_types, numpy_types], expected_java_class: str) -> None: v = Const(num) assert_java_class(v, expected_java_class) assert v.get_value() == num
def test_const_takes_label() -> None: label = "const" v = Const(3, label=label) assert v.get_label() == label
def test_const_takes_none_label() -> None: v = Const(3, label=None) assert v.get_label() == None
def test_can_pass_array_to_vertex(jvm_view: JVMView) -> None: gaussian = Vertex(jvm_view.GaussianVertex, "gaussian", [3, 3], Const(0.), Const(1.)) sample = gaussian.sample() assert sample.shape == (3, 3)
def test_const_does_not_take_empty_ndarray() -> None: ndarray = np.array([]) with pytest.raises(ValueError) as excinfo: Const(ndarray) assert str(excinfo.value) == "Cannot infer type because array is empty"
def test_rounding_is_only_supported_to_zero_digits() -> None: with pytest.raises(NotImplementedError, match=r"Keanu only supports rounding to 0 digits"): v = Const(1.55) round(v, 1)
import pytest import math from keanu.vartypes import numpy_types from keanu.vertex import Const from keanu.vertex.base import Vertex, Double, Integer, Boolean, is_floating_type from keanu.vertex import generated vertex_types = Union[Double, Boolean, Integer] ### Comparisons # yapf: disable @pytest.mark.parametrize("lhs, rhs, expected_result", [ (Const(np.array([1., 2.])), Const(np.array([1., -1.])), np.array([True, False])), (Const(np.array([1., 2.])), np.array([1., -1.]) , np.array([True, False])), (Const(np.array([1. ])), 1. , np.array([True ])), (Const(np.array([ 2.])), 1. , np.array([ False])), (Const(np.array([1., 2.])), Const(np.array([1. ])), np.array([True, False])), ]) # yapf: enable def test_can_do_equal_to(lhs: Vertex, rhs: Union[Vertex, numpy_types, float], expected_result: numpy_types) -> None: result = lhs == rhs assert isinstance(result, Vertex) assert (result.get_value() == expected_result).all() result = rhs == lhs # type: ignore # see https://github.com/python/mypy/issues/5951 assert isinstance(result, Vertex) assert (result.get_value() == expected_result).all()
def create_vertices(item: SequenceItem, point: Dict[str, Any]) -> None: item.add(Const(point["x"], label="x")) item.add(Const(point["y"], label="y"))