# ConsistentAlgebrae: testing algebrae consistency¶

This class test for any object conformance with linear algebrae rules

class vector_dict.ConsistentAlgebrae.ConsistentAlgebrae(**kw)

test wether an addition for two object is consistant

__init__(**kw)

only method really callable. Arguments :

• neutral : neutral element of addition for the object ;
• scalar : real, float, or complex (normaly anything that is 1D, and follow algebraic rules);
• one : an element to test
• other : other element to test
optionnal :
• other_scalar : real, float, or complex (normaly anything that is 1D, and follow algebraic rules);
• context : default “print” make it verbose ;
• collect_values : default lambda x : x, if testing for conservation a lambda fonction for getting the values

## How to use it¶

```    if cmd_folder not in sys.path:
sys.path.insert(0, cmd_folder)

try:
from numpy import array as array

ConsistentAlgebrae(
neutral=array([0, 0, 0]),
one=array([1, 2, 3]),
another=array([5, 2, 3]),
other=array([3, 4, -1]),
equal=lambda left, right: (right == left).all(),
)
except Exception as e:
print "only lamers dont use numpy"

ConsistentAlgebrae(
neutral=0,
one=1,
other=2,
another=3

)

ConsistentAlgebrae(
neutral=[],
one=[1],
other=[2],
another=[42]
)

ConsistentAlgebrae(
neutral="",
one="1",
other="2",
another="4"
)

ConsistentAlgebrae(
neutral=VectorDict(int, {}),
one=VectorDict(int, {"one": 1, "one_and_two": 3}),
other=VectorDict(int, {"one_and_two": - 1, "two": 2}),
another=VectorDict(int, {"one": 3, 'two':  2, "three": 1}),
collect_values=lambda x: x.values()
)

one = VectorDict(int, {"one": 1, "one_and_two": 12})
other = VectorDict(int, {"one_and_two": - 9, "two": 2})

print "just for fun \n\t%r\n\t+\n\t%r\n\t=\n\t%r" % (one, other, one + other)
```

## expected results¶

