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"))
