<jupyter_start><jupyter_text>Determining the n-th Term of an Arithmetic Sequence and Arithmetic Series Dalam latihan ini, kita akan membuat barisan aritmatika berhingga dan tak hingga menggunakan fungsi Python sederhana. Sebagai masukan, kita ingin memberikan suku pertama barisan tersebut, a1 , beda persekutuan , d , dan panjang barisan, n . Hanya satu suku (suku ke- n ) dari barisan tersebut.Urutan angka lengkap.Jumlah n suku deret aritmatika, untuk membandingkannya dengan hasil deret aritmatika yang diberikan sebelumnya. We need to provide the first term of the sequence, a1, the common difference, d, and the length of the sequence, n, as inputs.<jupyter_code># Pertama, tulis fungsi yang mereturn hanya n-th.

def a_n(a1, d, n):
    an = a1 + (n-1) * d
    return an<jupyter_output><empty_output><jupyter_text>Test thy codes<jupyter_code>a_n(4,3,10)<jupyter_output><empty_output><jupyter_text>Sekarang, tulis fungsi yang menginkrementasi suku awal, a1, sebanyak d, dan n kali. Selanjutnya kita menyimpannya semua kenaikan levelnya di dalam list<jupyter_code>def a_seq(a1, d, n):
    sequence = []
    for _ in range(n):
        sequence.append(a1)
        a1 = a1+d
    return sequence<jupyter_output><empty_output><jupyter_text>Test the code<jupyter_code>a_seq(4,3,10)

# From here, we can check, that the value increases by 3 starts at 4 and has a length of 10<jupyter_output><empty_output><jupyter_text>Sekarang, mari buat urutan infinit. Gunakan generator<jupyter_code>"""def infinite_a_sequence(a1,d):
    while True:
        yield a1
        a1 = a1 + d

