def _next_combination(binlist): ''' >>> binlist = [1, 0, 0, 1, 1] >>> >>> _next_combination(binlist) [1, 0, 1, 0, 1] >>> >>> _next_combination(binlist) [1, 0, 1, 1, 0] >>> _next_combination(binlist) [1, 1, 0, 1, 0] >>> _next_combination(binlist) [1, 1, 1, 0, 0] >>> _next_combination(binlist) >>> >>> binlist = [1, 0, 1, 1, 0] >>> _next_combination(binlist) [1, 1, 0, 1, 0] >>> _next_combination(binlist) [1, 1, 1, 0, 0] >>> _next_combination(binlist) >>> ''' lngth = len(binlist) last = binlist[-1] if (last == 1): last_zero_index = elel.find_fst_index_eq_via_reversing(0, binlist) if (last_zero_index == None): return (None) else: pass next_one_index = last_zero_index + 1 elel.swap(last_zero_index, next_one_index, binlist) # hl = binlist[:next_one_index + 1] tl = binlist[next_one_index + 1:] tl = _get_minbinlist(tl) binlist = elel.concat(hl, tl) # else: last_one_index = elel.find_fst_index_eq_via_reversing(1, binlist) prev_zero_index = elel.find_fst_index_eq_via_reversing( 0, binlist[:last_one_index]) if (prev_zero_index == None): return (None) else: pass prev_one_index = prev_zero_index + 1 elel.swap(prev_zero_index, prev_one_index, binlist) # hl = binlist[:prev_one_index + 1] tl = binlist[prev_one_index + 1:] tl = _get_minbinlist(tl) binlist = elel.concat(hl, tl) # return (binlist)
def _repl_cols(df,poses,*args,**kwargs): df = copy.deepcopy(df) args = list(args) if(isinstance(args[0],dict)): kl,vl = eded.d2kvlist(args[0]) else: if(isinstance(args[1],list)): kl = elel.select_evens(args) vl = elel.select_odds(args) else: kl,vl = elel.brkl2kvlist(args,df.index.__len__()+1) if(isinstance(poses[0],int)): pass else: colnames = poses clocs_array = [] for i in range(colnames.__len__()): clocs = _cn2clocs(colnames[i],**kwargs) clocs_array.append((clocs,i)) if("whiches" in kwargs): whiches = kwargs['whiches'] clocs_array = elel.mapv(clocs_array,lambda ele:ele[0]) clocs = elel.batexec(lambda clocs,which:clocs[which],clocs_array,whiches) poses = clocs else: #by default replace all nkl = [] nvl = [] nclocs = [] for i in range(clocs_array.__len__()): clocs = clocs_array[i][0] index = clocs_array[i][1] tmpkl = elel.init(clocs.__len__(),kl[i]) tmpvl = elel.init(clocs.__len__(),vl[i]) nkl = elel.concat(nkl,tmpkl) nvl = elel.concat(nvl,tmpvl) nclocs = elel.concat(nclocs,clocs) #batsort poses = nclocs kl,vl = elel.batsorted(nclocs,nkl,nvl) poses = elel.mapv(poses,lambda pos:pos+1) poses.sort() for i in range(0,poses.__len__()): pos = poses[i] df.insert(pos,kl[i],vl[i],kwargs['allow_duplicates']) pos = pos -1 all_clocs = elel.init_range(0,df.columns.__len__(),1) all_clocs.remove(pos) df = df.iloc[:,all_clocs] return(df)
def dcds1(one): ''' recur ''' d = dcds1_norecur(one) ele = {'data': d, 'pl': []} unhandled = [ele] while (unhandled.__len__() > 0): #yield(d) next_unhandled = [] for i in range(0, unhandled.__len__()): ele = unhandled[i] data = ele['data'] ppl = ele['pl'] cond = dcds1_is_leaf(data) if (cond): pass else: children, rchildren, plsuffix = dcds1_get_children(d, ppl) cpl = copy.deepcopy(ppl) if (plsuffix == None): pass else: cpl.append(plsuffix) eded._setitem_via_pathlist(d, cpl, rchildren) next_unhandled = elel.concat(next_unhandled, children) unhandled = next_unhandled return (d)
def _get_clocs(colnames,**kwargs): clocs = [] for i in range(colnames.__len__()): colname = colnames[i] tmp = _cn2clocs(colname,**kwargs) clocs = elel.concat(clocs,tmp) clocs.sort() return(clocs)
def _get_rlocs(rownames,**kwargs): rlocs = [] for i in range(rownames.__len__()): rowname = rownames[i] tmp = _rn2rlocs(rowname,**kwargs) rlocs = elel.concat(rlocs,tmp) rlocs.sort() return(rlocs)
def get_css_rule_cil(rule): ats = get_atkey(rule) head = [ats] pcil = get_prelude_cil(rule) head = elel.concat(head, pcil) c = dcds1(rule) ccil = cntnt2cil(c['content'], for_display=False) rslt = [head, ccil] return (rslt)
def _next_permutation(arr): pair = elel.find_fst_indexpair_fstltsnd_via_reversing(arr) if (pair == None): return (None) else: j = elel.find_fst_index_gt_via_reversing(arr[pair[0]], arr) arr = elel.swap(pair[0], j, arr) init = arr[:pair[1]] tail = sorted(arr[pair[1]:]) arr = elel.concat(init, tail) return (arr)
def type_q_sort_by_q(darr): darr1 = elel.cond_select_values_all(darr, cond_func=lambda ele: (ele['q'] == None)) darr2 = elel.cond_select_values_all(darr, cond_func=lambda ele: (ele['q'] != None)) ndarr1 = elel.sortDictList(darr1, cond_keys=['q', 'type'], reverse=True) idarr2 = elel.array_map(darr2, type_q_floatize) ndarr2 = elel.sortDictList(darr2, cond_keys=['q', 'type'], reverse=True) ndarr = elel.concat(ndarr1, ndarr2) return (ndarr)
def gen_4e_mat(rule, **kwargs): if ("codec" in kwargs): codec = kwargs['codec'] else: codec = 'utf-8' if ("prelude" in kwargs): prelude = kwargs['prelude'] else: prelude = 'str' if ("content" in kwargs): content = kwargs['content'] else: content = 'format' mat = [] d = gen_4e(rule, prelude) root = {"data": d, "pl": [0]} unhandled = [root] while (unhandled.__len__() > 0): next_unhandled = [] mat.append([]) level = mat[mat.__len__() - 1] for i in range(0, unhandled.__len__()): ele = unhandled[i] data = ele['data'] ppl = ele['pl'] ##### rules = srlz2rules(data['content']) #### cond = fe_is_leaf(rules) if (cond): ele['leaf'] = True if (content == 'format'): data['content'] = cbs_fmt(data['content']) else: pass else: ele['leaf'] = False si = next_unhandled.__len__() children = srlz_get_children_from_rules( rules, si, ppl, prelude, codec) next_unhandled = elel.concat(next_unhandled, children) level.append(ele) unhandled = next_unhandled return (mat)
def _rmrows(df,*rownames,**kwargs): df = copy.deepcopy(df) rownames = list(rownames) if(isinstance(rownames[0],list)): rownames = rownames[0] else: pass rlocs_array = [] for i in range(rownames.__len__()): rlocs = _rn2rlocs(rownames[i],**kwargs) rlocs_array.append(rlocs) if("whiches" in kwargs): whiches = kwargs['whiches'] rlocs = elel.batexec(lambda rlocs,which:rlocs[which],rlocs_array,whiches) else: #by default remove all rlocs = elel.concat(*rlocs_array) all_rlocs = elel.init_range(0,df.index.__len__(),1) lefted_rlocs = elel.select_seqs_not(all_rlocs,rlocs) return(df.iloc[lefted_rlocs])
def _rmcols(df,*colnames,**kwargs): df = copy.deepcopy(df) colnames = list(colnames) if(isinstance(colnames[0],list)): colnames = colnames[0] else: pass clocs_array = [] for i in range(colnames.__len__()): clocs = _cn2clocs(colnames[i],**kwargs) clocs_array.append(clocs) if("whiches" in kwargs): whiches = kwargs['whiches'] clocs = elel.batexec(lambda clocs,which:clocs[which],clocs_array,whiches) else: #by default remove all clocs = elel.concat(*clocs_array) all_clocs = elel.init_range(0,df.columns.__len__(),1) lefted_clocs = elel.select_seqs_not(all_clocs,clocs) return(df.iloc[:,lefted_clocs])
def cntnt_rm_whitespace(content): content = cntnt_fmt_norecur(content) rslt = elel.init(content.__len__()) unhandled = cntnt_init_unhandled(content) while (unhandled.__len__() > 0): next_unhandled = [] for i in range(0, unhandled.__len__()): ele = unhandled[i] data = ele['data'] ppl = ele['pl'] cond = cntnt_is_leaf(data) if (cond): rslt = elel.setitem_via_pathlist(rslt, data, ppl) else: children = cntnt_get_children(data, ppl) rchildren = elel.array_map(children, lambda child: child['data']) dummy = copy.deepcopy(data) dummy['content'] = rchildren rslt = elel.setitem_via_pathlist(rslt, dummy, ppl) next_unhandled = elel.concat(next_unhandled, children) unhandled = next_unhandled return (rslt)
def cntnt2cil(content, for_display=False): ####for comments if (content == None): return ([]) else: pass #### content = cntnt_fmt_norecur(content) rslt = elel.init(content.__len__()) unhandled = cntnt_init_unhandled(content) while (unhandled.__len__() > 0): next_unhandled = [] for i in range(0, unhandled.__len__()): ele = unhandled[i] data = ele['data'] ppl = ele['pl'] cond = cntnt_is_leaf(data) rpl = elel.remove_all(ppl, 'content') if (cond): s = encd_one(data) rslt = elel.setitem_via_pathlist(rslt, s, rpl) else: # treat square_blk as a leaf if (data['type'] == '[] block'): s = encd_square_blk(data, for_display) rslt = elel.setitem_via_pathlist(rslt, s, rpl) # treat paren_blk as a leaf elif (data['type'] == '() block'): s = encd_paren_blk(data) rslt = elel.setitem_via_pathlist(rslt, s, rpl) else: children = cntnt_get_children(data, ppl) dummy = elel.init(children.__len__()) rslt = elel.setitem_via_pathlist(rslt, dummy, rpl) next_unhandled = elel.concat(next_unhandled, children) unhandled = next_unhandled return (rslt)
def dig(root, func_is_leaf, get_children, **kwargs): ''' ''' if ('func_is_leaf_args' in kwargs): func_is_leaf_args = kwargs['func_is_leaf_args'] else: func_is_leaf_args = [] if ('get_children_args' in kwargs): get_children_args = kwargs['get_children_args'] else: get_children_args = [] unhandled = [root] while (unhandled.__len__() > 0): yield (unhandled) next_unhandled = [] for i in range(0, unhandled.__len__()): ele = unhandled[i] cond = func_is_leaf(ele, *func_is_leaf_args) if (cond): pass else: children = get_children(ele, *get_children_args) next_unhandled = elel.concat(next_unhandled, children) unhandled = next_unhandled
def centerlize(lines, cw, top, left): tb_padding = creat_tb_padding(cw, top) lines = padding_left(lines, left) return (elel.concat(tb_padding, lines, tb_padding))
def wfs_eles(wfsm): eles = elel.concat(*wfsm) return(eles)
def m2wfsel(m): l = elel.concat(*m) return(l)
def get_layer(nonleaf_unhandled): childrens = elel.mapv(nonleaf_unhandled, get_children) layer = elel.concat(*childrens) return (layer)
def _prev_combination(binlist): ''' >>> _prev_combination([1,1,1,1,1]) >>> _prev_combination([1,1,1,0,1]) [1, 1, 0, 1, 1] >>> _prev_combination([1,1,0,1,1]) [1, 0, 1, 1, 1] >>> >>> _prev_combination([1,0,1,1,1]) [0, 1, 1, 1, 1] >>> _prev_combination([0,1,1,1,1]) >>> >>> >>> _prev_combination([1, 0, 1, 1, 0]) [1, 0, 1, 0, 1] >>> >>> _prev_combination([1, 0, 1,0,1]) [1, 0, 0, 1, 1] >>> >>> _prev_combination([1, 0, 0,1,1]) [0, 1, 0, 1, 1] >>> _prev_combination([0,1,0,1,1]) [0, 0, 1, 1, 1] >>> _prev_combination([0,0,1,1,1]) >>> ''' lngth = len(binlist) last = binlist[-1] if (last == 1): ''' [1,0,0,1,1] ^-------------------find this 0 [0,1,0,1,1] ^ ^ ------------------swap with 1 after this 0 [1,0,1,0,1] ^-------------------find this 0 [0,1,1,0,1] ^ ^ ------------------swap with 1 after this 0 [1,1,1,1,1] --------None [0,0,1,1,1] --------None 0...0 1...1 ''' #从后往前找,find last zero last_zero_index = elel.find_fst_index_eq_via_reversing(0, binlist) if (last_zero_index == None): return (None) else: pass #从last-zero开始,从后往前找, 找到第一个1 prev_one_index = elel.find_fst_index_eq_via_reversing( 1, binlist[:last_zero_index]) if (prev_one_index == None): return (None) else: pass #这个1后面(从前往后)肯定是0,记录这个0 prev_zero_index = prev_one_index + 1 elel.swap(prev_zero_index, prev_one_index, binlist) # hl = binlist[:prev_zero_index + 1] tl = binlist[prev_zero_index + 1:] tl = _get_maxbinlist(tl) binlist = elel.concat(hl, tl) # else: ''' [1,0,1,1,0] ^----------------------find this 1 [1,0,1,1,0] ^ ^ --------------------swap with 1 before this 0 [0,0,0,0,0]-----------------None ''' last_one_index = elel.find_fst_index_eq_via_reversing(1, binlist) if (last_one_index == None): return (None) else: pass next_zero_index = last_one_index + 1 elel.swap(next_zero_index, last_one_index, binlist) # hl = binlist[:next_zero_index + 1] tl = binlist[next_zero_index + 1:] tl = _get_maxbinlist(tl) binlist = elel.concat(hl, tl) # return (binlist)