Esempio n. 1
0
 def test_as_abs_painters(self) -> None:
     canvas = Canvas.make_from((1, None, 1, '=', 2))
     rmem: WithAdjacentRelativePainters = RMem.make_instance(  # type: ignore[assignment]
         (WithAdjacentRelativePainters, LinearClarityWeight))
     p = (Match(1), Right(1), '+')
     self.assertCountEqual(rmem.as_abs_painters(canvas, p), [(1, 2, '+'),
                                                             (3, 4, '+')])
Esempio n. 2
0
 def testCountColumns(self) -> None:
     rmem = RMem.make_instance((WithCountColumns, RMemAbs))
     rmem.absorb_canvases(self.eqns)
     #print(rmem.niters)
     for cue in self.cues:
         #print(rmem.regenerate(cue))
         pass
Esempio n. 3
0
 def test_with_random_salt(self) -> None:
     rmem: WithRandomSalt = \
         RMem.make_instance((WithRandomSalt, RMemAbs)) # type: ignore[assignment]
     eqn = (1, '+', 1, '=', 2)
     self.assertEqual(
         len(as_tuple(rmem.prep_absorb(eqn))),
         15  # prepended rmem.nsalt random numbers
     )
     self.assertEqual(as_tuple(rmem.prep_regen(eqn)), (None, ) * 10 + eqn)
Esempio n. 4
0
    def test_with_sequential_salt(self) -> None:
        rmem: WithSequentialSalt = \
            RMem.make_instance((WithSequentialSalt, RMemAbs)) # type: ignore[assignment]

        eqn = (1, '+', 1, '=', 2)
        self.assertEqual(as_tuple(rmem.prep_absorb(eqn)),
                         (1, 2, 3, 4, 5) + eqn)
        self.assertEqual(as_tuple(rmem.prep_regen(eqn)),
                         (None, None, None, None, None) + eqn)
Esempio n. 5
0
 def make_rmem(self) -> RMem:
     if isinstance(self.rmem, RMem):
         return self.rmem
     else:
         if isinstance(self.rmem, tuple):
             rmem = RMem.make_instance(self.rmem, **self.kwargs)
         else:
             rmem = self.rmem.make_instance(**self.kwargs)
         rmem.absorb_canvases(self.make_initial_canvases())
         return rmem
Esempio n. 6
0
 def test_with_ndups(self) -> None:
     rmem: WithNDups = \
         RMem.make_instance((WithNDups, RMemAbs), ndups=3) # type: ignore[assignment]
     eqn = (1, '+', 1, '=', 2)
     self.assertEqual(rmem.prep_absorb(eqn), eqn * 4)
     self.assertEqual(rmem.prep_regen(eqn), (None, ) * 5 * 3 + eqn)