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