I unbroke the negations (accidentally drove the call one frame too de…

…ep in previous commit)

datascience/predicates.py

@@ -153,52 +153,52 @@ def contained_in(superstring):
     @staticmethod
     def not_equal_to(y):
         """Is not equal to y"""
-        return _not(are.equal_to)
+        return -(are.equal_to(y))
 
     @staticmethod
     def not_above(y):
         """Is not above y"""
-        return are.below_or_equal_to
+        return are.below_or_equal_to(y)
 
     @staticmethod
     def not_below(y):
         """Is not below y"""
-        return are.above_or_equal_to
+        return are.above_or_equal_to(y)
 
     @staticmethod
     def not_below_or_equal_to(y):
         """Is neither below y nor equal to y"""
-        return are.above
+        return are.above(y)
 
     @staticmethod
     def not_above_or_equal_to(y):
         """Is neither above y nor equal to y"""
-        return are.below
+        return are.below(y)
 
     @staticmethod
     def not_strictly_between(y, z):
         """Is equal to y or equal to z or less than y or greater than z"""
-        return  _not(are.strictly_between)
+        return  -(are.strictly_between(y,z))
 
     @staticmethod
     def not_between(y, z):
         """Is equal to y or less than y or greater than z"""
-        return _not(are.between)
+        return -(are.between(y,z))
 
     @staticmethod
     def not_between_or_equal_to(y,z):
         """Is less than y or greater than z"""
-        return _not(are.between_or_equal_to)
+        return -(are.between_or_equal_to(y,z))
 
     @staticmethod
     def not_containing(substring):
         """A string that does not contain substring""" 
-        return _not(are.containing)
+        return -(are.containing(substring))
 
     @staticmethod
     def not_contained_in(superstring):
         """A string that is not contained within the superstring"""
-        return _not(are.contained_in)
+        return -(are.contained_in(superstring))
 ###############
 # Combination #
 ###############