Cara menulis fungsi eksponensial dengan python

Dalam tutorial ini, kita belajar cara menggunakan eksponen dengan Python. Menaikkan angka ke pangkat dua sedikit lebih rumit daripada perkalian normal. Sederhananya, eksponen adalah berapa kali angka tersebut dikalikan dengan dirinya sendiri. Kita bisa menggunakan tiga cara berbeda di Python untuk melakukannya. Mari kita lihat apa saja cara-cara itu

Daftar Isi

• Apa itu eksponen?
• Menggunakan ** operator untuk eksponen
• Menggunakan fungsi pow() untuk eksponen Python
• Menggunakan matematika. pow() fungsi untuk eksponen Python
• Menutup pikiran

Apa itu eksponen?

Dalam istilah Matematika, eksponen mengacu pada angka yang ditempatkan sebagai superskrip angka. Dikatakan berapa kali bilangan dasar harus dikalikan dengan dirinya sendiri. Eksponensial ditulis sebagai mⁿ dan diucapkan sebagai "m pangkat n". Di sini "n" adalah eksponen dan "m" adalah basisnya. Artinya m adalah dikalikan dengan m, n berapa kali. Kita tidak dapat menyelesaikan eksponen seperti biasanya kita melakukan perkalian dengan Python

Tentunya, untuk 2^3 kita dapat mengalikan 2, 3 kali dan mendapatkan hasil tetapi akan gagal ketika kita berhadapan dengan angka yang lebih besar. Jadi, kita membutuhkan cara yang tepat untuk memecahkan eksponen

Menggunakan operator eksponen di Python

Operator eksponen atau operator pangkat bekerja pada dua nilai. Satu disebut basis dan yang lainnya adalah eksponen. Seperti yang dijelaskan sebelumnya, eksponen menunjukkan berapa kali basis harus dikalikan dengan dirinya sendiri

Sintaksis

m ** n

Di sini, operator eksponen menaikkan variabel kedua pangkat variabel pertama

Contoh

m = 3
n = 2
p = m ** n
print ("On solving the exponent, we get ", p)

Keluaran

On solving the exponent, we get 8

Menggunakan fungsi pow() untuk eksponen Python

Python memiliki fungsi bawaan yang berguna untuk menghitung daya. pow(). Ini menerima dua parameter yang merupakan basis dan eksponen. Ini mengembalikan modulus hasil. Hasilnya akan selalu bilangan bulat positif

Sintaksis

pow(m,n)

Di sini, "m" adalah basis (angka yang dipangkatkan dengan eksponen) dan "n" adalah eksponen (angka yang dipangkatkan basisnya)

Memasukkan

m = 2
n = 3
p = pow(m,n)
print ("The answer is: ", p)

Keluaran

The answer is: 8

Menggunakan matematika. pow() fungsi untuk eksponen Python

Python memiliki fungsi lain matematika. pow() yang memungkinkan Anda memecahkan eksponen. Itu juga menerima dua parameter. basis dan eksponen. Perbedaan utama antara pow() dan matematika. pow() adalah matematika itu. pow() mengubah kedua variabel menjadi floating point dan selalu mengembalikan float

Sintaksis

math.pow(m,n)

Memasukkan

m = 2
n = 3
p = math.pow(m,n)
print ("The answer is: ", p)

Keluaran

The answer is: 8.0

Menutup pikiran

Melakukan Matematika dengan Python itu mudah, tetapi menghitung eksponen dengan Python sedikit rumit. Kami telah belajar cara menggunakan eksponen dengan Python. Tapi ingat dengan Python, itu akan mengembalikan kesalahan pembagian nol jika kita menaikkan 0 ke pangkat apa pun. Python juga memiliki operator matematika lainnya, dan Anda dapat membacanya di sini

matematika. fungsi exp(x) mengembalikan nilai e pangkat x, di mana e adalah basis logaritma natural

exp(x) = e^x

Sintaksis

Sintaks untuk memanggil fungsi exp() adalah

math.exp(x)

di mana

Dalam contoh berikut, kita menemukan pangkat eksponensial dari 2, menggunakan fungsi exp() dari modul matematika

Program Piton

import math

x = 2
result = math.exp(x)
print('exp(x) :', result)

Keluaran

exp(x) : 7.38905609893065

Sekarang, mari kita cari pangkat eksponensial dari bilangan negatif

Program Piton

import math

x = -2
result = math.exp(x)
print('exp(x) :', result)

Keluaran

exp(x) : 0.1353352832366127

Ringkasan

Dalam tutorial Contoh Python ini, kami mempelajari sintaks, dan contoh untuk matematika. exp() fungsi

Jika Anda memiliki kumpulan titik data yang tampaknya meningkat dengan cepat, mungkin berguna untuk menyesuaikannya dengan garis yang halus dan meningkat secara eksponensial untuk menggambarkan bentuk umum data.

Garis yang perlu Anda paskan untuk mencapai bentuk ini akan menjadi salah satu yang dijelaskan oleh fungsi eksponensial, yaitu fungsi apa pun dari bentuk tersebut

\(y = AB^x + C\)

atau

\(y = ae^{bx} + c\)

(keduanya setara secara matematis karena \(AB^x = Ae^{x\ln(B)}\)). Hal penting yang harus disadari adalah bahwa fungsi eksponensial dapat didefinisikan sepenuhnya dengan tiga konstanta. Kami akan menggunakan formulasi kedua, yang dapat ditulis dengan Python sebagai

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

