def _make(_cls, cls: Type[Q], rmem: RMemFuncs, c: Dict[Func,
int]) -> Q:
return cls(
rmem=rmem,
funcs=as_tuple(c.keys()), # type: ignore[arg-type]
weights=as_tuple(c.values()) # type: ignore[arg-type]
)
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)
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)
def numbo(bricks: Collection[int], target: int) -> Solution:
step = SolutionStep(plus, as_tuple(bricks))
avails = next_avails(bricks, step)
if target in avails:
return (step, )
else:
raise CantSolve
def xp1() -> None:
global rmem
rmem = RMemAbs().absorb_canvases(pad_tup(e) for e in make_eqns([1], ['+']))
new_eqn = (2, '+', 1, '=', 3)
cues = [ # Parts of 2 + 1 = 3
(2, '+', None, None, None), (None, None, 1, '=', 3),
(2, '+', None, None, 3)
]
relateds: Set[Tuple] = set()
'''
for cue in cues:
print(rmem.run_gset(cue))
'''
while len(relateds) < 2:
rel = tuple(x if random() < 0.3 else None for x in new_eqn)
if all(x is None for x in rel):
continue
print(rel)
got = rmem.regenerate(pad_tup(rel))
print(got)
#relateds.add(as_tuple(got.contents)[-5:])
relateds.add(as_tuple(got)[-5:])
print()
pr(relateds)
new_canvas = reduce(operator.add, relateds) + new_eqn
rmem.absorb_canvases([new_canvas])
new_cue = (None, ) * 10 + (None, '+', 1, None, 3)
for _ in range(1):
print()
rmem.regenerate(new_cue, niters=100)
pr(rmem.lsteps)
def limit_cycle_of_psets(self,
canvas: CanvasAble,
funcs: Optional[Collection[Func]] = None,
max_iters: int = 100,
show: bool = False) -> Sequence[PSet]:
'''The canvases that this makes psets for will have extra columns
prepended for the painter counts.''' # TODO Clean that up so calling
# code isn't bug-prone.
base_tuple = as_tuple(canvas)
if funcs is None:
funcs = self.funcs_to_count
count_columns = (0, ) * len(funcs)
cc_history = [count_columns]
pset_history: List[PSet] = []
for _ in range(max_iters): # loop until a limit cycle completes
startc = count_columns + base_tuple
if show:
lo(startc)
pset = self.painters_to_pset(self.canvas_to_painters(startc))
pset_history.append(pset)
count_columns = tuple(
sum(1 for f in pset.values() if f == func) for func in funcs)
try:
index = cc_history.index(count_columns)
except ValueError:
cc_history.append(count_columns)
continue
if show:
pts(cc_history[index:])
lo(f' len={len(cc_history) - index} starts at: {cc_history[index]} index={index}'
)
cycle_len = len(cc_history) - index
return pset_history[-cycle_len:]
return []
def run(self, vv: Optional[int] = None) -> FidelityTestResult:
'''Run a full test: all canvases and cues.'''
vv: int = self.vv if vv is None else vv
seed = reseed(self.seed)
num_tests = 0 # number of tests actually run
results: Dict[Tuple[BaseValue, ...], int] = defaultdict(int)
if vv >= 1 and self.tspec:
print(self.tspec)
# Run the tests
start_time = perf_counter()
while num_tests <= self.nsamples:
canvas = choice(self.initial_canvases)
for _ in range(self.n_per_cue):
num_tests += 1
cue = self.canvas_to_cue(
canvas) # type: ignore[misc, operator]
if vv >= 3:
lo(' CUE', cue)
got = as_tuple(self.rmem.regenerate(canvas=cue))
if vv >= 3:
lo(' GOT', got)
if vv >= 4:
pr(self.rmem.lsteps)
yes = self.is_success(canvas,
got) # type: ignore[misc, operator]
if yes:
results[as_tuple(canvas)] += 1
if vv == 1:
print('+' if yes else '.', end='', flush=True)
duration = perf_counter() - start_time
if vv == 1:
print(flush=True)
return FidelityTestResult(
tspec=self.tspec,
rmem=self.rmem,
cue_maker=self.canvas_to_cue, # type: ignore[misc, arg-type]
results=results, # type: ignore[arg-type]
duration=duration,
num_tests=num_tests,
seed=seed)
def run( # type: ignore[override]
self,
fm: FARGModel,
noderef: NodeRef,
) -> ProgramResult:
return Paint(
noderef=noderef,
content=dict(operands=as_tuple(
sample_without_replacement(
#cellref.avails_at(),
fm.avails_at(noderef),
k=2))))
def __init__(self,
nugget: Union[Program, Complex],
*args: Union[Dict[str, Value], ArgsMap],
tags: Optional[Sequence[Value]] = None,
**kwargs):
force_setattr(self, 'nugget', nugget)
force_setattr(self, 'override',
ArgsMapSeries.make(*args, ArgsDict(kwargs)))
if tags:
force_setattr(self, 'tags', as_tuple(tags))
else:
force_setattr(self, 'tags', None)
def __call__(self, full_image: CanvasAble) -> CanvasAble:
full_image: ValueTup = as_tuple(full_image)
if self.npartial is None:
return full_image
l = len(full_image)
npartial = l + self.npartial if self.npartial < 0 else self.npartial
if npartial <= 0:
return (None, ) * l
if npartial >= l:
return full_image
r = range(l)
addrs = set(sample_without_replacement(r, k=npartial))
return tuple(full_image[a] if a in addrs else None for a in r)
def run(self, vv: Optional[int] = None) -> FidelityTestResult:
vv: int = self.vv if vv is None else vv
seed = reseed(self.seed)
num_tests = 0 # number of tests actually run
results: Dict[Tuple[BaseValue, ...], int] = defaultdict(int)
rmem, initial_canvases_f, initial_canvases, cue_maker = \
self.make_setup()
if vv >= 1:
print()
print(
f'{short(rmem):40} niters={rmem.niters} {short(initial_canvases_f)} {short(cue_maker)}'
)
#initial_canvases = set(initial_canvases)
num_initial_canvases = len(initial_canvases)
# Run the tests
start_time = perf_counter()
for canvas in sample_without_replacement(initial_canvases,
k=self.nsamples):
if vv >= 2:
lo(canvas)
for _ in range(self.n_per_sample):
num_tests += 1
cue = cue_maker(canvas)
if vv >= 3:
lo(' CUE', cue)
got = as_tuple(self.run1(cue, rmem, vv=vv))
if vv >= 3:
lo(' GOT', got)
yes = got[-len(canvas):] == canvas
if yes:
results[canvas] += 1
if vv == 1:
print('+' if yes else '.', end='', flush=True)
duration = perf_counter() - start_time
if vv == 1:
print(flush=True)
return FidelityTestResult(
tspec=self,
rmem=rmem,
initial_canvases_f=initial_canvases_f,
cue_maker=cue_maker,
results=results, # type: ignore[arg-type]
duration=duration,
num_tests=num_tests,
num_initial_canvases=num_initial_canvases,
seed=seed)
def Mult(*operands: int) -> Consume:
return Consume(name='Mult', operator=mult, operands=as_tuple(operands))
def Plus(*operands: int) -> Consume:
return Consume(name='Plus', operator=plus, operands=as_tuple(operands))
def prep_regen(self, c: CanvasAble) -> CanvasAble:
prefix = (None, ) * len(self.funcs_to_count)
return super().prep_regen(prefix + as_tuple(c))
def _make(_cls, cls: Type[rndfunc], c: Dict[Func, int]) -> rndfunc:
return cls(
funcs=as_tuple(c.keys()), # type: ignore[arg-type]
weights=as_tuple(c.values()) # type: ignore[arg-type]
)
def as_tuple(self) -> ValueTup:
return as_tuple(self.contents)
def prep_regen(self, c: CanvasAble) -> CanvasAble:
t = as_tuple(c)
blankdup: Tuple[Value, ...] = (None, ) * len(t)
return (blankdup * self.ndups) + t
def prep_absorb(self, c: CanvasAble) -> CanvasAble:
return as_tuple(c) * (self.ndups + 1)
def __call__(self, correct: CanvasAble, got: CanvasAble) -> bool:
correct = as_tuple(correct)
got = as_tuple(got)
return got[-self.base_canvas_len:] == correct
def dt3_and_mul(avails: Collection[int]) -> Optional[SolutionStep]:
operands = detect_three_tens(avails)
if operands:
return SolutionStep(times, as_tuple(operands))
else:
return None
def prep_absorb(self, c: CanvasAble) -> CanvasAble:
prefix = tuple(range(1, self.nseqsalt + 1))
return super().prep_absorb(prefix + as_tuple(c))
def Avails(*vs: Value) -> ArgsMap:
return ArgsMap(dict(avails=as_tuple(vs)))
def prep_regen(self, c: CanvasAble) -> CanvasAble:
prefix = (None, ) * self.nseqsalt
return super().prep_regen(prefix + as_tuple(c))
def make(cls, *argss: Union[None, Dict[str, Value], ArgsMap]) \
-> ArgsMapSeries:
# TODO Special treatment for empty and for existing ArgsMapSeries?
return ArgsMapSeries(as_tuple(cls.flatten(argss)))
def prep_absorb(self, c: CanvasAble) -> CanvasAble:
prefix = tuple(randrange(*self.saltrange) for _ in range(self.nsalt))
return super().prep_absorb(prefix + as_tuple(c))