```**************************************************

testing for  'ndarray' class

a = array([1, 2, 3])
b = array([ 3,  4, -1])
c = array([5, 2, 3])
an_int = 3
other_scalar = 4
neutral element for addition is array([0, 0, 0])

**************************************************

test #1
a + b = b + a
test_commutativity is ok

test #2
a + neutral = a
test_neutral is ok

test #3
1 * a = a
test_multiplicative_identity is ok

test #4
an_int * a = a + ... + a (n times )
test_scalar_multiplication is ok

test #5
an_int * a = a * an_int
test_scalar_commutativity is ok

test #6
-a = -1 * a
test_negative is ok

test #7
( an_int *  other_scalar ) * a = an_int ( other_scalar * a )
test_associativity_scalar_multiplication is ok

test #8
( an_int + other_scalar ) a = an_int * a  + other_scalar * a
test_multiply_scalar_associativity is ok

test #9
( a + b )  + c  = a + ( b + c )
test_associativity is ok

test #10
a - b = a + ( -1 * b)
test_substraction is ok

test #11
an_int ( a + b) = an_int *a + an_int * b
test_distributivity is ok

test #12
sum of the parts = sum of the total
conservation is ok

test #13
sum of the differences == differences of the sum
conservation_neg is ok
**************************************************

<type 'numpy.ndarray'> respects the algebraic acceptation of addition

**************************************************

**************************************************

testing for  'int' class

a = 1
b = 2
c = 3
an_int = 3
other_scalar = 4
neutral element for addition is 0

**************************************************

test #1
a + b = b + a
test_commutativity is ok

test #2
a + neutral = a
test_neutral is ok

test #3
1 * a = a
test_multiplicative_identity is ok

test #4
an_int * a = a + ... + a (n times )
test_scalar_multiplication is ok

test #5
an_int * a = a * an_int
test_scalar_commutativity is ok

test #6
-a = -1 * a
test_negative is ok

test #7
( an_int *  other_scalar ) * a = an_int ( other_scalar * a )
test_associativity_scalar_multiplication is ok

test #8
( an_int + other_scalar ) a = an_int * a  + other_scalar * a
test_multiply_scalar_associativity is ok

test #9
( a + b )  + c  = a + ( b + c )
test_associativity is ok

test #10
a - b = a + ( -1 * b)
test_substraction is ok

test #11
an_int ( a + b) = an_int *a + an_int * b
test_distributivity is ok
**************************************************

<type 'int'> respects the algebraic acceptation of addition

**************************************************

**************************************************

testing for  'list' class

a = [1]
b = [2]
c = [42]
an_int = 3
other_scalar = 4
neutral element for addition is []

**************************************************

test #1
a + b = b + a
test_commutativity is ko
[2, 1] != [1, 2]

test #2
a + neutral = a
test_neutral is ok

test #3
1 * a = a
test_multiplicative_identity is ok

test #4
an_int * a = a + ... + a (n times )
test_scalar_multiplication is ok

test #5
an_int * a = a * an_int
test_scalar_commutativity is ok

test #6
-a = -1 * a
test_negative is Arg : AttributeError("'list' object has no attribute '__neg__'",)

test #7
( an_int *  other_scalar ) * a = an_int ( other_scalar * a )
test_associativity_scalar_multiplication is ok

test #8
( an_int + other_scalar ) a = an_int * a  + other_scalar * a
test_multiply_scalar_associativity is ok

test #9
( a + b )  + c  = a + ( b + c )
test_associativity is ok

test #10
a - b = a + ( -1 * b)
test_substraction is Arg : TypeError("unsupported operand type(s) for -: 'list' and 'list'",)

test #11
an_int ( a + b) = an_int *a + an_int * b
test_distributivity is ko
[1, 2, 1, 2, 1, 2] != [1, 1, 1, 2, 2, 2]

test #12
sum of the parts = sum of the total
conservation is ok

test #13
sum of the differences == differences of the sum
conservation_neg is Arg : TypeError("unsupported operand type(s) for -: 'list' and 'list'",)
**************************************************

<type 'list'> follows the dutch logic

**************************************************

**************************************************

testing for  'str' class

a = '1'
b = '2'
c = '4'
an_int = 3
other_scalar = 4
neutral element for addition is ''

**************************************************

test #1
a + b = b + a
test_commutativity is ko
'21' != '12'

test #2
a + neutral = a
test_neutral is ok

test #3
1 * a = a
test_multiplicative_identity is ok

test #4
an_int * a = a + ... + a (n times )
test_scalar_multiplication is ok

test #5
an_int * a = a * an_int
test_scalar_commutativity is ok

test #6
-a = -1 * a
test_negative is Arg : AttributeError("'str' object has no attribute '__neg__'",)

test #7
( an_int *  other_scalar ) * a = an_int ( other_scalar * a )
test_associativity_scalar_multiplication is ok

test #8
( an_int + other_scalar ) a = an_int * a  + other_scalar * a
test_multiply_scalar_associativity is ok

test #9
( a + b )  + c  = a + ( b + c )
test_associativity is ok

test #10
a - b = a + ( -1 * b)
test_substraction is Arg : TypeError("unsupported operand type(s) for -: 'str' and 'str'",)

test #11
an_int ( a + b) = an_int *a + an_int * b
test_distributivity is ko
'121212' != '111222'
**************************************************

<type 'str'> follows the dutch logic

**************************************************

**************************************************

testing for  'AccuDict' class

a = defaultdict(<type 'int'>, {'one_and_two': 3, 'one': 1})
b = defaultdict(<type 'int'>, {'two': 2, 'one_and_two': -1})
c = defaultdict(<type 'int'>, {'one': 3, 'three': 1, 'two': 2})
an_int = 3
other_scalar = 4
neutral element for addition is defaultdict(<type 'int'>, {})

**************************************************

test #1
a + b = b + a
test_commutativity is ok

test #2
a + neutral = a
test_neutral is ok

test #3
1 * a = a
test_multiplicative_identity is ok

test #4
an_int * a = a + ... + a (n times )
test_scalar_multiplication is ok

test #5
an_int * a = a * an_int
test_scalar_commutativity is ok

test #6
-a = -1 * a
test_negative is ok

test #7
( an_int *  other_scalar ) * a = an_int ( other_scalar * a )
test_associativity_scalar_multiplication is ok

test #8
( an_int + other_scalar ) a = an_int * a  + other_scalar * a
test_multiply_scalar_associativity is ok

test #9
( a + b )  + c  = a + ( b + c )
test_associativity is ok

test #10
a - b = a + ( -1 * b)
test_substraction is ok

test #11
an_int ( a + b) = an_int *a + an_int * b
test_distributivity is ok

test #12
sum of the parts = sum of the total
conservation is ok

test #13
sum of the differences == differences of the sum
conservation_neg is ok
**************************************************

<class 'accu_dict.AccuDict'> respects the algebraic acceptation of addition

**************************************************
just for fun
defaultdict(<type 'int'>, {'one_and_two': 12, 'one': 1})
+
defaultdict(<type 'int'>, {'two': 2, 'one_and_two': -9})
=
defaultdict(<type 'int'>, {'two': 2, 'one_and_two': 3, 'one': 1})
```