Untuk tutorial ini, mari buat beberapa data palsu untuk digunakan sebagai contoh. Ini harus berupa kumpulan poin yang meningkat secara eksponensial (atau upaya kami untuk menyesuaikan kurva eksponensial dengannya tidak akan berhasil dengan baik. ) dengan beberapa derau acak yang dilemparkan untuk meniru data dunia nyata

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

Kebisingan acak ditambahkan dengan fungsi

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

Metode ini hanya bekerja ketika \(c = 0\), yaitu ketika Anda ingin menyesuaikan kurva dengan persamaan \(y = ae^{bx}\) ke data Anda. Jika Anda ingin mencocokkan kurva dengan persamaan \(y = ae^{bx} + c\) dengan \(c \neq 0\) Anda harus menggunakan metode 2

Perintah

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

\(y = ae^{bx} \menyiratkan \ln(y) = \ln(a) + bx\)

karena kita dapat mengambil logaritma natural dari kedua sisi. Ini menciptakan persamaan linier \(f(x) = mx + c\) di mana

• \(f(x) = \ln(y)\)
• \(m = b\)
• \(c = \ln(a)\)

Jadi

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

Polinomial ini sekarang dapat diubah kembali menjadi eksponensial

# Convert the polynomial back into an exponential
a = np.exp(p[1])
b = p[0]
x_fitted = np.linspace(np.min(x), np.max(x), 100)
y_fitted = a * np.exp(b * x_fitted)

Mari kita lihat kecocokannya

import matplotlib.pyplot as plt

ax = plt.axes()
ax.scatter(x, y, label='Raw data')
ax.plot(x_fitted, y_fitted, 'k', label='Fitted curve')
ax.set_title('Using polyfit() to fit an exponential function')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')
ax.legend()

Metode ini memiliki kelemahan karena terlalu menekankan nilai-nilai kecil. titik-titik yang memiliki nilai besar dan yang relatif dekat dengan garis linear paling cocok yang dibuat oleh

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

# Fit a weighted polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1, w=np.sqrt(y))

# Convert the polynomial back into an exponential
a = np.exp(p[1])
b = p[0]
x_fitted_weighted = np.linspace(np.min(x), np.max(x), 100)
y_fitted_weighted = a * np.exp(b * x_fitted_weighted)

# Plot
ax = plt.axes()
ax.scatter(x, y, label='Raw data')
ax.plot(x_fitted, y_fitted, 'k', label='Fitted curve, unweighted')
ax.plot(x_fitted_weighted, y_fitted_weighted, 'k--', label='Fitted curve, weighted')
ax.set_title('Using polyfit() to fit an exponential function')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')
ax.legend()

Menggunakan beban telah meningkatkan kecocokan

Dari paket Scipy kita bisa mendapatkan fungsi

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

Mari gunakan data contoh asli kita (dengan \(c \neq 0\))

import numpy as np
import matplotlib.pyplot as plt

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

Sekarang mari kita cocokkan fungsinya \(y = ae^{bx} + c\). Ini dilakukan dengan mendefinisikannya sebagai fungsi lambda (yaitu sebagai objek dan bukan sebagai perintah) dari variabel dummy \(t\) dan menggunakan fungsi

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

from scipy.optimize import curve_fit

# Fit the function a * np.exp(b * t) + c to x and y
popt, pcov = curve_fit(lambda t, a, b, c: a * np.exp(b * t) + c, x, y)

Perhatikan bahwa kita perlu menghapus nilai apa pun yang sama dengan nol dari data y kita (dan nilai x yang sesuai dari data x) agar ini berfungsi, meskipun tidak ada satu pun dari ini dalam data contoh ini jadi itu

Output pertama,

# Convert the polynomial back into an exponential
a = np.exp(p[1])
b = p[0]
x_fitted = np.linspace(np.min(x), np.max(x), 100)
y_fitted = a * np.exp(b * x_fitted)

a = popt[0]
b = popt[1]
c = popt[2]

Mari kita lihat seperti apa ini

# Create the fitted curve
x_fitted = np.linspace(np.min(x), np.max(x), 100)
y_fitted = a * np.exp(b * x_fitted) + c

# Plot
ax = plt.axes()
ax.scatter(x, y, label='Raw data')
ax.plot(x_fitted, y_fitted, 'k', label='Fitted curve')
ax.set_title(r'Using curve\_fit() to fit an exponential function')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')
ax.legend()

Ini terlihat sangat bagus, dan kami tidak perlu memberikan tebakan awal. Ini karena contoh data yang kami gunakan cukup dekat dengan sifat eksponensial sehingga algoritme pengoptimalan di belakang

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

Mari plot ketiga metode satu sama lain menggunakan data contoh yang sama (\(c = 0\)) untuk masing-masing

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

Seperti yang Anda lihat, metode

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

Kita dapat menggunakan kurva pas untuk memperkirakan seperti apa data kita untuk nilai lain dari \(x\) yang tidak ada dalam kumpulan data mentah kita. berapa nilainya di \(x=11\) (yang berada di luar domain kita dan karenanya mengharuskan kita untuk meramalkan ke masa depan) atau \(x = 8. 5\) (yang ada di dalam domain kita dan karenanya mengharuskan kita untuk 'mengisi celah' dalam data kita)?

Bagaimana Anda mengambil fungsi eksponensial dengan Python?

Bagaimana Anda menulis e eksponensial dengan Python?

Bagaimana cara menulis fungsi eksponensial?

Bagaimana Anda menulis eksponensial di Numpy Python?