def main(args): config = CliConfig.from_parseargs(args) prelude(config) logging.info("Start...") logging.info(config) with open(args.config) as f: cascade_config = yaml.safe_load(f) feature_cost = np.loadtxt(args.feature_cost) logging.info("Loading data...") X, y, qid = cache.load_svmlight_file(args.train, query_id=True) X_val, y_val, qid_val = cache.load_svmlight_file(args.valid, query_id=True) # fix feature cost shape for Yahoo! data. There are actually 699 features # in the data files, but the cost file has 700. feature_cost = feature_cost[:X.shape[1]] logging.info("Fit...") model = Cascade(cascade_config, feature_cost) model.fit(X, y, qid, X_val, y_val, qid_val, approx_grads=args.approx_grads) modelpath = Path(config.model_dir) / "{}.pkl".format(config.name) logging.info("Save model to {}...".format(modelpath)) joblib.dump(model, modelpath)
def test_D(): s = symbols('s') C = Rational(3, 2) L = Rational(1, 3) r = Rational(1, 2) # series L, shunt C C0 = Cascade.Series(L * s) C1 = Cascade.Series(1 / (C * s)) C2 = Cascade.Shunt(1 / r) print("test_D") print(C0) print(C1) print(C2) print(C1.hit(C0)) print(C2.hit(C1.hit(C0))) Y = ratsimp(1 / C2.hit(C1.hit(C0)).terminate(0)) print(Y) Z = ratsimp(1 / (Y - 2)) print(Z) Y = ratsimp(Z - s / 3) print(Y)
def test_B(): s, L, C, r = symbols('s L C r') # series L, shunt C C0 = Cascade.Series(L * s) C1 = Cascade.Shunt(C * s) print(simplify(C0.hit(C1).terminate(r)))
def cascade(num_stages, cutoffs, score_type='independent'): X, y, qid = fixtures.train_data() X_val, y_val, qid_val = fixtures.valid_data() config = fixtures.cascade_config(num_stages=num_stages, cutoffs=cutoffs) config['score_type'] = score_type cost = fixtures.feature_costs() cascade = Cascade(config, cost) cascade.create_boosters(X, y, qid, X_val, y_val, qid_val) return cascade
def main(): args = parse_args() p = args['p'] g = Cascade.create_random_graph(1000) model = Cascade(g, p) model.generate_cascade_result(5) model.save(open("dump.p", "wb")) return
def test_F(): "Hazony example 5.2.2" s = symbols('s') print("test_F") Z = (s**2 + s + 1) / (s**2 + 2 * s + 2) print(f"Z: {Z}") min_r = (3 - sympy.sqrt(2)) / 4 Z1 = ratsimp(Z - min_r) print(f"Z1: {Z1}") #plot_real_part( sympy.lambdify(s, Z1, "numpy")) Y1 = ratsimp(1 / Z - 1) print(f"Y1: {Y1}") C = Cascade.Shunt(1) Z2 = ratsimp(1 / Y1 - s) print(f"Z2: {Z2}") C = C.hit(Cascade.Series(s)) Y3 = ratsimp(1 / Z2 - s - 1) print(f"Y3: {Y3}") Ytotal = C.hit(Cascade.Shunt(1).hit( Cascade.Shunt(s))).terminate_with_admittance(0) assert sympy.Eq(0, ratsimp(1 / Ytotal - Z)) assert sympy.Eq(1, ratsimp(Ytotal * Z)) Ytotal = C.hit(Cascade.Shunt(s)).terminate_with_admittance(1) assert sympy.Eq(0, ratsimp(1 / Ytotal - Z)) assert sympy.Eq(1, ratsimp(Ytotal * Z)) Ytotal = C.terminate_with_admittance(1 + s) assert sympy.Eq(0, ratsimp(1 / Ytotal - Z)) assert sympy.Eq(1, ratsimp(Ytotal * Z))
def test_E(): "Chop Chop example" s = symbols('s') print("test_E") Z = (2 * s**2 + 2 * s + 1) / (s * (s**2 + s + 1)) print(f"Z: {Z}") Z = ratsimp(Z) print(f"Z: {Z}") Z = ratsimp(Z - 1 / s) print(f"Z-1/s: {Z}") C = Cascade.Series(1 / s) Y = ratsimp(1 / Z - s) print(f"Y: {Y}") C = C.hit(Cascade.Shunt(s)) Z = ratsimp(1 / Y) print(f"Z: {Z-1-s}") C = C.hit(Cascade.Series(1 + s)).terminate(0) print(ratsimp(C))
def test_C(): s = symbols('s') C = Rational(3, 2) L = Rational(1, 3) r = Rational(1, 2) # series L, shunt C C0 = Cascade.Shunt(1 / (1 / (C * s) + L * s)) print(ratsimp(C0.terminate(r))) X = ratsimp(1 / C0.terminate(r)) print(X) Y = ratsimp(1 / (X - 2)) print(Y) Z = ratsimp(Y - s / 3) print(Z)
def __init__(self, value_start, value_end, number_of_suits): self.cascades = [Cascade() for i in range(8)] self.foundations = [Foundation(i) for i in range(4)] self.cells = [Cell() for i in range(4)] self.cards = [] # init the cards for i in range(number_of_suits): suit = CardSuit(i) for j in range(value_start, value_end + 1): self.cards.append(Card(j, suit)) # shuffle the cards self.shuffle() # draw card from cards and place them onto eight cascades while self.cards.__len__() > 0: for cascade in self.cascades: card = self.draw_card() if card: cascade.cards.append(card) else: break
def main(): if len(sys.argv) != 3: print "Usage: python lector.py <cascade.xml> <img>" sys.exit(-1) #Reading arguments cascadeFile = sys.argv[1] imgFile = sys.argv[2] cascade = Cascade(cascadeFile, imgFile) params = cascade.getParams() #Features by stage for stageId, stage in enumerate(cascade.getStages()): print "<- Stage {} ({} weak classifiers) ->".format(stageId,len(stage)) #print params['height']*(len(stage)+1)/2 featuresPerRow = int(math.sqrt(len(stage))) height = params['height'] * ((len(stage) + (featuresPerRow - 1)) / featuresPerRow) width = params['width'] * featuresPerRow allFeatures = np.zeros((height,width,3), np.uint8) for idf,feat in enumerate(stage): img = cascade.getImage() feat.draw(img) yStart = params['height'] * (idf / featuresPerRow) yEnd = yStart + img.shape[0] xStart = params['width'] * (idf % featuresPerRow) xEnd = xStart + img.shape[1] allFeatures[yStart : yEnd, xStart : xEnd] = img #cv2.imshow("Stage {}".format(stageId), img) #cv2.waitKey() cv2.namedWindow("allFeat stage {}".format(stageId),cv.CV_WINDOW_NORMAL) cv2.imshow("allFeat stage {}".format(stageId),allFeatures) cv2.waitKey() sys.exit() #All features for feat in cascade.getFeatures(): img = cascade.getImage() feat.draw(img) cv2.imshow("Imagen original", img) cv2.waitKey()
def compute_cascade(train_images, train_labels, int_imgs, cascade=None): count = 1 if cascade == None else len(cascade.strong_learners) + 1 if cascade == None: cascade = Cascade() success_rate_overall = 0.0 last_success_rate = 0.05 while success_rate_overall < 0.99 and success_rate_overall != last_success_rate: print('***** starting round {} *****'.format(str(count))) cascade.add_strong_learner( adaboost_round(train_images, train_labels, count)) correct_bg_indices = cascade.get_correct_bg_indices( train_images, train_labels) train_images = np.delete(train_images, correct_bg_indices, axis=0) train_labels = np.delete(train_labels, correct_bg_indices, axis=0) last_success_rate = success_rate_overall success_rate_overall = cascade.calc_success_rate(int_imgs, labels) print('overall success rate after this round: {}'.format( str(success_rate_overall))) print('images left: {}'.format(str(train_images.shape[0]))) with open('partial_save_data.bin', 'wb') as f: pickle.dump(cascade, f) with open('partial_save_images.bin', 'wb') as f: pickle.dump(train_images, f) with open('partial_save_labels.bin', 'wb') as f: pickle.dump(train_labels, f) print('dumped partially trained model to file') count += 1 if success_rate_overall >= 0.99: print('at least 99% of images classified correctly.') else: print('process failed to converge. success rate:', success_rate_overall) return cascade
def dummy_cascade(): dummy_config = fixtures.cascade_config() dummy_cost = fixtures.feature_costs() return Cascade(dummy_config, dummy_cost)
def setup_app(): return ExceptionMiddleware(Cascade([fever_app, frontend_app]))
def __init__(self, regressor='linear', descriptor='sift_rotate'): Cascade.__init__(self, regressor, descriptor) self.mean_shape, self.mean_params, self.shp_transform = None, None, None self.encoder = None
f.close() if getPrevStat() == "stopped": quit() key = None secret = None if os.path.isfile(keyFileName): f = open(keyFileName, "r") key = f.readline().strip() secret = f.readline().strip() f.close() engine = Cascade(key, secret, silent) engine.setPair(pair) engine.setProfitPercent(profitPercent) engine.setStartPercent(startPercent) engine.setDeepPercent(deepPercent) engine.setTotalInvest(totalInvest) engine.setProfitPrecision(profitPrecision) engine.setActiveOrdersCount(activeOrdersCount) engine.setAllowRevers(allowRevers) if not silent: print("\ncur Pair:\t{0}".format(pair)) if os.path.isfile(cascadeFileName): # warning! not chek pair and another params
def main(args): start_start = time.time() feature_file = open(args.output, "w", newline='') feature_writer = csv.writer(feature_file) features_name = ["target_node", "target_neighbors_num", "First_nbr_adopter", "Second_nbr_adopter", \ "Third_nbr_adopter", "past_adoption_exist", "past_adoption_target_num", \ "com_hashtags_max", "com_hashtags_min", "com_hashtags_ave"] + ["outdeg_v1", "num_hashtags_v1", "orig_connections_k", "unique_Ak_num", \ "max_subG", "min_subG", "ave_subG", "views_1k", "subG_edges", "max_AkG_deg", \ "min_AkG_deg", "ave_AkG_deg", "time_ave_k", "time_ave_1_k2", "time_ave_k2_k", \ "speed_exposure", "speed_adoption"] + ["time_1_{}".format(i) for i in range(1, args.k)] + \ ["r_node_{}".format(i) for i in range(args.k)] + ["distKV_target_{}".format(i) for i in range(args.k)] + \ ["adoption_p", "label"] feature_writer.writerow(features_name) # p_nodeToH, p_G = get_G_nodeToHashtag() # p_G, p_nodeToH = {},{} count = 0 with open(args.input, 'r', encoding='utf-8') as f: for line in f: if count > args.cascades_counts: break cas = Cascade(args.k, line) if cas.isLargerK: cas.get_cascade_series_subcas() # print(cas.uniqueAK) hashtag = cas.cascade_with_unique_node[0] features = Features(cas.uniqueAK, hashtag) start = time.time() Infected_targetNodes = cas.getTargetNodes(flag=0) with ThreadPoolExecutor(max_workers=cpu_count()) as excutor: tf_infected = excutor.map(features.Target_Features, Infected_targetNodes) targetNodes = cas.getTargetNodes(flag=1) # partial_target_features = partial(features.Target_Features()) with ThreadPoolExecutor(max_workers=cpu_count()) as excutor: tf = excutor.map(features.Target_Features, targetNodes) fff = features.First_Forwarder_Features() fkff = features.First_K_Forwarders_Features() sf = features.Structure_Features() gtf = features.get_Temporal_Features( cas.uniqueAK_with_time_without_hashtag, cas.k) # tf = features.Target_Features(0, rwr) feature_list = fff + fkff + sf + gtf for tf_list in tf_infected: feature_list1 = tf_list[:-2 * args.k - 1] + feature_list + tf_list[ -2 * args.k - 1:] + [1] feature_writer.writerow(feature_list1) for tf_list in tf: feature_list1 = tf_list[:-2 * args.k - 1] + feature_list + tf_list[ -2 * args.k - 1:] + [0] feature_writer.writerow(feature_list1) # print(fff, fkff, sf, gtf, tf) print("串行运行时间:", time.time() - start) # ============================================================================= # start = time.time() # with ThreadPoolExecutor(max_workers = cpu_count()) as excutor: # fff = excutor.submit(features.First_Forwarder_Features) # fkff = excutor.submit(features.First_K_Forwarders_Features) # sf = excutor.submit(features.Structure_Features) # gtf = excutor.submit(features.get_Temporal_Features,cas.uniqueAK_with_time_without_hashtag, cas.k) # tf = excutor.submit(features.Target_Features,0, rwr) # print(type(fff.result())) # print(fff.result(),fkff.result(), sf.result(), gtf.result(),tf.result()) # print("并行运行时间:", time.time() - start) # ============================================================================= count += 1 feature_file.close() print("总运行时间:", time.time() - start_start)
def test_A(): r0, r1, r = 100, 200, 1 R0 = Cascade.Series(r0) R1 = Cascade.Series(r1) assert 301 == R0.hit(R1).terminate(r)
def test_G(): "Hazony example 5.2.2" s, k = symbols('s k') pprint("test_G") Z = (s**2 + s + 1) / (s**2 + s + 4) pprint(f"Z: {Z}") #plot_real_part( sympy.lambdify(s, Z, "numpy")) w0 = sympy.sqrt(2) target = radsimp(Z.subs({s: sympy.I * w0}) / (sympy.I * w0)) print(f"target: {target}") eq = sympy.Eq(Z.subs({s: k}) / k, target) roots = sympy.solveset(eq, k) if True: for k0 in roots: Z_k0 = Z.subs({s: k0}) eta = cancel((k0 * Z - s * Z_k0) / (k0 * Z_k0 - s * Z)) print(k0, Z_k0, eta) #plot_real_part( sympy.lambdify(s, eta, "numpy")) k0 = 1 Z_k0 = Z.subs({s: k0}) eta = cancel((k0 * Z - s * Z_k0) / (k0 * Z_k0 - s * Z)) print(k0, Z_k0, eta) print("normal") Z0 = eta * Z_k0 print(f"Z0: {Z0}") Y1 = cancel(1 / Z0 - 4) print(f"Y1: {Y1}") C = Cascade.Shunt(4) Z2 = cancel(1 / Y1 - s / 6 - 1 / (3 * s)) print(f"Z2: {Z2}") C = C.hit(Cascade.Series(s / 6)) C = C.hit(Cascade.Series(1 / (3 * s))) eta_Z_k0 = cancel(C.terminate(0)) print(f"eta_Z_k0: {eta_Z_k0}") assert sympy.Eq(cancel(eta_Z_k0 - Z0), 0) print("recip") Z0 = cancel(Z_k0 / eta) print(f"Z0: {Z0}") Z1 = cancel(Z0 - 1) print(f"Z1: {Z1}") C = Cascade.Series(1) Y2 = cancel(1 / Z1 - 2 * s / 3 - 4 / (3 * s)) print(f"Y2: {Y2}") C = C.hit(Cascade.Shunt(2 * s / 3)) C = C.hit(Cascade.Shunt(4 / (3 * s))) eta_over_Z_k0 = cancel(1 / C.terminate_with_admittance(0)) print(f"eta_over_Z_k0: {eta_over_Z_k0}") assert sympy.Eq(cancel(eta_over_Z_k0 - Z0), 0) def p(a, b): return 1 / (1 / a + 1 / b) constructed_Z = cancel( p(eta_Z_k0, (k0 * Z_k0) / s) + p(eta_over_Z_k0, (Z_k0 * s) / k0)) print(f"constructed_Z: {constructed_Z}") assert sympy.Eq(cancel(constructed_Z - Z), 0)
from config import TRAINING_NONFACE from config import CASACADE_LIMIT from cascade import Cascade from time import time from multiprocessing import freeze_support raise Exception("Unimplemented Cascade") if __name__ == "__main__": freeze_support() start_time = time() model = Cascade(TRAINING_FACE, TRAINING_NONFACE, limit = CASACADE_LIMIT) end_time = time() print "total Cost time: ", end_time - start_time try: model.train() model.save() except KeyboardInterrupt: print "key board interrupt happened. training pause."
def __init__(self, regressor='linear', descriptor='sift'): Cascade.__init__(self, regressor, descriptor) self.mean_shape = None
def __init__(self, regressor='linear', descriptor='sift_rotate'): Cascade.__init__(self, regressor, descriptor) self.mean_shape = None self.encoder = None
# print '~~~~~~~~~~~~~~~~~' # print sys.argv # print '~~~~~~~~~~~~~~~~~' tar = '' has_tar = False ready = True set_configs = False show_configs = False flags = dict() args = sys.argv # args = 'csinpsect.py NYC_01 -k'.split(' ') if '-h' in args: print LBREAK Cascade().print_help() print LBREAK else: try: x = 1 while x < len(args): current_item = args[x].upper() if '-' in current_item: if 'S' in args[x].upper(): set_configs = True x += 1 flags[args[x].upper()] = args[x + 1] x += 2 elif 'C' in current_item: show_configs = True x += 1
def test_H(): "Hazony problem 5.3.a" s, k = symbols('s k') w = symbols('w', real=True) pprint("test_H") Z = (s**3 + 4 * s**2 + 5 * s + 8) / (2 * s**3 + 2 * s**2 + 20 * s + 9) pprint(f"Z: {Z}") #plot_real_part( sympy.lambdify(s, Z, "numpy")) real_part = cancel(sympy.re(Z.subs({s: sympy.I * w}))) print(f"real_part: {real_part}") roots = sympy.solveset(real_part, w) print(f"roots for w: {roots}") #plot( sympy.lambdify(w, real_part, "numpy")) w0 = sympy.sqrt(6) target0 = radsimp(Z.subs({s: sympy.I * w0}) / (sympy.I * w0)) print(f"target: {target0}") target1 = radsimp(Z.subs({s: sympy.I * w0}) * (sympy.I * w0)) print(f"target: {target1}") assert target0 > 0 eq = sympy.Eq(Z.subs({s: k}) / k, target0) #eq = sympy.Eq( Z.subs({s:k})*k, target1) print(f"eq: {eq}") roots = sympy.solveset(eq, k) print(f"roots for k: {roots}") k0 = Rational(1, 4) + sympy.sqrt(33) / 4 Z_k0 = Z.subs({s: k0}) print(k0, Z_k0) print(k0.evalf(), Z_k0.evalf()) return f = s**2 + 6 den = cancel((k0 * Z_k0 - s * Z) / f) print(f"den factored: {sympy.factor(den)}") num = cancel((k0 * Z - s * Z_k0) / f) print(f"num factored: {sympy.factor(num).evalf()}") print(sympy.factor(cancel(den / num))) return eta = cancel(((k0 * Z - s * Z_k0) / (k0 * Z_k0 - s * Z)).evalf()) print(k0, Z_k0, eta) print(k0, Z_k0, eta.evalf()) print("normal") Z0 = eta * Z_k0 print(f"Z0: {Z0}") Y1 = cancel(1 / Z0 - 4) print(f"Y1: {Y1}") C = Cascade.Shunt(4) Z2 = cancel(1 / Y1 - s / 6 - 1 / (3 * s)) print(f"Z2: {Z2}") C = C.hit(Cascade.Series(s / 6)) C = C.hit(Cascade.Series(1 / (3 * s))) eta_Z_k0 = cancel(C.terminate(0)) print(f"eta_Z_k0: {eta_Z_k0}") assert sympy.Eq(cancel(eta_Z_k0 - Z0), 0) print("recip") Z0 = cancel(Z_k0 / eta) print(f"Z0: {Z0}") Z1 = cancel(Z0 - 1) print(f"Z1: {Z1}") C = Cascade.Series(1) Y2 = cancel(1 / Z1 - 2 * s / 3 - 4 / (3 * s)) print(f"Y2: {Y2}") C = C.hit(Cascade.Shunt(2 * s / 3)) C = C.hit(Cascade.Shunt(4 / (3 * s))) eta_over_Z_k0 = cancel(1 / C.terminate_with_admittance(0)) print(f"eta_over_Z_k0: {eta_over_Z_k0}") assert sympy.Eq(cancel(eta_over_Z_k0 - Z0), 0) def p(a, b): return 1 / (1 / a + 1 / b) constructed_Z = cancel( p(eta_Z_k0, (k0 * Z_k0) / s) + p(eta_over_Z_k0, (Z_k0 * s) / k0)) print(f"constructed_Z: {constructed_Z}") assert sympy.Eq(cancel(constructed_Z - Z), 0)
def test_I(): "Hazony problem 5.3.a" s, k = symbols('s k') w = symbols('w', real=True) pprint("test_I") Z = (s**3 + 3 * s**2 + s + 1) / (s**3 + s**2 + 3 * s + 1) pprint(f"Z: {Z}") #plot_real_part( sympy.lambdify(s, Z, "numpy")) real_part = cancel(sympy.re(Z.subs({s: sympy.I * w}))) print(f"real_part: {real_part}") roots = sympy.solveset(real_part, w) print(f"roots for w: {roots}") #plot( sympy.lambdify(w, real_part, "numpy")) w0 = 1 target0 = radsimp(Z.subs({s: sympy.I * w0}) / (sympy.I * w0)) print(f"target: {target0}") target1 = radsimp(Z.subs({s: sympy.I * w0}) * (sympy.I * w0)) print(f"target: {target1}") assert target0 > 0 eq = sympy.Eq(Z.subs({s: k}) / k, target0) #assert target1 > 0 #eq = sympy.Eq( Z.subs({s:k})*k, target1) roots = sympy.solveset(eq, k) print(f"roots for k: {roots}") k0 = Rational(1, 1) Z_k0 = Z.subs({s: k0}) print(k0, Z_k0) print(k0.evalf(), Z_k0.evalf()) den = cancel((k0 * Z_k0 - s * Z)) print(f"den factored: {sympy.factor(den)}") num = cancel((k0 * Z - s * Z_k0)) print(f"num factored: {sympy.factor(num)}") eta = cancel(num / den) print(k0, Z_k0, eta) print("normal") Z0 = eta * Z_k0 print(f"Z0: {Z0}") Y1 = ratsimp(1 / Z0 - 1) print(f"Y1: {Y1}") C = Cascade.Shunt(1) Z2 = ratsimp(1 / Y1 - s / 2 - 1 / (2 * s)) print(f"Z2: {Z2}") C = C.hit(Cascade.Series(s / 2)) C = C.hit(Cascade.Series(1 / (2 * s))) eta_Z_k0 = cancel(C.terminate(0)) print(f"eta_Z_k0: {eta_Z_k0}") assert sympy.Eq(cancel(eta_Z_k0 - Z0), 0) print("recip") Z0 = cancel(Z_k0 / eta) print(f"Z0: {Z0}") Z1 = ratsimp(Z0 - 1) print(f"Z1: {Z1}") C = Cascade.Series(1) Y2 = ratsimp(1 / Z1 - s / 2 - 1 / (2 * s)) print(f"Y2: {Y2}") C = C.hit(Cascade.Shunt(s / 2)) C = C.hit(Cascade.Shunt(1 / (2 * s))) eta_over_Z_k0 = cancel(1 / C.terminate_with_admittance(0)) print(f"eta_over_Z_k0: {eta_over_Z_k0}") assert sympy.Eq(cancel(eta_over_Z_k0 - Z0), 0) def p(a, b): return a * b / (a + b) constructed_Z = cancel( p(eta_Z_k0, (k0 * Z_k0) / s) + p(eta_over_Z_k0, (Z_k0 * s) / k0)) print(f"constructed_Z: {constructed_Z}") assert sympy.Eq(cancel(constructed_Z - Z), 0)
def test_J(): "Second problem in Guillemin" s, k = symbols('s k') w = symbols('w', real=True) pprint("test_I") Z = (s**2 + s + 8) / (s**2 + 2 * s + 2) pprint(f"Z: {Z}") Y = 1 / Z #plot_real_part( sympy.lambdify(s, Y, "numpy")) real_part = cancel(sympy.re(Y.subs({s: sympy.I * w}))) print(f"real_part: {real_part}") roots = sympy.solveset(real_part, w) print(f"roots for w: {roots}") #plot( sympy.lambdify(w, real_part, "numpy")) w0 = 2 target0 = radsimp(Y.subs({s: sympy.I * w0}) / (sympy.I * w0)) print(f"target: {target0.evalf()}") target0 = Rational(1, 2) target1 = radsimp(Y.subs({s: sympy.I * w0}) * (sympy.I * w0)) print(f"target: {target1.evalf()}") target1 = Rational(2, 1) assert target0 > 0 eq = sympy.Eq(Y.subs({s: k}) / k, target0) #assert target1 > 0 #eq = sympy.Eq( Z.subs({s:k})*k, target1) roots = sympy.solveset(eq, k) print(f"roots for k: {roots}") k0 = Rational(1, 1) Y_k0 = Y.subs({s: k0}) print(k0, Y_k0) print(k0.evalf(), Y_k0.evalf()) den = cancel((k0 * Y_k0 - s * Y)) print(f"den factored: {sympy.factor(den)}") num = cancel((k0 * Y - s * Y_k0)) print(f"num factored: {sympy.factor(num)}") eta = cancel(num / den) print(k0, Y_k0, eta) print("normal") Y0 = eta * Y_k0 print(f"Y0: {Y0}") Z1 = ratsimp(1 / Y0 - 4) print(f"Z1: {Z1}") C = Cascade.Series(4) Y2 = ratsimp(1 / Z1) print(f"Y2: {Y2}") C = C.hit(Cascade.Shunt(s / 10)) C = C.hit(Cascade.Shunt(2 / (5 * s))) eta_Y_k0 = cancel(C.terminate_with_admittance(0)) print(f"eta_Y_k0: {eta_Y_k0}") assert sympy.Eq(cancel(eta_Y_k0 - Y0), 0) print("recip") Y0 = ratsimp(Y_k0 / eta) print(f"Y0: {Y0}") Y1 = ratsimp(Y0 - 1) print(f"Y1: {Y1}") C = Cascade.Shunt(1) Z2 = ratsimp(1 / Y1 - 2 * s / 5 - 8 / (5 * s)) print(f"Z2: {Z2}") C = C.hit(Cascade.Series(2 * s / 5)) C = C.hit(Cascade.Series(8 / (5 * s))) eta_over_Y_k0 = cancel(1 / C.terminate(0)) print(f"eta_over_Y_k0: {eta_over_Y_k0}") assert sympy.Eq(cancel(eta_over_Y_k0 - Y0), 0) def p(a, b): return a * b / (a + b) constructed_Y = cancel( p(eta_Y_k0, (k0 * Y_k0) / s) + p(eta_over_Y_k0, (Y_k0 * s) / k0)) print(f"constructed_Y: {constructed_Y}") assert sympy.Eq(cancel(constructed_Y - Y), 0)