for i in infinite_a_sequence(4,3):
    print(i, end=" ")"""

print("Don't run this cell")
# So let's calculate the sum of the terms of our sequence by calling the sum() method
sum(a_seq(4,3,10))<jupyter_output><empty_output><jupyter_text>Implementasikan formula an=a1 + (n-1)d, yang memberi kita urutan aritmetik, jadi kita bisa membandingkannya dengan hasil kita<jupyter_code>def a_series(a1, d, n):
    result = n*(a1 + a_n(a1, d, n))/2
    return result

a_series(4,3,10)<jupyter_output><empty_output><jupyter_text>Geometric Sequences<jupyter_code># First as example, let's write a python function that calculates the nth term of a geomteric
# function, based of the an = rn - 1a formula

def n_geom_seq(r, a, n):
    an = r**(n-1)*a
    return an
n_geom_seq(2,3,10)
def sum_n(r, a, n):
    sum_n = a*(1-r**n)/(1-r)
    return sum_n

sum_n(2,3,10)<jupyter_output><empty_output><jupyter_text>Writing a Function to Find the Next Term of the Sequence Jumlah bakteri meningkat secara geometris dan sekuensial. Diberikan jumalh populasi bakteri per hari, dalam hari n, selanjutnya kita akan membuat fungsi yang menghitung populasi pada hari n+1. 1.	Tulis fungsi yang menerima sejumlah variabel argumen ( *args ) dan menghitung rasio antara elemen apa pun dan elemen sebelumnya (dimulai dari elemen kedua). Kemudian, periksa apakah semua rasio yang ditemukan identik dan kembalikan nilai uniknya. Jika tidak, fungsi mengembalikan -1 (urutan tidak memiliki rasio umum yang unik)<jupyter_code>def find_ratio(*args):
    arg0 = args[0]
    ratios = []
    for arg in args[1:]:
        ratio = round(arg/arg0,8)
        arg0 = arg
        ratios.append(ratio)
    
    if len(set(ratios)) == 1:
        return ratio
    else:
        return -1<jupyter_output><empty_output><jupyter_text>Sekarang, cek fungsi tersebut untuk 2 kasus berbeda. Pertama, gunakan urutan berikut<jupyter_code>find_ratio(1,2,4,8,16,32,64,128,256,512)<jupyter_output><empty_output><jupyter_text>Gunakan urutan yang lebih berbeda lagi<jupyter_code>find_ratio(1,2,3)<jupyter_output><empty_output><jupyter_text>Seperti output di atas, fungsi mencetak rasio jika rasionya ada, dan memprint -1 jika urutannya tidak geometris Selanjutnya, buat fungsi kedua yang membaca secara berurutan dan mencetak next term yang akan terjadi. Untuk melakukannya, baca dalam daftar angka (dipisahkan koma), temukan rasionya, dan dari situ, prediksi suku berikutnya<jupyter_code>def find_next(*args):
    if find_ratio(*args) == -1:
        raise ValueError("The sequence you entered isn't geometric sequence. Pls check the input!")
    else:
        return args[-1]*find_ratio(*args)<jupyter_output><empty_output><jupyter_text>Ingat bahwa kita ingin memeriksa apakah daftar bilangan ini memiliki rasio yang sama dengan cara memanggil fungsi find_ratio(). Jika ada kesalahan, dia akan me-raise value error, jika tidak, dia akanmencari next term, dan meretrunnya. Check if it works by using the following sequence<jupyter_code>find_next(1,2,4)
find_next(1.36,0.85680,0.539784,0.34006392)<jupyter_output><empty_output><jupyter_text>Dalam kasus pertama, hasil yang jelas, 8.0 , dicetak. Dalam kasus kedua, hasil yang kurang jelas dari barisan geometri menurun ditemukan dan dicetak. Untuk meringkasnya, kita dapat menulis fungsi yang mendeteksi barisan geometri, menemukan rasionya, dan menggunakannya untuk memprediksi suku barisan berikutnya. Ini sangat berguna dalam skenario kehidupan nyata, seperti dalam kasus di mana suku bunga majemuk perlu diverifikasi<jupyter_code>"""
find_next(1,2,4,3)
"""

print("ValueError")
def factorial(n):
    if n==0 or n==1 :
        return 1
    elif n==2:
        return 2
    else:
        return n*factorial(n-1)
factorial(1)
factorial(2)
factorial(3)
factorial(4)
factorial(5)
factorial(100)<jupyter_output><empty_output><jupyter_text>Creating a Custom Recursive Sequence In this exercise, we will create a custom recursive sequence using the concepts we explained in the previous section. Given the first three elements of the sequence, Pn, that is, P1=1, P2=7, and P3=2, find the next seven terms of the sequence that is recursively defined via the relation: Pn+3= (3*Pn+1 - Pn+2)/(Pn – 1).  Pertama, kita define fungsi rekursif python, dan mengimplementasikan hubungan yang diberikan sebelumnya untuk elemen ke-n.<jupyter_code>def p_n(n):
    if n < 1:
        return -1
    elif n == 1:
        return 1
    elif n == 2:
        return 7
    elif n == 3:
        return 2
    else:
        pn = (3*p_n(n-2) - p_n(n-1) )/ (p_n(n-3) + 1)
        return pn<jupyter_output><empty_output><jupyter_text>Di sini, kita mulai dengan mendefinisikan kasus dasar, yaitu hasil yang diketahui seperti yang diberikan dalam ringkasan: jika n=1 , maka P=1 , jika n=2 , maka P=7 , dan jika n=3 , maka P =2 . Kami juga menyertakan kasus di mana n<1 . Ini adalah input yang tidak valid dan, seperti biasa, fungsi kami mengembalikan nilai -1 . Ini membuat fungsi kita dibatasi dan dilindungi dari memasuki infinite loop dan input yang tidak valid. Setelah kasus-kasus ini telah ditangani, maka kita telah mendefinisikan relasi rekursif. Sekarang, mari uji fungsi kita dan mencetak 10 nilai percentile<jupyter_code>for i in range(1,11):
    print(p_n(i))<jupyter_output>1
7
2
9.5
-0.4375
9.645833333333334
-1.0436507936507937
53.29982363315697
-5.30073825572847
-3784.586609737289<jupyter_text>Bisa dilihat, fungsi kita bekerja dan mereturn kembali nilai yang diketahui ( P 1 = 1 , P 2 = 7 , dan P 3 = 2 ) dari barisan dan suku berikutnya ( P_1 hingga P_10 ) yang kita sedang mencari Sebagai bonus, sekarang kita coba plot hasilnya<jupyter_code>"""from matplotlib import pyplot as plt

