def search_param_(param_name, param):
ddert_, mdert_ = [], [] # line-wide (i, p, d, m)_, + (negL, negM) in mdert: variable-range search
rdn = param[1]
param_ = param[0]
_param, _L, _x0 = param_[0]
for i, (param, L, x0) in enumerate(param_[1:], start=1):
dert = comp_param(_param, param, param_name, ave/rdn) # param is compared to prior-P param
ddert_.append(dert)
negL = negM = 0
comb_M = dert.m
j = i
while comb_M > 0 and j+1 < len(param_):
j += 1
ext_param, ext_L, ext_x0 = param_[j] # extend search beyond next param
dert = comp_param(param, ext_param, param_name, ave)
comb_M = dert.m + negM - ave / (1 - (negL / (negL + L + _L)))
negM += dert.m
negL += ext_L
# after extended search, if any:
mdert_.append( Cmdert( i=dert.i, p=dert.p, d=dert.d, m=dert.m, negL=negL, negM=negM))
_param = param
# Ppm_ = form_Pp_(mdert_)
# Ppd_ = form_Pp_(ddert_
param[0].append(([],[])) # replace with ((Ppm_, Ppd_))
def search_param_(param_name, iparam):
ddert_, mdert_ = [], [] # line-wide (i, p, d, m)_, + (negL, negM) in mdert: variable-range search
rdn = iparam[1] # iparam = (param_, P.L, P.x0), rdn
param_ = iparam[0]
_param, _L, _x0 = param_[0]
for i, (param, L, x0) in enumerate(param_[1:], start=1):
# param is compared to prior-P param:
dert = comp_param(_param, param, param_name, ave/rdn)
# or div_comp(L), norm_comp(I, D, M): value conserve, mean doesn't?
# -> splice or higher composition: preserve inputs?
ddert_.append( Cpdert( i=dert.i, p=dert.p, d=dert.d, m=dert.m, x0=x0, L=L) )
negL=negM=0 # comp next only
comb_M = dert.m
j = i
while comb_M > 0 and j+1 < len(param_):
j += 1
ext_param, ext_L, ext_x0 = param_[j] # extend search beyond next param
dert = comp_param(param, ext_param, param_name, ave)
if dert.m > 0:
break # 1st matching param takes over connectivity search from _param, in the next loop
else:
comb_M = dert.m + negM - ave_M # adjust ave_M for relative continuity and similarity?
negM += dert.m
negL += ext_L
# after extended search, if any:
mdert_.append( Cpdert( i=dert.i, p=dert.p, d=dert.d, m=dert.m, x0=x0, L=L, negL=negL, negM=negM))
_param = param
Ppm_ = form_Pp_(mdert_, param_name, rdn, fPd=0)
Ppd_ = form_Pp_(ddert_, param_name, rdn, fPd=1)
iparam[0] = (Ppm_, Ppd_)
def sub_search_param_(_P_, P_, ipdert): # variable-range search
# this is for single param only, most likely incorrect
rave = 1
for i, _P in enumerate(_P_):
negM = 0 # per _P
for j, P in enumerate(P_):
if (_P.M + P.M) / 2 + ipdert.m + negM > ave_M:
_pI = _P.I - (_P.D / 2) # forward project by _D
pI = P.I + (P.D / 2) # backward project by D
dert = comp_param(
_pI, pI, "I_",
ave_mI) # param is compared to prior-P _param
pdert = Cpdert(i=dert.i, p=dert.p, d=dert.d,
m=dert.m) # convert Cdert to Cpdert
ipdert.accumulate(sub_M=pdert.m, sub_D=pdert.d)
curr_M = pdert.m * rave + (
_P.M + P.M) / 2 # P.M is bidirectional (include ipdert.m?)
if curr_M > ave_sub: # comp all sub_P_ params, for core I only?
comp_sublayers_draft(_P, P, pdert) # should set dert.sub_M
if curr_M + pdert.sub_M > ave_M: # match between sublayers; or > ave_cM?
break # 1st match takes over connectivity search in the next loop
else:
pdert.negM += curr_M - ave_M # known to be negative, accum per dert
pdert.negiL += P.L
pdert.negL += 1
negM = pdert.negM
def form_comp_Derts(_P, P, root_v):
subDertt_t = [[],
[]] # two comparands, each preserved for future processing
# form Derts:
for _sublayer, sublayer in zip(_P.sublayers, P.sublayers):
for i, isublayer in enumerate([
_sublayer, sublayer
]): # list of subsets: index 0 = _P.sublayers, index 1 = P.sublayers
nsub = 0
for subset in isublayer:
nsub += len(subset[2]) + len(
subset[3]
) # or nsub_t, for separate form mDert | dDert eval?
if root_v * nsub > ave_M * 5: # ave_Dert, separate eval for m and d?
subDertt = [[0, 0, 0, 0],
[0, 0, 0, 0]] # Pm,Pd' L,I,D,M summed in sublayer
for rdn, rng, sub_rval_Pm_, sub_rval_Pd_, xsub_pmdertt_, xsub_pddertt_, _, _ in isublayer: # current layer subsets
for j, sub_rval_P__ in enumerate(
[sub_rval_Pm_, sub_rval_Pd_]): # j: Pm | Pd
for Rval, sub_rval_P_ in sub_rval_P__:
for rval, sub_rval_P in sub_rval_P_:
subDertt[j][0] += sub_rval_P.L
subDertt[j][1] += sub_rval_P.I
subDertt[j][2] += sub_rval_P.D
subDertt[j][3] += sub_rval_P.M
subDertt_t[i].append(
subDertt) # 2-tuple, index 0 = _P, index 1 = P
else:
break # deeper Derts are not formed
_P.subDertt_ = subDertt_t[0]
P.subDertt_ = subDertt_t[1]
# comp Derts, sum xlayer:
xDert_vt = [0, 0]
derDertt = [[], []]
for (_mDert, _dDert), (mDert, dDert) in zip(subDertt_t[0], subDertt_t[1]):
for i, (_iDert,
iDert) in enumerate(zip((_mDert, _dDert), (mDert, dDert))):
derDert = []
for _param, param, param_name, ave in zip(_iDert, iDert,
param_names, aves):
dert = comp_param(_param, param, param_name, ave)
if i: # higher value for L?
vd = abs(dert.d) - ave_d
if vd > 0:
xDert_vt[
i] += vd # no neg value sum: -Ps won't be processed
elif dert.m > 0:
xDert_vt[i] += dert.m
derDert.append(
dert
) # dert per param, derDert_ per _subDert, copy in subDert?
derDertt[i].append(derDert) # m, d derDerts per sublayer
_P.derDertt_.append(derDertt) # derDert_ per _P, P pair
P.derDertt_.append(derDertt) # bilateral assignment?
return xDert_vt
def merge_comp_P(
P_, _P, P, i, j, neg_M, neg_L,
remove_index): # multi-variate cross-comp, _smP = 0 in line_patterns
mP = dP = 0
layer1 = dict({'L': .0, 'I': .0, 'D': .0, 'M': .0})
dist_coef = ave_rM**(
1 + neg_L / _P.L
) # average match projected at current distance from P: neg_L, separate for min_match, add coef / var?
for param_name in layer1:
if param_name == "I":
dist_ave = ave_inv * dist_coef
else:
dist_ave = ave_min * dist_coef
param = getattr(
_P, param_name
) / _P.L # swap _ convention here, it's different in search
_param = getattr(P, param_name) / P.L
dm = comp_param(_param, param, [], dist_ave)
rdn = layer0_rdn[param_name]
mP += dm.m * rdn
dP += dm.d * rdn
layer1[param_name] = dm
if neg_L == 0:
mP += _P.dert_[0].m
dP += _P.dert_[0].d
rel_distance = neg_L / _P.L
if mP / max(
rel_distance, 1
) > ave_merge: # merge(_P, P): splice proximate and param/L- similar Ps:
_P.accum_from(P)
_P.dert_ += P.dert_
remove_index.append(j)
if _P.fPd: _P.sign = P.D > 0
else: P.sign = P.M > 0
if (i - 1) >= 0 and (i - 1) not in remove_index and (
i) not in remove_index:
derP, _L, _smP = merge_comp_P(P_, P_[i - 1], _P, i - 1, i, neg_M,
neg_L,
remove_index) # backward re-comp_P
elif (j + 1) <= len(P_) - 1 and (j + 1) not in remove_index and (
i) not in remove_index:
derP, _L, _smP = merge_comp_P(P_, _P, P_[j + 1], i, j + 1, neg_M,
neg_L,
remove_index) # forward comp_P
else:
derP = None
else: # form derP:
derP, L, _smP = comp_P(_P, P, neg_L, neg_M)
return derP, _P.L, _P.sign
def comp_Pp(_Pp, Pp, layer0):
'''
next level line_PPPs:
PPm_ = search_Pp_(layer0, fPd=0) # calls comp_Pp_ and form_PP_ per param
PPd_ = search_Pp_(layer0, fPd=1)
'''
mPp = dPp = 0
layer1 = dict({'L': .0, 'I': .0, 'D': .0, 'M': .0})
dist_coef = ave_rM * (1 + _Pp.negL / _Pp.L)
# average match projected at current distance, needs a review
for param_name in layer1:
if param_name == "I":
ave = ave_inv # * dist_coef
else:
ave = ave_min # * dist_coef
param = getattr(_Pp, param_name)
_param = getattr(Pp, param_name)
dert = comp_param(_param, param, [], ave)
rdn = layer0[param_name + '_'][1] # index 1 =rdn
mPp += dert.m * rdn
dPp += dert.d * rdn
layer1[param_name] = dert
negM = _Pp.negM - Pp.negM
negL = _Pp.L - Pp.negL
negiL = _Pp.iL - Pp.negiL
'''
options for div_comp, etc.
if P.sign == _P.sign: mP *= 2 # sign is MSB, value of sign match = full magnitude match?
if mP > 0
# positive forward match, compare sublayers between P.sub_H and _P.sub_H:
comp_sublayers(_P, P, mP)
if isinstance(_P.derP, CderP): # derP is created in comp_sublayers
_P.derP.sign = sign
_P.derP.layer1 = layer1
_P.derP.accumulate(mP=mP, neg_M=neg_M, neg_L=neg_L, P=_P)
derP = _P.derP
else:
derP = CderP(sign=sign, mP=mP, neg_M=neg_M, neg_L=neg_L, P=_P, layer1=layer1)
_P.derP = derP
'''
derPp = CderPp(mPp=mPp,
dPp=dPp,
negM=negM,
negL=negL,
negiL=negiL,
_Pp=_Pp,
Pp=Pp,
layer1=layer1)
return derPp
def search(P_, fPd): # cross-compare patterns within horizontal line
Ldert_, Idert_, Ddert_, Mdert_, dert1_, dert2_, LP_, IP_, DP_, MP_ = [], [], [], [], [], [], [], [], [], []
for _P, P, P2 in zip(P_, P_[1:], P_[2:] +
[CP()]): # for P_ cross-comp over step=1 and step=2
_L, _I, _D, _M, *_ = _P.unpack() # *_: skip remaining params
L, I, D, M, *_ = P.unpack()
D2, M2 = P2.D, P2.M
# div_comp for L:
rL = L / _L # higher order of scale, not accumulated: no search, rL is directional
int_rL = int(max(rL, 1 / rL))
frac_rL = max(rL, 1 / rL) - int_rL
mL = int_rL * min(L, _L) - (
int_rL * frac_rL
) / 2 - ave_mL # div_comp match is additive compression: +=min, not directional
Ldert_.append(Cdert(i=L, p=L + _L, d=rL,
m=mL)) # add mrdn if default form Pd?
# summed params comp:
if fPd:
Idert_ += [comp_param(_I, I, "I_", ave_mI)]
Ddert = comp_param(_D, D2, "D_",
ave_mD) # step=2 for same-D-sign comp
Ddert_ += [Ddert]
dert2_ += [Ddert.copy()]
dert1_ += [comp_param(_D, D, "D_", ave_mD)] # to splice Pds
Mdert_ += [comp_param(_M, M, "M_", ave_mM)]
else:
Ddert_ += [comp_param(_D, D, "D_", ave_mD)]
Mdert = comp_param(_M, M2, "M_",
ave_mM) # step=2 for same-M-sign comp
Mdert_ += [Mdert]
dert2_ += [Mdert.copy()]
dert1_ += [comp_param(_M, M, "M_", ave_mM)] # to splice Pms
_L, _I, _D, _M = L, I, D, M
LP_ = P_[:-1]
dert2_ = dert2_[:-1] # due to filled CP() in P2 ( for loop above )
if not fPd:
Idert_, IP_ = search_param_(
P_, ave_mI, rave=1) # comp x variable range, depending on M of Is
Mdert_ = Mdert_[:-1] # due to filled CP() in P2 ( for loop above )
DP_, MP_ = P_[:-1], P_[:-2]
else:
IP_, DP_, MP_ = P_[:-1], P_[:-2], P_[:-1]
# comp x variable range, depending on M of Is
if not fPd: Idert_, IP_ = search_param_(P_, ave_mI, rave=1)
Pdert_t = (Ldert_, LP_), (Idert_, IP_), (Ddert_, DP_), (Mdert_, MP_)
return Pdert_t, dert1_, dert2_
def comp_P(_P, P, neg_L,
neg_M): # multi-variate cross-comp, _smP = 0 in line_patterns
mP = dP = 0
layer1 = dict({'L': .0, 'I': .0, 'D': .0, 'M': .0})
dist_coef = ave_rM**(1 + neg_L / _P.L
) # average match projected at current distance:
for param_name in layer1:
if param_name == "I":
dist_ave = ave_inv * dist_coef
else:
dist_ave = ave_min * dist_coef
param = getattr(_P, param_name)
_param = getattr(P, param_name)
dm = comp_param(_param, param, [], dist_ave)
rdn = layer0_rdn[param_name]
mP += dm.m * rdn
dP += dm.d * rdn
layer1[param_name] = dm
'''
main comp is between summed params, with an option for div_comp, etc.
mP -= ave_M * ave_rM ** (1 + neg_L / P.L) # average match projected at current distance: neg_L, add coef / var?
match(P,_P), ave_M is addition to ave? or abs for projection in search?
'''
if P.sign == _P.sign:
mP *= 2 # sign is MSB, value of sign match = full magnitude match?
sign = mP > 0
if sign: # positive forward match, compare sublayers between P.sub_H and _P.sub_H:
comp_sublayers(_P, P, mP)
if isinstance(_P.derP, CderP): # derP is created in comp_sublayers
_P.derP.sign = sign
_P.derP.layer1 = layer1
_P.derP.accumulate(mP=mP, neg_M=neg_M, neg_L=neg_L, P=_P)
derP = _P.derP
else:
derP = CderP(sign=sign,
mP=mP,
neg_M=neg_M,
neg_L=neg_L,
P=_P,
layer1=layer1)
_P.derP = derP
return derP, _P.L, _P.sign
def search_param_(
P_, ave,
rave): # variable-range search in mdert_, only if param is core param?
# higher local ave for extended rng: -> lower m and term by match, and higher proj_M?
Idert_, _P_ = [], [] # line-wide (i, p, d, m, negL, negM, negiL)
for i, _P in enumerate(P_[:-1]):
negM = 0
_pI = _P.I - (_P.D / 2) # forward project by _D
j = i + 1 # init with positive-M Is only: internal match projects xP I match:
while _P.M + negM > ave_M and j < len(
P_
): # starts with positive _P.Ms, but continues over negM if > ave
P = P_[j]
pI = P.I + (P.D / 2) # backward project by D
dert = comp_param(_pI, pI, "I_",
ave) # param is compared to prior-P _param
pdert = Cpdert(i=dert.i, p=dert.p, d=dert.d,
m=dert.m) # convert Cdert to Cpdert
curr_M = pdert.m * rave + (
_P.M + P.M) / 2 # P.M is bilateral, no fPd in search_param
if curr_M > ave_sub and (_P.sublayers and P.sublayers
): # comp sub_P_s, for core I only?
comp_sublayers(
P_[i], P_[j],
pdert.m) # between sublayers[0], forms pdert.sub_M:
if curr_M + pdert.sub_M > ave_M * 4: # 4 = ave_cM coef
break # 1st match takes over connectivity search in the next loop
else:
pdert.negM += curr_M - ave_M # known to be negative, accum per dert
pdert.negiL += P.L
pdert.negL += 1
negM = pdert.negM
j += 1
if "pdert" in locals(): # after extended search, if any:
Idert_.append(pdert)
_P_.append(_P)
del pdert # prevent reuse of same pdert in multiple loops
return Idert_, _P_
def search_param_(
I_, D_, P_, ave,
rave): # variable-range search in mdert_, only if param is core param?
# higher local ave for extended rng: -> lower m and term by match, and higher proj_M?
mdert_ = [] # line-wide (i, p, d, m, negL, negM, negiL)
for i, (_I, _D, _P) in enumerate(zip(I_[:-1], D_[:-1], P_[:-1])):
proj_M = 1
negiL = negL = negM = 0
_pI = _I - (_D / 2) # forward project by _D
j = i + 1
while proj_M > 0 and j < len(I_):
I = I_[j]
D = D_[j]
P = P_[j]
pI = I - (D / 2) # backward project by D
dert = comp_param(_pI, pI, "I_",
ave) # param is compared to prior-P _param
if dert.m > 0:
if dert.m + _P.M > 0:
comp_sublayers(P_[i], P_[j], dert.m, dert.d)
break # 1st matching param takes over connectivity search from _param, in the next loop
else:
proj_M = dert.m * rave + negM - ave_M # lower ave_M instead of projection?
negM += dert.m * rave # or abs m only?
negiL += P.L
negL += 1
j += 1
# after extended search, if any:
mdert_.append(
Cpdert(i=dert.i,
p=dert.p,
d=dert.d,
m=dert.m,
negiL=negiL,
negL=negL,
negM=negM))
return mdert_
def comp_sublayers(_P, P, mP, dP): # not revised; also add dP?
if P.sublayers and _P.sublayers: # not empty sub layers
for _sub_layer, sub_layer in zip(_P.sublayers[0], P.sublayers[0]):
if _sub_layer and sub_layer:
_fPd, _rdn, _rng, _sub_P_, _sub_Pp__, = _sub_layer
fPd, rdn, rng, sub_P_, sub_Pp__ = sub_layer
# fork comparison:
if fPd == _fPd and rng == _rng and min(_P.L, P.L) > ave_Ls:
sub_mP = sub_dP = 0
# compare all sub_Ps to each _sub_P:
for _sub_P in _sub_P_:
for sub_P in sub_P_:
sub_dert = comp_param(_sub_P.I, sub_P.I, "I_", ave)
sub_mP += sub_dert.m # of compared H, no specific mP?
sub_dP += sub_dert.d
if sub_mP + mP < ave_sub_M:
# potentially mH: trans-layer induction: if mP + sub_mP < ave_sub_M: both local and global values of mP.
break # low vertical induction, deeper sublayers are not compared
else:
break # deeper P and _P sublayers are from different intra_comp forks, not comparable?
def comp_sub_P(_sub_P, sub_P, xsub_pdertt, P_, root_v, fPd):
fbreak = 0
xsub_P_vt = [0, 0] # vm,vd combined across params
dist_decay = 2 # decay of projected match with relative distance between sub_Ps
distance = (sub_P.x0 + sub_P.L / 2) - (_sub_P.x0 + _sub_P.L / 2
) # distance between mean xs
mean_L = (_sub_P.L + sub_P.L) / 2
rel_distance = distance / mean_L # not gap and overlap: edge-specific?
if fPd:
sub_V = abs((_sub_P.D + sub_P.D) / 2) - ave_d * mean_L
else:
sub_V = (_sub_P.M + sub_P.M) / 2
V = sub_V + root_v
# or comp all, then filter by distance?
if V * rel_distance * dist_decay > ave_M * (fPd * ave_D):
# 1x1 comp:
for i, (param_name, ave) in enumerate(zip(param_names, aves)):
_param = getattr(_sub_P, param_name[0]) # can be simpler?
param = getattr(sub_P, param_name[0])
dert = comp_param(_param, param, param_name, ave)
sub_pdert = Cpdert(i=dert.i, p=dert.p, d=dert.d,
m=dert.m) # convert Cdert to Cpdert
# no negative-value sum: -Ps won't be processed:
if dert.m > 0: xsub_P_vt[0] += dert.m
vd = abs(dert.d) - ave_d # convert to coef
if vd > 0: xsub_P_vt[1] += vd
xsub_pdertt[i].append(sub_pdert) # per L, I, D, M' xsub_pdert
P_.append(sub_P) # same sub_P for all xsub_Pps
V += xsub_P_vt[0] + xsub_P_vt[
1] # or two separate values for comp_sublayers?
if V > ave_M * 4 and _sub_P.sublayers and sub_P.sublayers: # 4: ave_comp_sublayers coef
comp_sublayers(_sub_P, sub_P, V) # recursion for deeper layers
else:
fbreak = 1 # only sub_Ps with relatively proximate position in sub_P_|_sub_P_ are compared
return fbreak
def intra_Pp_(
rootPp, rval_Pp, param_name, fPd
): # evaluate for sub-recursion in line Pm_, pack results into sub_Pm_
comb_sublayers = [] # combine into root P sublayers[1:]
# each Pp may be compared over incremental range and derivation, as in line_patterns but with local aves
for rval, Pp in rval_Pp: # each sub_layer is nested to depth = sublayers[n]
if Pp.L > 2:
mean_M = Pp.M / Pp.L # for internal Pd eval, +opposite-side mean_M?
# all params norm?
if fPd: # Pp is Ppd
if abs(
Pp.D
) * mean_M > ave_D * Pp.Rdn and Pp.L > 3: # mean_M from adjacent +ve Ppms
# search in top sublayer, eval by pdert.d:
sub_search_draft(Pp.P_, fPd)
rdn_ = [rdn + 1 for rdn in Pp.rdn_[:-1]]
sub_Ppm_, sub_Ppd_ = [], []
Pp.sublayers = [[(fPd, sub_Ppm_, sub_Ppd_)]]
ddert_ = []
# higher derivation comp, if sublayers.D?
for _pdert, pdert in zip(
Pp.pdert_[:-1],
Pp.pdert_[1:]): # Pd.pdert_ is dert1_
_param = _pdert.d
param = pdert.d
dert = comp_param(
_param, param, param_name[0], ave
) # cross-comp of ds in dert1_, !search, local aves?
ddert_ += [
Cdert(i=dert.i, p=dert.p, d=dert.d, m=dert.m)
]
# cluster Pd derts by md sign:
sub_Ppm_[:] = form_Pp_(Pp,
ddert_, [], [],
param_name,
rdn_,
Pp.P_,
fPd=False)
sub_Ppd_[:] = form_Pp_(Pp,
ddert_, [], [],
param_name,
rdn_,
Pp.P_,
fPd=True)
else: # Pp is Ppm
if Pp.M > 0 and Pp.M > ave_M * Pp.Rdn and param_name == "I_": # and if variable cost: Pp.M / Pp.L? -lend to contrast?
# search in top sublayer, eval by pdert.m:
sub_search_draft(Pp.P_, fPd)
# +Ppm -> sub_Ppm_: low-variation span, eval rng_comp:
rdn_ = [rdn + 1 for rdn in Pp.rdn_[:-1]]
sub_Ppm_, sub_Ppd_ = [], []
Pp.sublayers = [[(fPd, sub_Ppm_, sub_Ppd_)]]
# range extended by incr ave: less term by match, and decr proj_P = dert.m * rave ((M/L) / ave): less term by miss
rpdert_, rP_ = search_param_(
Pp.P_, (ave + Pp.M) / 2,
rave=Pp.M / ave) # rpdert_len-=1 in search_param:
sub_Ppm_[:] = form_Pp_(
Pp,
rpdert_, [], [],
param_name,
rdn_[:-1],
rP_,
fPd=False) # cluster by m sign, eval intra_Pm_
sub_Ppd_[:] = form_Pp_(
Pp,
Pp.pdert_, [], [],
param_name,
rdn_,
Pp.P_,
fPd=True
) # cluster by d sign: partial d match, eval intra_Pm_(Pdm_)
if rootPp and Pp.sublayers:
comb_sublayers = [
comb_subset_ + subset_ for comb_subset_, subset_ in
zip_longest(comb_sublayers, Pp.sublayers, fillvalue=[])
]
if rootPp:
return comb_sublayers
else:
return rval_Pp
def search(P_, fPd): # cross-compare patterns within horizontal line
sub_search_recursive(
P_, fPd) # search with incremental distance: first inside sublayers?
layer0 = {
'L_': [],
'I_': [],
'D_': [],
'M_': []
} # param_name: [param values]
Ldert_ = []
for P in P_: # unpack P params
L = P.L
if "_P" in locals(): # not the 1st P
_L = _P.L
rL = L / _L # div_comp L: higher-scale, not accumulated: no search
# add ave_Ls to L param match computation?
mL = int(max(rL, 1 / rL)) * min(
L, _L
) - ave_mL # div_comp match is additive compression, not directional
Ldert_.append(Cdert(i=L, p=L + _L, d=rL, m=mL))
_P = P
layer0['I_'].append(P.I / L) # mean values for comp_param
layer0['D_'].append(P.D / L)
layer0['M_'].append(P.M / L)
Pdert__ = [Ldert_] # no search for L, step=1 only
if fPd: # comp | search per param type, separate dert1_ and dert2_ (step=1 and step=2 comp) for P splice only
# I
dert1_I = [
comp_param(_par, par, "I_", ave_mI)
for _par, par in zip(layer0["I_"][:-1], layer0["I_"][1:])
]
# D: Pd-defining param
dert1_D = [
comp_param(_par, par, "D_", ave_mD)
for _par, par in zip(layer0["D_"][:-1], layer0["D_"][1:])
]
dert2_D = [
comp_param(_par, par, "D_", ave_mD)
for _par, par in zip(layer0["D_"][:-2], layer0["D_"][2:])
]
# M
dert1_M = [
comp_param(_par, par, "M_", ave_mM)
for _par, par in zip(layer0["M_"][:-1], layer0["M_"][1:])
]
# generic
Pdert__ += [dert1_I, dert1_D, dert1_M]
dert1_ = dert1_D # for Pd splicing
dert2_ = dert2_D
else:
# I: Pm-defining param
pdert_I = search_param_(layer0["I_"], layer0["D_"], P_, ave_mI,
rave=1) # forms variable-negL pderts
dert1_I = [
comp_param(__par, par, "I_", ave_mI)
for __par, par in zip(layer0["I_"][:-1], layer0["I_"][1:])
]
dert2_I = [
comp_param(__par, par, "I_", ave_mI)
for __par, par in zip(layer0["I_"][:-2], layer0["I_"][2:])
]
# D
dert1_D = [
comp_param(_par, par, "D_", ave_mD)
for _par, par in zip(layer0["D_"][:-1], layer0["D_"][1:])
]
# M
dert2_M = [
comp_param(_par, par, "M_", ave_mM)
for _par, par in zip(layer0["M_"][:-2], layer0["M_"][2:])
]
# generic
Pdert__ += [pdert_I, dert1_D, dert2_M]
dert1_ = dert1_I # for Pm splicing
dert2_ = dert2_I
'''
old:
for param_name in ["I_", "D_", "M_"]:
param_ = layer0[param_name] # param values
# if dert-level P-defining param:
if ((param_name == "I_") and not fPd) or ((param_name == "D_") and fPd):
if not fPd:
Pdert__ += [search_param_(param_, layer0["D_"], P_, ave_mI, rave=1)] # pdert_ if "I_"
# step=2 comp for P splice only:
dert2_ = [comp_param(__par, par, param_name[0], ave) for __par, par in zip( param_[:-2], param_[2:])]
# else step=1 per param only:
dert1_ = [comp_param(_par, par, param_name[0], ave) for _par, par in zip( param_[:-1], param_[1:])]
dert1__ += [dert1_]
if not param_name == "I_":
Pdert__ += [dert1_] # clustered into Pps in form_Pp_
'''
rdn__ = sum_rdn_(
layer0, Pdert__, fPd=1
) # assign redundancy to lesser-magnitude m|d in param pair for same-_P Pderts
rval_Pp__ = []
Ppm__ = [] # for visualization
for param_name, Pdert_, rdn_ in zip(layer0, Pdert__,
rdn__): # segment Pdert__ into Pps
if param_name == "I_" and not fPd:
Ppm_ = form_Pp_rng(None, Pdert_, rdn_, P_)
else:
Ppm_ = form_Pp_(
None, Pdert_, param_name, rdn_, P_,
fPd=0) # Ppd_ is formed in -Ppms only, in intra_Ppm_
# rval_Pp_s per param:
rval_Pp__ += [form_rval_Pp_(Ppm_, param_name, dert1_, dert2_,
fPd=0)] # evaluates for compact()
Ppm__ += [Ppm_]
return rval_Pp__, Ppm__
def intra_Pp_(
Pp_, param_name, rdn_, fPd
): # evaluate for sub-recursion in line Pm_, pack results into sub_Pm_
comb_layers = [] # combine into root P sublayers[1:]
# each Pp is evaluated for incremental range and derivation xcomp, as in line_patterns but with local aves
for Pp, rdn in zip(
Pp_, rdn_): # each sub_layer is nested to depth = sublayers[n]
if Pp.L > 2: # no rel_adj_M = adj_M / -P.M: discontinuous search?
mean_M = Pp.M / Pp.L # for internal Pd eval, +opposite-side mean_M?
if fPd: # Pp is Ppd
if abs(
Pp.D
) * mean_M > ave_D * rdn and Pp.L > 3: # mean_M from adjacent +ve Ppms
rdn_ = [rdn + 1 for rdn in rdn_]
ddert_ = []
for _pdert, pdert in zip(
Pp.pdert_[:-1],
Pp.pdert_[1:]): # Pd.pdert_ is dert1_
_param = _pdert.d
param = pdert.d
dert = comp_param(
_param, param, param_name[0], ave
) # cross-comp of ds in dert1_, !search, local aves?
ddert_ += [
Cdert(i=dert.i, p=dert.p, d=dert.d, m=dert.m)
]
# cluster Pd derts by md sign:
form_Pp_(Pp, ddert_, param_name, rdn_, Pp.P_, fPd=True)
else: # Pp is Ppm
# +Ppm -> sub_Ppm_: low-variation span, eval rng_comp:
if Pp.M > 0 and Pp.M > ave_M * rdn and param_name == "I_": # and if variable cost: Pp.M / Pp.L? -lend to contrast?
rdn_ = [rdn + 1 for rdn in rdn_]
I_ = [pdert.i for pdert in (Pp.pdert_[:-1])]
D_ = [pdert.d for pdert in (Pp.pdert_[:-1])]
# search range is extended by higher ave: less replacing by match,
# and by higher proj_P = dert.m * rave ((Pp.M / Pp.L) / ave): less term by miss:
P_ave = Pp.M / Pp.L
rpdert_ = search_param_(I_,
D_,
Pp.P_, (ave + P_ave) / 2,
rave=P_ave / ave)
form_Pp_(Pp, rpdert_, param_name, rdn_, Pp.P_,
fPd=False) # cluster by m sign, eval intra_Pm_
# -Ppm -> sub_Ppd:
elif -Pp.M > ave_D * rdn: # high-variation span, -M is contrast borrowed from adjacent +Ppms: or abs D: likely sign match span?
rdn_ = [rdn + 1 for rdn in rdn_]
form_Pp_(
Pp, Pp.pdert_, param_name, rdn_, Pp.P_, fPd=True
) # cluster by d sign: partial d match, eval intra_Pm_(Pdm_)
if Pp.sublayers: # splice sublayers from all sub_Pp calls in Pp:
comb_layers = [
comb_layer + sublayer for comb_layer, sublayer in
zip_longest(comb_layers, Pp.sublayers, fillvalue=[])
]
''' list comprehension:
if P.sublayers: # combine sublayers of all sub_Ps:
comb_layers = [([(comb_param + param) # \
for comb_param, param # } Accumulated Dert
in zip(comb_Dert, Dert)], # /
comb_subset_ + subset_) # Accumulated subset_
for (comb_Dert, comb_subset_), (Dert, subset_) # zipped Dert and subset_ from 2 layer lists
in zip_longest(comb_layers, P.sublayers, fillvalue=([0,0,0,0], []))]
'''
# old:
if P.sublayers: # combine sublayers of all sub_Ps:
for comb_layer, sublayer in zip_longest(
comb_layers, P.sublayers, fillvalue=([0, 0, 0,
0], [])):
if sublayer[
1]: # sublayer (Dert, subset_) is not empty
if not comb_layer[1]:
comb_layers.append(
comb_layer) # initialized ([0,0,0,0], [])
# accumulate combined Dert:
for i, param_value in enumerate(sublayer[0]):
comb_layer[0][i] += param_value
# append combined subset_ (array of sub_P_ param sets):
comb_layer[1].extend(
sublayer[1]) # append would increase nesting
comb_layers = []
if P.sublayers:
new_sublayers = []
for comb_subset_, subset_ in zip_longest(comb_layers,
P.sublayers,
fillvalue=([])):
# append combined subset_ (array of sub_P_ param sets):
new_sublayers += [comb_subset_.extend(subset_)]
comb_layers = [new_sublayers]
# to be used de novo in line_PPs, depending on pdert.m, sub_M, and rdn,
# line_patterns should only form sublayers?
comb_subDerts = []
for comb_subset_ in comb_layers:
if P.M * len(
comb_subset_
) > ave_M * 5: # 5 is a placeholder, form subDert:
new_subDerts = []
for comb_Dert, subset_ in zip_longest(
comb_subDerts, comb_subset_,
fillvalue=([])):
if subset_:
if not comb_Dert: comb_Dert = [0, 0, 0, 0]
for subset in subset_:
for sub_P in subset[
3]: # accumulate combined Dert:
comb_Dert[0] += sub_P.L
comb_Dert[1] += sub_P.I
comb_Dert[2] += sub_P.D
comb_Dert[3] += sub_P.M
new_subDerts += comb_Dert
comb_subDerts = new_subDerts
else:
break # no skip to deeper layers
return comb_layers
def div_comp_P(PP_): # draft, check all PPs for x-param comp by division between element Ps
'''
div x param if projected div match: compression per PP, no internal range for ind eval.
~ (L*D + L*M) * rm: L=min, positive if same-sign L & S, proportional to both but includes fractional miss
+ PPm' DL * DS: xP difference compression, additive to x param (intra) compression: S / L -> comp rS
also + ML * MS: redundant unless min or converted?
vs. norm param: Var*rL-> comp norm param, simpler but diffs are not L-proportional?
'''
for PP in PP_:
vdP = (PP.adj_mP + PP.P.M) * abs(PP.dP) - ave_div
if vdP > 0:
# if irM * D_vars: match rate projects der and div match,
# div if scale invariance: comp x dVars, signed
'''
| abs(dL + dI + dD + dM): div value ~= L, Vars correlation: stability of density, opposite signs cancel-out?
| div_comp value is match: min(dL, dI, dD, dM) * 4, | sum of pairwise mins?
'''
_derP = PP.derP_[0]
# smP, vmP, neg_M, neg_L, iP, mL, dL, mI, dI, mD, dD, mM, dM = P,
#_sign, _L, _I, _D, _M, _dert_, _sub_H, __smP = _derP.P
_P = _derP.P
for i, derP in enumerate(PP.derP_[1:]):
P = derP.P
# DIV comp L, SUB comp (summed param * rL) -> scale-independent d, neg if cross-sign:
rL = P.L / _P.L
# mL = whole_rL * min_L?
'''
dI = I * rL - _I # rL-normalized dI, vs. nI = dI * rL or aI = I / L
mI = ave - abs(dI) # I is not derived, match is inverse deviation of miss
dD = D * rL - _D # sum if opposite-sign
mD = min(D, _D) # same-sign D in dP?
dM = M * rL - _M # sum if opposite-sign
mM = min(M, _M) # - ave_rM * M? negative if x-sign, M += adj_M + deep_M: P value before layer value?
mP = mI + mM + mD # match(P, _P) for derived vars, defines norm_PPm, no ndx: single, but nmx is summed
'''
for (param, _param) in zip([P.I, P.D, P.M], [_P.I, _P.D, _P.M]):
dm = comp_param(param, _param, [], ave, rL)
layer1.append([dm.d, dm.m])
mP += dm.m; dP += dm.d
if dP > P.derP.dP:
ndP_rdn = 1; dP_rdn = 0 #Not sure what to do with these
else:
dP_rdn = 1; ndP_rdn = 0
if mP > derP.mP:
rrdn = 1 # added to rdn, or diff alt, olp, div rdn?
else:
rrdn = 2
if mP > ave * 3 * rrdn:
#rvars = mP, mI, mD, mM, dI, dD, dM # redundant vars: dPP_rdn, ndPP_rdn, assigned in each fork?
rvars = layer1
else:
rvars = []
# append rrdn and ratio variables to current derP:
#PP.derP_[i] += [rrdn, rvars]
PP.derP_[i].rrdn = rrdn; PP.derP_[i].layer1 = rvars
# P vars -> _P vars:
_P = P
'''
m and d from comp_rate is more accurate than comp_norm?
rm, rd: rate value is relative?
also define Pd, if strongly directional?
if dP > ndP: ndPP_rdn = 1; dPP_rdn = 0 # value = D | nD
else: dPP_rdn = 1; ndPP_rdn = 0
'''
return PP_
def search_old(P_, fPd): # cross-compare patterns within horizontal line
sub_search_recursive(P_, fPd) # search with incremental distance: first inside sublayers
layer0 = {'L_': [], 'I_': [], 'D_': [], 'M_': []} # param_name: [params]
if len(P_) > 1: # at least 2 comparands
Ldert_ = []; rL_ = []
# unpack Ps:
for P in P_:
if "_P" in locals(): # not the 1st P
L = P.L; _L = _P.L
rL = L / _L # div_comp L: higher-scale, not accumulated: no search
mL = int(max(rL, 1 / rL)) * min(L, _L) # match in comp by division as additive compression, not directional
Ldert_.append(Cdert(i=L, p=L + _L, d=rL, m=mL))
rL_.append(rL)
_P = P
layer0['I_'].append([P.I, P.L, P.x0]) # I tuple
layer0['D_'].append([P.D, P.L, P.x0]) # D tuple
layer0['M_'].append([P.M, P.L, P.x0]) # M tuple
dert1__ = [Ldert_] # no search for L, step=1 only, contains derts vs. pderts
Pdert__ = [Ldert_] # Pp elements: pderts if param is core m, else derts
for param_name in ["I_", "D_", "M_"]:
param_ = layer0[param_name] # param values
par_ = param_[1:] # compared vectors:
_par_ = [[_par * rL, L, x0] for [_par, L, x0], rL in zip(param_[:-1], rL_)] # normalize by rL
if ((param_name == "I_") and not fPd) or ((param_name == "D_") and fPd): # dert-level P-defining params
if not fPd:
# project I by D, or D by Dd in deriv_comp sub_Ps:
_par_ = [[_par - (D / 2), L, x0] for [_par, L, x0], [D, _, _] in zip(_par_, layer0["D_"][:-1])]
# _I in (I,L,x0) is - (D / 2): forward projected by _D in (D,L,x0)
par_ = [[par + (D / 2), L, x0] for [par, L, x0], [D, _, _] in zip(par_, layer0["D_"][1:])]
# I in (I,L,x0) is backward projected by D in (D,L,x0)
Pdert__ += [search_param_(_par_, par_, P_[:-1], ave, rave=1)] # pdert_ if "I_"
del _P
_rL_ = []
for P in P_: # form rLs to normalize cross-comp of same-M-sign Ps in pdert2_
if "_P" in locals(): # not the 1st P
if "__P" in locals(): # not the 2nd P
_rL_.append(P.L / __P.L)
__P = _P
_P = P
__par_ = [[__par * _rL, L, x0] for [__par, L, x0], _rL in zip(param_[:-2], _rL_)] # normalize by _rL
# step=2 comp for P splice, one param: (I and not fPd) or (D and fPd):
dert2_ = [comp_param(__par, par, param_name[0], ave) for __par, par in zip(__par_, par_[1:])]
# else step=1 only:
dert1_ = [comp_param(_par, par, param_name[0], ave) for _par, par in zip(_par_, par_)] # append pdert1_ per param_
dert1__ += [dert1_]
if not param_name == "I_": Pdert__ += [dert1_] # dert_ = comp_param_
rdn__ = sum_rdn_(layer0, Pdert__, fPd=1) # assign redundancy to lesser-magnitude m|d in param pair for same-_P Pderts
rdn_Ppm__ = []
for param_name, Pdert_, rdn_ in zip(layer0, Pdert__, rdn__): # segment Pdert__ into Pps
if param_name == "I_" and not fPd: # = isinstance(Pdert_[0], Cpdert)
Ppm_ = form_Pp_rng(Pdert_, rdn_, P_)
else:
Ppm_ = form_Pp_(Pdert_, param_name, rdn_, P_, fPd=0) # Ppd_ is formed in -Ppms only, in intra_Ppm_
# list of param rdn_Ppm_s:
rdn_Ppm__ += [form_rdn_Pp_(Ppm_, param_name, dert1__, dert2_, fPd=0)]
return rdn_Ppm__
def comp_sublayers(
_P, P,
root_m): # if pdert.m -> if summed params m -> if positional m: mx0?
# comp subDerts:
subDertt_ = [] # preserved for future processing
# form Derts:
for _sublayer, sublayer in zip(_P.sublayers, P.sublayers):
subDertt_s = [[], []] # preserved for future processing
for i, isublayer in enumerate(_sublayer, sublayer): # list of subsets:
if root_m * len(
isublayer
) > ave_M * 5: # won't work, first len(isublayer) = 1, need to think about it
subDertt = []
for fPd, rdn, rng, sub_Pm_, xsub_pmdertt_, sub_Pd_, xsub_pddertt_ in sublayer:
for isub_P_ in sub_Pm_, sub_Pd_:
Dert = [0, 0, 0,
0] # P. L, I, D, M summed within sublayer
for sub_P in isub_P_:
Dert[0] += sub_P.L
Dert[1] += sub_P.I
Dert[2] += sub_P.D
Dert[3] += sub_P.M
subDertt.append(Dert)
subDertt_.append(subDertt) # 2tuple
else:
break # deeper Derts are not formed
subDertt_s[i] = subDertt_
_P.subDertt_ = subDertt_s[0]
P.subDertt_ = subDertt_s[1]
# comp Derts, sum cross-layer:
if not _P.derDertt_: _P.derDertt_ = []
xDert_mt = [0, 0]
derDertt = []
for (_mDert, _dDert), (mDert, dDert) in zip(subDertt_, subDertt_):
for i, _iDert, iDert in enumerate(zip((_mDert, mDert),
(_dDert, dDert))):
derDert = []
for _param, param, param_name, ave in zip(_iDert, iDert,
param_names, aves):
dert = comp_param(_param, param, param_name, ave)
if dert.m > 0:
xDert_mt[
i] += dert.m # pdert is higher-layer, also higher-value mL? no -m sum: won't be processed
derDert.append(
dert
) # dert per param, derDert_ per _subDert, a copy for subDert?
derDertt[i].append(derDert) # m, d derDerts per sublayer
_P.derDertt_.append(derDertt) # derDert_ per _P and P pair
P.derDertt_.append(derDertt) # bilateral assignment?
# comp sub_Ps:
if xDert_mt[
i] + root_m > ave_M * 4 and _P.sublayers and P.sublayers: # or pdert.sub_M + pdert.m + P.M?
# comp sub_Ps between sub_P_s in 1st sublayer:
_fPd, _rdn, _rng, _sub_P_, _xsub_pdertt_, _sub_Pp__ = _P.sublayers[0][
0] # 2nd [0] is the 1st and only subset
fPd, rdn, rng, sub_P_, xsub_pdertt_, sub_Pp__ = P.sublayers[0][0]
# if same intra_comp fork, else not comparable:
if fPd == _fPd and rng == _rng and min(_P.L,
P.L) > ave_Ls and root_m > 0:
# compare sub_Ps to each _sub_P within max relative distance, comb_M- proportional:
_SL = SL = 0 # summed Ls
start_index = next_index = 0 # index of starting sub_P for current _sub_P
_xsub_pdertt_ += [
[]
] # array of cross-sub_P pdert tuples: inner brackets, per sub_P_
xsub_pdertt_ += [
[]
] # append xsub_dertt per _sub_P_ and sub_P_, sparse?
for _sub_P in _sub_P_: # form xsub_pdertt_[ xsub_dertt [ xsub_pdert_[ sub_pdert]]]: each bracket is level of nesting
P_ = [] # to form xsub_Pps
_xsub_pdertt = [[], [], [],
[]] # tuple of L, I, D, M xsub_pderts
_SL += _sub_P.L # ix0 of next _sub_P
# search right:
for sub_P in sub_P_[
start_index:]: # index_ix0 > _ix0, only sub_Ps at proximate relative positions in sub_P_ are compared
if comp_sub_P(_sub_P, sub_P, _xsub_pdertt, P_, root_m):
break
# if next ix overlap: ix0 of next _sub_P < ix0 of current sub_P
if SL < _SL: next_index += 1
SL += sub_P.L # ix0 of next sub_P
# search left:
for sub_P in reversed(
sub_P_[len(sub_P_) - start_index:]
): # index_ix0 <= _ix0, invert positions of sub_P and _sub_P:
if comp_sub_P(sub_P, _sub_P, _xsub_pdertt, P_, root_m):
break
# not implemented: if param_name == "I_" and not fPd: sub_pdert = search_param_(param_)
# for next _sub_P:
start_index = next_index
if _xsub_pdertt[
0]: # at least 1 sub_pdert, real min length ~ 8, very unlikely
sub_Pdertt_ = [
(_xsub_pdertt[0], P_), (_xsub_pdertt[1], P_),
(_xsub_pdertt[2], P_), (_xsub_pdertt[3], P_)
]
# form 4-tuple of xsub_Pp_s:
xsub_rval_Pp_t, sub_Ppm__ = form_Pp_root(sub_Pdertt_, [],
[],
fPd=0)
_xsub_pdertt_[-1][:] = xsub_rval_Pp_t
xsub_pdertt_[-1][:] = _xsub_pdertt_[
-1] # bilateral assignment
else:
_xsub_pdertt_[-1].append(_xsub_pdertt) # preserve nesting
