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)