plist = []
for i in range(1,40):
    plist.append(p_n(i))
plt.plot(plist,linestyle = "--", marker='o',color='b')
plt.show()"""

print("Don't run this. Take a long time fuck")
from math import sqrt

def hypotenuse(a,b):
    h = sqrt(a**2 + b**2)
    return h

hypotenuse(3,4)<jupyter_output><empty_output><jupyter_text>Plotting a Right-Angled Triangle In this exercise, we will write Python functions that will plot a right triangle for the given points, p1 and p2. The right-angled triangle will correspond to the endpoints of the legs of the triangle. We will also calculate the three trigonometric functions for either of the non-right angles. Let's plot the basic trigonometry functions<jupyter_code>import numpy as np
from matplotlib import pyplot as plt

# Sekarang, tulis sebuah fungsi yang mereturn hipotemus menggunakan algoritma pitagoras

def find_hypotenuse(p1,p2):
    p3 = round((p1**2 + p2**2)**0.5,8)
    return p3<jupyter_output><empty_output><jupyter_text>Tulis fungsi lain yang mengimplementasikan relasi untuk, sinus, cosinus, dan tangen. Inputnya adalah panjang dari tiap sisi di setiap sisi segitiga<jupyter_code>def find_trig(adjacent, opposite, hypotenuse):
    return opposite/hypotenuse, adjacent/hypotenuse, opposite/adjacent<jupyter_output><empty_output><jupyter_text>Tulis fungsi yang memvisualisasikan triangle nya. Secara simple, tempatkan angle yang bagus pada koordinat (0,0).<jupyter_code>def plot_triangle(p1, p2, lw=5):
    x = [0, p1, 0]
    y = [0, 0, p2]
    n = ['0', 'p1', 'p2']
    fig, ax = plt.subplots(figsize=(p1,p2))
    # plot points
    ax.scatter(x, y, s=400, c="#8C4799", alpha=0.4)
    ax.annotate(find_hypotenuse(p1,p2),(p1/2,p2/2))
    # plot edges
    ax.plot([0, p1], [0, 0], lw=lw, color='r')
    ax.plot([0, 0], [0, p2], lw=lw, color='b')
    ax.plot([0, p1], [p2, 0], lw=lw, color='y')
    for i, txt in enumerate(n):
        ax.annotate(txt, (x[i], y[i]), va='center')<jupyter_output><empty_output><jupyter_text>Di sini, kita membuat daftar, x dan y , yang menyimpan poin dan satu daftar lagi, n , untuk label. Kemudian, kita membuat objek pyplot yang memplot titik terlebih dahulu, lalu tepinya. Dua baris terakhir digunakan untuk membubuhi keterangan plot kita; yaitu, tambahkan label (dari daftar, n ) di sebelah poin kita Selanjutnya kita perlu memilih 2 point secara berurut untuk mendefine sebuah segitiga. Kemudain kita panggil fungsi kita untuk menampilkan visualisasinya<jupyter_code>p01 = 4
p02 = 4
print(find_trig(p01,p02,find_hypotenuse(p01,p02)))
plot_triangle(p01,p02)<jupyter_output>(0.707106781123095, 0.707106781123095, 1.0)<jupyter_text>Correct! finally, untuk mendapatkan general overview dari sinus dan cosinus, kita visualisasikan mereka!<jupyter_code>x = np.linspace(0,10,200)
sin = np.sin(x) # For sinus
cos = np.cos(x) # For cosinus

plt.xticks([0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi, 5*np.pi/2, 3*np.pi],['0','','\u03C0','','2\u03C0','','3\u03C0'])
plt.plot(x, sin, marker='o', label='sin')
plt.plot(x, cos, marker='x', label='cos')
plt.legend(loc="upper left")
plt.ylim(-1.1, 1.6)
plt.show()<jupyter_output><empty_output><jupyter_text>Finding the Shortest Way to the Treasure Using Inverse Trigonometric Functions Pada kegiatan kali ini, anda akan diberikan secret map yang mengarah pada B, tempat target yakni harta telah tersimpan lama. Asumsikan anda pada point A, dan instruksinya. Anda harus menavigasi 20 km ke selatan lalu 33 km ke barat sehingga Anda tiba di harta karun. Namun, segmen garis lurus, AB , adalah yang terpendek. Anda perlu menemukan sudut θ pada peta sehingga navigasi Anda berorientasi dengan benar - First import atan and phi<jupyter_code>from math import atan, pi<jupyter_output><empty_output><jupyter_text>- Find the tangent of theta using BC and AC<jupyter_code>AC = 33
BC = 20

tan_th = BC/AC
print(tan_th)<jupyter_output>0.6060606060606061<jupyter_text>- Selanjutnya, temukan angle nya dengan menggunakan reverse tangent<jupyter_code>theta = atan(tan_th)
print(theta)
theta_degrees = theta * 180/pi
print(theta_degrees)<jupyter_output>31.218402764346372<jupyter_text>This answer is 31.22, that will navigate us correctly - Calculate the distance that we will travel along the path AB using Pythagorean Theorem<jupyter_code>AB = (AC**2 + BC**2)**0.5
print(AB)<jupyter_output>38.58756276314948<jupyter_text>The sortest distance is 38.59 km.  Finding the Optimal Distance from an Object Anda mengunjungiing arena lokal Anda untuk menonton acara favorit Anda, dan Anda berdiri di tengah arena. Selain panggung utama, ada juga layar tampilan agar orang bisa menonton dan tidak ketinggalan detail pertunjukan. Bagian bawah layar berdiri 3 m di atas ketinggian mata Anda, dan layar itu sendiri tingginya 7 m. Sudut pandang dibentuk dengan melihat bagian bawah dan atas layar. Temukan jarak optimal, x , antara Anda dan layar sehingga sudut pandang dimaksimalkan Ini adalah masalah yang sedikit melibatkan yang membutuhkan sedikit aljabar, tetapi kami akan memecahnya menjadi langkah-langkah sederhana dan menjelaskan logikanya. Pertama, perhatikan seberapa banyak plot masalah memandu kita dan membantu kita sampai pada solusi. Masalah dunia nyata yang tampaknya kompleks ini diterjemahkan ke dalam gambaran geometris yang jauh lebih abstrak dan sederhana.  Vectors<jupyter_code>import numpy as np

A = np.array([1,2,3]) # Vector A
B = np.array([4,5,6]) # Vector B

# Sum of A and B
print(A + B)
# The difference 
A - B
# Element-wise product
A * B
# Dot product
A.dot(B)
# Cross product
np.cross(A,B)<jupyter_output><empty_output><jupyter_text>Note that vector addition, subtraction, and the dot product are associative and commutative operations, whereas the cross product is associative but not commutative. In other words, a x b does not equal b x a, but rather b x a, which is why it is called anticommutative.<jupyter_code># Next we write a Python program that calculates the angle between two vectors with numpy!

import numpy as np
from math import acos

A = np.array([2,10,0])
B = np.array([9,1,-1])

print(A)
print(B)
print("-----------")

# find the norm (magnitude) of each vector
Amagn = np.sqrt(A.dot(A))
Bmagn = np.sqrt(B.dot(B))

print(Amagn)
print(Bmagn)
print("-----------")

# Finally, find the angle
theta = acos(A.dot(B) / (Amagn * Bmagn))
print(theta)<jupyter_output>[ 2 10  0]
[ 9  1 -1]
-----------
10.198039027185569
9.1104335791443
-----------
1.2646655256233297<jupyter_text>Visualizing Vectors<jupyter_code># Here we will write function that plots two vctors in 2D space.
import numpy as np
import matplotlib.pyplot as plt

# Create functiion that admits two vectors as inputs, as list, plots them
def plot_vectors(vec1, vec2, isSum=False):
    label1 = "A";label2 = "B";label3 = "A+B"
    orig = [0.0, 0.0] # Position of origin axes<jupyter_output><empty_output><jupyter_text>vector 1 dan vector 2 masing-masing berisi dua bilangan real. Di mana tiap pasangannya menunjukkan koordinat titik akhir (head) dari vector yang sesuai, sedangkan titik asalnya ditetapkan pada koordinat (0,0). Untuk label sendiri sudah ada pada label yang terletak pada variable label di dalam function tersebut. - Next, kita tempatkan koordinat pada objek matplotlib.pyplot<jupyter_code>def plot_vectors(vec1, vec2, isSum = False):
    label1 = "A"; label2 = "B"; label3 = "A+B"
    orig = [0.0, 0.0] # position of origin of axes
    ax = plt.axes()
    ax.annotate(label1, [vec1[0]+0.5,vec1[1]+0.5] )
    # shift position of label for better visibility
    ax.annotate(label2, [vec2[0]+0.5,vec2[1]+0.5] )
    if isSum:
        vec3 = [vec1[0]+vec2[0], vec1[1]+vec2[1]]
        # if isSum=True calculate the sum of the two vectors
        ax.annotate(label3, [vec3[0]+0.5,vec3[1]+0.5] )
    ax.arrow(*orig, *vec1, head_width=0.4, head_length=0.65)
    ax.arrow(*orig, *vec2, head_width=0.4, head_length=0.65, \
             ec='blue')
    if isSum:
        ax.arrow(*orig, *vec3, head_width=0.2, \
                 head_length=0.25, ec='yellow')
        # plot the vector sum as well
    plt.grid()
    e=3
    # shift limits by e for better visibility
    plt.xlim(min(vec1[0],vec2[0],0)-e, max(vec1[0],\
                 vec2[0],0)+e)
    # set plot limits to the min/max of coordinates
    plt.ylim(min(vec1[1],vec2[1],0)-e, max(vec1[1],\
                 vec2[1],0)+e)
    # so that all vectors are inside the plot area
    plt.title('Vector sum',fontsize=14)
    plt.show()
    plt.close()<jupyter_output><empty_output><jupyter_text>- Now, we will write a function that calculates the angle between the two input vectors, as explained previously, with the help of the dot (inner) product<jupyter_code>def find_angle(vec1, vec2, isRadians = True, isSum = False):
    vec1 = np.array(vec1)
    vec2 = np.array(vec2)
    product12 = np.dot(vec1,vec2)
    cos_theta = product12/(np.dot(vec1,vec1)**0.5 * \
                           np.dot(vec2,vec2)**0.5 )
    cos_theta = round(cos_theta, 12)
    theta = np.arccos(cos_theta)
    plot_vectors(vec1, vec2, isSum=isSum)
    if isRadians:
        return theta
    else:
        return 180*theta/np.pi<jupyter_output><empty_output><jupyter_text>First, we map our input lists to numpy arrays so that we can use the methods of this module. We calculate the dot product (named product12) and then divide that by the product of the magnitude of vec1 with the magnitude of vec2. Recall that the magnitude of a vector is given by the square root (or **0.5) of the dot product with itself. As given by the definition of the dot product, we know that this quantity is the cos of the angle theta between the two vectors. Lastly, after rounding cos to avoid input errors in the next line, calculate theta by making use of the arccos method of numpy - Selanjutnya kita gabungkan dua fungsi untuk mengimplementasikannya<jupyter_code>ve1 = [1,5]
ve2 = [5,-1]

find_angle(ve1,ve2,isRadians=False,isSum=True)
ve1 = [1,5]
ve2 = [0.5,2.5]
find_angle(ve1, ve2, isRadians = False, isSum = True)
ve1 = [1,5]
ve2 = [-3,-5]
find_angle(ve1, ve2, isRadians = False, isSum = True)<jupyter_output><empty_output><jupyter_text>Complex Numbers<jupyter_code>a = 1
b = -3
z = complex(a,b)
print(z)
print(z.real)
print(z.imag)
def find_polar(x):
    from math import asin
    x = z.real
    y = z.imag
    r = (x**2 + y**2)**0.5
    phi = asin(y/r)

    return r, phi

find_polar(1-3j)
def complex_operations2(c1, c2):
    print('Addition =', c1 + c2)
    print('Subtraction =', c1 - c2)
    print('Multiplication =', c1 * c2)
    print('Division =', c1 / c2)<jupyter_output><empty_output><jupyter_text>Now, let's try these functions for a generic pair of complex numbers, c1=10+2j/3 and c2=2.9+1j/3<jupyter_code>complex_operations2(10+2j/3, 2.9+1j/3)<jupyter_output>Addition = (12.9+1j)
Subtraction = (7.1+0.3333333333333333j)
Multiplication = (28.77777777777778+5.266666666666666j)
Division = (3.429391054896336-0.16429782240187768j)<jupyter_text>Using purely imaginary number<jupyter_code>complex_operations2(1, 1j)
import cmath
def complex_operations1(c):
    modulus = abs(c)
    phase = cmath.phase(c)
    polar = cmath.polar(c)
    print('Modulus =', modulus)
    print('Phase =', phase)
    print('Polar Coordinates =', polar)
    print('Conjugate =',c.conjugate())
    print('Rectangular Coordinates =', \
           cmath.rect(modulus, phase))
complex_operations1(3+4j)<jupyter_output>Modulus = 5.0
Phase = 0.9272952180016122
Polar Coordinates = (5.0, 0.9272952180016122)
Conjugate = (3-4j)
Rectangular Coordinates = (3.0000000000000004+3.9999999999999996j)<jupyter_text>Conditional Multiplication of Complex Numbers Dalam latihan ini, Anda akan menulis sebuah fungsi yang membaca bilangan kompleks, c , dan mengalikannya dengan dirinya sendiri jika argumen bilangan kompleks lebih besar dari nol, mengambil akar kuadrat dari c jika argumennya kurang dari nol, dan tidak tidak ada jika argumen sama dengan nol. Plot dan diskusikan temuan Anda - Import the necessary packages!<jupyter_code>import cmath
from matplotlib import pyplot as plt
import warnings
warnings.filterwarnings("ignore")<jupyter_output><empty_output><jupyter_text>- Define a function to plot the vector of the input complex number<jupyter_code>def plot_complex(c, color='b', label=None):
    ax = plt.axes()
    ax.arrow(0,0, c.real, c.imag, head_width=0.2, head_length=0.3, color=color)
    ax.annotate(label, xy=(0.6*c.real, 1.15*c.imag))
    plt.xlim(-3,3)
    plt.ylim(-3,3)
    plt.grid(b=True, which='major')<jupyter_output><empty_output><jupyter_text>- Next, create a function that reads the input, plot it by calling the function defined previously, and then investigates the different cases, depending on the phase of the input.<jupyter_code>def mult_complex(c, label1='old', label2='new'):
    phase = cmath.phase(c)
    plot_complex(c, label=label1)
    if phase == 0:
        result = -1
    elif phase < 0:
        print('old phase:', phase)
        result = cmath.sqrt(c)
        print('new phase:', cmath.phase(result))
        plot_complex(result, 'red', label=label2)
    elif phase > 0:
        print('old phase:', phase)
        result = c*c
        print('new phase:', cmath.phase(result))
        plot_complex(result, 'red', label=label2)
    return result<jupyter_output><empty_output><jupyter_text>Note that for negative phases, we take the square root of c, whereas for positive phases, we take the square of c - Now, transform a number that lies on the upper half of the complex plane<jupyter_code>mult_complex(1 + 1.2j)

mult_complex(1-1.2j)
c0 = 1+1.2j
n = 0
while n < 6:
    c0 = mult_complex(c0, None, str(n))
    n+=1<jupyter_output>old phase: 0.8760580505981934
new phase: 1.7521161011963868
old phase: 1.7521161011963868
new phase: -2.778953104786813
old phase: -2.778953104786813
new phase: -1.3894765523934065
old phase: -1.3894765523934065
new phase: -0.6947382761967033
old phase: -0.6947382761967033
new phase: -0.3473691380983516
old phase: -0.3473691380983516
new phase: -0.1736845690491758<jupyter_text>Calculating Your Retirement Plan Using Series Di beberapa negara, program pensiun ditawarkan oleh beberapa perusahaan. Rencana ini memungkinkan anda langsung berkontribusi dari gaji anda, sehingga membuat efektivitas meningkat untuk menabung dan berinvestasi untuk masa pensiun. Next, anda ditugaskan untuk menghitung dan memplot pengembalian bulanan anda berdasarkan jumlah dan durasi kontribusi.Rencana ini terakumulasi oleh waktu, persis seperti deret geometris. Modelnya seperti investasi, di mana anda menyimpan uang setiap bulan untuk mengumpulkannya nanti, setiap bulan, dengan nilai tambah atau bunga. Variabel utama untuk menghitung laba ini adalah saldo anda saat ini, kontribusi bulanan, kontribusi majikan, usia pensiun, tingkat pengembalian, harapan hidup, dan biaya lainnya.  1.	Identify the variables of our problem. These will be the variables of our functions. Make sure you read through the activity description carefully and internalize what is known and what is to be calculated.2.	Identify the sequence and write one function that calculates the value of the retirement plan at some year, n. The function should admit the current balance, annual salary, year, n, and more as inputs and return a tuple of contribution, employer's match, and total retirement value at year n.3.	Identify the series and write one function that calculates the accumulated value of the retirement plan after n years. The present function should read the input, call the previous function that calculates the value of the plan at each year, and sum all the (per year) savings. For visualization purposes, the contributions (per year), employer match (per year), and total value (per year) should be returned as lists in a tuple.4.	Run the function for a variety of chosen values and ensure it runs properly.5.	Plot the results with Matplotlib - First, we need to identify the input variables and note that the problem boils down to calculating the n-term of a geometric sequence with a common ratio (1 + interest) and scale factor for the annual salary.annual_salary and the percentage, contrib, of it is what we contribute toward our plan. current_balance is the money that we have at year 0 and should be added to the total amount. annual_cap is the maximum percentage that we can contribute; any input value beyond that should be equal to contrib_cap. annual_salary_increase tells us how much we expect our salary to increase by per year. employer_match gives us the percentage amount the employer contributes to the plan (typically, this is between 0.5 and 1). Lastly, the current age, the duration of the plan in years, the life expectancy in years, and any other fees that the plan might incur are input variables. The per_month Boolean variable determines whether the output will be printed as a per-year or per-month amount of the return. - Buat fungsi pertama. untuk menghitung element ke-n dari deret punya kita, yang mereturn kontribusi dan kecocokan pemberi kerja sebagai tuple yang dipisahkan koma<jupyter_code>def retirement_n(current_balance, annual_salary, \
                 annual_cap, n, contrib, \
                 annual_salary_increase, employer_match, \
                 match_cap, rate):
    '''
    return :: retirement amount at year n
    '''
    annual_salary_n = annual_salary*\
                      (1+annual_salary_increase)**n
    your_contrib = contrib*annual_salary_n
    your_contrib = min(your_contrib, annual_cap)
    employer_contrib = contrib*annual_salary_n*employer_match
    employer_contrib = min(employer_contrib,match_cap\
                           *annual_salary_n*employer_match)
    contrib_total = your_contrib + employer_contrib
    return your_contrib, employer_contrib, current_balance + contrib_total*(1+rate)**n<jupyter_output><empty_output><jupyter_text>Seperti yang ditunjukkan di sini, adalah saldo saat ini dan gaji tahunan dalam nilai absolut. Kita juga mendefinisikan kontribusi, batas kontribusi (yaitu nilai maksimum yang diizinkan), kenaikan gaji tahunan, kecocokan pemberi kerja, dan tingkat pengembalian sebagai nilai relatif (floating antara 0 dan 1). Batas tahunan juga dimaksudkan untuk dibaca sebagai nilai absolut - Buat fungsi untuk menjumlahkan jumlah individu setiap tahun dan menghhitung nilai total dari rencananya. Ini akan membagi angka ini dengan jumlah tahun di mana rencana kana digunakan, sehingga pengembalian per tahun dari rencana akan direturn oleh fungsi ini. Sebagai input, parameter ini harus membaca usia saat ini, durasi paket, dan harapan hidup.<jupyter_code>def retirement_total(current_balance, annual_salary, \
    annual_cap=18000, contrib=0.05, \
    annual_salary_increase=0.02, employer_match=0.5, \
    match_cap=0.06, rate=0.03, current_age=35, \
    plan_years=35, life_expectancy=80, fees=0, \
    per_month=False):
    i = 0
    result = 0
    contrib_list = []; ematch_list = []; total_list = []
    while i <= plan_years:
        cn = retirement_n(current_balance=current_balance, \
             annual_salary=annual_salary, \
             annual_cap=annual_cap, n=i, \
             contrib=contrib, match_cap=match_cap, \
             annual_salary_increase=annual_salary_increase,\
             employer_match=employer_match, rate=rate)
        contrib_list.append(cn[0])
        ematch_list.append(cn[1])
        total_list.append(cn[2])
        result = result + cn[2]
        i+=1
    result = result - fees
    years_payback = life_expectancy - (current_age + plan_years)
    if per_month:
        months = 12
    else:
        months = 1
    result = result / (years_payback*months)
    print('You get back:',result)
    return result, contrib_list, ematch_list, total_list
result, contrib, ematch, total = retirement_total(current_balance=1000, plan_years=35,\
                 current_age=36, annual_salary=40000, \
                 per_month=True)

from matplotlib import pyplot as plt
years = [i for i in range(len(total))]
plt.plot(years, total,'-o',color='b')
width=0.85
p1 = plt.bar(years, total, width=width)
p2 = plt.bar(years, contrib, width=width)
p3 = plt.bar(years, ematch, width=width)
plt.xlabel('Years')
plt.ylabel('Return')
plt.title('Retirement plan evolution')
plt.legend((p1[0], p2[0], p3[0]), ('Investment returns','Contributions','Employer match'))
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.09375227289257401, 'fraction_numerical': 0.04538511891773947, 'mean_word_length': 4.457233578090891, 'pattern_counts': {'":': 0, '<': 157, '<?xml version=': 0, '>': 153, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 6, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '40', 'dir': 'jupyter-structured-clean-dedup', 'id': '511858', 'license': 'Apache-2.0', 'n_tokens_mistral': 10725, 'n_tokens_neox': 9888, 'n_words': 3052, 'path': 'Work_5/work_5-1.ipynb', 'repo_name': 'samyon7/Statistics-Python', 'size': '27498'}