Buku Ringkasan Calculation

2021
RINGKASAN TERJEMAHAN BUKU
MATEMATIKA
TEKNIK
21539144004
S1-TEKNIK MANUFAKTUR-E2
Sultan Hulio Andrian

DAFTAR ISI
1.1 PRINSIP GEOMETRI—ILMU UKUR BIDANG ..................................................................................... 6
1.2 BAB 1 ............................................................................................................................................... 7
MATEMATIKA UNTUK MESIN DAN PEKERJA LOGAM 1.3 ......................................................................... 8
1.4 Bab 1 ............................................................................................................................................... 9
MATEMATIKA UNTUK MESIN DAN PEKERJA LOGAM 1.5 ....................................................................... 10
1.6 BAB SATU ...................................................................................................................................... 11
1.2 ALJABAR DASAR ........................................................................................................................ 12
1.8 Bab satu ........................................................................................................................................ 13
1.2.2 Transposisi Persamaan (Sederhana dan Kompleks) .............................................................. 14
1.10 BAB SATU ...................................................................................................................................... 15
MATEMATIKA UNTUK MESIN DAN PEKERJA LOGAM 1.11 ..................................................................... 16
1.3 TRIGONOMETRI PESAWAT ............................................................................................................ 16
1.12 BAB PERTAMA ............................................................................................................................... 17
1.3.1 Hukum Trigonometri ............................................................................................................. 18
GAMBAR 1.21 Segitiga miring. .............................................................................................................. 18
1.14 BAB SATU ...................................................................................................................................... 19
1.6 BAB SATU ...................................................................................................................................... 21
1.18 BAB SATU ...................................................................................................................................... 23
1.20 BAB SATU ...................................................................................................................................... 25
1.3.2 Contoh Soal Menggunakan Trigonometri .............................................................................. 26
1.22 BAB SATU ...................................................................................................................................... 27
1.24 BAB SATU ...................................................................................................................................... 29
1.26 BAB SATU ...................................................................................................................................... 31
1.28 BAB SATU ...................................................................................................................................... 33
1.4.1 Jenis Kalkulator ..................................................................................................................... 34
1.4.2 Teknik Kalkulator Modern ..................................................................................................... 35
1.30 BAB SATU ...................................................................................................................................... 35
1.4.3 Prosedur Bracketing Kalkulator Saku ..................................................................................... 38
1.32 BAB SATU ...................................................................................................................................... 38
1.5 KONVERSI SUDUT—DERAJAT DAN RADIAN .................................................................................... 39
1.34 BAB SATU ...................................................................................................................................... 40
1.6 NOTASI POWERS-OF-TEN .......................................................................................................... 40
1.7 PERCENTAGE PERHITUNGAN .................................................................................................... 42
1.36 BAB SATU ...................................................................................................................................... 44
1.8 SISTEM SUHU DAN KONVERSI ................................................................................................... 44
1.9 SETARA DESIMAL DAN milimeter .............................................................................................. 45
1.38 BAB SATU ...................................................................................................................................... 46
1.10 SETARA BERAT KECIL: ADAT AS (Biji-bijian DAN OUNS) VERSUS METRIK (GRAM) ..................... 46
1.11 TANDA DAN SIMBOL MATEMATIKA .......................................................................................... 47
PART 2..................................................................................................................................................... 158
2.5 Aturan dan Definisi Transformasi...................................................................................................... 221
2.7 Modularitas dan Penamaan Benda ................................................................................................... 226
2.7.1 Modul dan Variabel Lokal .......................................................................................................... 226
2.7.2 Konstanta Lokal .......................................................................................................................... 229
2.7.5 Variabel Dummy dalam Matematika ......................................................................................... 233
2.7.6 Blok dan Nilai Lokal .................................................................................................................... 235
2.7.7 Blok Dibandingkan dengan Modul ............................................................................................. 238
2.7.8 Konteks ...................................................................................................................................... 239
2.7.9 Konteks dan Paket...................................................................................................................... 243
2.7.11 Pemuatan Paket Otomatis ....................................................................................................... 247
2.7.12 Memanipulasi Simbol dan Konteks dengan Nama ................................................................... 247
2.9.6String-Oriented Output Formats ........................................................................................ 293
Sintaks Bahasa Mathematica .................................................................................................................. 306
Operator tanpa Makna Bawaan .............................................................................................................. 311
Mendefinisikan Format Output .............................................................................................................. 313
Topik Lanjutan: Aturan Input dan Output Tingkat Rendah ..................................................................... 316
Menghasilkan Output Tidak Terstruktur ................................................................................................. 318
Menghasilkan Output Bergaya di Notebook ........................................................................................... 319
Requesting Input..................................................................................................................................... 320
Messages ................................................................................................................................................ 320
International Messages........................................................................................................................... 324
Konstruksi Dokumentasi ......................................................................................................................... 325
Struktur Grafik dan Suara ....................................................................................................................... 326
Elemen Grafis Dua Dimensi..................................................................................................................... 333
Arahan dan Opsi Grafis ........................................................................................................................... 342
Messages ................................................................................................................................................ 360
Messages ................................................................................................................................................ 399
2. 10. 9 Arahan Grafis Tiga Dimensi ................................................................................................... 440
2. 10. 10 Sistem Koordinat untuk Grafik Tiga Dimensi ..................................................................... 446
2.1.1 Merencanakan Permukaan Tiga Dimensi .............................................................................. 460
SurfaceGraphics ..................................................................................................................................... 467
2.1.2 Pencahayaan dan Properti Permukaan ........................................................................... 471
2.1.3 Pelabelan Grafik Tiga Dimensi ............................................................................................... 476
2.1.4 Topik Lanjutan:Rendering Grafis Tingkat Rendah ................................................................. 482
2.1.5 Format untuk Teks dalam Grafik ........................................................................................... 484
Sin[x]2 .................................................................................................................................................. 488
Sin[x ]2............................................................................................................................................ 489
Part 3 ...................................................................................................................................................... 570
[{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6} 3] ................................. 572
Interval [{- }]...................................................................................... 577

BAB 1
MATEMATIKA UNTUK MESIN DAN

PEKERJAAN LOGAM
Bab ini mencakup semua prosedur matematika dasar dan khusus untuk nilai
masinis modern dan pekerja logam. Geometri dan trigonometri bidang adalah bilangan
prima penting, seperti manipulasi aljabar dasar. Solusi untuk banyak dasar dan operasi
permesinan dan pengerjaan logam yang kompleks akan sulit atau tidak mungkin tanpa
menggunakan cabang-cabang matematika ini. Dalam bab ini dan subbagian lain dari
buku pegangan ini, semua aspek dasar dan penting dari cabang-cabang matematika
ini akan dibahas secara rinci. Contoh permesinan dan pengerjaan logam yang khas
masalah dan solusi mereka disajikan di seluruh buku pegangan ini.
1.1 PRINSIP GEOMETRI—ILMU UKUR BIDANG
Pada segitiga sembarang, sudut A + sudut B + sudut C = 180°, dan sudut A =

180°-(sudut A + sudut B), dan seterusnya (lihat Gambar 1.1). Jika tiga sisi dari sebuah
segitiga sebanding dengan sisi-sisi yang bersesuaian dari segitiga lain, segitiga-
segitiga itu sebangun. Juga, jika a:b:c = a′:b′:c′, maka sudut A
= sudut A′, sudut B = sudut B′, sudut C = sudut C′, dan a/a′ = b/b′ = c/c′.
Sebaliknya, jika sudut-sudut suatu segitiga sama besar dengan sudut-sudut pada
segitiga lainnya, segitiga-segitiga itu sebangun dan sisi-sisinya proporsional; jadi jika
sudut A = sudut A′, sudut B = sudut B′, dan sudut C = sudut C′, maka a:b:c = a′:b′:c′
dan a/a′ = b/b′ = c/c′.
Gambar 1.1 Segitiga

1.2 BAB 1
Gambar 1.2 Segitiga Sembarang
Segitiga sama kaki (lihat Gambar 1.3). Jika sisi c = sisi b, maka sudut C = sudut B.
Segitiga sama sisi (lihat Gambar 1.4). Jika sisi a = sisi b = sisi c, sudut A, B, dan C sama
(60 °).
Segitiga siku-siku (lihat Gbr.1.5). c2 = a2 + b2 dan c = (a2 + b2) 1/2 jika sudut C =
90°. Oleh karena itu, a = (c2 b2) 1/2 dan b = (c2 a2) 1/2. Hubungan ini pada semua segitiga
siku-siku disebut teorema Pythagoras.
Sudut luar segitiga (lihat Gambar 1.6). Sudut C = sudut A + sudut B
GAMBAR 1.3 Sama Kaki segi tiga. GAMBAR 1.4 Segitiga sama sisi.
GAMBAR 1.5 Segitiga siku-siku. GAMBAR 1.6 Sudut luar segitiga.

MATEMATIKA UNTUK MESIN DAN PEKERJA LOGAM 1.3
Perpotongan garis lurus (lihat Gambar 1.7). Sudut A = sudut A′, dan sudut B =
sudut B′.
GAMBAR 1.7 Garis lurus berpotongan.
Dua garis sejajar berpotongan dengan garis lurus (lihat Gambar 1.8). Interior
alternative dan sudut luar sama besar: sudut A = sudut A′; sudut B = sudut B′.
Gambar geometris empat sisi (lihat Gambar 1.9). Jumlah semua sudut dalam =
360°; sudut A + sudut B + sudut C + sudut D = 360°.
Garis singgung sebuah titik pada lingkaran berada pada 90°, atau normal,
terhadap garis radial yang ditarik ke titik singgung (lihat Gambar 1.10).
GAMBAR 1.8 Garis lurus yang memotong dua garis sejajar.
GAMBAR 1.9 Segiempat (empat sisi). GAMBAR 1.10 Garis singgung pada suatu titik pada
lingkaran.
1.4 Bab 1
Titik singgung persekutuan dua lingkaran berpotongan dengan garis yang ditarik antara pusat (lihat
Gambar 1.11).
Sisi a = a′; sudut A = sudut A′ (lihat Gambar

1.12). Sudut A = 1/2 sudut B (lihat Gambar 1.13).
GAMBAR 1.11 Titik singgung bersama.
GAMBAR 1.12 Garis singgung dan sudut.
GAMBAR 1.13 Setengah sudut (A).

Sudut A = sudut B = sudut C. Semua sudut keliling tali busur adalah sama (lihat
Gambar 1.14).
Sudut B = 1/2 sudut A (lihat Gambar

1.15). a2 = bc (lihat Gambar 1.16).
Semua sudut keliling dalam lingkaran, yang ditarik dari diameternya, adalah 90°
(lihat Gambar 1.17). Panjang busur sebanding dengan sudut internal (lihat Gambar 1.18).
Sudut A: sudut B = a:b. Jadi, jika sudut A = 89°, sudut B = 30°, dan busur a = 2,15
satuan panjang, busur b akan dihitung sebagai
GAMBAR 1.14 Sudut keliling tali busur. GAMBAR 1.15 Setengah sudut (B).
FIGURE 1.16 Line and circle relationship (a 2 = bc).

1.6 BAB SATU
GAMBAR 1.17 Sudut keliling 90°. GAMBAR 1.18 Busur dan sudut proporsional.
CATATAN. Sudut dapat diberikan dalam derajat desimal atau radian, secara konsisten.
Keliling sebanding dengan jari-jarinya masing-masing (lihat Gambar 1.19). C:C′ = r:R,
dan luas sebanding dengan kuadrat dari jari-jari masing-masing.
GAMBAR 1.19 Keliling dan proporsionalitas jari-jari.

1.2 ALJABAR DASAR
1.2.1 Prosedur Aljabar
Memecahkan Persamaan Aljabar Khas. Persamaan aljabar diselesaikan dengan

mengganti nilai numerik yang ditetapkan ke variabel yang dilambangkan dengan huruf,
dan kemudian menemukan nilai yang tidak diketahui, menggunakan prosedur aljabar.
Contoh :
Sebagian besar persamaan yang ditunjukkan dalam buku pegangan ini diselesaikan
dengan cara yang sama, yaitu, dengan mengganti nilai yang diketahui untuk variabel
dalam persamaan dan memecahkan kuantitas yang tidak diketahui menggunakan aturan
dan prosedur aljabar dan trigonometri standar
Jika a, b, dan c real, jika b2 4ac positif, akar-akarnya real dan tidak sama.Jika b2 4ac
adalah nol, akar-akarnya nyata dan sama. Jika b2 4ac negatif, akar-akarnya imajiner dan
tidak setara.
1.8 Bab satu
Logaritma bilangan N ke basis a adalah pangkat eksponen untuk dimana a harus

dinaikkan untuk mendapatkan N. Jadi N = ax dan x = loga N. Juga loga 1 = 0 dan loga
= 1.
Hubungan lainnya mengikuti:
Logaritma basis 10 disebut sebagai logaritma umum atau logaritma Briggs, setelah
penemu mereka. Logaritma basis e (di mana e = 2,71828) dinyatakan sebagai natural,
hiperbolik, atau Logaritma Naperi, label terakhir yang mengacu pada penemunya. Dasar
alami sistem logaritma didefinisikan oleh deret tak hingga.
Jika a dan b adalah sembarang dua basa, maka
Cukup kalikan log natural dengan 0,43429 (modulus) untuk mendapatkan yang
setara catatan umum.
Demikian pula, kalikan log umum dengan 2,30261 untuk mendapatkan persamaan
natural catatan. (Akurasi adalah hingga empat tempat desimal untuk kedua kasus.)
1.2.2 Transposisi Persamaan (Sederhana dan Kompleks)
Transpos Persamaan. Kami dapat memecahkan untuk salah satu yang tidak
diketahui jika semua variabel lainnya diketahui. persamaan yang diberikan adalah
Persamaan dengan lima variabel, ditunjukkan dalam bentuk R. Pemecahan untuk G:
Penyelesaian untuk d:
1.10 BAB SATU
Penyelesaian untuk d :
Selesaikan untuk N menggunakan prosedur transposisi yang sama seperti yang

ditunjukkan sebelumnya.
CATATAN. Ketika persamaan kompleks perlu diubah, personel toko dapat

menghubungi departemen teknik atau teknik alat mereka, di mana program MathCad
biasanya tersedia. Transposisi Persamaan menggunakan MathCad (Persamaan
Kompleks). Transposisi persamaan aljabar dasar memiliki banyak kegunaan dalam
penyelesaian masalah pemesinan dan pengerjaan logam. Mengubah persamaan yang
kompleks membutuhkan keterampilan yang cukup besar dalam matematika. Untuk
menyederhanakan prosedur ini, penggunaan MathCad sangat berharga. Sebagai contoh,
persamaan dasar yang melibatkan fungsi trigonometri ditunjukkan di sini, dalam bentuk
asli dan yang dialihkan. Transposisi dilakukan dengan menggunakan metode simbolik,
dengan derajat atau radian untuk nilai sudut.
Persamaan Dasar
Persamaan yang Ditransposisikan (Sudut dalam Derajat
CATATAN. Nilai sudut dinyatakan dalam

derajat. Persamaan Dasar
Persamaan yang Ditransposisikan (Sudut dalam Radian)
CATATAN. Nilai sudut dinyatakan dalam radian, yaitu, 90 derajat = /2

radian; 2π radian = 360°; radian = 180°.
1.3 TRIGONOMETRI PESAWAT
Ada enam fungsi trigonometri: sinus, cosinus, tangen, kotangen, secan, dan
kosekans. Hubungan fungsi trigonometri ditunjukkan pada Gambar. 1.20. Fungsi
trigonometri yang ditunjukkan untuk sudut A (segitiga siku-siku) meliputi:
sin A = a/c (sinus)

cos A = b/c
(cosinus)
tan A = a/b
(singgung) cot A =
b/a (kotangen)
detik A = c/b
(secan) csc A = c/a
(kosekan)
Untuk sudut B, fungsinya menjadi (lihat Gambar 1.20)
sin B = b/c
(sinus) cos B =
a/c (cosinus)
GAMBAR 1.20 Segitiga siku-siku.

1.12 BAB PERTAMA
tan B = b/a
(singgung) cot B =
a/b (kotangen)
detik B = c/a
(secan) csc B = c/b
(kosekan)
Seperti yang dapat dilihat dari sebelumnya, sinus dari suatu sudut tertentu selalu
merupakan sisi berlawanan dengan sudut yang diberikan dibagi dengan sisi miring
segitiga. Kosinus selalu adalah sisi yang berdekatan dengan sudut yang diberikan dibagi
dengan sisi miring, dan garis singgungnya selalu sisi di hadapan sudut yang diberikan
dibagi dengan sisi yang berdekatan dengan sudut. Hubungan ini harus diingat setiap saat
ketika melakukan operasi trigonometri.
Juga:
Ini mencerminkan fakta penting bahwa kosekan, sekan, dan kotangen adalah
kebalikan dari sinus, cosinus, dan tangen. Fakta ini juga harus diingat ketika melakukan
operasi trigonometri.
Tanda dan Batas Fungsi Trigonometri. Bagan koordinat berikut menunjukkan tanda
fungsi di setiap kuadran dan batas numeriknya. Sebagai contoh, sinus dari setiap sudut
antara 0 dan 90° akan selalu positif, dan numeriknya nilai akan berkisar antara 0 dan 1,
sedangkan cosinus dari setiap sudut antara 90 dan 180 ° akan selalu negatif, dan nilai
numeriknya akan berkisar antara 0 dan 1. Setiap kata-kata kasar kuadran berisi 90°;
dengan demikian kuadran keempat berkisar antara 270 dan 360°.
1.3.1 Hukum Trigonometri
Hukum trigonometri menunjukkan hubungan antara sisi dan sudut segitiga tidak
siku-siku atau segitiga miring dan memungkinkan kita untuk menghitung yang tidak
diketahui bagian dari segitiga ketika nilai-nilai tertentu diketahui. Lihat Gambar 1.21 untuk
ilustrasi hukum trigonometri berikut.
GAMBAR 1.21 Segitiga miring.
Hukum Sinus. Lihat Gambar 1.21.
dan
Jadi a × sin B = b × sin A; b × sin C = c × sin B, dll.
Dengan hukum sebelumnya, fungsi trigonometri untuk segitiga siku-siku, Teorema

Pythagoras, dan diagram solusi segitiga berikut, akan mungkin untuk temukan solusi
untuk masalah segitiga bidang apa pun, asalkan bagian yang benar ditentukan.
1.14 BAB SATU
Solusi Segitiga
- Dalam segitiga siku-siku Untuk memecahkan

• Diketahui: Sebarang dua sisi
• Diketahui: Salah satu sisi dan salah satunya
sisinya 90°.
• Diketahui: Tiga sudut dan tidak ada sisi (semua segitiga).
• Diketahui: Tiga sisi
- Penyelesaian
• Gunakan teorema Pythagoras untuk menyelesaikan sisi yang tidak diketahui;
kemudian gunakan trigonometri berfungsi untuk menyelesaikan dua sudut yang

tidak diketahui. Sudut ketiga adalah 90°.
• Gunakan fungsi trigonometri untuk menyelesaikan keduanya salah satu sudut yang
tidak diketahui. Sudut ketiga adalah 180° jumlah dua sudut yang diketahui.
• Tidak dapat diselesaikan karena ada tak hingga jumlah segitiga yang memenuhi tiga
sudut dalam yang diketahui.
• Gunakan fungsi trigonometri untuk menyelesaikan keduanya sudut yang tidak
diketahui.
- Dalam segitiga miring Untuk memecahkan
• Diketahui: Dua sisi dan salah satu dari
• Diketahui: Dua sisi dan sisinya
• Diketahui: Dua sudut dan salah satu sisinya
• Diketahui: Tiga sisi
• Diketahui: Satu sudut dan satu sisi (segitiga tidak siku-siku)
- Penyelesaian
• Gunakan hukum sinus untuk menyelesaikan yang kedua dua sudut yang tidak
termasuk sudut yang tidak diketahui. Sudut ketiga adalah 180° jumlah dua
sudut yang diketahui. Kemudian temukan sisi lain menggunakan hukum sinus
atau hukum garis singgung.
• Gunakan hukum kosinus untuk satu sisi dan hukum sudut sinus untuk kedua sudut.
• Gunakan hukum sinus untuk menyelesaikan sisi yang lain atau hukum tangen.
Sudut ketiga adalah 180° jumlah dua sudut yang diketahui.
• Gunakan hukum kosinus untuk menyelesaikan dua dari sudut yang tidak
diketahui. Sudut ketiga adalah 180° jumlah dua sudut yang diketahui.
• Tidak dapat diselesaikan kecuali di bawah tertentu kondisi. Jika segitiga sama
sisi atau sama kaki, dapat diselesaikan jika diketahui sudut berlawanan dengan
sisi yang diketahui.
Mencari Ketinggian Segitiga Tidak Siku Siku. Tinggi x ditunjukkan pada Gambar. 1.22 dan 1,23 ditemukan dari
GAMBAR 1.22 Tinggi segitiga x.
GAMBAR 1.23 Tinggi segitiga x.
Daerah Segitiga. Lihat Gambar 1.24a dan b.
GAMBAR 1.24 Segitiga: (a) segitiga siku-siku; (b) segitiga miring.

Area ketika ketiga sisi diketahui (lihat Gbr. 1.25) (ini berlaku untuk sembarang segitiga):
Dimana
GAMBAR 1.25 segitiga.
1.6 BAB SATU
Teorema Pythagoras. Untuk segitiga siku-siku:
CATATAN. Sisi c adalah sisi miring.
Solusi Praktis untuk Segitiga. Bagian sebelumnya tentang dasar fungsi trigonometri
dan hukum trigonometri, bersama-sama dengan solusi segitiga grafik, akan
memungkinkan Anda untuk menyelesaikan semua segitiga bidang, baik bagian dan
areanya. Kapanpun Anda memecahkan segitiga, pertanyaan selalu muncul, "Apakah
solusinya benar?" Di kantor teknik, segitiga dapat ditarik ke skala menggunakan AutoCad
dan sudutnya dan sisi diukur, tetapi di toko ini tidak dapat dilakukan dengan akurat.
Dalam permesinan, masalah gearing, dan tool engineering, segitiga harus diselesaikan
dengan akurasi tinggi dan solusinya diverifikasi.
Untuk memverifikasi atau memeriksa solusi segitiga, kami memiliki persamaan

Mollweide, yang melibatkan semua bagian segitiga. Dengan menggunakan persamaan
klasik ini, kita tahu jika solusi untuk setiap segitiga yang diberikan benar atau jika telah
dihitung dengan benar.
Persamaan Mollweide
Substitusikan nilai yang dihitung dari semua sisi dan sudut ke dalam persamaan
Mollweide dan lihat apakah persamaan tersebut seimbang secara aljabar. Penggunaan
persamaan Mollweide akan menjadi ditampilkan di bagian selanjutnya. Perhatikan bahwa
sudut harus ditentukan dalam derajat desimal saat menggunakan persamaan ini.
Konversi Sudut ke Derajat Desimal. Sudut yang diberikan dalam derajat, menit, dan
detik harus dikonversi ke derajat desimal sebelum menemukan fungsi trigonometri sudut
pada kalkulator genggam modern.
Mengonversi Derajat, Menit, dan Detik ke Derajat Desimal Prosedur. Ubah 26°41′26″ ke
derajat desimal. Derajat = 26.000.000 dalam derajat desimal
Menit = 41/60 = 0,683333 dalam bagian desimal

derajat Detik = 26/3600 = 0,007222 dalam bagian
desimal derajat Sudut dalam derajat desimal
adalah
26.000.000 + 0,683333 + 0,007222 = 26,690555 °
Mengonversi Derajat Desimal ke Derajat, Menit, dan Detik Prosedur. Ubah 56,5675
derajat desimal menjadi derajat, menit, dan detik.
Derajat = 56 derajat
Menit = 0,5675 × 60 = 34,05 = 34 menit
Detik = 0,05 (menit) × 60 = 3 detik
Oleh karena itu, jawabannya adalah 56°34′3″.
Ringkasan Prosedur Trigonometri untuk Segitiga. Ada empat kemungkinan kasus

dalam penyelesaian segitiga miring:
Kasus 1. Diketahui satu sisi dan dua sudut: a, A, B
Kasus 2. Diketahui dua sisi dan sudut yang berhadapan dengannya: a,

b, A atau B Kasus 3. Diberikan dua sisi dan sudut yang disertakan: a, b,
C
Kasus 4. Diketahui tiga sisi: a, b, c
Semua segitiga miring (tidak siku-siku) dapat diselesaikan dengan menggunakan

fungsi metrik trigono alami: hukum sinus, hukum kosinus, dan rumus sudut, sudut A +
sudut B + sudut C = 180°. Ini dapat dilakukan dengan cara berikut:
Kasus 1. Diberikan a, A, dan B, sudut C dapat ditemukan dari rumus sudut; kemudian
sisi b dan c dapat ditemukan dengan menggunakan hukum sinus dua kali.
Kasus 2. Diketahui a, b, dan A, sudut B dapat ditentukan dengan hukum sinus, sudut C
dari rumus sudut, dan sisi c oleh hukum sinus lagi.
Kasus 3. Diberikan a, b, dan C, sisi c dapat ditemukan dengan hukum cosinus, dan
sudut A dan B dapat ditemukan dengan hukum sinus yang digunakan dua kali; atau
sudut A dari hokum sinus dan sudut B dari rumus sudut.
Kasus 4. Mengingat a, b, dan c, semua sudut dapat ditemukan dengan hukum cosinus;
atau sudut A dapat ditemukan dari hukum cosinus, dan sudut B dan C dari hokum dari
sinus; atau sudut A dari hukum cosinus, sudut B dari hukum sinus, dan sudut C dari
rumus sudut.
Dalam semua kasus, solusi dapat diperiksa dengan persamaan Mollweide.
CATATAN. Kasus 2 disebut kasus ambigu, di mana mungkin ada satu solusi, dua
solusi, atau tidak ada solusi, diberikan a, b, dan A.
● Jika sudut A < 90° dan a < b sin A, tidak ada solusi.
● Jika sudut A < 90° dan a = b sin A, ada satu solusi—segitiga siku-siku.
● Jika sudut A < 90° dan b > a > b sin A, ada dua solusi—segitiga miring.
● Jika sudut A < 90° dan a b, ada satu solusi—segitiga miring.
● Jika sudut A < 90° dan a b, tidak ada solusi.
● Jika sudut A > 90° dan a > b, ada satu solusi—segitiga miring.
1.18 BAB SATU
Variasi Persamaan Mollweide. Ada dua bentuk persamaan Mollweide:

Gunakan salah satu formulir untuk memeriksa
segitiga. Akurasi Sudut Terhitung
Rumus Setengah Sudut Khusus. Dalam kasus 4 segitiga di mana hanya tiga sisi a,
b, dan c diketahui, himpunan rumus setengah sudut yang ditunjukkan di sini dapat
digunakan untuk mencari sudut
Dimana
Hubungan Tambahan dari Fungsi Trigonometri

Fungsi Setengah Sudut
CATATAN. Tanda sebelum radikal tergantung pada kuadran di mana x/2 jatuh. Lihat
fungsi dalam grafik empat kuadran dalam teks.
Fungsi Beberapa Sudut
Fungsi Jumlah Sudut
1.20 BAB SATU
Hubungan Lain-lain
Hubungan Antara Sisi dan Sudut Segitiga Bidang Segitiga

Dimana
Fungsi Trigonometri Direduksi ke Kuadran Pertama. Lihat Gambar 1.26.
GAMBAR 1.26 Fungsi trigonometri direduksi menjadi kuadran pertama.
1.3.2 Contoh Soal Menggunakan Trigonometri
Contoh Solusi untuk Segitiga

Memecahkan segitiga siku-siku dengan trigonometri. Diperlukan: Setiap satu sisi
dan sudut A atau sudut B (lihat Gambar 1.27). Selesaikan untuk sisi a
GAMBAR 1.27 Memecahkan segitiga.
1.22 BAB SATU
Selesaikan untuk sisi b:
Kemudian
Kita sekarang tahu sisi a, b, dan c dan sudut A, B, dan C. Menyelesaikan Segitiga
Tidak Siku Kanan Menggunakan Hukum Trigonometri. Selesaikan segitiga pada Gambar
1.28. Diketahui: Dua sudut dan satu sisi:
GAMBAR 1.28 Memecahkan segitiga.
Pertama, cari sudut C:
Kedua, temukan sisi b dengan hukum sinus:
Maka
Ketiga, cari sisi c dengan hukum sinus:

Maka
Solusi untuk segitiga ini telah dihitung sebagai a = 3.250, b = 4.3457, c = 2.0150,
sudut A = 45°, sudut B = 109°, dan sudut C = 26°.
Kami sekarang menggunakan persamaan Mollweide untuk memeriksa jawaban yang

dihitung dengan mengganti bagian-bagian ke dalam persamaan dan memeriksa
keseimbangan, yang menandakan kesetaraan dan solusi yang tepat
1.24 BAB SATU
Persamaan ini menunjukkan bahwa solusi terhitung untuk segitiga yang

ditunjukkan pada Gambar
1.28 adalah benar.
Selesaikan segitiga pada Gambar 1.29. Diketahui: Dua sisi dan satu sudut:
Pertama, cari sudut B dari hukum sinus:
Kedua, cari sudut C:
Ketiga, temukan sisi c dari hukum sinus:

Kita sekarang dapat menemukan ketinggian atau tinggi x dari segitiga ini (lihat
Gambar 1.29).
Lihat Gambar. 1,23 dan teks untuk persamaan berikut untuk x.
Tinggi x ini juga dapat ditemukan dari fungsi sinus sudut C′, ketika sisi a diketahui,
seperti yang ditunjukkan di sini:
1.26 BAB SATU
Kedua metode menghasilkan solusi numerik yang sama: 1,051. Juga, solusi
sebelumnya untuk segitiga yang ditunjukkan pada Gambar. 1.29 benar karena akan
menyeimbangkan Mollweide persamaan.
Selesaikan segitiga pada Gambar 1.30. Diketahui: Tiga sisi dan tidak ada
sudut.Menurut bagan solusi segitiga sebelumnya, memecahkan segitiga ini membutuhkan
penggunaan hokum kosinus. Lanjutkan sebagai berikut. Pertama, selesaikan untuk setiap
sudut (kita akan mengambil sudut C terlebih dahulu).
Kedua, menurut hukum cosinus, cari sudut B:
Kemudian, sudut A ditemukan dari
Oleh karena itu, solusi untuk segitiga yang ditunjukkan pada Gambar 1.30 adalah a
= 1,1875, b = 2,4375, c = 1,7500 (diberikan), sudut A = 27,113°, sudut B = 110.695°,
dan sudut C = 42,192° (dihitung). Ini juga dapat diperiksa menggunakan persamaan
Mollweide.
Bukti Persamaan Mollweide. Dari teorema Pythagoras diketahui dan dapat
dibuktikan bahwa setiap segitiga dengan sisi sama dengan 3 dan 4 dan sisi miring dari 5
akan menjadi segitiga siku-siku sempurna. Kelipatan angka 3, 4, dan 5 juga menghasilkan
segitiga siku-siku sempurna, seperti 6, 8, dan 10, dst. (c 2 = a2 + b2 ). Jika Anda
memecahkan 3, 4, dan 5 segitiga proporsional untuk sudut internal dan kemudian
Substitusikan sisi dan sudut ke dalam persamaan Mollweide, persamaan tersebut akan
seimbang, yang menunjukkan bahwa solusi tersebut valid secara matematis.
Catatan tentang penggunaan persamaan Mollweide saat memeriksa segitiga: Jika

persamaan Moll weide tidak seimbang,
● Solusi untuk segitiga salah.
● Solusinya tidak akurat.
● Persamaan Mollweide salah dihitung.
● Segitiga tidak “tertutup”, atau jumlah sudut dalam tidak sama dengan 180°.
FungsiTrigonometri Alami. Tidak ada tabel trigonometri alami fungsi atau logaritma
dalam buku pegangan ini. Ini karena ketersediaannya yang luas kalkulator digital
elektronik. Anda dapat menemukan nilai numerik ini lebih cepat dan lebih akurat daripada
yang dapat disediakan oleh tabel mana pun. Lihat Sec. 1.4 untuk penggunaan kalkulator
dan teknik teknis yang berlaku untuk praktik permesinan dan pengerjaan logam.
Fungsi trigonometri alami untuk sinus, kosinus, dan tangen dapat dihitung
menggunakan persamaan deret tak hingga berikut. Fungsi kotangen, secan, dan cosecant
hanyalah kebalikan numerik dari tangen, cosinus, dan sinus fungsi,masing-masing.
Menghitung Fungsi Trigonometri Alami. Seri tak terbatas untuk sinus (sudut x harus
diberikan dalam radian).
1.28 BAB SATU

Deret tak hingga untuk kosinus (sudut x harus diberikan dalam radian)
Garis singgung alami sekarang dapat ditemukan dari deret sinus dan kosinus
menggunakan Persamaan
1.4 KALKULATOR SAKU MODERN PROSEDUR
1.4.1 Jenis Kalkulator
Kalkulator elektronik digital genggam atau saku modern adalah alat yang sangat
berharga untuk masinis dan pekerja logam. Banyak tabel rumit seperti fungsi metrik
trigono natural, pangkat dan akar, tabel batang sinus, fungsi involute, dan tabel mic
logarit tidak disertakan dalam buku pegangan ini karena ketersediaannya yang siap pakai,
kesederhanaan, kecepatan, dan akurasi tinggi dari perangkat ini.
Kalkulator saku multifungsi yang khas ditunjukkan pada Gambar 1.31. Jenis ini
perangkat akan digunakan untuk mengilustrasikan metode kalkulator yang ditunjukkan
pada Sec. 1.4.2 berikut.
GAMBAR 1.31 Kalkulator saku standar biasa.

Munculnya generasi terbaru kalkulator genggam yang dapat deprogram termasuk
Texas Instruments TI-85 dan Hewlett Packard HP-48G (lihat Gambar. 1.32) telah
memungkinkan banyak rekayasa yang sebelumnya sulit atau hampir mustahil
perhitungan. Kedua instrumen tersebut memiliki kemampuan yang sangat besar dalam
memecahkan masalah matematika umum yang kompleks. Lihat Sec. 11.5 untuk
penjelasan lengkap tentang melamar kalkulator ini ke mekanisme hubungan empat
batang yang penting dan berguna, berdasarkan pada penggunaan persamaan standar
Freudenstein.
GAMBAR 1.32 Kalkulator yang dapat diprogram dengan kemampuan memecahkan persamaan
yang kompleks dan fitur-fitur canggih lainnya. HP-48G di sebelah kanan dan TI-85 di sebelah
kiri.
Beberapa mesin yang lebih baru juga tidak mengandalkan daya baterai, karena
memiliki a built-in panel konversi surya sensitivitas tinggi yang mengubah cahaya ruangan
menjadi energi listrik untuk menyalakan kalkulator. Meluasnya penggunaan perangkat ini
telah meningkatkan produktivitas industri secara signifikan sejak diperkenalkan pada
tahun 1970-an.
1.4.2 Teknik Kalkulator Modern
Menemukan Fungsi Trigonometri Alami. Fungsi trigonometri alami dari semua sudut
diperoleh dengan mudah, dengan kecepatan dan presisi tinggi.
CONTOH. Temukan fungsi trigonometri alami dari sin 26°41′26″. Pertama,

konversikan dari derajat, menit, dan detik ke derajat desimal (lihat Sec.1.3.1):
26°41′26″ = 26.690555°
1.30 BAB SATU

Tekan: sin
Masukkan: 26.690555, lalu =

Jawaban: 0.4491717 (fungsi
alami)
Sinus natural, cosinus, dan tangen dari sembarang sudut dapat ditemukan. Negatif
sudut ditemukan dengan menekan sin, cos, atau tan; memasukkan derajat desimal;
berubah tanda ke minus; dan kemudian menekan =.
Kotangen, secan, dan cosecan dicari dengan menggunakan tombol resiprokal (x−1)
pada kalkulator.
Menemukan Logaritma Umum dan Alami Bilangan. Umum, atau Briggs, sistem
logaritma dibangun dengan basis 10 (lihat Bagian 1.2.1).
CONTOH
101 = 10 dan log10 10 = 1
102 = 100 dan log10 100 = 2
103 = 1000 dan log10 1000 = 3
Oleh karena itu, log10 110.235 ditemukan dengan menekan log dan memasukkan
nomor ke dalam Kalkulator:
Tekan: log
Masukkan: 110.235,
lalu = Jawaban:
2.042319506
Karena nilai logaritmik adalah eksponen yang dinaikkan 10 untuk mendapatkan
nomor, kami akan melakukan perhitungan ini:
102.042319506 = 110.235
BUKTI
Masukkan:
10 Tekan:
yx
Masukkan: 2.042319506
Tekan: =
Jawaban: 110.2349999, atau 110.235 sampai tiga tempat desimal.
Logaritma alami, atau hiperbolik, dari suatu bilangan ditemukan dengan cara
yang sama. CONTOH. Temukan logaritma natural, atau hiperbolik, dari 110,235.
Tekan: ln
Masukkan: 110.235,
lalu = Jawaban:
4.702614451
Pangkat dan Akar (Eksponensial). Menemukan pangkat dan akar (eksponensial) dari
angka sederhana di kalkulator saku dan membuat prosedur logaritmik dan tabel logaritma
usang, serta fungsi tabel angka yang ditemukan di buku pegangan usang.
CONTOH. Temukan akar kuadrat dari 3,4575.
Tekan: x
Masukkan: 3,4575,
lalu = Jawaban:
1.859435398
Prosedur ini hanya memakan waktu beberapa
detik. CONTOH. Temukan (0,0625)4.
Masukkan:
0,0625 Tekan:
xy Masukkan: 4
Tekan: =
Jawaban: 1.525879 × 10−5
CONTOH. Temukan akar pangkat tiga dari 5.2795, atau

(5.2795)1/3. Masukkan: 3 atau Masukkan:
5.2795
Tekan: x y Tekan: xy
Masukkan: 5.2795 Masukkan: 0.33333
Tekan: = Tekan: =
Jawaban: 1.7412626 Jawaban:

1.74126 CATATAN. Radikal ditulis dalam notasi
eksponensial:
1.4.3 Prosedur Bracketing Kalkulator Saku
Saat memasukkan persamaan ke dalam kalkulator saku, prosedur bracketing yang

benar harus digunakan untuk mencegah kesalahan perhitungan. Prosedur yang salah
menghasilkan pesan SYN ERROR atau MATH ERROR pada tampilan kalkulator, atau
jawaban numerik yang salah.
1.32 BAB SATU
CONTOH. x = tidak diketahui untuk dihitung
Contoh yang ditampilkan adalah beberapa jenis bracketing yang lebih umum. Tanda
kurung akan menjadi lebih sulit pada persamaan yang panjang dan kompleks. Penjelasan
dari urutan masuk dan prosedur bracketing biasanya ditunjukkan dalam instruksi buku
yang datang dengan kalkulator saku. Kalkulator yang menampilkan persamaan karena
sedang dimasukkan ke dalam kalkulator adalah jenis yang disukai. Kalkulator Casio
ditunjukkan pada Gambar. 1.31 adalah jenis ini. Kalkulator TI dan HP
yang lebih canggih ditunjukkan pada: Gambar 1.32 juga menampilkan seluruh
persamaan yang dimasukkan, sehingga lebih mudah digunakan dan mengurangi
kemungkinan kesalahan entri braket.
1.5 KONVERSI SUDUT—DERAJAT DAN RADIAN
Konversi Derajat ke Radian dan Radian ke Derajat. Untuk mengonversi dari

derajat ke radian, Anda harus terlebih dahulu menemukan derajat sebagai derajat
desimal (lihat bagian sebelumnya).
Jika R menyatakan radian, maka
CONTOH. Ubah 56,785° ke radian.
56,785 × 0,0174533 = 0,9911 radian
Jadi
56,785° = 0,9911
radian CONTOH. Ubah 2.0978R ke derajat desimal.
57.2957795 × 2.0978 = 120.0591°
Jadi
2.0978 radian = 120.0591°
Lihat template radian dan derajat—Gbr. 1.33.

GAMBAR 1.33 Bagan konversi derajat ke radian.
1.34 BAB SATU

Konstanta Matematika
Penting π=
3.1415926535898
1 radian = 57.295779513082°
1° = 0,0174532925199 radian
2πR =
360° R =
180 °
1 radian =
180/π°
1°=π/180
radian
e = 2,718281828 (basis logaritma natural)
1.6 NOTASI POWERS-OF-TEN
Bilangan yang ditulis dalam bentuk 1,875 × 10 5 atau 3,452 × 10−6 dinyatakan
dalam notasi pangkat sepuluh. Operasi aritmatika pada bilangan yang sangat besar atau
sangat kecil dengan mudah dan nyaman
diproses menggunakan notasi pangkat sepuluh dan Prosedur. Proses ini secara otomatis
dilakukan oleh kalkulator kalkulasi ilmiah genggam. Jika jawaban yang dihitung lebih
besar atau lebih kecil dari yang dapat ditangani oleh tampilan digital, jawabannya akan
diberikan dalam notasi pangkat sepuluh.
Metode penanganan angka ini selalu digunakan dalam perhitungan ilmiah dan teknik
ketika nilai angka begitu menentukan. Notasi teknik biasanya diberikan dalam kelipatan
3, seperti 1,246 × 103 , 6,983
× 10−6 , dll.
Cara Menghitung dengan Notasi Powers-of-Ten. Angka dengan banyak digit

mungkin diekspresikan lebih nyaman dalam notasi pangkat sepuluh, seperti yang
ditunjukkan di sini.
0,000001389 = 1,389 × 10−6
3.768.145 = 3.768145 × 106
Anda sebenarnya menghitung jumlah tempat di mana titik desimal digeser, baik ke
kanan atau ke kiri. Pergeseran ke kanan menghasilkan eksponen negatif, dan bergeser
ke kiri menghasilkan eksponen positif.
Perkalian, pembagian, eksponen, dan radikal dalam notasi pangkat sepuluh adalah
mudah ditangani, seperti yang ditunjukkan di sini.
1,246 × 104 (2,573 × 10−4) = 3,206 × 100 = 3,206 (Catatan: 100 = 1)
1,785 × 107 (1,039 × 10−4) = (1,785/1,039) × 107 (−4) = 1,718 × 1011
(1,447 × 105)2 = (1,447)2 × 1010 = 2,094 × 1010
1,391 × 108 = 1,3911/2 × 108/2 = 1,179 × 104
Dalam contoh sebelumnya, Anda harus menggunakan aturan aljabar standar untuk
penjumlahan, pengurangan, perkalian, dan pembagian pangkat atau pangkat bilangan.
Dengan demikian,
● Eksponen ditambahkan secara aljabar untuk perkalian.
● Eksponen dikurangkan secara aljabar untuk pembagian.

● Eksponen dikalikan secara aljabar untuk peningkatan daya.
● Eksponen dibagi secara aljabar untuk akar.
1.7 PERCENTAGE PERHITUNGAN
Prosedur perhitungan persentase memiliki banyak aplikasi dalam permesinan,

desain, dan masalah pengerjaan logam. Meskipun prosedurnya relatif sederhana, mudah
untuk membuat kesalahan dalam manipulasi angka-angka yang terlibat.
Biasanya, 100 persen dari setiap kuantitas diwakili oleh angka 1.00, yang berarti
jumlah total. Jadi, jika kita mengambil 50 persen dari kuantitas apa pun, atau kelipatan
apa pun dari 100 persen, itu harus dinyatakan sebagai desimal:
1% = 0,01
10% = 0,10
65,5% = 0,655
145% = 1,45
Akibatnya, kami membagi angka persentase, seperti 65,5 persen, dengan 100 untuk
mendapatkan pada ekuivalen desimal yang diperlukan untuk perhitungan.
Mari kita ambil persentase dari angka yang diberikan:
45% dari 136,5 = 0,45 × 136,5 = 61,425
33,5% dari 235,7 = 0,335 × 235,7 = 78,9595
Mari kita bandingkan dua bilangan arbitrer, 33 dan 52, sebagai ilustrasi:
Jadi, angka 52 adalah 57,58 persen lebih besar dari angka 33. Dapat juga dikatakan
bahwa 33 meningkat 57,58 persen sama dengan 52; yaitu, 0,5758 × 33 + 33 = 52.
Sekarang,
Jadi, bilangan 52 dikurangi 36,54 persen itu sendiri adalah 33. Kita juga dapat
mengatakan bahwa 33 adalah 36,54 persen lebih kecil dari 52 yaitu 0,3654 × 52 = 19
dan 52 19 = 33.Bilangan 33 adalah
berapa persen dari 52? Artinya, 33/52 = 0,6346. Jadi, 33 adalah 63,46 persen dari 52.
1.36 BAB SATU
Contoh Perhitungan Persentase Praktis. Aspring dikompresi menjadi 417 lbf dan
kemudian didekompresi menjadi 400 lbf, atau beban. Persentase penurunan tekanan
adalah (417-400)/417 = 0,0408, atau 4,08 persen. Tekanan, atau beban, kemudian
dinaikkan menjadi 515 lbf. persentase kenaikan lebih dari 400 lbf adalah (515 400)/515
= 0,2875, atau 28,75 persen.
Persentase kesalahan masalah cukup umum, meskipun perhitungannya sederhana.

Dalam kebanyakan kasus, jika Anda ingat bahwa pembagi adalah jumlah yang Anda ingin
persentase, baik meningkat atau menurun, kesalahan sederhana dapat dihindari. Selalu
periksa kembali jawaban Anda menggunakan persentase terhadap angka.
1.8 SISTEM SUHU DAN KONVERSI
Ada empat sistem temperatur yang umum digunakan dalam perhitungan teknik dan
desain: Fahrenheit (°F), Celcius (sebelumnya Celcius; °C), Kelvin (K), dan Rankine (°R).
Persamaan konversi untuk Celcius ke Fahrenheit atau Fahrenheit ke Celcius adalah
Persamaan relasional yang tepat ini adalah semua yang Anda butuhkan untuk
mengkonversi dari kedua sistem.
Masukkan suhu yang diketahui, dan selesaikan persamaan untuk nilai yang tidak
diketahui. CONTOH. Anda ingin mengonversi 66°C ke Fahrenheit.
Cara ini jauh lebih mudah daripada mencoba mengingat dua persamaan yang ekuivalen,
yaitu:
Dua sistem lainnya, Kelvin dan Rankine, dikonversi seperti yang dijelaskan di
sini Skala Kelvin dan Celcius dihubungkan oleh
K = 273,18 + °C
Jadi, 0 °C = 273,18 K. Nol mutlak sama dengan 273,18°C
CONTOH. Suhu 75°C = 273,18 + (−75°C) = 198,18 K.
Skala Rankine dan Fahrenheit dihubungkan oleh
°R = 459,69 + °F
Jadi, 0°F = 459.69°R. Nol mutlak sama dengan

459.69°F. CONTOH. Suhu 75°F = 459,69 +
(75°F) = 534,69°R.
1.9 SETARA DESIMAL DAN milimeter
Lihat Gambar 1.34.

1.38 BAB SATU
1.10 SETARA BERAT KECIL: ADAT AS (Biji-bijian DAN OUNS) VERSUS METRIK
(GRAM)
1 gram = 15,43 butir
1 gram = 15.430 miligrain
1 pon = 7000 butir
1 ons = 437,5 butir
1 ons = 28,35 gram
1 butir = 0,0648 gram
1 butir = 64,8 miligram
0,1 butir = 6,48 miligram

1 mikrograin = 0,0000648 miligram
1000 mikrograin = 0,0648 miligram
1 butir = 0,002286 ons
10 butir = 0,02286 ons atau 0,648 gram
100 butir = 0,2286 ons atau 6,48 gram
CONTOH. Untuk mendapatkan berat dalam gram, kalikan berat dalam biji-bijian dengan
0,0648. Atau, bagi berat dalam butir dengan 15,43.
CONTOH. Untuk mendapatkan berat dalam biji-bijian, kalikan berat dalam gram dengan
15,43. Atau, bagi berat dalam gram dengan 0,0648.
1.11 TANDA DAN SIMBOL MATEMATIKA

1.40 BAB SATU
TABEL 1.2 Alfabet Yunani

INTEGRASI
Kuis F.13
1. Tentukan integral berikut:

a) ꭍ x2 dx f) ꭍ 6x dx
b) ꭍ 4 cos x dx g) ꭍ 9x⅓ dx
c) ꭍ 2ex dx h) ꭍ 4 sec2x dx
d) ꭍ 12 dx i) ꭍ 9 sin x dx
e) ꭍ x-4 dx j) ꭍ 8/x dx
2. Tentukan integral
berikut: a) I = ꭍ (x3 -x2 + x -1)
dx
b) I = ꭍ (4x3 -9x2 + 8x -2) dx mengingat bahwa I = 11/16 dimana x = ½.
3. Tentukan integral berikut:

a) ꭍ (5x-1)4 dx
e) ꭍ 51-x dx
b) ꭍ sin(6x-1)/3 dx
f) ꭍ 3/2x-3 dx
c) ꭍ √4-2x dx g) ꭍ sec2(2-5x)/5 dx
d) ꭍ 2e3x+2dx
4. Integralkan dengan pecahan parsial dari integral berikut:

a) ꭍ 5x/6x2-x-1 dx
b) ꭍ 14x+1/2-7x-4x2 dx
c) ꭍ 1-9x/1-9x2 dx
5. Hitunglah luas daerah yang dilingkupi antara sumbu x dan kurva y= e x antara x =1 dan x
=2, berikan jawaban anda dalam bentuk e.
6. Hitunglah luas daerah yang dilingkupi antara kurva y=e x dan garis lurus y=1 x antara x=1
dan x=2, berikan jawabanmu untuk 3 dp.
Integrasi 1
Integrasi adalah proses kebalikan dari diferensiasi. Ketika kita membedakan kita mulai 1
dengan ekspresi dan lanjutkan untuk menemukan turunannya. Ketika kita berintegrasi,
kita mulai dengan turunannya dan kemudian temukan ekspresi dari mana turunannya
diturunkan.
Misalnya, d/dx (x4) =4x3. Jadi, integral dari 4x3 terhadap x kita tahu menjadi x4
Ini tertulis: ꭍ 4x3 dx = x4
Simbol f (x) dx menyatakan integral dari f (x) terhadap variabel x; symbol ꭍ
dikembangkan dari huruf kapital S yang digunakan pada abad ke-17 ketika ide-ide
kalkulus pertama kali dibuat.
Ekspresi f( x) yang akan diintegralkan disebut integran dan dx diferensial berguna
untuk membantu dalam evaluasi tertentu integral, seperti yang akan kita lihat di
Program selanjutnya.
Konstanta integrasi
Dalam tiga contoh ini kita kebetulan mengetahui ekspresi dari mana turunan 4x3
diturunkan. Tetapi setiap suku konstan dalam ekspresi aslinya menjadi nol dalam turunan
dan semua jejaknya hilang. Jadi jika kita tidak tahu sejarahnya turunan 4x3 kami tidak
memiliki bukti nilai suku konstan, baik itu 0, +2, -5 atau nilai lainnya. Oleh karena itu,
kami mengakui keberadaan istilah konstan seperti itu dari beberapa nilai dengan
menambahkan simbol C ke hasil integrasi:
C disebut konstanta integrasi dan harus selalu disertakan. Integral semacam itu disebut
integral tak tentu karena biasanya kita tidak mengetahui nilai C. Namun, dalam keadaan
tertentu, nilai C dapat ditemukan jika informasi lebih lanjut tentang integral tersedia.
Misalnya, untuk menentukan I = ꭍ 4x3 dx, mengingatkan bahwa I = 3 dimana x = 2.
Seperti sebelumnya:
Tapi I = 3 ketika x2 sehingga 3 = 24 +C =16 +C : C=- 13. Jadi, dalam hal ini I = x4-13.
Integral standar 2
Setiap turunan yang ditulis terbalik memberikan integral.
Oleh karena itu, daftar turunan standar kami menyediakan sumber
standar integral.
Seperti halnya diferensiasi, koefisien konstan tetap tidak berubah
Mengumpulkan hasil bersama-sama, kami memiliki:
Rangkuman ulasan 3
1 Integrasi adalah proses kebalikan dari diferensiasi. Diberikan turunan kita harus
menemukan ekspresi dari mana itu berasal.

2 Karena konstanta memiliki turunan nol, kami menemukan bahwa ketika kami membalikkan
proses diferensiasi kita harus memasukkan konstanta integrasi ke dalam hasil kami.
3.Integral demikian disebut integral tak tentu,
Tinjau Latihan 1
Integrasi ekspresi polynomial 6
Dalam Program sebelumnya kita membedakan ekspresi polinomial dengan berurusan

dengan ketentuan tersendiri, satu per satu. Oleh karena itu, tidak mengherankan bahwa
kami melakukan banyak hal sama dengan integrasi ekspresi polinomial.
Ekspresi polinomial terintegrasi suku demi suku dengan konstanta individu dari integrasi
dikonsolidasikan menjadi satu konstanta C untuk seluruh ekspresi. Sebagai contoh:
Jadi, bagaimana dengan yang satu ini? Jika I=ꭍ(8x3 -3x2+ 4x5)dx, tentukan
nilainya dari I ketika x=3, mengingat bahwa pada x= 2, I=26.
Pertama kita harus menentukan fungsi untuk I, sehingga melakukan integrasi, kita
dapatkan I ...........
7
Sekarang kita dapat menghitung nilai C karena kita diberitahu bahwa ketika x 2, I 26. Jadi,
menyatakan fungsi untuk I dalam bentuk bersarang, kita memiliki
I = …..
Fungsi dari fungsi linier dari x 12
Seringkali perlu untuk mengintegrasikan salah satu dari ekspresi yang ditampilkan dalam
daftar kami integral standar ketika variabel x diganti dengan ekspresi linier di x. Itu
adalah, berbentuk ax+b. Misalnya, y=ꭍ(3x+2)4 dx memiliki struktur yang sama dengan
y=ꭍx4 dx kecuali bahwa x digantikan oleh ekspresi linier 3x +2. Mari kita
masukkan u=3x+2 maka:
ꭍ(3x+2)4 dx menjadi ꭍu4 dx
Kita sekarang harus mengubah variabel x dalam dx sebelum kita dapat melanjutkan.
Sekarang, u 3x 2
yang seperti itu:

Untuk mengintegrasikan 'fungsi dari fungsi linier x', cukup ganti x dalam hasil standar
yang sesuai dengan ekspresi linier dan bagi dengan koefisien dari x dalam ekspresi
linier.
Berikut adalah tiga contoh :
Lihat saja integral standar dasar dengan bentuk yang sama, ganti x dalam hasil dengan
ekspresi linier dan akhirnya dibagi dengan koefisien x dalam ekspresi linier dan ingat
konstanta integrasi.
Pada titik ini mari kita berhenti sejenak dan meringkas fakta-fakta utama yang
berhubungan dengan integrasi ekspresi polinomial dan 'fungsi fungsi linier dari x'.
Rangkuman ulasan
Integrasi ekspresi polinomial 13
1 Integrasikan suku demi suku dan gabungkan konstanta integrasi individual ke dalam satu simbol.
2 Integrasi 'fungsi fungsi linear dari x' Ganti x dalam integral standar yang sesuai dengan
ekspresi linier dan membagi hasilnya dengan koefisien x dalam ekspresi linier.
Tinjau Latihan
Integrasi dengan pecahan parsial 16
Ekspresi seperti ꭍ7x+8/2x2+11x+5 dx tidak muncul dalam daftar integral standar

kami, tetapi memang, pada kenyataannya, terjadi di banyak aplikasi matematika. Kami
melihat di Program F.8 bahwa ekspresi seperti ꭍ7x+8/2x2+11x+5 dx dapat dinyatakan
dalam pecahan parsial yang lebih sederhana dalam struktur.
Pecahan parsial ini adalah 'fungsi fungsi linier dari x', berdasarkan pada integral standar
ꭍ1/x dx, jadi hasilnya jelas:
Anda akan mengingat Aturan Pecahan Parsial yang kami daftarkan sebelumnya dan
digunakan di Program F.8, jadi mari kita terapkan dalam contoh ini. Kami hanya akan
berurusan dengan yang sederhana penyebut linier pada tahap ini.
Langkah pertama adalah
untuk membagi 17
karena pembilangnya tidak lebih rendah derajatnya dari penyebutnya
18
Penyebut memfaktorkan menjadi (3x-1) (x+2) sehingga pecahan parsial dari

is
20 f=*+
4.ln(3x-1)
+ 3.ln(z + 2) -F :
[4x’ + 2hx + 5
) 2x2 + 9x + 4
Rangkuman ulasan
Integrasi dengan pecahan parsial 23
Pecahan aljabar sering dapat dinyatakan dalam pecahan parsial. Ini membuat
integrasi pecahan aljabar seperti itu mungkin, integrasi setiap parsial pecahan.
Tinjau Latihan 24
1 Integrasikan dengan pecahan parsial masing-masing integral berikut:

Daerah di bawah kurva 26
Perhatikan luas A dari gambar dibatasi oleh kurva y=f( x), sumbu x dan dua garis vertikal
melalui x=a dan x=b (di mana b > a).
Untuk mengevaluasi area A Anda perlu pertimbangkan luas total antara yang sama kurva
dan sumbu x dari kiri ke atas beberapa titik P sewenang-wenang pada kurva dengan
koordinat (x, y) yang akan kita nyatakan oleh Ax.
Luas Ax adalah luas yang dibatasi oleh garis di bawah busur PQ di mana Q memiliki
koordinat (x+∂x, ∂y+y). Jika strip didekati dengan persegi panjang dengan tinggi y dan
lebar x maka ∂Ax
∂y.x. Ini berarti bahwa:
Kesalahan dalam pendekatan ini diberikan oleh luas PQR pada gambar di sebelah
kanan, di mana strip berada diperbesar.
Jika lebar strip dikurangi maka kesalahannya adalah sesuai dikurangi. Juga, jika x ! 0 lalu
Kapak
! 0 dan
sehingga dalam batas
Akibatnya, karena integrasi adalah proses kebalikan dari diferensiasi, itu terlihat itu:
Luas total antara kurva dan sumbu x hingga titik P diberikan oleh tak tentu integral.
Karena b > a, selisih kedua luas ini Ab Aa memberikan luas yang dibutuhkan A. Itu
adalah:
Bilangan a dan b disebut limit integral dimana limit kanannya adalah di atas tanda integral
dan limit kiri di bawah. Seperti integral dengan batas disebut integral tertentu. Perhatikan
bahwa dalam proses pengurangan ketika integral dievaluasi, konstanta integrasi
menghilang meninggalkan nilai numerik daerah tersebut.
Contoh 1
Untuk menentukan luas daerah yang dibatasi oleh kurva y=3x 2+6x+8, sumbu x dan
ordinat x=1 dan x=3.
Perhatikan bahwa kami menyertakan ekspresi dalam tanda kurung siku dengan batas
terlampir. Sekarang hitung nilai pada batas atas dan bawah dan kurangi yang kedua dari
yang pertama memberikan A ........
Contoh 2
Tentukan luas daerah yang dibatasi oleh kurva y 3x 2+14x+15, sumbu x dan ordinat di
x=1 dan x=2.
Contoh 3
Hitung luas daerah yang dibatasi oleh kurva y 6x 2+24x+10, sumbu x dan koordinat x=0
dan x=4.
Dan sekarang:
Contoh 4
Tentukan luas daerah di bawah kurva y=e x antara x=2 dan x=3. Lakukan ini dengan
metode yang sama. Kekuatan e tersedia dari sebagian besar kalkulator atau dari tabel.
A = ………….
Pada titik ini mari kita berhenti sejenak dan meringkas fakta-fakta utama yang
berhubungan dengan area di bawah ini kurva
Rangkuman ulasan 30
Area A, dibatasi oleh kurva y=f (x), the sumbu x dan ordinat x a dan x b, adalah diberikan
oleh:
1 Tentukan luas yang dibatasi oleh y=5+4x-x2, sumbu x dan ordinat x=1
dan x=4. 2 Hitung luas di bawah kurva y=2x 2+4x+3, antara x=2 dan
x=5.
3 Tentukan luas yang dibatasi oleh y=x2-2x+3, sumbu x dan
ordinat x=1 dan x=3.
Perhatikan bahwa dalam semua integral tertentu ini, kita menghilangkan konstanta
integrasi karena kita tahu itu akan hilang pada tahap pengurangan.
Dalam integral tak tentu, bagaimanapun, itu harus selalu disertakan.
Integrasi sebagai penjumlahan 33
Kami telah mengidentifikasi nilai integral tertentu sebagai area di bawah kurva. Namun,
beberapa integral tertentu memiliki nilai negatif, jadi bagaimana kita menghubungkannya
dengan luas karena semua luas adalah besaran positif? Sebelum kita dapat membuat
tautan ini, kita harus pertimbangkan penentuan area dengan cara yang sedikit berbeda.
Kita telah melihat bahwa area A di bawah kurva y=f (x) antara x=a dan
x=b adalah diberikan oleh integral tertentu:
Mari kita lihat area ini sedikit lebih dekat:

Misalkan P adalah titik (x,y) pada kurva dan Q titik serupa (x +∂x, y+∂y). Perkiraan
luas A dari strip di bawah busur PQ diberikan oleh
Seperti yang telah kami tunjukkan sebelumnya, kesalahan dalam aproksimasinya

adalah luas di atas empat persegi panjang.
Jika kita membagi seluruh gambar antara x=a dan x=b menjadi beberapa strip seperti
itu, luas total adalah kira-kira jumlah luas semua persegi panjang y: x. yaitu A jumlah
semua persegi panjang y:
x antara x a dan x b. Ini bisa ditulis di mana simbol mewakili 'jumlah semua l
suku bentuk ...'
Jika kita membuat strip lebih sempit, akan ada lebih dari mereka untuk menutupi seluruh
gambar, tetapi kesalahan total dalam aproksimasi berkurang.
Jika kita melanjutkan prosesnya, kita sampai pada suatu jumlah tak terbatas dari persegi
kecil yang sempit, masing-masing dengan area yang terlalu kecil untuk ada sendiri.
34 Untuk mengilustrasikannya, perhatikan luas A di bawah garis lurus y=x, di atas sumbu
x dan antara nilai x=2 dan x=4 seperti yang ditunjukkan pada gambar di bawah ini
Luas segitiga adalah 1/2 tinggi dasar dan luas A sama dengan selisih luas dari dua
segitiga OQQ’ dan OPP’ yang seperti itu:
A=1/2x4x4-1/2x2x2
=8-2=6 unit2
Nilai ini sekarang akan dikonfirmasi dengan membagi area menjadi strip yang sama,
menjumlahkan daerah mereka dan kemudian mengambil batas sebagai lebar strip
pergi ke nol.
Pada gambar, luas dibagi menjadi n strip masing-masing lebar x di mana:

Sekarang, tanpa mengikuti prosedur di atas, tetapi dengan mengintegrasikan secara normal, temukan luas yang dibatasi oleh
kurva y=x2 -9 dan sumbu x dan antara x=3 dan x=3.
Cukup sederhana, tetapi apa yang dimaksud dengan area negatif?
Luas yang terletak di bawah sumbu x 36
Jika kita membuat sketsa gambar yang kita dapatkan:

Seperti sebelumnya, luas strip dan luas keseluruhan
Tapi, untuk semua strip seperti itu di seluruh gambar, y negatif dan x bernilai positif.
Oleh karena itu, dalam kasus ini, y∂x negatif dan jumlah semua besaran tersebut memberikan total negatif, bahkan ketika
Jadi ꭍ33 y dx memiliki nilai negatif, yaitu dikurangi nilai daerah tertutup.
Masalah muncul ketika bagian dari area yang akan dihitung terletak di atas sumbu x dan bagian di bawah. Dalam hal ini, integrasi dari
x=a ke x=b memberikan jumlah aljabar dari dua bagian.
Oleh karena itu, selalu bijaksana untuk membuat sketsa gambaran masalah sebelum melakukan integrasi dan, jika perlu, untuk
menghitung bagian positif dan negative secara terpisah dan menambahkan nilai numerik dari setiap bagian untuk mendapatkan area
fisik antara batas yang ditentukan.
Sebagai contoh, kita akan menentukan luas fisis bangun yang dibatasi oleh kurva y=x2-4, sumbu x dan koordinat pada x=1 dan
x=4.
Kurva y=x2-4 adalah, tentu saja, parabola y=x2 menurunkan 4 unit di sumbu y. Ini melintasi sumbu x ketika y=0, yaitu x 2-
4=0, x2=4 ; x=±2
Gambar dari masalah kita terbentang dari x=1 sampai x=4, yang meliputi luas di bawah sumbu x antara x=1 dan x=2 dan area di atas
sumbu x antara x=2 dan x=4. Oleh karena itu, kami menghitung luas fisis yang dilingkupi dua bagian dan tambahkan hasilnya.
Seandainya kita terintegrasi langsung dalam satu perhitungan, kita seharusnya memperoleh:
Meskipun memberikan nilai integral tertentu yang benar, tidak memberikan nilai yang benar dari total area tertutup.
Luas antara kurva dan garis berpotongan 37
Mencari luas daerah yang dibatasi oleh kurva y=25-x2 dan garis lurus y=x+13.
Pertama kita harus mengembangkan gambar. Kita ketahuilah bahwa y=x2 adalah parabola biasa:
maka y=-x2 adalah terbalik parabola:
Y=25-x2 adalah parabola terbalik mengangkat 25 unit pada skala y. Juga ketika y=0,
x2=25, jadi x=±5.

y=x+13 adalah garis lurus yang memotong y=25-x2 kapan x+13=25-x2, x2+x -12=0; (x-3) (x+4)= 0 ; x=-4 atau 3
Jadi luas A yang kita butuhkan adalah bagian yang diarsir.
Misalkan P1(x,y1) menjadi titik pada y1-25-x2 dan P2(x; y2) titik yang sesuai pada y2=x+13. Maka luas strip
P1P2 ≈(y1 -y2).∂x Maka
luas gambar
yang sekarang dapat Anda selesaikan, untuk memberi A= .....
Rangkuman ulasan 40
1 Integral tentu
Integral dengan limit (misalnya x=a dan x=b) disebut integral tertentu. konstanta integrasi C dalam kasus seperti itu akan selalu
hilang pada pengurangan panggung, sejak
Tinjau Latihan 41
1 Evaluasilah setiap integral tentu berikut ini:
2 Temukan area yang tertutup antara sumbu x dan kurva:
(a) y=x3+2x2+x+1 antara x=1 dan x=2

(b) y=x2-25 untuk -5≤x≤5.
3 Tentukan luas daerah yang dilingkupi antara kurva y=x 3 dan garis lurus y=x.
2 (a) Grafik y=x3+2x2+x+1 antara x=1 dan x=2 terletak seluruhnya di atas sumbu x
sehingga luas yang dilingkupi antara kurva, sumbu x dan antara x=1 dan x=2 diberikan oleh:
(b) Grafik y=x2-25 untuk -5≤x≤5 terletak seluruhnya di bawah sumbu x

sehingga luas yang dilingkupi antara kurva dan sumbu x untuk-5≤x≤5 adalah diberikan oleh saya di mana:
3 Kurva y=x3 dan garis y=x berpotongan ketika x3-x, yaitu ketika x3-x=0.
Memfaktorkan kita melihat bahwa ini berarti x(x2-1)=0 yang dipenuhi jika x=0, x=1 dan x=1.
Dari gambar tersebut kita dapat melihat bahwa luas yang dilingkupi antara kurva y=x 3 dan garis lurus y x ada dua bagian, satu di
atas sumbu x dan yang lainnya di bawah. Dari gambar tersebut dengan mudah dapat dilihat bahwa kedua bagian tersebut sama,
jadi kita hanya perlu mencari cari luas antara x=0 dan x=1 lalu gandakan luas totalnya diselubungi.
Luas daerah antara x=0 dan x=1 sama dengan luas di bawah garis y=x dikurangi luas di bawah kurva y=x3. Itu adalah:
Luas total yang dilingkupi kemudian dua kali ini, yaitu ½ unit2.
:. :, Test exercise F.13
45 ,. i
(c) 3x A 2wc *A
2 (ai O‹= m u‹ -st - s - ‹)a.
Express ”’ 14z -F 30 in partial fractions and hcrrcc
(a Eva 1h pea under ih sun.c So’ bch«en
mine the area enclosed by the curve y - 36— I and ihe
,^” Further problems F.13
2 Dctm-rntoc (( ^°“ " “ 1z*—2 " ”“ ') °
_ , _
5 Oct q fied curve y = t'(.i'i. mc z-axis and flan

"t’s‘""t r›1lowi
(bj jr = ZN + .S, z = — 2 and i
= 3 (cl jr = 5 + 6z — .fi °. x = 0 and
.v = 2
(cl 1• = z™ 10, x = —1 and .v = 2
Q) .=*--4x-20. )=Ir i=0andr =4
(c) r=2O-Ir-
RINGKASAN WOLFRAM
PART 1
Menjalankan Mathematica
Untuk mengetahui cara menginstal dan menjalankan Mathematica, Anda harus
membaca dokumentasi yang disertakan dengan salinan matematika. Detailnya berbeda
dari satu sistem komputer ke sistem komputer lainnya, dan dipengaruhi oleh berbagai
jenis penyesuaian yang dapat dilakukan pada Mathematica. Namun demikian, bagian
ini menguraikan dua kasus umum.
Perhatikan bahwa meskipun detail menjalankan Mathematica berbeda dari satu
sistem komputer ke sistem komputer lainnya, struktur dari perhitungan Mathematica
adalah sama dalam semua kasus. Anda memasukkan input, lalu Mathematica
memprosesnya, dan mengembalikan hasilnya.
1.0 Antar muka
Dalam antarmuka "notebook", Anda berinteraksi dengan Mathematica dengan
membuat dokumen interaktif.jika Anda menggunakan komputer Anda melalui
antarmuka grafis murni, Anda biasanya akan mengklik dua kali ikon Mathematica
untuk memulai matematika. Jika Anda menggunakan komputer Anda melalui sistem
operasi berbasis teks, Anda biasanya akan mengetikkan perintah mathematica untuk
memulai Mathematica.
Ketika Mathematica dijalankan, biasanya memberikan Anda buku catatan
kosong. Anda memasukkan input Mathematica ke dalam notebook, lalu ketik Shift-
Enter untuk membuat Mathematica memproses input Anda. (Untuk mengetik Shift-
Enter, tahan tombol Shift, lalu tekan Enter.) Anda dapat menggunakan fitur pengeditan
standar dari antarmuka grafis Anda untuk menyiapkan input Anda, yang mungkin akan
terjadi aktif untuk beberapa baris. Shift-Enter memberi tahu Mathematica bahwa Anda
telah menyelesaikan input Anda. Jika keyboard Anda memiliki angka keypad, Anda
dapat menggunakan tombol Enter sebagai ganti Shift-Enter.
Setelah Anda mengirim input Mathematica dari notebook Anda, Mathematica akan
melabeli input Anda dengan In[n]:=. Ini memberi label pada keluaran yang sesuai
Keluar[n]=.
Anda mengetik 2 + 2, lalu akhiri input Anda dengan Shift-Enter. Mathematica
memproses input, lalu menambahkan label input In[1]:=, dan memberikan keluaran.
Bagian 0.5.1 membahas beberapa detail penting tentang mereproduksi dialog pada sistem
komputer Anda. Bagian 1.3 memberikan informasi lebih lanjut tentang notebook Mathematica.
Anda harus menyadari bahwa notebook adalah bagian dari "ujung depan" untuk
Mathematica. Kernel Mathematica yang benar-benar melakukan komputasi dapat
dijalankan pada komputer yang sama dengan front end, atau pada komputer lain yang
terhubung melalui beberapa jenis jaringan atau jalur. Dalam kebanyakan kasus, kernel
bahkan tidak dimulai sampai Anda benar-benar melakukan perhitungan
denganMatematika.
Untuk keluar dari Mathematica, Anda biasanya memilih item menu Keluar di antarmuka
notebook
1.1 Antarmuka Berbasis Teks

Dengan antarmuka berbasis teks, Anda berinteraksi dengan komputer Anda terutama
dengan mengetik teks pada keyboard.
Untuk memulai Mathematica dengan antarmuka berbasis teks, Anda biasanya
mengetikkan perintah matematika di sistem operasi mengingatkan. Pada beberapa
sistem, Anda mungkin juga dapat memulai Mathematica dengan antarmuka berbasis
teks dengan mengklik dua kali pada ikon Kernel Mathematica.
Ketika Mathematica telah dimulai, itu akan mencetak prompt In[1]:=, menandakan
bahwa itu siap untuk input Anda. Kamu bisa lalu ketik input Anda, diakhiri dengan Enter
atau Return.
Mathematica kemudian akan memproses input, dan menghasilkan hasil. Jika ia mencetak
hasilnya, ia akan melabelinya dengan Out[1]=.
Sepanjang buku ini, dialog dengan Mathematica ditampilkan sebagai berikut:
Komputer mencetak Dalam[1]:=. Anda cukup mengetik 2 + 2. Baris yang dimulai
dengan Out[1]= adalah hasil dari Mathematica.
Bagian 0.5.1 membahas beberapa detail penting tentang mereproduksi dialog
pada sistem komputer Anda. Perhatikan bahwa Anda jangan ketik In[n]:= prompt
secara eksplisit; hanya ketik teks yang mengikuti prompt ini.
Perhatikan juga bahwa sebagian besar dialog aktual yang diberikan dalam buku
menunjukkan keluaran dalam bentuk yang Anda dapatkan dengan antarmuka
notebook untuk Matematika; output dengan antarmuka berbasis teks terlihat serupa,
tetapi tidak memiliki fitur seperti karakter dan font khusus perubahan ukuran.
Bagian 1.3 memberikan rincian lebih lanjut tentang menjalankan Mathematica
dengan antarmuka berbasis teks. Untuk keluar dari Mathematica, ketikkan Control-D,
Control-Z atau Quit[ ] pada prompt input.
Perhitungan Numerik
Aritmatika
Anda dapat melakukan aritmatika dengan Mathematica seperti yang Anda lakukan pada
kalkulator elektronik.
Hasil Persis dan Perkiraan
Kalkulator elektronik standar melakukan semua perhitungan Anda dengan
akurasi tertentu, katakanlah sepuluh digit desimal. Namun, dengan Mathe matica,
Anda sering kali bisa mendapatkan hasil yang tepat.
Beberapa Fungsi Matematika
Mathematica mencakup koleksi fungsi matematika yang sangat banyak. Bagian
3.2 memberikan daftar lengkap. Berikut adalah beberapa yang umum.
• Argumen dari semua fungsi Mathematica diapit dalam tanda kurung siku.
• Nama fungsi Mathematica bawaan dimulai dengan huruf kapital.
Dua poin penting tentang fungsi dalam Mathematica.
Penting untuk diingat bahwa semua argumen fungsi di Mathematica diapit
dalam tanda kurung siku, bukan tanda kurung. Tanda kurung di Mathematica hanya
digunakan untuk menunjukkan pengelompokan istilah, dan tidak pernah memberikan
argumen fungsi. Ini memberikan log H8.4L. Perhatikan huruf kapital untuk Log, dan
tanda kurung siku untuk argumennya.
Dalam[1]:= Log[8.4]
Keluar[1]= 2.12823
Sama seperti operasi aritmatika, Mathematica mencoba memberikan nilai eksak untuk
fungsi matematika ketika Anda memberikannya masukan yang tepat.
Perhitungan Presisi Sewenang-wenang
Saat Anda menggunakan //N untuk mendapatkan hasil numerik, Mathematica
melakukan apa yang akan dilakukan kalkulator standar: ini memberi Anda a
menghasilkan sejumlah angka penting yang tetap. Anda juga dapat memberi tahu
Mathematica dengan tepat berapa banyak angka penting untuk tetap dalam
perhitungan tertentu. Ini memungkinkan Anda untuk mendapatkan hasil numerik di
Mathematica hingga tingkat presisi apa pun.
Melakukan segala jenis perhitungan numerik dapat menyebabkan kesalahan

pembulatan kecil ke dalam hasil Anda. Ketika Anda meningkatkan presisi numerik,
kesalahan ini biasanya menjadi lebih kecil. Pastikan Anda mendapatkan jawaban yang
sama ketika Anda meningkatkan presisi numerik seringkali merupakan cara yang baik
untuk memeriksa hasil Anda. Bilangan Kompleks
Membiasakan Matematika
• Argumen fungsi diberikan dalam tanda kurung siku.
• Nama-nama fungsi bawaan memiliki huruf pertama yang dikapitalisasi.
• Perkalian dapat dilambangkan dengan spasi.
• Kekuatan dilambangkan dengan ^ .
• Angka dalam notasi ilmiah dimasukkan, misalnya, sebagai 2.5*^-4 atau 2.5 10^−4 .
Bagian ini telah memberi Anda pandangan pertama tentang Mathematica. Jika
Anda pernah menggunakan sistem komputer lain sebelumnya, Anda akan mungkin
telah memperhatikan beberapa persamaan dan beberapa perbedaan. Seringkali Anda
akan menemukan perbedaan yang paling sulit bagian yang perlu diingat. Akan tetapi,
mungkin membantu Anda untuk memahami sedikit tentang mengapa Mathematica
diatur seperti itu, dan mengapa perbedaan seperti itu ada.
Salah satu fitur penting Mathematica yang berbeda dari bahasa komputer lain,
dan dari notasi matematika konvensional, adalah bahwa argumen fungsi diapit dalam
tanda kurung siku, bukan tanda kurung. Tanda kurung dalam Mathematica
dicadangkan secara khusus untuk menunjukkan pengelompokan istilah. Jelas ada
perbedaan konseptual antaramemberikan argumen ke fungsi dan istilah
pengelompokan bersama-sama; fakta bahwa notasi yang sama sering digunakan untuk
keduanya sebagian besar merupakan konsekuensi dari tipografi dan keyboard
komputer awal. Dalam Mathematica, konsepnya adalah dibedakan dengan notasi yang
berbeda.
Perbedaan ini memiliki beberapa keunggulan. Dalam notasi kurung, tidak jelas
apakah c H1 + xL berarti c[1 + x] atau c*(1 + x). Menggunakan tanda kurung siku
untuk argumen fungsi menghilangkan ambiguitas ini. Ini juga memungkinkan
perkalian menjadi ditunjukkan tanpa * eksplisit atau karakter lain. Hasilnya,
Mathematica dapat menangani ekspresi seperti 2x dan a x or a (1 + x),
memperlakukannya seperti dalam notasi matematika standar.
Anda akan melihat di bagian ini bahwa fungsi Mathematica bawaan sering kali
memiliki nama yang cukup panjang. Anda mungkin bertanya-tanya mengapa,
misalnya, fungsi angka pseudorandom disebut Acak, daripada, katakanlah, Rand.
Jawabannya, yang meliputi sebagian besar desain Mathematica, adalah konsistensi.
Ada konvensi umum di Mathematica bahwa semua nama fungsi dieja sebagai kata
bahasa Inggris lengkap, kecuali ada singkatan matematika standar untuk mereka.
Keuntungan besar dari skema ini adalah dapat diprediksi. Setelah Anda mengetahui
fungsi suatu fungsi, Anda biasanya akan menjadi bisa menebak dengan tepat apa namanya.
Jika namanya disingkat, Anda harus selalu ingat yang mana pemendekan kata-kata bahasa
Inggris standar digunakan.
Fitur lain dari nama Mathematica bawaan adalah semuanya dimulai dengan
huruf kapital. Di bagian selanjutnya, Anda akan melihat bagaimana mendefinisikan
variabel dan fungsi Anda sendiri. Konvensi huruf kapital memudahkan untuk
membedakan built-in objek. Jika Mathematica menggunakan max alih-alih Max untuk
mewakili operasi pencarian maksimum, maka Anda akan tidak pernah dapat
menggunakan max sebagai nama salah satu variabel Anda. Selain itu, saat Anda
membaca program yang ditulis dalam Mathe matica, kapitalisasi nama bawaan
membuatnya lebih mudah untuk dipilih.
Notasi Matematika dalam Buku Catatan
Jika Anda menggunakan antarmuka berbasis teks ke Mathematica, maka input
yang Anda berikan harus hanya terdiri dari karakter yang Anda bisa ketik langsung di
keyboard komputer Anda. Tetapi jika Anda menggunakan antarmuka notebook maka
jenis input lain menjadi mungkin.
Biasanya tersedia palet yang beroperasi seperti ekstensi keyboard Anda, dan
yang memiliki tombol yang Anda dapat mengklik untuk memasukkan formulir
tertentu. Anda biasanya dapat mengakses palet standar menggunakan submenu Palet
dari File Tidak bisa.
Dalam bahasa komputer tradisional seperti C, Fortran, Java atau Perl, input yang
Anda berikan harus selalu terdiri dari string karakter biasa yang bisa diketik langsung
di keyboard. Tetapi bahasa Mathematica juga memungkinkan Anda memberi input
yang berisi karakter khusus, superskrip, pecahan bawaan, dan sebagainya.
Bahasa ini menggabungkan banyak fitur notasi matematika tradisional. Tetapi
Anda harus menyadari bahwa tujuan dari bahasa adalah untuk menyediakan cara yang
tepat dan konsisten untuk menentukan perhitungan. Dan sebagai hasilnya, itu tidak
mengikuti semua detail yang agak serampangan dari notasi matematika tradisional.
Namun demikian, seperti yang dibahas dalam Bagian 1.10.9, Mathematica selalu
memungkinkan untuk menghasilkan keluaran yang meniru setiap aspek notasi
matematika tradisional. Dan seperti yang dibahas dalam Bagian 1.10.9, Mathemat ica
juga dapat mengimpor teks yang menggunakan notasi tersebut, dan sampai batas
tertentu menerjemahkannya ke dalam bahasanya sendiri yang lebih tepat.
Membangun Perhitungan
Menggunakan Hasil Sebelumnya
Dalam melakukan perhitungan, Anda akan sering perlu menggunakan hasil
sebelumnya yang sudah Anda dapatkan. Di Mathematica, % selalu berdiri untuk hasil
terakhir Anda.
Mendefinisikan Variabel
Saat Anda melakukan perhitungan panjang, seringkali lebih mudah untuk
memberi nama pada hasil antara Anda. Sama seperti dalam standar matematika, atau
dalam bahasa komputer lainnya, Anda dapat melakukannya dengan memperkenalkan
variabel bernama.
Sangat penting untuk menyadari bahwa nilai yang Anda tetapkan ke variabel
bersifat permanen. Setelah Anda menetapkan nilai untuk a variabel tertentu, nilainya
akan disimpan sampai Anda menghapusnya secara eksplisit. Nilainya tentu saja akan
hilang jika Anda mulai sesi Mathematica yang sama sekali baru.
Melupakan definisi yang Anda buat sebelumnya adalah satu-satunya penyebab
kesalahan paling umum saat menggunakan Mathematica. Jika
Anda menetapkan x = 5, Mathematica mengasumsikan bahwa Anda selalu ingin
x memiliki nilai 5, sampai atau kecuali Anda secara eksplisit mengatakannya
sebaliknya. Untuk menghindari kesalahan, Anda harus menghapus nilai yang telah
Anda tetapkan segera setelah Anda selesai menggunakannya.
Variabel yang Anda definisikan dapat memiliki hampir semua nama. Tidak ada
batasan panjang nama mereka. Satu kendala, namun, apakah nama variabel tidak
pernah bisa dimulai dengan angka. Misalnya, x2 dapat berupa variabel, tetapi 2x
berarti 2*x.
Mathematica menggunakan huruf besar dan huruf kecil. Ada konvensi bahwa
objek
Mathematica bawaan selalu memiliki nama yang dimulai dengan huruf besar (kapital). Untuk
menghindari kebingungan, Anda harus selalu memilih nama untuk Anda variabel sendiri yang
dimulai dengan huruf kecil.
Membuat Daftar Objek
Dalam melakukan perhitungan, seringkali lebih mudah untuk mengumpulkan
beberapa objek, dan memperlakukannya sebagai satu kesatuan. Daftar memberi Anda
cara untuk membuat koleksi objek di Mathematica. Seperti yang akan Anda lihat nanti,
daftar sangat penting dan struktur umum di Mathematica.
Daftar seperti {3, 5, 1} adalah kumpulan dari tiga objek. Tetapi dalam banyak
hal, Anda dapat memperlakukan seluruh daftar sebagai satu kesatuan obyek. Anda
dapat, misalnya, melakukan aritmatika pada seluruh daftar sekaligus, atau menetapkan
seluruh daftar menjadi nilai a variabel.
Memanipulasi Elemen Daftar
Banyak dari operasi manipulasi daftar yang paling kuat di Mathematica
memperlakukan seluruh daftar sebagai objek tunggal. Kadang-kadang, namun, Anda
perlu memilih atau mengatur elemen individual dalam daftar.
Anda dapat merujuk ke elemen daftar Mathematica dengan memberikan "indeks" -nya.
Elemen diberi nomor secara berurutan,
mulai pada 1.
Empat Jenis Bracketing di Mathematica
Selama beberapa bagian terakhir, kami telah memperkenalkan masing-masing dari
empat jenis bracketing yang digunakan dalam Mathematica.
Setiap jenis bracketing memiliki arti yang sangat berbeda. Penting bagi Anda untuk
mengingat semuanya.
Ketika ekspresi yang Anda ketik rumit, sering kali merupakan ide yang baik untuk
menempatkan ruang ekstra di dalam setiap rangkaian tanda kurung.
Ini membuat Anda lebih mudah melihat pasangan tanda kurung yang cocok. v[[ 8a, b<
]], misalnya, lebih mudah untuk mengenali dari v[[8a, b<]].
Urutan Operasi
Dalam melakukan perhitungan dengan Mathematica, Anda biasanya melalui urutan
langkahlangkah. Jika Anda mau, Anda bisa melakukannya masing-masing melangkah di jalur
terpisah.
Namun, seringkali Anda akan merasa nyaman untuk menempatkan beberapa langkah
pada baris yang sama. Anda dapat melakukan ini hanya dengan memisahkan bagian
input yang ingin Anda berikan dengan titik koma.
Menggunakan Sistem Mathematica

Struktur Mathematica
Mathematica kernel bagian yang benar-benar melakukan
perhitungan Bagian depan Mathematica yang menangani
interaksi dengan pengguna Bagian dasar dari sistem
Mathematica.
Mathematica adalah sistem perangkat lunak modular di mana kernel yang benar-benar
melakukan perhitungan terpisah dari ujung depan yang menangani interaksi dengan pengguna.
Jenis ujung depan yang paling umum untuk Mathematica didasarkan pada
dokumen interaktif yang dikenal sebagai buku catatan. Buku catatan memadukan input
dan output Mathematica dengan teks, grafik, palet, dan materi lainnya. Anda juga
dapat menggunakan buku catatan untuk melakukan perhitungan yang sedang
berlangsung, atau sebagai sarana untuk mempresentasikan atau mempublikasikan
hasil Anda.
Dokumen interaktif antarmuka notebook
Teks antarmuka berbasis teks dari keyboard
Komunikasi antarmuka MathLink dengan
program lain Jenis antarmuka yang umum untuk
Mathematica.
Ujung depan notebook mencakup banyak menu dan alat grafis untuk membuat dan
membaca dokumen notebook dan untuk mengirim dan menerima materi dari kernel
Mathematica.
Sebuah notebook pencampuran teks, grafik dan input dan output Mathematica.
Dalam beberapa kasus, Anda mungkin tidak perlu menggunakan ujung depan
notebook, dan Anda mungkin ingin berinteraksi lebih langsung dengan kernel
Mathematica. Anda dapat melakukan ini dengan menggunakan antarmuka berbasis
teks, di mana teks yang Anda ketik di keyboard langsung ke kernel.
Perbedaan antara Sistem Komputer
Ada banyak perbedaan rinci antara berbagai jenis sistem komputer. Tapi salah
satu fitur penting dari Mathematica memungkinkan Anda untuk bekerja dan membuat
materi tanpa khawatir tentang perbedaan tersebut.
Untuk menyesuaikan sebaik mungkin dengan sistem komputer tertentu,
antarmuka pengguna untuk Mathematica pada yang berbeda sistem pasti setidaknya
sedikit berbeda. Tetapi poin pentingnya adalah bahwa di luar perbedaan yang dangkal,
Mathematica diatur untuk bekerja dengan cara yang persis sama pada setiap jenis
sistem komputer.
• Bahasa yang digunakan oleh kernel Mathematica
• Struktur buku catatan Mathematica
• Protokol komunikasi MathLink
• Elemen Mathematica yang persis sama pada semua sistem komputer.
• Perintah yang Anda berikan ke kernel Mathematica, misalnya, benar-benar identik di
setiap computer sistem. Ini berarti bahwa ketika Anda menulis program menggunakan
perintah ini, Anda dapat langsung mengambil program dan jalankan di komputer mana
pun yang mendukung Mathematica.
Struktur notebook Mathematica juga sama pada semua sistem komputer. Dan
sebagai hasilnya, jika Anda membuat notebook di satu sistem komputer, Anda dapat
langsung mengambilnya dan menggunakannya di sistem lain.
• Tampilan visual jendela, font, dll.
• Mekanisme untuk mengimpor dan mengekspor materi dari notebook
• Pintasan keyboard untuk perintah menu
• Elemen yang dapat berbeda antara satu sistem komputer dengan sistem komputer lainnya.
• Meskipun struktur yang mendasari notebook Mathematica selalu sama, sering kali ada
perbedaan yang dangkal dalam cara notebook terlihat pada sistem komputer yang
berbeda, dan dalam beberapa mekanisme yang disediakan untuk berinteraksi dengan
mereka.
Tujuannya dalam setiap kasus adalah untuk membuat buku catatan bekerja dengan cara
yang akrab bagi orang-orang yang terbiasa jenis tertentu dari sistem komputer.
Selain itu, dengan menyesuaikan detail notebook ke setiap sistem komputer
tertentu, pertukaran menjadi lebih mudah materi antara notebook dan program lain
yang berjalan di sistem komputer itu.
Notebook Mathematica yang sama pada tiga sistem komputer yang berbeda. Struktur
dasarnya persis sama, tetapi beberapa rincian presentasinya berbeda.
Topik Khusus: Menggunakan Antarmuka Berbasis Teks
Dengan antarmuka berbasis teks, Anda berinteraksi dengan Mathematica hanya dengan
mengetik baris input yang berurutan, dan kembali baris output berturut-turut di layar Anda.
Pada setiap tahap, Mathematica mencetak prompt dalam bentuk In[n]:= untuk
memberi tahu Anda bahwa ia siap menerima input. Kapan Anda telah memasukkan
input Anda, Mathematica memprosesnya, dan kemudian menampilkan hasilnya
dengan label formulir Out[n]=.
Jika input Anda pendek, maka Anda dapat memberikannya pada satu baris,
mengakhiri baris dengan menekan Enter atau Return. Jika masukan Anda adalah lagi,
Anda dapat memberikannya pada beberapa baris. Mathematica akan secara otomatis
melanjutkan membaca baris-baris yang berurutan sampai memiliki menerima ekspresi
lengkap. Jadi, misalnya, jika Anda mengetik tanda kurung buka pada satu baris,
Mathematica akan lanjutkan membaca baris input yang berurutan sampai melihat
tanda kurung penutup yang sesuai. Perhatikan bahwa jika Anda memasukkan baris
yang benar-benar kosong, Mathematica akan membuang baris yang telah Anda ketik
sejauh ini, dan mengeluarkan prompt input baru.
Melakukan Perhitungan di Notebook
Sebuah notebook Mathematica khas yang berisi teks, grafik dan ekspresi
Mathematica.
Tanda kurung di sebelah kanan
menunjukkan luas masing-
masing sel.
Buku Catatan sebagai Dokumen
Notebook Mathematica memungkinkan Anda membuat dokumen yang dapat
dilihat secara interaktif di layar atau dicetak di atas kertas.Khususnya di buku catatan
yang lebih besar, biasanya ada bab, bagian, dan seterusnya, masing-masing diwakili
oleh kelompok sel. Luasnya kelompokkelompok ini ditunjukkan oleh tanda kurung di
sebelah kanan.
Sekelompok sel dapat terbuka atau tertutup. Saat terbuka, Anda dapat melihat
semua sel di dalamnya secara eksplisit. Tapi ketika itu ditutup, Anda hanya melihat
sel pertama atau judul dalam grup. Notebook besar sering didistribusikan dengan
banyak kelompok sel tertutup, sehingga ketika Anda pertama kali melihat notebook,
Anda hanya melihat garis besar isinya. Anda kemudian dapat membuka bagian yang
Anda minati dengan mengklik dua kali yang sesuai kurung. Elemen Aktif di Notebook
Salah satu fitur yang paling kuat dari notebook Mathematica adalah bahwa
tindakan mereka dapat diprogram. Jadi, untuk misalnya, Anda dapat mengatur tombol
di notebook Mathematica yang menyebabkan berbagai operasi dilakukan setiap kali
Anda mengkliknya.
Topik Khusus: Hyperlink dan Teks Aktif

Ujung depan Mathematica menyediakan berbagai cara untuk mencari kata atau
teks tertentu di buku catatan Mathematica. Tetapi terutama ketika dokumen besar atau
kumpulan dokumen terlibat, seringkali lebih mudah untuk menyisipkan hyperlink
yang segera membawa Anda ke titik tertentu di buku catatan, seperti yang sering
dilakukan di situs web.
Hyperlink biasanya ditunjukkan dengan kata atau frasa yang digarisbawahi, dan
seringkali dalam warna yang berbeda. Mengklik hyperlink segera membawa Anda ke mana
pun hyperlink menunjuk. Hyperlink di notebook bekerja sangat mirip dengan tombol yang
dibahas di bagian sebelumnya. Dan sekali lagi, semua aspek hyperlink dapat diprogram.
Memang, dimungkinkan untuk mengatur teks aktif di buku catatan yang melakukan
hampir semua jenis tindakan.
Mendapatkan Bantuan di Front End Notebook
Di sebagian besar versi ujung depan notebook Mathematica, menu Bantuan
memberi Anda akses ke Browser Bantuan, yang berfungsi sebagai titik masuk ke
sejumlah besar dokumentasi online untuk Mathematica.
Memulai awal yang cepat untuk menggunakan Mathematica
Informasi Fungsi Built-in pada semua fungsi built-in
The Mathematica Memesan buku lengkap secara online
Indeks Master Index dari semua materi dokumentasi online
Jenis bantuan umum yang tersedia dengan ujung depan notebook.
Mendapatkan Bantuan dengan Antarmuka Berbasis Teks

• Nama menunjukkan informasi tentang Nama
• Nama menunjukkan informasi tambahan tentang Nama
• Aaaa menampilkan informasi tentang semua objek yang namanya dimulai dengan Aaaa
• Cara mendapatkan informasi langsung dari kernel Mathematica.
Paket Mathematica
Salah satu fitur yang paling penting dari Mathematica adalah bahwa itu adalah
sistem yang dapat diperluas. Ada sejumlah matematika dan fungsionalitas lain yang
dibangun ke dalam Mathematica. Tetapi dengan menggunakan bahasa Mathematica,
itu adalah selalu memungkinkan untuk menambahkan lebih banyak fungsi.
Untuk banyak jenis perhitungan, apa yang dibangun ke dalam versi standar
Mathematica akan cukup memadai. Namun, jika Anda bekerja di area khusus tertentu,
Anda mungkin mendapati bahwa Anda sering kali perlu menggunakan fungsi tertentu
yang tidak dibangun ke dalam Mathematica.
Dalam kasus seperti itu, Anda mungkin dapat menemukan paket Mathematica yang
berisi fungsi yang Anda butuhkan. Matematika paket adalah file yang ditulis dalam bahasa
Mathematica.
Mereka terdiri dari kumpulan definisi Mathematica yang
"mengajarkan" Mathematica tentang area aplikasi
tertentu.
paket dibaca dalam paket
Mathematica Membaca dalam paket
Mathematica.
Jika Anda ingin menggunakan fungsi dari paket tertentu, Anda harus terlebih
dahulu membaca paket tersebut ke Mathematica. Rinciannya tentang bagaimana
melakukan ini dibahas dalam Bagian 1.11. Ada berbagai konvensi yang mengatur
nama yang harus Anda gunakan untuk merujuk ke paket.
Peringatan dan Pesan
Mathematica biasanya melakukan pekerjaannya secara diam-diam, memberikan output
hanya ketika selesai melakukan perhitungan Anda diminta.
Namun, jika Mathematica melakukan sesuatu yang sebenarnya tidak Anda
inginkan, Mathematica biasanya akan mencetak pesan untuk memperingatkan Anda.
Fungsi akar kuadrat seharusnya hanya memiliki satu argumen. Mathematica mencetak
pesan untuk memperingatkan Anda bahwa Anda telah memberikan dua argumen di
sini.
1.3.12 Mengganggu Perhitungan
Mungkin akan ada saatnya Anda ingin menghentikan Mathematica di tengah
perhitungan.
Mungkin kamu sadar bahwa Anda meminta Mathematica untuk melakukan hal yang
salah. Atau mungkin
perhitungannya hanya memakan waktu lama, dan Anda
mau untuk mencari tahu apa yang sedang terjadi.
Cara Anda menginterupsi perhitungan Mathematica tergantung pada jenis antarmuka
yang Anda gunakan.
• Antarmuka notebook Alt-Comma atau Command-Comma
• Antarmuka berbasis teks Control-C
Kunci khas untuk menginterupsi perhitungan di Mathematica.
Pada beberapa sistem komputer, Mathematica mungkin memerlukan beberapa
waktu untuk merespons interupsi Anda. Ketika Mathematica melakukannya
menanggapi, biasanya akan memberi Anda menu hal-hal yang mungkin untuk
dilakukan.
• lanjutkan melanjutkan perhitungan
• tunjukkan tunjukkan apa yang dilakukan Mathematica
• periksa periksa keadaan perhitungan Anda saat ini
• batalkan batalkan perhitungan khusus ini
• keluar keluar dari Mathematica sepenuhnya
Perhitungan Aljabar
Komputasi Simbolik
Salah satu fitur penting dari Mathematica adalah dapat melakukan perhitungan
simbolik, serta numerik. Ini berarti yang dapat menangani rumus aljabar serta angka.
Nilai untuk Simbol

Ketika Mathematica mengubah ekspresi seperti x + x menjadi 2x, itu
memperlakukan variabel x dalam simbolik murni atau busana resmi. Dalam kasus
seperti itu, x adalah simbol yang dapat mewakili ekspresi apa pun.
Namun, seringkali Anda perlu mengganti simbol seperti x dengan "nilai" tertentu.
Terkadang nilai ini berupa angka; seringkali itu akan menjadi ekspresi lain.
Untuk mengambil ekspresi seperti 1 + 2x dan mengganti simbol x yang muncul
di dalamnya dengan nilai tertentu, Anda dapat membuat Aturan transformasi
Mathematica, dan kemudian terapkan aturan ini ke ekspresi. Untuk mengganti x
dengan nilai 3, Anda akan buat aturan transformasi x -> 3. Anda harus mengetik ->
sebagai sepasang karakter, tanpa spasi di antaranya. Kamu bisa pikirkan x -> 3 sebagai
aturan di mana " x pergi ke 3".
Untuk menerapkan aturan transformasi ke ekspresi Mathematica tertentu, Anda
mengetik expr /. aturan. Penggantian operator” /. diketik sebagai sepasang karakter, tanpa
spasi di antaranya.
Mengubah Ekspresi Aljabar
Seringkali ada banyak cara berbeda untuk menulis ekspresi aljabar yang sama.
Sebagai salah satu contoh, ekspresi H1 + xL2 dapat ditulis sebagai 1 + 2 x + x2 .
Mathematica menyediakan banyak koleksi fungsi untuk mengkonversi antara yang
berbeda bentuk ekspresi aljabar.
Menyederhanakan Ekspresi Aljabar
Ada banyak situasi di mana Anda ingin menulis ekspresi aljabar tertentu dalam
bentuk yang paling sederhana. Meskipun sulit untuk mengetahui secara pasti apa yang
dimaksud dalam semua kasus dengan “bentuk paling sederhana”, sebuah praktik yang
bermanfaat prosedurnya adalah dengan melihat berbagai bentuk ekspresi, dan memilih
salah satu yang melibatkan jumlah terkecil dari bagian.
Topik Lanjutan: Menempatkan Ekspresi ke dalam Berbagai Bentuk
Ekspresi aljabar yang rumit biasanya dapat ditulis dalam berbagai cara. Mathematica
menyediakan berbagai fungsi untuk mengubah ekspresi dari satu bentuk ke bentuk lainnya.
Dalam banyak aplikasi, fungsi yang paling umum adalah Expand, Factor dan
Simplify. Namun, khususnya ketika Anda memiliki ekspresi rasional yang berisi hasil
bagi, Anda mungkin perlu menggunakan fungsi lain.
Topik Lanjutan: Menyederhanakan dengan Asumsi
Memilih Potongan Ekspresi Aljabar

Mengontrol Tampilan Ekspresi Besar
Ketika Anda melakukan perhitungan simbolis, cukup mudah untuk berakhir
dengan ekspresi yang sangat rumit. Seringkali, Anda akan bahkan tidak ingin melihat
hasil perhitungan yang lengkap.
Jika Anda mengakhiri input Anda dengan titik koma, Mathematica akan
melakukan perhitungan yang Anda minta, tetapi tidak akan menampilkan hasil. Anda
tetap dapat menggunakan % atau Out[n] untuk merujuk ke hasil.
Meskipun Anda mungkin tidak ingin melihat keseluruhan hasil dari suatu
perhitungan, Anda sering kali perlu melihat bentuk dasarnya. Anda dapat
menggunakan Pendek untuk menampilkan kerangka ekspresi, dengan menghilangkan
beberapa istilah.
Batas Mathematica
Hanya dalam satu perintah Mathematica, Anda dapat dengan mudah
menentukan perhitungan yang terlalu rumit untuk komputer mana pun melakukan.
Misalnya, Anda dapat meminta Perluas[(1+x)^(10^100)]. Hasil dari perhitungan ini
akan memiliki 10100 + 1 suku—lebih dari jumlah total partikel di alam semesta.
Anda seharusnya tidak mengalami kesulitan dalam mengerjakan Expand[(1+x)^100] di
komputer mana pun yang dapat menjalankan Mathematica. Tetapi sebagai
Anda meningkatkan eksponen (1+x), hasil yang Anda dapatkan pada akhirnya
akan menjadi terlalu besar untuk memori komputer Anda memegang. Tepat pada titik
mana hal ini terjadi tidak hanya bergantung pada jumlah total memori yang dimiliki
komputer Anda, tetapi juga sering juga pada detail seperti pekerjaan lain yang sedang
berjalan di komputer Anda saat Anda mencoba melakukan perhitungan.
Jika komputer Anda kehabisan memori di tengah perhitungan, sebagian besar
versi Mathematica tidak punya pilihan tetapi untuk segera berhenti. Akibatnya,
penting untuk merencanakan perhitungan Anda sehingga mereka tidak pernah
membutuhkan lebih banyak memori daripada komputer Anda miliki.
Bahkan jika hasil perhitungan aljabar cukup sederhana, ekspresi antara yang
Anda hasilkan dalam tentu saja perhitungannya bisa sangat rumit. Ini berarti bahwa
meskipun hasil akhirnya kecil, perantara bagian dari perhitungan bisa terlalu besar
untuk ditangani komputer Anda. Jika ini terjadi, Anda biasanya dapat memecah
perhitungan menjadi beberapa bagian, dan berhasil mengerjakan setiap bagiannya
sendiri. Anda harus tahu bahwa skema internal yang digunakan Mathe matica untuk
manajemen memori sedemikian rupa sehingga setelah bagian dari perhitungan selesai,
memori yang digunakan untuk menyimpan ekspresi antara yang muncul segera
tersedia untuk ekspresi baru.
Ruang memori adalah faktor pembatas yang paling umum dalam perhitungan
Mathematica.
Namun, waktu juga bisa menjadi pembatas faktor. Anda biasanya akan bersiap untuk
menunggu satu detik, atau bahkan satu menit, untuk hasil perhitungan. Tapi Anda akan
kurang sering bersiaplah untuk menunggu satu jam atau satu hari, dan Anda hampir
tidak akan pernah bisa menunggu setahun.
Kode internal Mathematica menggunakan algoritma yang sangat efisien dan
dioptimalkan. Tapi ada beberapa tugas yang algoritma yang paling terkenal pada
akhirnya selalu membutuhkan banyak waktu. Masalah khas adalah bahwa waktu yang
dibutuhkan oleh algoritma dapat meningkat hampir secara eksponensial dengan
ukuran input. Kasus klasik adalah bilangan bulat faktorisasi—di mana algoritma yang
paling terkenal membutuhkan waktu yang tumbuh hampir secara eksponensial dengan
jumlah digit.
Dalam praktiknya, Anda akan menemukan bahwa FactorInteger[k] akan segera
memberikan hasil ketika k memiliki kurang dari sekitar 40 digit. Tetapi jika k memiliki
60 digit, FactorInteger[k] dapat mulai memakan waktu yang sangat lama.
Dalam beberapa kasus, ada peningkatan progresif dalam algoritma yang
diketahui, sehingga versi berturut-turut dari Mathematica dapat melakukan
perhitungan tertentu secara progresif lebih cepat. Tapi ide dari teori komputasi sangat
menyarankan bahwa banyak perhitungan akan selalu berlaku membutuhkan jumlah
pekerjaan komputasi yang tidak dapat direduksi — jadi bahwa tidak ada algoritma
cepat untuk mereka yang akan ditemukan.
Apakah satu-satunya pilihan melibatkan jumlah waktu yang meningkat secara
eksponensial, akan selalu ada titiknya di mana perhitungan terlalu besar atau memakan
waktu untuk dilakukan pada sistem komputer khusus Anda. Saat Anda bekerja dengan
Mathematica, Anda harus mengembangkan beberapa perasaan untuk batasan pada
jenis perhitungan yang dapat Anda lakukan di bidang Anda daerah aplikasi.
Menggunakan Simbol untuk Menandai Objek
Ada banyak cara untuk menggunakan simbol di Mathematica. Sejauh ini, kami
telah berkonsentrasi pada penggunaan simbol untuk menyimpan nilai dan untuk
mewakili variabel matematika. Bagian ini menjelaskan cara lain untuk menggunakan
simbol di Mathematica. Idenya adalah menggunakan simbol sebagai "tag" untuk
berbagai jenis objek.
Bekerja dengan unit fisik memberikan satu contoh sederhana. Saat Anda
menentukan panjang suatu objek, Anda ingin memberi not hanya angka, tetapi juga
unit di mana panjang diukur. Dalam notasi standar, Anda dapat menulis panjang
sebagai 12 meter.
Anda dapat meniru notasi ini hampir secara langsung di Mathematica. Misalnya, Anda
dapat menggunakan meter simbol untuk menunjukkan unit pengukuran kami.
Matematika Simbolik
Operasi Dasar
Kemampuan Mathematica untuk menangani ekspresi simbolik, serta angka,
memungkinkan Anda untuk menggunakannya untuk berbagai jenis matematika.
Kalkulus adalah salah satu contohnya. Dengan Mathematica, Anda dapat membedakan
ekspresi secara simbolis, dan mendapatkan rumus untuk hasil.
Diferensiasi
Integrasi
Mathematica tahu bagaimana melakukan hampir semua integral yang dapat

dilakukan dalam hal fungsi matematika standar. Tetapi
Anda harus menyadari bahwa meskipun suatu integral mungkin hanya berisi fungsi
yang cukup sederhana, integralnya mungkin melibatkan:
fungsi yang jauh lebih rumit—atau mungkin tidak dapat diekspresikan sama
sekali dalam
bentuk fungsi matematika standar.
Jumlah dan Produk
Persamaan
Bagian 1.2.2 membahas tugas-tugas seperti x = y yang mengatur x sama dengan
y. Bagian ini membahas persamaan, yang menguji persamaan. Persamaan x == y
menguji apakah x sama dengan y
Sangat penting untuk tidak mengacaukan x = y dengan x == y. Sedangkan x = y

adalah pernyataan imperatif yang sebenarnya menyebabkan tugas dilakukan, x == y
hanya menguji apakah x dan y sama, dan tidak menyebabkan tindakan eksplisit. Jika
kamu telah menggunakan bahasa pemrograman C, Anda akan mengenali bahwa notasi
untuk penugasan dan pengujian di
Mathematica sama seperti di C
Operator Relasional dan Logika
Menyelesaikan Persamaan
Ekspresi seperti x^2 + 2 x - 7 == 0 mewakili persamaan dalam Mathematica. Anda
akan sering perlu menyelesaikan persamaan seperti ini, untuk mengetahui berapa nilai x yang
benar.
Solve selalu mencoba memberi Anda rumus eksplisit untuk solusi persamaan.
Namun, ini adalah matematika dasar menghasilkan bahwa, untuk persamaan yang
cukup rumit, rumus aljabar eksplisit tidak dapat diberikan. Jika Anda memiliki aljabar
persamaan dalam satu variabel, dan pangkat tertinggi dari variabel adalah paling
banyak empat, maka Mathematica selalu dapat memberi Anda rumus untuk solusi.
Namun, jika kekuatan tertinggi adalah lima atau lebih, mungkin secara matematis
tidak mungkin untuk diberikan rumus aljabar eksplisit untuk semua solusi.
Ketidaksetaraan
Persamaan Diferensial
Seri Daya
Operasi matematika yang telah kita bahas sejauh ini adalah eksak. Dengan input yang
tepat, hasilnya adalah formula yang tepat.
Namun, dalam banyak situasi, Anda tidak memerlukan hasil yang pasti.
Mungkin cukup memadai, misalnya, untuk menemukan rumus perkiraan yang valid,
katakanlah, bila kuantitas x kecil.
Deret pangkat adalah rumus perkiraan yang memainkan banyak peran yang sama
sehubungan dengan ekspresi aljabar sebagai angka perkiraan bermain sehubungan dengan
ekspresi numerik. Mathematica memungkinkan Anda melakukan operasi dengan daya seri,
dalam semua kasus mempertahankan urutan yang sesuai atau "tingkat presisi" untuk rangkaian
daya yang dihasilkan.
Batas
Transformasi Integral
Persamaan Pengulangan
Paket untuk Matematika Simbolik

Ada banyak paket Mathematica yang mengimplementasikan operasi matematika
simbolik. Bagian ini memberikan beberapa contoh yang diambil dari set standar paket
yang didistribusikan dengan Mathematica. Seperti yang dibahas dalam Bagian 1.3.10,
beberapa salinan Mathematica dapat diatur sehingga fungsi yang dijelaskan di sini
secara otomatis dimuat ke Mathematica jika:
mereka selalu dibutuhkan.
Topik Lanjutan: Kasus Generik dan Non-Generik
Tujuan keseluruhan dari komputasi simbolik biasanya untuk mendapatkan
rumus yang valid untuk banyak nilai yang mungkin dari variabel yang muncul di
dalamnya. Namun seringkali tidak praktis untuk mencoba mendapatkan formula yang
benar-benar valid untuk semua kemungkinan nilai dari setiap variabel.
Jika Mathematica tidak secara otomatis mengganti 0 x dengan 0, maka beberapa
perhitungan simbolis akan menjadi sangat jauh. Tapi kamu harus menyadari bahwa
kebutuhan praktis untuk melakukan penggantian semacam itu dapat menyebabkan
diperolehnya hasil yang menyesatkan ketika nilai parameter yang luar biasa
digunakan. Operasi dasar Mathematica bagaimanapun diatur dengan hati-hati
sehingga bila memungkinkan hasil yang diperoleh akan berlaku untuk hampir semua
nilai dari setiap variabel.
Notasi Matematika dalam Notebook
Jika Anda menggunakan ujung depan notebook untuk Mathematica, maka Anda dapat
memasukkan beberapa operasi yang dibahas di bagian ini dengan cara-cara khusus.
Matematika Numerik
Operasi Dasar
Hasil simbolis yang tepat biasanya sangat diinginkan ketika dapat ditemukan.
Dalam banyak perhitungan, bagaimanapun, tidak mungkin untuk mendapatkan hasil
simbolis. Dalam kasus seperti itu, Anda harus menggunakan metode numerik.
Jumlah Numerik, Produk dan Integral
Penyelesaian Persamaan Numerik
Persamaan Diferensial Numerik
Dengan persamaan aljabar seperti x2 + 3 x + 1 = 0, setiap solusi untuk x hanyalah

sebuah bilangan tunggal. Untuk diferensial persamaan, bagaimanapun, solusinya
adalah fungsi, bukan angka tunggal. Misalnya, dalam persamaan y£ HxL = y HxL,
Anda ingin mendapatkan perkiraan ke fungsi y HxL karena variabel independen x
bervariasi pada beberapa rentang.
Mathematica mewakili perkiraan numerik untuk fungsi sebagai objek InterpolingFunction.
Ini objek adalah fungsi yang, ketika diterapkan pada x tertentu, mengembalikan nilai
perkiraan y HxL pada titik itu. NS
InterpolatingFunction secara efektif menyimpan tabel nilai untuk y HxiL,
kemudian menginterpolasi tabel ini untuk menemukan pendekatan ke y HxL pada x
tertentu yang Anda inginkan
Optimasi Numerik
Memanipulasi Data Numerik

Ketika Anda memiliki data numerik, seringkali lebih mudah untuk menemukan
rumus sederhana yang mendekatinya. Misalnya, Anda dapat mencoba
"menyesuaikan" garis atau kurva melalui titik-titik dalam data Anda.
Statistik
Fungsi dan Program

Mendefinisikan Fungsi
Di bagian buku ini, kita telah melihat banyak contoh fungsi yang dibangun ke
dalam Mathematica. Di bagian ini, kita diskusikan bagaimana Anda dapat
menambahkan fungsi sederhana Anda sendiri ke Mathematica. Bagian 2 akan
menjelaskan secara lebih rinci tentang mekanisme untuk menambahkan fungsi ke
Mathematica.
Sebagai contoh pertama, pertimbangkan untuk menambahkan fungsi yang
disebut f yang mengkuadratkan argumennya. Perintah Mathematica untuk definisikan
fungsi ini adalah f[x_] := x^2. Tanda _ (disebut sebagai “kosong”) di sisi kiri sangat
penting; apa itu sarana akan dibahas di bawah ini. Untuk saat ini, ingatlah untuk
meletakkan _ di sisi kiri, tetapi tidak di sisi kanan, definisi Anda.
Fungsi sebagai Prosedur
Dalam banyak jenis perhitungan, Anda mungkin menemukan diri Anda
mengetik input yang sama ke Mathematica berulang kali. Anda dapat menghemat
banyak pengetikan dengan mendefinisikan fungsi yang berisi perintah input Anda.
Fungsi yang Anda definisikan di Mathematica pada dasarnya adalah prosedur
yang menjalankan perintah yang Anda berikan. Kamu bisa memiliki beberapa langkah
dalam prosedur Anda, dipisahkan oleh titik koma.
Operasi Berulang
Dalam menggunakan Mathematica, terkadang Anda perlu mengulang suatu
operasi berkalikali. Ada banyak cara untuk melakukan ini. Sering yang paling alami
sebenarnya adalah membuat struktur seperti daftar dengan banyak elemen, dan
kemudian menerapkan operasi Anda ke masingmasing dari elemen.
Pendekatan lain adalah dengan menggunakan fungsi Mathematica Do, yang
bekerja seperti konstruksi iterasi dalam bahasa seperti C dan Fortran. Apakah
menggunakan notasi iterator Mathematica standar yang diperkenalkan untuk Jumlah
dan Produk di Bagian 1.5.4.
Aturan Transformasi untuk Fungsi
Bagian 1.4.2 membahas bagaimana Anda dapat menggunakan aturan
transformasi dari bentuk x -> nilai untuk mengganti simbol dengan nilai. NS gagasan
aturan transformasi di Mathematica, bagaimanapun, cukup umum. Anda dapat
mengatur aturan transformasi tidak hanya untuk simbol, tetapi untuk ekspresi
Mathematica apa pun.
Daftar
Mengumpulkan Objek Bersama
Kami pertama kali menemukan daftar di Bagian 1.2.3 sebagai cara
mengumpulkan angka bersama-sama. Di bagian ini, kita akan melihat banyak cara
yang berbeda untuk menggunakan daftar. Anda akan menemukan bahwa daftar adalah
beberapa objek yang paling fleksibel dan kuat di Mathematica.
Anda akan melihat bahwa daftar di Mathematica mewakili generalisasi dari
beberapa konsep standar dalam matematika dan ilmu Komputer.
Pada tingkat dasar, apa yang dilakukan daftar Mathematica pada dasarnya adalah
menyediakan cara bagi Anda untuk mengumpulkan beberapa ekspresi dalam bentuk apa pun.
Membuat Tabel Nilai
Anda dapat menggunakan daftar sebagai tabel nilai. Anda dapat membuat tabel,
misalnya, dengan mengevaluasi ekspresi untuk a urutan nilai parameter yang berbeda.
Vektor dan Matriks
Vektor dan matriks di Mathematica hanya diwakili oleh daftar dan daftar daftar,
masingmasing.
Mendapatkan Potongan Daftar
Pengujian dan Pencarian Elemen Daftar

Menambah, Menghapus, dan Memodifikasi Elemen Daftar
Menggabungkan Daftar
Topik Lanjutan: Daftar sebagai Set

Mathematica biasanya menyimpan elemen-elemen daftar persis dengan urutan
yang Anda masukkan. Jika Anda ingin mengobati Daftar Mathematica seperti
himpunan matematika, namun, Anda mungkin ingin mengabaikan urutan elemen
dalam daftar.
Menyusun Ulang Daftar
Mengelompokkan Elemen Daftar Bersama
Memesan dalam Daftar

Topik Lanjutan: Menata Ulang Daftar Bersarang
Anda akan menemukan daftar bersarang jika Anda menggunakan matriks atau
menghasilkan array dan tabel multidimensi. Matematika menyediakan banyak fungsi
untuk menangani daftar tersebut.
Grafik dan Suara
Dasar Plotting
Untuk mendapatkan kurva yang mulus, Mathematica harus mengevaluasi fungsi
yang Anda plot pada sejumlah besar titik. Akibatnya adalah penting bahwa Anda
mengatur segalanya sehingga setiap evaluasi fungsi secepat mungkin.
Ketika Anda meminta Mathematica untuk memplot suatu objek, katakanlah f,
sebagai fungsi dari x, ada dua kemungkinan pendekatan yang dapat diambil.
Salah satu pendekatan adalah pertama-tama mencoba dan mengevaluasi f,
mungkin mendapatkan ekspresi simbolis dalam bentuk x, dan kemudian mengevaluasi
ekspresi ini secara numerik untuk nilai spesifik x yang diperlukan dalam plot.
Pendekatan kedua adalah yang pertama untuk mengetahui nilai x apa yang diperlukan,
dan hanya selanjutnya untuk mengevaluasi f dengan nilai x tersebut. Jika Anda
mengetik Plot[f, 8x, xmin, xmax<] ini adalah pendekatan kedua yang digunakan. Ini
memiliki keuntungan bahwa
Mathematica hanya mencoba untuk mengevaluasi f untuk nilai numerik tertentu dari x;
tidak masalah apakah nilai yang masuk akal itu didefinisikan untuk f ketika x adalah simbolis.
Namun, ada beberapa kasus di mana lebih baik jika Mathematica mengevaluasi f
sebelum mulai membuat merencanakan. Kasus tipikal adalah ketika f sebenarnya adalah
perintah yang menghasilkan tabel fungsi. Anda ingin memiliki Mathematica pertama-tama
buat tabelnya, lalu evaluasi fungsinya, daripada mencoba membuat tabel lagi untuk setiap
nilai x. Anda dapat melakukannya dengan mengetik Plot[Evaluate[f], 8x, xmin, xmax<].
Opsi
Ketika Mathematica membuat grafik untuk Anda, ia harus membuat banyak
pilihan. Itu harus bekerja di luar skala apa yang seharusnya, di mana fungsi harus
diambil sampelnya, bagaimana sumbu harus digambar, dan sebagainya. Sebagian
besar waktu, Mathematica akan mungkin membuat pilihan yang cukup bagus. Namun,
jika Anda ingin mendapatkan gambar terbaik untuk foto Anda tujuan, Anda mungkin
harus membantu Mathematica dalam membuat beberapa pilihannya.
Ada mekanisme umum untuk menentukan "opsi" dalam fungsi Mathematica.
Setiap opsi memiliki nama yang pasti. Sebagai argumen terakhir untuk fungsi seperti
Plot, Anda dapat menyertakan urutan aturan dari nama formulir->nilai, ke tentukan
nilai untuk berbagai opsi. Opsi apa pun yang tidak Anda berikan aturan eksplisitnya
diambil untuk memilikinya nilai "default".
Menggambar Ulang dan Menggabungkan Plot
Mathematica menyimpan informasi tentang setiap plot yang Anda hasilkan,
sehingga Anda dapat menggambar ulang nanti. Saat Anda menggambar ulang plot,
Anda dapat mengubah beberapa opsi yang Anda gunakan.
Topik Lanjutan: Memanipulasi Opsi
Ada sejumlah fungsi yang dibangun ke dalam Mathematica yang, seperti Plot,
memiliki berbagai opsi yang dapat Anda atur. Mathemat ica menyediakan beberapa
mekanisme umum untuk menangani opsi tersebut.
Jika Anda tidak memberikan pengaturan khusus untuk opsi pada fungsi seperti
Plot, maka Mathematica akan secara otomatis menggunakan a nilai default untuk opsi.
Fungsi Opsi[fungsi, opsi] memungkinkan Anda mengetahui nilai default untuk a
pilihan tertentu. Anda dapat mengatur ulang default menggunakan SetOptions[fungsi,
opsi->nilai]. Perhatikan bahwa jika Anda melakukan ini, nilai default yang Anda
berikan akan tetap ada sampai Anda mengubahnya secara eksplisit.
Plot Kontur dan Kepadatan
Plot Permukaan Tiga Dimensi
Konversi antara Jenis Grafik
Kontur, kepadatan, dan plot permukaan adalah tiga cara berbeda untuk
menampilkan informasi yang pada dasarnya sama tentang suatu fungsi. Dalam semua
kasus, Anda memerlukan nilai fungsi pada kisi titik. Fungsi Mathematica ContourPlot,
DensityPlot dan Plot3D semuanya menghasilkan objek grafik Mathematica yang
menyertakan daftar nilai fungsi Anda pada kisi. Hasilnya, setelah menggunakan salah
satu dari fungsi ini, Mathe matica dapat dengan mudah mengambil outputnya dan
menggunakannya untuk menghasilkan jenis grafik lain.
Merencanakan Daftar Data

Sejauh ini, kita telah membahas bagaimana Anda dapat menggunakan
Mathematica untuk membuat plot fungsi. Anda memberi Mathematica fungsi, dan itu
membangun kurva atau permukaan dengan mengevaluasi fungsi di banyak titik yang
berbeda.
Bagian ini menjelaskan bagaimana Anda bisa membuat plot dari daftar data,
bukan fungsi. (Bagian 1.11.3 membahas cara membaca data dari file dan program
eksternal.) Perintah Mathematica untuk merencanakan daftar data adalah analog
langsung dari yang dibahas di atas untuk merencanakan fungsi.
Plot Parametrik
Bagian 1.9.1 menjelaskan cara memplot kurva dalam Mathematica di mana Anda
memberikan koordinat y dari setiap titik sebagai a fungsi koordinat x. Anda juga dapat
menggunakan Mathematica untuk membuat plot parametrik. Dalam plot parametrik, Anda
memberikan baik koordinat x dan y dari setiap titik sebagai fungsi dari parameter ketiga,
misalkan t.
Beberapa Plot Khusus
Seperti yang dibahas dalam Bagian 2.10, Mathematica menyertakan bahasa
pemrograman grafis lengkap. Dalam bahasa ini, Anda bisa mengatur berbagai jenis
plot. Beberapa yang umum disertakan dalam paket Mathematica standar.
Topik Khusus: Grafik Animasi

Pada banyak sistem komputer, Mathematica tidak hanya dapat menghasilkan
gambar statis, tetapi juga grafik animasi atau "film" Ide dasar dalam semua kasus
adalah untuk menghasilkan urutan "bingkai" yang dapat ditampilkan secara berurutan
dengan cepat. Kamu bisa gunakan fungsi grafik Mathematica standar yang dijelaskan
di atas untuk menghasilkan setiap frame. Mekanisme untuk menampilkan bingkai
sebagai film tergantung pada antarmuka Mathematica yang Anda gunakan. Dengan
antarmuka berbasis notebook, Anda biasanya menempatkan bingkai dalam urutan sel,
lalu pilih sel dan pilih perintah untuk menganimasikannya. Dengan antarmuka
berbasis teks, sering ada program eksternal yang disediakan untuk menampilkan grafik
animasi.
Programnya bisa biasanya dapat diakses dari dalam Mathematica menggunakan fungsi
Animate.
<<GraphicsÀnimation` memuat paket animasi Jika perluL
Animate@ plot, 8 t, tmin, tmax < D mengeksekusi plot perintah grafis untuk
urutan nilai t , dan menganimasikan urutan frame yang dihasilkan
ShowAnimation@ 8 g1, g2, … < D menghasilkan animasi dari urutan
objek grafis Cara umum untuk menghasilkan grafik animasi.
Saat Anda menghasilkan urutan bingkai untuk sebuah film, penting agar bingkai
yang berbeda konsisten. Jadi, untuk misalnya, Anda biasanya harus memberikan
pengaturan eksplisit untuk opsi PlotRange, daripada menggunakan Autog . default
pengaturan matic, untuk memastikan bahwa timbangan yang digunakan dalam bingkai
yang berbeda adalah sama. Jika Anda memiliki tiga dimensi grafik dengan sudut
pandang berbeda, Anda juga harus mengatur SphericalRegion -> True untuk
memastikan bahwa skala plot yang berbeda adalah sama.
Suara
Pada kebanyakan sistem komputer, Mathematica tidak hanya dapat
menghasilkan grafik tetapi juga suara. Mathematica memperlakukan grafik dan
terdengar dengan cara yang sangat mirip.
Misalnya, sama seperti Anda dapat menggunakan Plot[f, 8x, xmin, xmax<]
untuk memplot suatu fungsi, Anda juga dapat menggunakan Play[f, 8t, 0, tmax<]
untuk "memainkan" suatu fungsi. Play mengambil fungsi untuk menentukan bentuk
gelombang suara: nilai fungsi memberikan amplitudo suara sebagai fungsi waktu.
Input dan Output di Notebook
1.10.1 Memasukkan Huruf Yunani
1.10.2 Memasuki Input Dua Dimensi
1.10.3 Mengedit dan Mengevaluasi Ekspresi Dua Dimensi
Saat Anda melihat ekspresi dua dimensi di layar, Anda dapat mengeditnya
seperti halnya mengedit teks. Anda bisa untuk contoh tempatkan kursor Anda di suatu
tempat dan mulailah mengetik. Atau Anda dapat memilih bagian dari ekspresi, lalu
menghapusnya menggunakan tombol Hapus, atau masukkan versi baru dengan
mengetiknya.
Selain fitur pengeditan teks biasa, ada beberapa tombol yang dapat Anda gunakan untuk
bergerak secara dua dimensi ekspresi.
1.10.4 Memasukkan Rumus
1.10.5 Memasukkan Tabel dan Matriks
Ujung depan Mathematica biasanya menyediakan item menu Create
Table/Matrix/Palette yang memungkinkan Anda membuat a array kosong dengan
jumlah baris dan kolom yang ditentukan. Setelah Anda memiliki array seperti itu,
Anda dapat mengeditnya untuk diisi elemen apa pun yang Anda inginkan.
1.10.6 Subskrip, Bilah, dan Pengubah Lainnya
1.10.7 Topik Khusus: Karakter dan Keyboard Non-Bahasa Inggris
Jika Anda memasukkan teks dalam bahasa selain bahasa Inggris, Anda biasanya
perlu menggunakan berbagai aksen tambahan dan lainnya karakter. Jika sistem
komputer Anda diatur dengan cara yang tepat, maka Anda akan sering dapat
memasukkan karakter seperti itu langsung menggunakan tombol standar pada
keyboard Anda. Namun bagaimanapun sistem Anda diatur, Mathematica selalu
menyediakan a cara yang seragam untuk menangani karakter tersebut.
1.10.8 Notasi Matematika Lainnya
Mathematica mendukung notasi matematika yang sangat luas, meskipun sering
kali tidak memberikan makna yang telah ditentukan sebelumnya. Jadi, misalnya, Anda
dapat memasukkan ekspresi seperti x y, tetapi Mathematica tidak akan awalnya
membuat asumsi tentang apa yang Anda maksud dengan .
1.10.9 Bentuk Input dan Output
Notebook Mathematica memungkinkan Anda untuk memberikan input dan
mendapatkan output dalam berbagai bentuk yang berbeda. Biasanya bagian depan
menyediakan perintah menu untuk mengubah sel dari satu bentuk ke bentuk lainnya.
1.10.10 Mencampur Teks dan Rumus
Cara paling sederhana untuk mencampur teks dan rumus dalam buku catatan
Mathematica adalah dengan meletakkan setiap jenis materi dalam sel terpisah.
Namun, terkadang Anda mungkin ingin menyematkan rumus di dalam sel teks, atau
sebaliknya.
1.10.11 Menampilkan dan Mencetak Notebook Mathematica
Tergantung pada tujuan Anda menggunakan notebook Mathematica, Anda
mungkin ingin mengubahnya secara keseluruhan penampilan. Ujung depan
memungkinkan Anda menentukan sendiri gaya yang akan digunakan untuk tampilan
di layar dan untuk pencetakan. Biasanya Anda dapat melakukan ini dengan memilih
item yang sesuai di menu Format.
1.10.12 Membuat Palet Anda Sendiri
Ujung depan notebook Mathematica hadir dengan koleksi palet standar. Tetapi
itu juga memungkinkan Anda untuk membuat palet sendiri.
Siapkan palet kosong menggunakan Create TableêMatrixêPalette di bawah
menu Input Isi isinya
Jadikan palet aktif menggunakan Generate Palette from Selection di bawah menu
File
1.10.13 Menyiapkan Hyperlink
Hyperlink adalah jenis tombol khusus yang melompat ke bagian lain dari
notebook ketika ditekan. Biasanya hyper link ditunjukkan dalam Mathematica dengan
teks biru atau digarisbawahi. Untuk menyiapkan hyperlink, cukup pilih teks atau objek
lain yang ingin dijadikan hyperlink. Kemudian pilih item menu Buat Hyperlink dan
isikan spesifikasi tempat tujuan hyperlink yang Anda inginkan.
1.10.14 Penomoran Otomatis
Pilih gaya sel seperti NumberedEquation
Gunakan menu Buat Objek Penomoran Otomatis, dengan nama penghitung
seperti Bagian
1.10.15 Eksposisi dalam Notebook Mathematica
Notebook Mathematica menyediakan teknologi dasar yang Anda butuhkan
untuk dapat membuat berbagai macam dokumen interaktif yang canggih. Tetapi untuk
mendapatkan yang terbaik dari teknologi ini, Anda perlu mengembangkan gaya yang
sesuai eksposisi.
Banyak orang pada awalnya cenderung menggunakan notebook Mathematica
baik sebagai lembar kerja sederhana yang berisi urutan input dan jalur keluaran, atau
sebagai versi di layar dari buku tradisional dan materi cetak lainnya. Tapi yang paling
efektif dan penggunaan produktif notebook Mathematica cenderung tidak berada pada
salah satu dari ekstrem ini, dan sebaliknya biasanya melibatkan a pencampuran halus
input dan output Mathematica dengan teks penjelasan. Dalam kebanyakan kasus, satu-
satunya yang paling penting faktor dalam memperoleh pencampuran halus seperti itu
adalah penggunaan bahasa Mathematica yang seragam.
Orang mungkin berpikir bahwa akan cenderung ada tiga jenis materi dalam
buku catatan
Mathematica: teks biasa, rumus matematika, dan kode komputer. Tetapi salah satu ide
utama Mathematica adalah menyediakan satu bahasa yang menawarkan yang terbaik
dari kedua rumus matematika tradisional dan kode komputer.
Dalam StandardForm, ekspresi Mathematica memiliki jenis kekompakan dan
keanggunan yang sama seperti rumus matematika tradisional. Tapi tidak seperti rumus
seperti itu, ekspresi Mathematica diatur dengan benar-benar konsisten dan seragam
cara. Akibatnya, jika Anda menggunakan ekspresi Mathematica, maka terlepas dari
materi pelajaran Anda, Anda tidak perlu pergi kembali dan jelaskan kembali notasi
dasar Anda: itu selalu hanya notasi bahasa Mathematica. Selain itu, jika Anda
mengatur penjelasan Anda dalam hal ekspresi Mathematica, maka pembaca buku
catatan Anda dapat segera mengambil apa yang telah Anda berikan, dan benar-benar
menjalankannya sebagai input Mathematica.
File dan Operasi Eksternal
Membaca dan Menulis File Mathematica
Anda dapat menggunakan file di sistem komputer Anda untuk menyimpan
definisi dan hasil dari Mathematica. Yang paling umum pendekatan adalah untuk
menyimpan semuanya sebagai teks biasa yang sesuai untuk input ke Mathematica.
Dengan pendekatan ini, sebuah versi
Mathematica yang berjalan di satu sistem komputer menghasilkan file yang
dapat dibaca oleh versi yang berjalan di komputer mana pun sistem. Selain itu, file
tersebut dapat dimanipulasi oleh program standar lainnya, seperti editor teks.
Topik Lanjutan: Menemukan dan Memanipulasi File
Meskipun detail tentang bagaimana file diberi nama dan diatur berbeda dari satu
sistem komputer ke sistem komputer lainnya, Mathematica menyediakan beberapa
mekanisme yang cukup umum untuk menemukan dan menangani file.
Mathematica menganggap bahwa file di sistem komputer Anda mengatur dalam
kumpulan direktori. Kapan pun, Anda memiliki direktori kerja saat ini. Anda selalu
dapat merujuk ke direktori file di direktori ini hanya dengan memberikan namanya.
Mengimpor dan Mengekspor Data
Mengekspor Grafik dan Suara

Mathematica memungkinkan Anda untuk mengekspor grafik dan suara dalam
berbagai format. Jika Anda menggunakan ujung depan notebook untuk Mathematica,
maka Anda biasanya dapat menyalin dan menempelkan grafik dan suara langsung ke
program lain menggunakan mekanisme standar yang tersedia di sistem komputer
Anda.
Mengekspor Rumus dari Notebook
Menghasilkan TeX
Notebook Mathematica menyediakan lingkungan yang canggih untuk membuat
dokumen teknis. Tetapi terutama jika Anda ingin menggabungkan pekerjaan Anda
dengan materi yang ada di TeX, Anda mungkin merasa nyaman menggunakan
TeXForm untuk mengonversi ekspresi di Mathematica ke dalam bentuk yang cocok
untuk input ke TeX.
Bertukar Materi dengan Web
Menghasilkan Ekspresi C dan Fortran
Jika Anda memiliki program tujuan khusus yang ditulis dalam C atau Fortran,
Anda mungkin ingin mengambil rumus yang telah Anda buat di Mathematica dan
masukkan ke dalam kode sumber program Anda. Mathematica memungkinkan Anda
mengonversi matematika ekspresi menjadi ekspresi C dan Fortran
Menyambung Output Mathematica ke File Eksternal
Jika Anda ingin memanfaatkan keluaran Mathematica dalam file eksternal
seperti program atau dokumen, Anda akan sering menemukannya berguna untuk
"menyambung" output secara otomatis ke dalam file.
Menjalankan Program Eksternal
Meskipun Mathematica melakukan banyak hal dengan baik, ada beberapa hal
yang pasti lebih baik dilakukan oleh program eksternal. Anda dapat menggunakan
Mathematica untuk mengontrol program eksternal, atau untuk menganalisis output
yang dihasilkannya.
Pada hampir semua sistem komputer, dimungkinkan untuk menjalankan
program eksternal langsung dari dalam Mathematica. Mathemat ica berkomunikasi
dengan program eksternal melalui mekanisme komunikasi antarproses seperti pipa.
Dalam kasus yang paling sederhana, satusatunya komunikasi yang Anda butuhkan
adalah mengirim dan menerima teks biasa. Anda dapat menyiapkan masukan di
Mathematica, kemudian berikan sebagai input standar untuk program eksternal.
Atau Anda dapat mengambil output standar dari program eksternal, dan
menggunakannya sebagai input ke Mathematica.
Secara umum, Mathematica memungkinkan Anda untuk memperlakukan aliran
data yang dipertukarkan dengan program eksternal seperti file. Di tempat nama file,
Anda memberikan perintah eksternal untuk dijalankan, diawali dengan tanda seru.
Tautan Matematika
Bagian sebelumnya membahas bagaimana menukar teks biasa dengan program
eksternal. Namun, dalam banyak kasus, Anda akan merasa nyaman untuk
berkomunikasi dengan program eksternal di tingkat yang lebih tinggi, dan untuk
bertukar data yang lebih terstruktur dengan mereka.
Pada hampir semua sistem komputer, Mathematica mendukung standar
komunikasi
MathLink, yang memungkinkan komunikasi tingkat tinggi antara Mathematica dan
program eksternal. Untuk menggunakan MathLink, eksternal program harus
menyertakan beberapa kode sumber khusus, yang biasanya didistribusikan dengan
Mathematica.
MathLink memungkinkan program eksternal untuk memanggil Mathematica,
dan dipanggil oleh Mathematica. Bagian 2.13 membahas beberapa detail MathLink.
Dengan menggunakan MathLink, Anda dapat, misalnya, memperlakukan
Mathematica pada dasarnya seperti subrutin yang tertanam di dalam program
eksternal. Atau Anda dapat membuat front end yang mengimplementasikan antarmuka
pengguna Anda sendiri, dan berkomunikasi dengan kernel Mathematica melalui
MathLink.
Anda juga dapat menggunakan MathLink untuk membiarkan Mathematica memanggil
fungsi individual di dalam program eksternal. Seperti yang dijelaskan dalam
Bagian 2.13, Anda dapat mengatur file template MathLink untuk menentukan
bagaimana fungsi tertentu di Mathematica harus dipanggil fungsi di dalam program
eksternal Anda. Dari file template MathLink, Anda dapat membuat kode sumber untuk
disertakan dalam program Anda. Kemudian ketika Anda memulai program Anda,
definisi Mathematica yang sesuai akan dibuat secara otomatis, dan ketika Anda
memanggil fungsi Mathematica tertentu, kode dalam program eksternal Anda
dijalankan.
Topik Khusus: Bagian Dalam Mathematica
Mengapa Anda Biasanya Tidak Perlu Tahu tentang Internal
Sebagian besar buku ini berkaitan dengan menjelaskan apa yang dilakukan
Mathematica, bukan bagaimana melakukannya. Tapi tujuan ini bab ini untuk
mengatakan setidaknya sedikit tentang bagaimana Mathematica melakukan apa yang
dilakukannya. Lampiran A.9 memberikan beberapa rincian lebih lanjut.
Anda harus menyadari sejak awal bahwa meskipun mengetahui tentang internal
Mathematica mungkin menarik secara intelektual, itu biasanya jauh kurang penting
dalam praktik daripada yang mungkin diperkirakan pada awalnya.
Memang, salah satu poin utama Mathematica adalah ia menyediakan lingkungan
di mana Anda dapat melakukan matematika dan operasi lainnya tanpa harus
memikirkan secara detail tentang bagaimana operasi ini sebenarnya dilakukan di
dalam komputer.
Jadi, misalnya, jika Anda ingin memfaktorkan polinomial x15 - 1, Anda dapat
melakukannya hanya dengan memberikan Mathematica faktor perintah[x^15 - 1];
Anda tidak perlu tahu detail yang cukup rumit tentang bagaimana faktorisasi seperti
itu sebenarnya dilakukan oleh kode internal Mathematica.
Memang, di hampir semua penggunaan praktis Mathematica, masalah tentang
bagaimana Mathematica bekerja di dalam ternyata sebagian besar tidak relevan. Untuk
sebagian besar tujuan, cukup untuk melihat Mathematica hanya sebagai sistem abstrak
yang melakukan tertentu operasi matematika dan operasi lainnya.
Anda mungkin berpikir bahwa mengetahui bagaimana Mathematica bekerja di dalam
akan diperlukan dalam menentukan jawaban apa yang akan didapat memberi. Tapi ini hanya
sangat jarang terjadi. Untuk sebagian besar perhitungan yang dilakukan Mathematica
sepenuhnya ditentukan oleh definisi operasi matematika atau lainnya.
Jadi, misalnya, 3^40 akan selalu menjadi 12157665459056928801, terlepas dari
bagaimana Mathematica secara internal menghitung hasil ini.
Ada beberapa situasi, bagaimanapun, di mana beberapa jawaban yang berbeda
semuanya sama-sama konsisten dengan definisi matematika formal. Jadi, misalnya,
dalam menghitung integral simbolik, seringkali ada beberapa ekspresi berbeda yang:
semuanya menghasilkan turunan yang sama. Manakah dari ekspresi ini yang benar-
benar dihasilkan oleh Integrate yang kemudian dapat bergantung pada bagaimana
Integrasi bekerja di dalam.
Arsitektur Internal Dasar
Saat Anda mengetik input ke Mathematica, struktur data dibuat di memori komputer
Anda untuk mewakili ekspresi yang Anda masukkan
Secara umum, potongan ekspresi Anda yang berbeda akan disimpan di tempat
yang berbeda dalam memori. Jadi, misalnya, untuk daftar seperti {2, x, y + z} "tulang
punggung" dari daftar akan disimpan di satu tempat, sementara masing-masing elemen
yang sebenarnya akan disimpan disimpan di tempat yang berbeda.
Tulang punggung daftar kemudian hanya terdiri dari tiga "pointer" yang
menentukan alamat dalam memori komputer di mana: ekspresi aktual yang
membentuk elemen daftar dapat ditemukan. Ekspresi ini kemudian pada gilirannya
mengandung pointer untuk subekspresi mereka. Rantai pointer berakhir ketika
seseorang mencapai objek seperti angka atau string, yaitu disimpan secara langsung
sebagai pola bit dalam memori komputer.
Penting untuk operasi Mathematica adalah gagasan simbol seperti x. Setiap kali x
muncul dalam ekspresi,
Mathematica mewakilinya dengan pointer. Tetapi penunjuk selalu ke tempat
yang sama di memori komputer—sebuah entri di a tabel pusat dari semua simbol yang
ditentukan dalam sesi Mathematica Anda.
Tabel ini adalah tempat penyimpanan semua informasi tentang setiap simbol. Ini
berisi pointer ke string yang memberikan symbol nama, serta pointer ke ekspresi yang
memberikan aturan untuk mengevaluasi simbol.
Daur ulang memori segera setelah data di dalamnya tidak lagi direferensikan.
Prinsip dasar manajemen memori Mathematica.
Setiap bagian dari memori yang digunakan oleh Mathematica mempertahankan
hitungan berapa banyak pointer saat ini menunjuk ke sana. Kapan ini hitungan turun
ke nol, Mathematica tahu bahwa potongan memori tidak lagi direferensikan, dan
segera membuat bagian memori tersedia untuk sesuatu yang baru.
Strategi ini pada dasarnya memastikan bahwa tidak ada memori yang terbuang
sia-sia, dan setiap bagian memori yang digunakan Mathematica adalah sebenarnya
menyimpan data yang perlu Anda akses dalam sesi Mathematica Anda.
Buat ekspresi yang sesuai dengan input yang Anda berikan.
Memproses ekspresi menggunakan semua aturan yang diketahui untuk objek di
dalamnya. Menghasilkan output yang sesuai dengan ekspresi yang dihasilkan.
Tindakan dasar Mathematica. Inti dari Mathematica adalah prosedur konseptual
sederhana yang dikenal sebagai evaluator yang mengambil setiap fungsi yang muncul
dalam ekspresi dan mengevaluasi fungsi itu.
Ketika fungsinya adalah salah satu dari seribu atau lebih yang dibangun ke
dalam Mathematica, yang dilakukan oleh evaluator adalah mengeksekusi kode
internal langsung dalam sistem Mathematica. Kode ini diatur untuk melakukan operasi
yang sesuai dengan fungsi, dan kemudian membangun ekspresi baru yang mewakili
hasilnya.
Fungsi bawaan Mathematica mendukung komputasi universal.
Fitur dasar yang membuat Mathematica sistem mandiri.
Sebuah fitur penting dari fungsi built-in di Mathematica adalah bahwa mereka
mendukung perhitungan universal. Apa artinya ini? adalah bahwa dari fungsi-fungsi
ini Anda dapat membuat program yang benar-benar melakukan semua jenis operasi
yang mungkin untuk komputer.
Ternyata, subset kecil dari fungsi bawaan Mathematica akan cukup memadai
untuk mendukung komputasi universal. Tetapi memiliki seluruh koleksi fungsi
membuatnya lebih mudah dalam praktiknya untuk membangun program yang
dibutuhkan seseorang.
Namun, poin yang mendasarinya adalah karena Mathematica mendukung
komputasi universal, Anda tidak perlu memodifikasinya fungsi bawaannya: yang
harus Anda lakukan untuk melakukan tugas tertentu adalah menggabungkan fungsi-
fungsi ini secara tepat cara.
Algoritma Mathematica
Fungsi bawaan Mathematica mengimplementasikan sejumlah besar algoritma
dari ilmu komputer dan matematika. Beberapa dari algoritma ini cukup tua, tetapi
sebagian besar harus dibuat atau setidaknya dimodifikasi khusus untuk Mathematica.
Sebagian besar algoritma matematika di Mathematica akhirnya melakukan operasi
yang setidaknya pada beberapa waktu di masa lalu dilakukan dengan tangan. Namun,
dalam hampir semua kasus, algoritma menggunakan metode yang sangat berbeda dari
yang umum dalam perhitungan tangan.
Integrasi simbolik memberikan contoh. Dalam perhitungan tangan, integrasi simbolik
biasanya dilakukan oleh besar sejumlah trik yang melibatkan perubahan variabel dan
sejenisnya.
Tetapi dalam Mathematica, integrasi simbolik dilakukan oleh sejumlah kecil
prosedur yang sangat sistematis. Untuk integrasi tak tentu, ide dari prosedur ini adalah
untuk menemukan bentuk integral yang paling umum, kemudian untuk
membedakannya ini dan mencoba untuk mencocokkan koefisien yang belum
ditentukan.
Seringkali prosedur ini menghasilkan ekspresi aljabar yang sangat rumit pada
tahap menengah, dan kadang-kadang jenis fungsi matematika yang sangat canggih.
Tetapi keuntungan besar dari prosedur ini adalah sepenuhnya sistematis, dan
pengoperasiannya tidak memerlukan kepandaian khusus yang hanya dapat diberikan
oleh manusia.
Dalam memiliki Mathematica melakukan integral, oleh karena itu, seseorang
dapat yakin bahwa itu akan mendapatkan hasil secara sistematis, tetapi satu tidak dapat
berharap bahwa cara hasil-hasil ini diperoleh akan sangat berkaitan dengan cara
mereka diturunkan oleh tangan.
Hal yang sama berlaku dengan sebagian besar algoritma matematika di
Mathematica. Salah satu fitur yang mencolok adalah bahkan untuk operasi yang
sederhana untuk dijelaskan, algoritma sistematis untuk melakukan operasi ini di
Mathematica melibatkan ide-ide matematika atau komputasi yang cukup maju.
Jadi, misalnya, memfaktorkan polinomial dalam x pertama-tama dilakukan
modulo a prima seperti 17 dengan mencari ruang nol dari a matriks diperoleh dengan
mengurangi kekuatan tinggi x modulo prima dan polinomial asli. Kemudian
faktorisasi selesai bilangan bulat dicapai dengan "mengangkat" kekuatan modulo
berturut-turut dari bilangan prima menggunakan kumpulan teorema rumit di aljabar
dan analisis.
Penggunaan algoritme sistematis yang kuat penting dalam membuat fungsi
bawaan di Mathematica mampu menangani kasus yang sulit dan umum. Tetapi untuk
kasus-kasus mudah yang mungkin cukup umum dalam praktiknya, seringkali
dimungkinkan untuk menggunakan yang lebih sederhana dan algoritma yang lebih
efisien.
Akibatnya, fungsi built-in di Mathematica sering kali memiliki sejumlah besar potongan
tambahan yang menangani berbagai jenis kasus khusus. Potongan ekstra ini dapat berkontribusi
besar pada kompleksitas kode internal, sering kali mengambil apa yang akan jika tidak, jadilah
algoritma lima halaman dan membuatnya menjadi ratusan halaman.
Sebagian besar algoritma di Mathematica, termasuk semua kasus khusus
mereka, secara eksplisit dibangun dengan tangan. Tetapi beberapa algoritma malah
secara efektif dibuat secara otomatis oleh komputer.
Rekayasa Perangkat Lunak Mathematica
Mathematica adalah salah satu sistem perangkat lunak yang lebih kompleks
yang pernah dibangun. Kode sumbernya ditulis dalam kombinasi dari C dan
Mathematica, dan untuk Versi 5, kode untuk kernel terdiri dari sekitar 1,5 juta baris C
dan 150.000 baris baris Mathematica. Ini setara dengan sekitar 50 megabyte data, atau
sekitar 50.000 halaman cetak.
Kode C di Mathematica sebenarnya ditulis dalam ekstensi khusus C yang
mendukung manajemen memori tertentu dan fitur berorientasi objek. Kode
Mathematica dioptimalkan menggunakan Share dan DumpSave.
Dalam kernel Mathematica, perincian bagian-bagian kode yang berbeda kira-
kira sebagai berikut: bahasa dan sistem: 30%; perhitungan numerik: 25%; perhitungan
aljabar: 25%; grafis dan output kernel: 20%.
Sebagian besar kode ini cukup padat dan algoritmik: bagian-bagian yang berlaku
prosedur atau tabel sederhana menggunakan minimal kode karena cenderung ditulis
pada tingkat yang lebih tinggi—seringkali langsung di Mathematica.
Kode sumber untuk kernel, simpan sepersekian persen, identik untuk semua sistem
komputer di mana Mathematica berjalan.
Namun, untuk ujung depan, sejumlah besar kode khusus diperlukan untuk
mendukung setiap jenis pengguna yang berbeda lingkungan antarmuka. Ujung depan
berisi sekitar 650.000 baris kode sumber C yang tidak bergantung pada sistem, di
antaranya: kira-kira 150.000 baris berkaitan dengan pemformatan ekspresi. Lalu ada
antara 50.000 dan 100.000 baris kode khusus yang disesuaikan untuk setiap
lingkungan antarmuka pengguna.
Mathematica menggunakan model komputasi client-server. Ujung depan dan
kernel terhubung melalui MathLink—sama sistem seperti yang digunakan untuk
berkomunikasi dengan program lain.
Dalam bagian kode C dari kernel Mathematica, modularitas dan konsistensi
dicapai dengan memiliki perbedaan bagian berkomunikasi terutama dengan bertukar
ekspresi Mathematica lengkap.
Tetapi perlu dicatat bahwa meskipun bagian yang berbeda dari sistem cukup
independen pada tingkat kode sumber, mereka memiliki banyak interdependensi
algoritmik. Jadi, misalnya, adalah umum untuk membuat fungsi numerik: ekstensif
menggunakan algoritme aljabar, atau untuk kode grafis menggunakan algoritme
matematika yang cukup maju yang diwujudkan dalam fungsi Mathematica yang
sangat berbeda.
Sejak awal pengembangannya pada tahun 1986, upaya yang dihabiskan
langsung untuk membuat kode sumber untuk Mathematica adalah sebagian kecil dari
seribu tahun manusia. Selain itu, upaya yang sebanding atau agak lebih besar telah
dihabiskan untuk pengujian dan verifikasi.
Kode sumber Mathematica telah banyak berubah sejak Versi 1 dirilis. Jumlah
total baris kode di kernel tumbuh dari 150.000 di Versi 1 menjadi 350.000 di Versi 2,
600.000 di Versi 3, 800.000 di Versi 4 dan sekitar 1,5 juta di Versi 5. Selain itu, pada
setiap tahap kode yang ada telah direvisi—sehingga Versi 5 hanya memiliki beberapa
persen kodenya sama dengan Versi 1.
Terlepas dari perubahan dalam kode internal ini, desain tingkat pengguna Mathematica
tetap kompatibel dari
Versi 1 aktif. Banyak fungsi telah ditambahkan, tetapi program yang dibuat untuk
Mathematica Versi 1 hampir selalu dijalankan sama sekali tidak berubah di bawah Versi 5.
Pengujian dan Verifikasi
Setiap versi Mathematica mengalami banyak pengujian sebelum dirilis. Sebagian
besar dari ini pengujian dilakukan oleh sistem otomatis yang ditulis dalam Mathematica.
Sistem otomatis mengumpankan jutaan masukan ke Mathematica, dan
memeriksa apakah keluaran diperoleh darinya benar. Seringkali ada beberapa
kehalusan dalam melakukan pemeriksaan seperti itu: seseorang harus
memperhitungkan perilaku acak yang berbeda algoritma dan untuk masalah seperti
perbedaan dalam aritmatika presisi mesin pada komputer yang berbeda. Input
pengujian yang digunakan oleh sistem otomatis diperoleh dengan beberapa cara:
Untuk setiap fungsi Mathematica, input dirancang untuk menangani kasus umum dan
kasus ekstrim.
Input dirancang untuk menjalankan setiap fitur kode internal.
Semua contoh dalam buku ini dan buku lain tentang Mathematica digunakan.
Tabel numerik standar dipindai secara optik untuk input pengujian.
Rumus dari semua tabel matematika standar dimasukkan.
Latihan dari buku teks dimasukkan.
Untuk pasangan fungsi seperti Integrate dan D atau Factor and Expand, ekspresi
acak dihasilkan dan diuji. Saat pengujian dijalankan, sistem pengujian otomatis tidak
hanya memeriksa hasil, tetapi juga efek samping seperti pesan, seperti: serta
penggunaan memori dan kecepatan.
PART 2
Bagian 1 memperkenalkan Mathematica dengan menunjukkan kepada Anda bagaimana
menggunakan beberapa fitur yang lebih umum. Bagian ini melihat Mathematica dengan cara yang berbeda.
Alih-alih membahas fitur individu, ini berkonsentrasi pada struktur global Mathematica, dan menjelaskan
kerangka kerja di mana semua fitur cocok.
Ketika Anda pertama kali mulai melakukan perhitungan dengan Mathematica, Anda mungkin akan merasa
cukup hanya dengan membaca yang relevanbagian dari Bagian 1. Namun, setelah Anda memiliki beberapa
keakraban umum dengan sistem Mathematica, Anda harus membuat: titik membaca Bagian ini.
Bagian ini menjelaskan struktur dasar bahasa Mathematica, yang dengannya Anda dapat memperluas
Mathematica, menambahkan fungsi Anda sendiri, objek atau konstruksi lainnya. Bagian ini menunjukkan
bagaimana Mathematica menggunakan jumlah yang cukup kecil dari metode pemrograman simbolis yang
kuat untuk memungkinkan Anda membangun berbagai jenis program. Sebagian besar Bagian ini
mengasumsikan tidak ada pengetahuan khusus sebelumnya tentang ilmu komputer. Namun demikian,
beberapa di antaranya menjelajah ke beberapa masalah yang cukup rumit. Anda mungkin dapat mengabaikan
masalah ini kecuali jika masalah tersebut secara khusus memengaruhi program Anda menulis.
Jika Anda ahli dalam bahasa komputer, Anda mungkin dapat memperoleh pemahaman tentang
Mathematica dengan melihat: pada Panduan Referensi di bagian akhir buku ini. Namun demikian, untuk
mendapatkan apresiasi yang nyata terhadap prinsip-prinsip Mathematica, Anda harus membaca Bagian ini.
2.1 Ekspresi
2.1.1 Semuanya Adalah Ekspresi
Mathematica menangani berbagai macam hal: rumus matematika, daftar dan grafik, untuk beberapa
nama.
Meskipun mereka sering terlihat sangat berbeda, Mathematica mewakili semua hal ini dalam satu cara
yang seragam. Mereka semua ekspresi.
Contoh prototipikal dari ekspresi Mathematica adalah f[x, y]. Anda dapat menggunakan f[x, y] untuk
merepresentasikan fungsi matematika f Hx, yL. Fungsi tersebut diberi nama f, dan memiliki dua argumen, x
dan y.
Anda tidak selalu harus menulis ekspresi dalam bentuk f[x, y, … ]. Misalnya, x + y juga merupakan
ekspresi. Kapan
Anda mengetik x + y, Mathematica mengubahnya menjadi bentuk standar Plus[x, y]. Kemudian, ketika
mencetaknya lagi, itu memberikannya sebagai x + y.
Hal yang sama berlaku untuk "operator" lainnya, seperti ^ (Power) dan / (Divide).
Faktanya, semua yang Anda ketikkan ke Mathematica diperlakukan sebagai ekspresi.
Anda dapat melihat bentuk lengkap dari ekspresi apapun dengan menggunakan FullForm[expr].
Berikut adalah ekspresi.
Ini adalah bentuk lengkap dari ekspresi.
Berikut adalah ekspresi lain.
Bentuk lengkapnya memiliki beberapa potongan bersarang.

Objek f dalam ekspresi f[x, y, … ] dikenal sebagai kepala ekspresi. Anda dapat mengekstraknya
menggunakan Head[ekspr]. Khususnya ketika Anda menulis program di Mathematica, Anda akan sering
ingin menguji kepala ekspresi untuk mengetahui jenis ekspresinya.
Kepala memberikan “nama fungsi” f.
Di sini Head memberi nama "operator"
Angka juga memiliki kepala.
Anda dapat membedakan berbagai jenis angka dengan kepala mereka
2. 1. 2 Arti Ekspresi
Gagasan tentang ekspresi adalah prinsip pemersatu yang penting dalam Mathematica. Ini adalah fakta
bahwa setiap objek di Mathematica memiliki struktur dasar yang sama yang memungkinkan Mathematica
untuk mencakup begitu banyak area dengan perbandingan sejumlah kecil operasi dasar. Meskipun semua
ekspresi memiliki struktur dasar yang sama, ada banyak cara berbeda untuk menggunakan ekspresi. Berikut
adalah beberapa interpretasi yang dapat Anda berikan pada bagian-bagian dari sebuah ekspresi.
Ekspresi dalam Mathematica sering digunakan untuk menentukan operasi. Jadi, misalnya, mengetik
2 + 3 menyebabkan 2 dan 3 menjadi ditambahkan bersama-sama, sementara Faktor[x^6 - 1] melakukan
faktorisasi.
Mungkin penggunaan ekspresi yang lebih penting dalam Mathematica, bagaimanapun, adalah untuk
mempertahankan struktur, yang dapat: kemudian ditindaklanjuti oleh fungsi lainnya. Ekspresi seperti {a, b,
c} tidak menentukan operasi. Itu hanya mempertahankan struktur daftar, yang berisi kumpulan tiga elemen.
Fungsi lain, seperti Reverse atau Dot, dapat bertindak berdasarkan ini struktur.
Bentuk lengkap dari ekspresi {a, b, c} adalah Daftar [a, b, c]. Daftar kepala tidak melakukan operasi.
Sebaliknya, itu tujuannya adalah untuk berfungsi sebagai "tag" untuk menentukan "tipe" struktur.
Anda dapat menggunakan ekspresi di Mathematica untuk membuat struktur Anda sendiri. Misalnya,
Anda mungkin ingin mewakili titik dalam ruang tiga dimensi, ditentukan oleh tiga koordinat. Anda dapat
memberikan setiap titik sebagai titik[x, y, z]. NS titik "fungsi" lagi tidak melakukan operasi. Ini berfungsi
hanya untuk mengumpulkan tiga koordinat bersama-sama, dan untuk memberi label objek yang dihasilkan
sebagai titik.
Anda dapat menganggap ekspresi seperti titik[x, y, z] sebagai "paket data", ditandai dengan kepala
tertentu. Bahkan meskipun semua ekspresi memiliki struktur dasar yang sama, Anda dapat membedakan
"jenis" ekspresi yang berbeda dengan memberi mereka berbeda kepala. Anda kemudian dapat mengatur
aturan dan program transformasi yang memperlakukan berbagai jenis ekspresi dengan cara yang berbeda.
2. 1. 3 Cara Khusus untuk Memasukkan Ekspresi

Mathematica memungkinkan Anda menggunakan notasi khusus untuk banyak operator umum.
Misalnya, meskipun secara internal Mathematica mewakili jumlah dua suku sebagai Plus [x, y], Anda dapat
memasukkan ekspresi ini dalam bentuk yang jauh lebih mudah x + y.
Bahasa Mathematica memiliki tata bahasa tertentu yang menentukan bagaimana input Anda harus
dikonversi ke internal membentuk. Salah satu aspek tata bahasa adalah menentukan bagaimana bagian dari
input Anda harus dikelompokkan. Misalnya, jika Anda masukkan ekspresi seperti a + b ^ c, tata bahasa
Mathematica menetapkan bahwa ini harus dipertimbangkan, berikut:
notasi matematika standar, sebagai a + (b^c) daripada (a + b)^c. Mathematica memilih pengelompokan ini
karena itu memperlakukan operator ^ sebagai memiliki prioritas lebih tinggi dari +. Secara umum, argumen
operator dengan yang lebih tinggi didahulukan dikelompokkan sebelum operator dengan prioritas lebih
rendah.
Anda harus menyadari bahwa mutlak setiap formulir masukan khusus di Mathematica diberikan
prioritas yang pasti. Ini tidak hanya mencakup operator matematika tradisional, tetapi juga bentuk seperti >,
:= atau titik koma yang digunakan untuk ekspresi terpisah dalam program Mathematica.
Tabel di Bagian A.2.7 memberikan semua operator Mathematica dalam urutan penurunan prioritas.
diutamakan adalah diatur, jika memungkinkan, untuk mengikuti penggunaan matematika standar, dan untuk
meminimalkan jumlah tanda kurung yang biasanya dibutuhkan.
Anda akan menemukan, misalnya, bahwa operator relasional seperti < memiliki prioritas lebih rendah
daripada operator aritmatika seperti +. Ini berarti Anda dapat menulis ekspresi seperti x + y > 7 tanpa
menggunakan tanda kurung.
Namun demikian, ada banyak kasus di mana Anda harus menggunakan tanda kurung. Misalnya, sejak
; memiliki prioritas yang lebih rendah than =, Anda perlu menggunakan tanda kurung untuk menulis x = ( a
; b ). Mathematica menginterpretasikan ekspresi x = a ; b sebagai (x = A) ; B. Secara umum, tidak ada
salahnya untuk menyertakan tanda kurung tambahan, tetapi dapat menyebabkan banyak masalah jika Anda
keluar tanda kurung, dan Mathematica menafsirkan masukan Anda dengan cara yang tidak Anda harapkan.
Ada beberapa jenis operator yang umum di Mathematica. + di x + y adalah operator "infix". - di -p
adalah operator "awalan". Bahkan ketika Anda memasukkan ekspresi seperti f[x, y, … ] Mathematica
memungkinkan Anda melakukannya dengan cara yang meniru bentuk infiks, prefiks, dan postfiks.
Anda harus memperhatikan bahwa // memiliki prioritas yang sangat rendah. Jika Anda meletakkan
//f di akhir ekspresi apa pun yang berisi operator aritmatika atau logika, f diterapkan ke seluruh ekspresi.
Jadi, misalnya, x+y //f berarti f[x+y], bukan x+f[y]. Bentuk awalan @ memiliki prioritas yang jauh lebih
tinggi. f @ x + y setara dengan f[x] + y, bukan f [x + y]. Anda dapat menulis f [x + y] dalam bentuk awalan
sebagai f @ (x + y). 2.1.4 Bagian dari Ekspresi
Karena daftar hanyalah jenis ekspresi tertentu, tidak mengherankan jika Anda dapat merujuk ke
bagian ekspresi apa pun seperti halnya Anda merujuk ke bagian daftar.
Anda harus menyadari bahwa penetapan indeks ke bagian ekspresi dilakukan berdasarkan bentuk
internal Mathematica dari ekspresi, seperti yang ditunjukkan oleh FullForm. Bentuk-bentuk ini tidak selalu
berhubungan langsung dengan apa yang Anda lihat dicetak. Hal ini terutama berlaku untuk ekspresi aljabar,
di mana Mathematica menggunakan bentuk internal standar, tetapi mencetak ekspresi dengan cara khusus.
Bagian 1.2.4 membahas bagaimana Anda dapat menggunakan daftar indeks untuk memilih beberapa
elemen daftar sekaligus. Anda dapat menggunakan prosedur yang sama untuk memilih beberapa bagian
dalam ekspresi pada suatu waktu.
Setiap bagian dalam ekspresi dapat dilihat sebagai argumen dari beberapa fungsi. Ketika Anda
memilih beberapa bagian dengan memberikan daftar indeks, bagian-bagian digabungkan menggunakan
fungsi yang sama seperti dalam ekspresi. 2.1.5 Memanipulasi Ekspresi seperti Daftar
Anda dapat menggunakan sebagian besar operasi daftar yang dibahas di Bagian 1.8 pada semua jenis ekspresi
Mathematica. Dengan menggunakan operasi ini, Anda dapat memanipulasi struktur ekspresi dalam banyak
cara.
Berikut adalah ekspresi yang sesuai dengan jumlah istilah.
Take[t, 2] mengambil dua elemen pertama dari t, sama seperti jika t adalah sebuah daftar.
Panjang memberikan jumlah elemen dalam t
Anda dapat menggunakan FreeQ[expr, form] untuk menguji apakah formulir tidak muncul di mana pun di
expr.
Ini memberikan daftar posisi di mana x muncul di t
Anda harus ingat bahwa semua fungsi yang memanipulasi struktur ekspresi bertindak pada bentuk internal
ini
ekspresi. Anda dapat melihat formulir ini menggunakan FullForm[expr]. Mereka mungkin tidak seperti yang
Anda harapkan dari versi cetak dari ekspresi.
Here is a function with four arguments.
Anda dapat menambahkan argumen menggunakan Append.
Ini membalikkan argumen.

Ada beberapa fungsi tambahan yang dapat digunakan dengan ekspresi, seperti yang dibahas dalam Bagian
2.2.10.
2.1.6 Ekspresi sebagai Pohon

Berikut adalah ekspresi dalam bentuk lengkap.
TreeForm mencetak ekspresi untuk menunjukkan struktur "pohon" mereka.
Anda dapat menganggap ekspresi Mathematica sebagai pohon. Dalam ekspresi di atas, simpul teratas di
pohon terdiri dari a
Plus. Dari simpul ini muncul dua “cabang”, x^3 dan (1 + x)^2. Dari simpul x^3, kemudian ada dua cabang,
x dan 3, yang dapat dilihat sebagai "daun" dari pohon. Matriks ini adalah pohon sederhana dengan hanya
dua tingkat.
Berikut adalah ekspresi yang lebih rumit.
Pohon untuk ekspresi ini memiliki beberapa tingkatan. Representasi pohon di sini terlalu panjang untuk
ditampung dalam satu baris, jadi itu harus dipecah menjadi dua baris.
Indeks yang melabeli setiap bagian dari sebuah ekspresi memiliki interpretasi sederhana dalam hal pohon.
Turun dari atas simpul pohon, setiap indeks menentukan cabang mana yang akan diambil untuk mencapai
bagian yang Anda inginkan.
2.1.7 Level dalam Ekspresi

Fungsi Bagian memungkinkan Anda untuk mengakses bagian tertentu dari ekspresi Mathematica. Tapi
terutama ketika Anda ekspresi memiliki struktur yang cukup seragam, seringkali lebih mudah untuk dapat
merujuk ke seluruh koleksi bagian di waktu yang sama.
Levels menyediakan cara umum untuk menentukan kumpulan bagian dalam ekspresi Mathematica. Banyak
Matematika fungsi memungkinkan Anda untuk menentukan level dalam ekspresi di mana mereka harus
bertindak.
Berikut adalah ekspresi sederhana, ditampilkan dalam bentuk pohon.
Ini mencari x dalam ekspresi t ke level 1. Ini hanya menemukan satu kejadian.
Ini mencari ke level 2. Sekarang ia menemukan kedua kemunculan x.

Anda dapat memikirkan level dalam ekspresi dalam bentuk pohon. Tingkat bagian tertentu dalam
ekspresi hanyalah jarak ke bawah pohon di mana bagian itu muncul, dengan bagian atas pohon dianggap
sebagai level 0.
Hal ini setara dengan mengatakan bahwa bagian-bagian yang muncul pada tingkat n adalah bagian-
bagian yang dapat ditentukan oleh urutan tepat indeks.
Berikut adalah ekspresi, ditampilkan dalam bentuk pohon.
Ini mencari a pada level dari 2 ke bawah.
Ini menunjukkan di mana f muncul selain di kepala ekspresi.
Ini termasuk kemunculan f di kepala ekspresi.

Ini memberikan daftar semua bagian u yang muncul hingga level 2.
Berikut adalah bagian-bagian khusus di level 2.
Ketika Anda sudah memahami level biasa, Anda dapat mencoba memikirkan level negatif. Bagian label level
negative ekspresi mulai dari bagian bawah pohon. Level -1 berisi semua daun pohon: objek seperti simbol
dan angka.
Ini menunjukkan bagian u pada level -1.
Anda dapat menganggap ekspresi memiliki "kedalaman", yang sama dengan jumlah maksimum level yang
ditunjukkan oleh Bentuk Pohon. Secara umum, level -n dalam suatu ekspresi didefinisikan terdiri dari semua
subekspresi yang kedalamannya n.
2. 2 Operasi Fungsional
2. 2. 1 Nama Fungsi sebagai Ekspresi
Dalam ekspresi seperti f[x], "nama fungsi" f itu sendiri adalah ekspresi, dan Anda dapat memperlakukannya
seperti yang Anda lakukan lainnya ekspresi.
Anda dapat mengganti nama fungsi menggunakan aturan transformasi.
Setiap tugas yang Anda buat akan digunakan pada nama fungsi.
Ini mendefinisikan fungsi yang mengambil nama fungsi sebagai argument
Ini memberikan Log sebagai nama fungsi yang akan digunakan.
Kemampuan untuk memperlakukan nama-nama fungsi seperti jenis ekspresi lainnya merupakan
konsekuensi penting dari sifat simbolis dari bahasa Mathematica. Itu memungkinkan seluruh jajaran operasi
fungsional yang dibahas dalam bagian-bagian yang mengikuti.
Fungsi Mathematica biasa seperti Log atau Integrasi biasanya beroperasi pada data seperti angka dan
aljabar ekspresi. Fungsi Mathematica yang mewakili operasi fungsional, bagaimanapun, dapat beroperasi
tidak hanya pada biasa data, tetapi juga pada fungsi itu sendiri. Jadi, misalnya, operasi fungsional Inverse
Function mengambil Nama fungsi Mathematica sebagai argumen, dan mewakili kebalikan dari fungsi
tersebut.
InverseFunction adalah operasi fungsional: dibutuhkan fungsi Mathematica sebagai argumen, dan
mengembalikan fungsi lain yang mewakili kebalikannya.
Hasil yang diperoleh dari InverseFunction adalah fungsi yang dapat Anda terapkan pada data.
Anda juga dapat menggunakan InverseFunction dengan cara yang murni simbolis.
Ada banyak jenis operasi fungsional di Mathematica. Beberapa mewakili operasi matematika; yang lain
mewakili berbagai macam prosedur dan algoritma.
Kecuali jika Anda terbiasa dengan bahasa simbolik tingkat lanjut, Anda mungkin tidak akan mengenali
sebagian besar fungsi operasi dibahas di bagian berikut. Pada awalnya, operasi mungkin tampak sulit untuk
dipahami. Tapi itu layak dipertahankan. Operasi fungsional menyediakan salah satu cara paling efisien secara
konseptual dan praktis untuk digunakan Matematika.
2.2.2 Menerapkan Fungsi Berulang Kali
Banyak program yang Anda tulis akan melibatkan operasi yang perlu diulang beberapa kali. Nest dan
NestList adalah konstruksi yang kuat untuk melakukan ini.
Nest[f, x, n] mengambil “nama” f dari suatu fungsi, dan menerapkan fungsi tersebut sebanyak n kali ke x.
Ini membuat daftar setiap bersarang berturut-turut
Berikut adalah fungsi sederhana.
Anda dapat berulang fungsi menggunakan Nest.
Nest dan NestList memungkinkan Anda menerapkan fungsi beberapa kali. Seringkali Anda mungkin ingin
menerapkan fungsi sampai hasilnya tidak berubah lagi. Anda dapat melakukan ini menggunakan FixedPoint
dan FixedPointList.
Berikut adalah fungsi yang mengambil satu langkah dalam pendekatan Newton ke
Berikut adalah lima iterasi fungsi yang berurutan, mulai dari x = 1.

Dengan menggunakan fungsi FixedPoint, Anda dapat secara otomatis terus menerapkan newton3 hingga
hasilnya tidak lagi berubah.
Berikut urutan hasilnya.
Berikut adalah fungsi yang membagi bilangan dengan 2.
Ini berulang kali menerapkan divide2 hingga hasilnya bukan lagi bilangan genap.
Ini berulang kali menerapkan newton3, berhenti ketika dua hasil berturut-turut tidak lagi dianggap tidak
sama, seperti di FixedPoint List.
Hal ini berlangsung sampai pertama kali hasil yang telah terlihat sebelumnya muncul kembali.
Operasi seperti Nest mengambil fungsi f dari satu argumen, dan menerapkannya berulang kali. Pada setiap
langkah, mereka menggunakan hasil dari langkah sebelumnya sebagai argumen baru dari f.
Penting untuk menggeneralisasi gagasan ini ke fungsi dua argumen. Anda dapat kembali menerapkan fungsi
tersebut berulang kali, tetapi sekarang setiap hasil Anda mendapatkan persediaan hanya salah satu argumen
baru yang Anda butuhkan. Pendekatan yang nyaman adalah mendapatkan yang lain argumen pada setiap
langkah dari elemen daftar yang berurutan.
Berikut adalah contoh dari apa yang dilakukan FoldList
Fold memberikan elemen terakhir dari daftar yang dihasilkan oleh FoldList.
Ini memberikan daftar jumlah kumulatif.
Menggunakan Fold dan FoldList Anda dapat menulis banyak program yang elegan dan efisien di
Mathematica. Dalam beberapa kasus, Anda mungkin terbantu untuk menganggap Fold dan FoldList sebagai
menghasilkan sarang sederhana dari keluarga fungsi yang diindeks oleh argumen kedua mereka.
Ini mendefinisikan fungsi nextdigit.
Ini sekarang seperti fungsi bawaan FromDigits.
Berikut adalah contoh fungsi dalam aksi.
2.2.3 Menerapkan Fungsi ke Daftar dan Ekspresi Lainnya

Dalam ekspresi seperti f[{a, b, c}] Anda memberikan daftar sebagai argumen untuk suatu fungsi. Seringkali
Anda perlu menerapkan fungsi langsung ke elemen daftar, bukan ke daftar secara keseluruhan. Anda dapat
melakukan ini di Mathematica menggunakan Terapkan.
Ini membuat setiap elemen daftar menjadi argumen dari fungsi f.
Ini memberikan Plus[a, b, c] yang menghasilkan jumlah elemen dalam daftar.
Berikut adalah definisi mean statistik, yang ditulis menggunakan Apply.
Apa yang Apply lakukan secara umum adalah mengganti kepala ekspresi dengan fungsi yang Anda tentukan.
Ini dia menggantikan plus dengan daftar.
2.2.4 Menerapkan Fungsi ke Bagian Ekspresi
Jika Anda memiliki daftar elemen, seringkali penting untuk dapat menerapkan fungsi secara terpisah ke
masing-masing elemen. Anda dapat melakukan ini di Mathematica menggunakan Peta.
Ini berlaku f secara terpisah untuk setiap elemen dalam daftar.
Ini mendefinisikan fungsi yang mengambil dua elemen pertama dari daftar.
Apa yang Map[f, expr] lakukan secara efektif adalah "membungkus" fungsi f di sekitar setiap elemen
ekspresi expr. Kamu bisa gunakan Peta pada ekspresi apa pun, bukan hanya daftar.
Ini berlaku untuk setiap elemen dalam jumlah.
Ini berlaku Sqrt untuk setiap argumen dari g.

Peta [f, expr] berlaku f ke tingkat pertama bagian di expr. Anda dapat menggunakan MapAll[f, expr] untuk
menerapkan f ke semua bagian dari ekspr.
Secara umum, Anda dapat menggunakan spesifikasi level seperti yang dijelaskan di Bagian 2.1.7 untuk
memberi tahu Map ke bagian ekspresi mana yang harus terapkan fungsi Anda.
Ini berlaku f hanya untuk bagian m di level 2.
Mengatur opsi Heads->True membungkus f di sekitar kepala setiap bagian, serta elemennya.
Spesifikasi level memungkinkan Anda memberi tahu Map ke level bagian mana dalam ekspresi yang Anda
inginkan untuk diterapkan fungsi. Dengan MapAt, bagaimanapun, Anda bisa memberikan daftar eksplisit
bagian di mana Anda ingin fungsi diterapkan. Anda menentukan masing-masing bagian dengan memberikan
indeksnya, seperti yang dibahas dalam Bagian 2.1.4.
Peta memungkinkan Anda untuk menerapkan fungsi dari satu argumen ke bagian ekspresi. Terkadang,
bagaimanapun, Anda mungkin sebagai gantinya ingin menerapkan fungsi beberapa argumen ke bagian yang
sesuai dari beberapa ekspresi berbeda. Kamu bisa melakukan ini menggunakan MapThread.
Fungsi seperti Peta memungkinkan Anda membuat ekspresi dengan bagian yang dimodifikasi. Terkadang
Anda hanya ingin melalui sebuah ekspresi, dan menerapkan fungsi tertentu ke beberapa bagian, tanpa
membangun ekspresi baru. Kasus yang khas adalah ketika fungsi yang Anda terapkan memiliki “efek
samping” tertentu, seperti membuat tugas, atau menghasilkan keluaran.
Peta membangun daftar baru di mana f telah diterapkan ke setiap elemen daftar.
Pemindaian mengevaluasi hasil penerapan fungsi ke setiap elemen, tetapi tidak membuat ekspresi baru.
2.2.5 Fungsi Murni
Saat Anda menggunakan operasi fungsional seperti Nest dan Map, Anda harus selalu menentukan fungsi
yang akan diterapkan. Dalam semua contoh di atas, kami telah menggunakan "nama" fungsi untuk
menentukan fungsi. Fungsi murni memungkinkan Anda memberi fungsi yang dapat diterapkan pada
argumen, tanpa harus mendefinisikan nama fungsi secara eksplisit.
Ini mendefinisikan fungsi h.
Setelah mendefinisikan h, Anda sekarang dapat menggunakan namanya di Map.
Berikut adalah cara untuk mendapatkan hasil yang sama menggunakan fungsi murni.
Ada beberapa cara yang setara untuk menulis fungsi murni di Mathematica. Idenya dalam semua kasus
adalah untuk membangun sebuah objek yang, ketika diberikan dengan argumen yang sesuai, menghitung
fungsi tertentu. Jadi, misalnya, jika kesenangan itu murni fungsi, kemudian fun[a] mengevaluasi fungsi
dengan argumen a.
Berikut adalah fungsi murni yang mewakili operasi kuadrat.
Memasok argumen n ke fungsi murni menghasilkan kuadrat dari n.
Anda dapat menggunakan fungsi murni di mana pun Anda biasanya memberi nama fungsi.
Jika Anda akan menggunakan fungsi tertentu berulang kali, maka Anda dapat mendefinisikan fungsi tersebut
menggunakan f[x_] := body, dan mengacu pada fungsi dengan namanya f. Di sisi lain, jika Anda hanya
berniat menggunakan fungsi sekali, Anda mungkin akan menemukan lebih baik memberikan fungsi dalam
bentuk fungsi murni, tanpa pernah menamainya.
Jika Anda terbiasa dengan logika formal atau bahasa pemrograman LISP, Anda akan mengenali fungsi murni
Mathematica sebagai ekspresi seperti l atau fungsi anonim. Fungsi murni juga dekat dengan gagasan
matematika murni dari operator.
Sama seperti nama suatu fungsi tidak relevan jika Anda tidak berniat untuk merujuk ke fungsi itu lagi,
demikian juga nama-nama dari argumen dalam fungsi murni tidak relevan. Mathematica memungkinkan
Anda untuk menghindari penggunaan nama eksplisit untuk argument fungsi murni, dan sebagai gantinya
untuk menentukan argumen dengan memberikan "nomor slot" #n. Dalam fungsi murni Mathematica, #n
adalah singkatan dari argumen ke-n yang Anda berikan. # singkatan dari argumen pertama.
#^2 & adalah bentuk singkat untuk fungsi murni yang mengkuadratkan argumennya.
Ini menerapkan fungsi yang mengambil dua elemen pertama dari setiap daftar. Dengan menggunakan fungsi
murni, Anda tidak perlu mendefinisikan berfungsi secara terpisah.
Saat Anda menggunakan formulir pendek untuk fungsi murni, sangat penting untuk tidak melupakan
ampersand. Jika Anda meninggalkan ampersand out, Mathematica tidak akan tahu bahwa ekspresi yang
Anda berikan akan digunakan sebagai fungsi murni.
Saat Anda menggunakan notasi ampersand untuk fungsi murni, Anda harus berhati-hati tentang
pengelompokan bagian di Anda memasukkan. Seperti yang ditunjukkan pada Bagian A.2.7, notasi
ampersand memiliki prioritas yang cukup rendah, yang berarti Anda dapat mengetik ekspresi seperti #1 +
#2 & tanpa tanda kurung. Di sisi lain, jika Anda ingin, misalnya, menyetel opsi menjadi a fungsi murni,
Anda perlu menggunakan tanda kurung, seperti pada opsi -> (menyenangkan &). Fungsi murni di
Mathematica dapat mengambil sejumlah argumen. Anda dapat menggunakan ## untuk mewakili semua
argumen yang diberikan, dan ##n untuk mewakili argumen ke-n dan selanjutnya. ## adalah singkatan dari
semua argumen.
2.2.6 Daftar Bangunan dari Fungsi
Ini membuat daftar 5 elemen, masing-masing berbentuk p[i].
Berikut adalah cara lain untuk menghasilkan daftar yang sama.
Ini menghasilkan daftar yang elemennya adalah i + i^2
Ini menghasilkan matriks 2x3 yang entrinya adalah m[i, j].
Ini menghasilkan matriks 3x3 yang elemen-elemennya adalah kuadrat dari jumlah indeksnya.
NestList dan FoldList telah dibahas di Bagian 2.2.2. Khususnya dengan menggunakannya dengan fungsi
murni, Anda bisa membangun beberapa program Mathematica yang sangat elegan dan efisien.
Ini memberikan daftar hasil yang diperoleh dengan mendiferensiasikan xn secara berurutan terhadap x.
2.2.7 Memilih Bagian Ekspresi dengan Fungsi

Bagian 1.2.4 menunjukkan bagaimana Anda dapat memilih elemen daftar berdasarkan posisinya. Namun,
seringkali Anda perlu pilih elemen tidak berdasarkan di mana mereka berada, melainkan pada apa mereka.
Select[list, f] memilih elemen daftar menggunakan fungsi f sebagai kriteria. Pilih berlaku f untuk setiap
elemen daftar di putar, dan simpan hanya yang hasilnya Benar.
Ini memilih elemen dari daftar yang fungsi murninya menghasilkan True, yaitu, yang secara numerik lebih
besar dari 4.
Anda dapat menggunakan Select untuk memilih bagian dari ekspresi apa pun, bukan hanya elemen daftar.
Ini memberikan jumlah istilah yang melibatkan x, y dan z.
Anda dapat menggunakan Select untuk memilih hanya istilah-istilah dalam jumlah yang tidak melibatkan
simbol x.
Bagian 2.3.5 membahas beberapa “predikat” yang sering digunakan sebagai kriteria dalam Select.
Ini memberikan elemen pertama yang memenuhi kriteria yang Anda tentukan.
2.2.8 Ekspresi dengan Kepala Yang Bukan Simbol
Dalam kebanyakan kasus, Anda ingin kepala f dari ekspresi Mathematica seperti f[x] menjadi simbol
tunggal. Namun, ada beberapa aplikasi penting dari kepala yang bukan simbol.
Ekspresi ini memiliki f[3] sebagai kepala. Anda dapat menggunakan kepala seperti ini untuk mewakili
"fungsi yang diindeks".
Anda dapat menggunakan ekspresi apa pun sebagai kepala. Ingatlah untuk memasukkan tanda kurung yang
diperlukan.
Satu kasus di mana kita telah menemukan penggunaan ekspresi rumit sebagai kepala dalam bekerja dengan
murni fungsi dalam Bagian 2.2.5. Dengan memberikan Function[vars, body] sebagai kepala ekspresi, Anda
menentukan fungsi dari argumen yang akan dievaluasi.
Dengan fungsi kepala[x, x^2], nilai ekspresi adalah kuadrat dari argumen.
Ada beberapa konstruksi di Mathematica yang bekerja seperti fungsi murni, tetapi yang mewakili jenis
tertentu fungsi, biasanya yang numerik. Dalam semua kasus, mekanisme dasar melibatkan pemberian kepala
yang berisi informasi lengkap tentang fungsi yang ingin Anda gunakan.
NDSove mengembalikan daftar aturan yang memberikan y sebagai objek InterpolatingFunction
Berikut adalah objek InterpolingFunction

Anda dapat menggunakan objek InterpolatingFunction sebagai kepala untuk mendapatkan aproksimasi
numerik untuk nilai fungsi y.
Penggunaan penting lainnya dari ekspresi yang lebih rumit sebagai kepala adalah dalam
mengimplementasikan fungsi dan operator fungsional dalam matematika.
Sebagai salah satu contoh, perhatikan operasi diferensiasi. Seperti yang akan dibahas dalam Bagian 3.5.4,
ekspresi seperti f'
mewakili fungsi turunan, diperoleh dari f dengan menerapkan operator fungsional padanya. Dalam
Mathematica, f' direpresentasikan sebagai Derivatif[1][f]: "operator fungsional" Derivatif[1] diterapkan ke f
untuk memberikan yang lain fungsi, direpresentasikan sebagai f'.
Ekspresi ini memiliki kepala yang mewakili penerapan "operator fungsional" Derivatif[1] ke "fungsi" f.
Anda dapat mengganti kepala f' dengan kepala lain, seperti fp. Ini secara efektif menjadikan fp sebagai
"fungsi turunan" yang diperoleh dari F.
2.2.9 Topik Lanjutan: Bekerja dengan Operator

Anda dapat memikirkan ekspresi seperti f[x] yang dibentuk dengan menerapkan operator f ke ekspresi x.
Anda bisa berpikir dari ekspresi seperti f[g[x]] sebagai hasil dari penyusunan operator f dan g, dan
menerapkan hasilnya ke x.
Ini mewakili komposisi fungsi f, g dan h.
Anda dapat memanipulasi komposisi fungsi secara simbolis.
Komposisi dievaluasi secara eksplisit saat Anda memberikan argumen tertentu.
Anda bisa mendapatkan jumlah dari dua ekspresi di Mathematica hanya dengan mengetik x + y. Terkadang
juga berharga untuk
pertimbangkan untuk melakukan operasi seperti penambahan pada operator Anda
dapat menganggap ini sebagai penjumlahan dari dua operator f dan g.
Menggunakan Through, Anda dapat mengonversi ekspresi ke bentuk yang lebih eksplisit.
This corresponds to the mathematical operator 1+ 𝛿
𝛿𝑥
Mathematica tidak secara otomatis menerapkan bagian terpisah dari operator ke ekspresi.
Anda dapat menggunakan Melalui untuk menerapkan operator.
Ini memiliki ekspresi yang rumit sebagai kepala
Fungsi seperti Perluas tidak secara otomatis masuk ke dalam kepala ekspresi.
Dengan opsi Heads disetel ke True, MapAll masuk ke dalam head.
Operator pengganti /. tidak masuk ke dalam kepala ekspresi.
Anda dapat menggunakan Operate untuk menerapkan fungsi secara khusus ke kepala ekspresi.
2.2.10 Operasi Struktural

Mathematica berisi beberapa primitif yang kuat untuk membuat perubahan struktural pada ekspresi. Anda
dapat menggunakan ini primitif baik untuk menerapkan sifat matematika seperti asosiatif dan distributivitas,
dan untuk memberikan dasar untuk beberapa program yang ringkas dan efisien.
Bagian ini menjelaskan berbagai operasi yang dapat Anda lakukan secara eksplisit pada ekspresi. Bagian
2.6.3 akan menjelaskan bagaimana beberapa operasi ini dapat dilakukan secara otomatis pada semua ekspresi
dengan kepala tertentu dengan menetapkan
atribut yang sesuai untuk kepala itu.
Anda dapat menggunakan fungsi Mathematica Sort[expr] untuk mengurutkan elemen tidak hanya dari daftar,
tetapi juga ekspresi dengan sembarang kepala. Dengan cara ini, Anda dapat menerapkan sifat matematika
komutatif atau simetri untuk fungsi arbitrer.
Anda dapat menggunakan Sortir untuk menempatkan argumen fungsi apa pun ke dalam urutan standar
Argumen kedua untuk Sort adalah fungsi yang digunakan untuk menentukan apakah pasangan berurutan. Ini
mengurutkan angka ke dalam urutan menurun.
Kriteria pengurutan ini menempatkan elemen yang tidak bergantung pada x sebelum elemen yang
bergantung pada x.
Flatten menghapus kemunculan bersarang dari suatu fungsi.
Anda dapat menggunakan Flatten untuk "menyambung" urutan elemen ke dalam daftar atau ekspresi lainnya.
Anda dapat menggunakan Flatten untuk mengimplementasikan properti matematika dari associativity.
Fungsi Distribusi memungkinkan
Anda untuk mengimplementasikan properti seperti distributivity dan linearity.
Ini "mendistribusikan" f lebih dari a + b.
Berikut adalah contoh yang lebih rumit.
Secara umum, jika f distributif terhadap Plus, maka ekspresi seperti f[a + b] dapat “diperluas” menjadi f[a] +
f[b].
Fungsi Expand melakukan ekspansi semacam ini untuk operator aljabar standar seperti Times.
Mendistribusikan memungkinkan Anda melakukan jenis ekspansi yang sama untuk operator arbitrer.
Perluas menggunakan distribusi Times over Plus untuk melakukan ekspansi aljabar.
Ini menerapkan distribusi atas daftar, bukan jumlah. Hasilnya berisi semua kemungkinan pasangan argumen.
Ini mendistribusikan lebih dari daftar, tetapi melakukannya hanya jika kepala dari seluruh ekspresi adalah f
Ini mendistribusikan daftar, memastikan bahwa kepala seluruh ekspresi adalah f. Hasilnya, ia
menggunakan gp sebagai pengganti Daftar, dan fp menggantikan f
Terkait dengan Distribute adalah fungsi Thread. Apa yang dilakukan Thread secara efektif adalah
menerapkan fungsi secara paralel ke semua elemen dari daftar atau ekspresi lainnya.
Berikut adalah fungsi yang argumennya adalah daftar.
Utas menerapkan fungsi "secara paralel" ke setiap elemen daftar.
Argumen yang bukan daftar diulang.
Seperti disebutkan dalam Bagian 1.8.1, dan dibahas secara lebih rinci di Bagian 2.6.3, banyak fungsi
Mathematica bawaan memiliki properti sebagai "dapat dicantumkan", sehingga mereka secara otomatis
ditempatkan di atas daftar apa pun yang muncul sebagai argumen.
Fungsi matematis bawaan seperti Log dapat dicantumkan, sehingga secara otomatis dimasukkan ke dalam
daftar.
Log, bagaimanapun, tidak secara otomatis melewati persamaan.
Anda dapat menggunakan Utas untuk menerapkan fungsi ke kedua sisi persamaan.
Outer[f, list1, list2 ] mengambil semua kemungkinan kombinasi elemen dari list1 dan list2 , dan
menggabungkannya dengan f.
Luar dapat dilihat sebagai generalisasi dari produk Cartesian untuk tensor, seperti yang dibahas dalam Bagian
3.7.11.
Bentuk luar semua kemungkinan kombinasi elemen, dan berlaku f untuk mereka.
Di sini Outer menghasilkan matriks Boolean segitiga bawah.
Anda dapat menggunakan Outer pada urutan ekspresi apa pun dengan kepala yang sama.
Outer, like Distribute, constructs all possible combinations of elements. On the other hand, Inner, like Thread,
constructs only combinations of elements that have corresponding positions in the expressions it acts on.
Berikut adalah struktur yang dibangun oleh Inner.
Inner adalah generalisasi dari Dot.

2.2.11 Urutan
Fungsi Flatten memungkinkan Anda untuk meratakan semua sublist secara eksplisit.
FlattenAt memungkinkan Anda menentukan pada posisi apa Anda ingin sublist diratakan.
Objek urutan secara otomatis disambungkan, dan tidak memerlukan perataan eksplisit.
urutan argumen yang akan secara otomatis disambungkan ke fungsi

apa pun Urutan berfungsi dalam fungsi apa pun.
Ini termasuk fungsi dengan formulir input khusus.
Berikut adalah cara umum yang digunakan Sequence.
2.3 Pola
2.3.1 Pendahuluan
Pola digunakan di seluruh Mathematica untuk mewakili kelas ekspresi. Contoh sederhana dari sebuah pola
adalah ekspresi f[x_]. Pola ini mewakili kelas ekspresi dengan bentuk f[anything]. Kekuatan utama dari pola
berasal dari fakta bahwa banyak operasi di Mathematica dapat dilakukan tidak hanya dengan satu ekspresi,
tetapi juga dengan pola yang mewakili seluruh kelas ekspresi. Anda dapat menggunakan pola dalam aturan
transformasi untuk menentukan bagaimana kelas ekspresi harus diubah.
Anda dapat menggunakan pola untuk menemukan posisi semua ekspresi di kelas tertentu
Objek dasar yang muncul di hampir semua pola Mathematica adalah _ (secara tradisional disebut "kosong"
oleh Mathematica programmer). Aturan dasarnya adalah bahwa _ adalah singkatan dari ekspresi apa pun.
Pada sebagian besar keyboard, _ garis bawah karakter muncul sebagai versi yang digeser dari - karakter
tanda hubung. Jadi, misalnya, pola f[_] mewakili ekspresi apa pun dari bentuk f[anything]. Pola f[x_] juga
singkatan dari ekspresi apa pun dalam bentuk f[anything], tetapi memberi nama x ke ekspresi apa pun,
memungkinkan Anda untuklihat di sisi kanan aturan transformasi. Anda dapat mengosongkan di mana saja
dalam ekspresi. Apa yang Anda dapatkan adalah pola yang cocok dengan semua ekspresi yang bisa dibuat
dengan "mengisi bagian yang kosong" dengan cara apa pun.
Anda dapat membuat pola untuk ekspresi dengan struktur apa pun
Salah satu penggunaan pola yang paling umum adalah untuk argumen fungsi "menghancurkan". Jika Anda
membuat definisi untuk f[list_], maka Anda perlu menggunakan fungsi seperti Bagian secara eksplisit untuk
memilih elemen daftar. Tapi jika kamu tahu misalnya bahwa daftar akan selalu memiliki dua elemen, maka
biasanya jauh lebih mudah daripada memberikan sebuah definisi sebagai gantinya untuk f[{x_, y_}].
Kemudian Anda dapat merujuk ke elemen daftar secara langsung sebagai x dan y. Tambahan, Mathematica
tidak akan menggunakan definisi yang Anda berikan kecuali argumen f benar-benar berbentuk daftar yang
diperlukan dari dua ekspresi.
Berikut adalah salah satu cara untuk mendefinisikan fungsi yang mengambil daftar dua elemen, dan
mengevaluasi elemen pertama yang dipangkatkan elemen kedua
Berikut adalah cara yang jauh lebih elegan untuk membuat definisi, menggunakan pola.
Poin penting untuk dipahami adalah bahwa pola Mathematica mewakili kelas ekspresi dengan struktur
tertentu. Satu pola akan cocok dengan ekspresi tertentu jika struktur polanya sama dengan struktur ekspresi,
di arti bahwa dengan mengisi kekosongan dalam pola Anda bisa mendapatkan ekspresi. Meskipun dua
ekspresi mungkin sama secara matematis, mereka tidak dapat diwakili oleh pola Mathematica yang sama
kecuali mereka memiliki struktur yang sama.
Jadi, misalnya, pola (1 + x_)^2 dapat mewakili ekspresi seperti (1 + a)^2 atau (1 + b^3)^2 yang memiliki
struktur yang sama. Namun, itu tidak dapat digunakan untuk ekspresi 1 + 2 a + a^2. Meskipun ekspresi ini
secara matematis sama dengan (1 + a)^2, tidak memiliki struktur yang sama dengan pola (1 + x_)^2. Fakta
bahwa pola di Mathematica menentukan struktur ekspresi sangat penting dalam memungkinkan untuk
mengatur aturan transformasi yang mengubah struktur ekspresi, sementara membiarkannya secara matematis
sama. Perlu disadari bahwa secara umum sangat tidak mungkin bagi Mathematica untuk mencocokkan pola
dengan matematika, daripada struktural, kesetaraan. Dalam kasus ekspresi seperti (1 + a)^2 dan 1 + 2 a +
a^2, Anda dapat menentukan kesetaraan hanya dengan menggunakan fungsi seperti Expand dan Factor. Tapi,
seperti yang dibahas dalam Bagian 2.6.2 tidak ada yang umum cara untuk mengetahui apakah pasangan
arbitrer ekspresi matematika adalah sama. Sebagai contoh lain, pola x^_ akan cocok dengan ekspresi x^2.
Namun, itu tidak akan cocok dengan ekspresi 1, bahkan meskipun ini dapat dianggap sebagai x^0. Bagian
2.3.9 akan membahas bagaimana membangun pola yang khusus ini
kasus akan cocok. Tetapi Anda harus memahami bahwa dalam semua kasus, pencocokan pola di
Mathematica pada dasarnya bersifat struktural.
x^n_ hanya cocok dengan x^2 dan x^3. 1 dan x secara matematis dapat ditulis sebagai xn , tetapi tidak
memiliki struktur yang sama.
Hal lain yang perlu disadari adalah bahwa struktur yang digunakan Mathematica dalam pencocokan pola
adalah bentuk penuh dari ekspresi dicetak oleh FullForm. Jadi, misalnya, objek seperti 1/x, yang bentuk
lengkapnya adalah Power[x, -1] akan dicocokkan dengan pola x_^n_, tetapi tidak dengan pola x_/y_, yang
bentuk lengkapnya adalah Kali[x_, Daya[y_, -1]]. Lagi, Bagian 2.3.9 akan membahas bagaimana Anda dapat
membangun pola yang dapat cocok dengan semua kasus ini.
Ekspresi dalam daftar berisi kekuatan eksplisit b, sehingga aturan transformasi dapat diterapkan.
Berikut adalah bentuk lengkap dari daftar.
Meskipun Mathematica tidak menggunakan kesetaraan matematis seperti x1 = x saat mencocokkan pola, ia
menggunakan kesetaraan struktural tertentu. Jadi, misalnya, Mathematica memperhitungkan sifat-sifat
seperti komutatif dan asosiatif dalam pencocokan pola.
Untuk menerapkan aturan transformasi ini, Mathematica menggunakan komutatifitas dan asosiatifitas
penjumlahan.
Diskusi sejauh ini hanya mempertimbangkan objek pola seperti x_ yang dapat mewakili ekspresi tunggal apa
pun. Nanti subbagian, kami membahas konstruksi yang digunakan Mathematica untuk memperluas dan
membatasi kelas ekspresi yang diwakili oleh pola.
2.3.2 Menemukan Ekspresi yang Cocok dengan Pola
Ini memberikan elemen daftar yang cocok dengan pola x^_.
Berikut adalah jumlah total elemen yang cocok dengan pola.

Anda dapat menerapkan fungsi seperti Kasus tidak hanya ke daftar, tetapi ke ekspresi apa pun. Selain itu,
Anda dapat menentukan tingkat bagian di mana Anda ingin melihat.
Ini mengembalikan daftar eksponen n.
Pola _Integer cocok dengan bilangan bulat apa pun. Ini memberikan daftar bilangan bulat yang muncul di
level mana pun.
temukan hanya n bagian pertama yang cocok dengan bentuk

berikan posisi n bagian pertama yang cocok dengan bentuk
Ini memberikan posisi dua pangkat pertama dari x yang muncul di tingkat mana pun.
Posisi ditentukan dengan tepat dalam bentuk yang digunakan oleh fungsi seperti Extract dan ReplacePart
yang dibahas di Bagian 1.8.
hapus elemen expr yang cocok dengan formular

hapus bagian dari expr yang cocok dengan formulir pada level yang
ditentukan oleh lev Ini
menghapus elemen yang cocok dengan x^n_.
Ini menghapus semua bilangan bulat yang muncul di level mana pun.
temukan semua cara agar expr bisa cocok dengan lhs
Ini menemukan semua cara agar jumlah dapat ditulis dalam dua bagian.
Ini menemukan semua pasangan elemen identik. Pola ___ singkatan dari setiap urutan elemen.
2.3.3 Penamaan Potongan Pola

Khususnya ketika Anda menggunakan aturan transformasi, Anda sering perlu memberi nama potongan pola.
Sebuah objek seperti x_ singkatan dari ekspresi apapun, tetapi memberikan ekspresi nama x. Anda kemudian
dapat, misalnya, menggunakan nama ini di sisi kanan aturan transformasi.
Poin penting adalah ketika Anda menggunakan x_, Mathematica mengharuskan semua kemunculan kosong
dengan nama yang sama x dalam ekspresi tertentu harus mewakili ekspresi yang sama.
Jadi f[x_, x_] hanya dapat digunakan untuk ekspresi di mana dua argumen dari f persis sama. f[_, _], pada
sisi lain, dapat mewakili ekspresi apa pun dalam bentuk f[x, y], di mana x dan y tidak harus sama.
Aturan transformasi hanya berlaku untuk kasus di mana dua argumen dari f adalah identic
Mathematica allows you to give names not just to single blanks, but to any piece of a pattern. The object
x:pattern in general represents a pattern which is assigned the name x. In transformation rules, you can use
this mechanism to name exactly those pieces of a pattern that you need to refer to on the right-hand side of
the rule.
Ini memberi nama untuk bentuk lengkap _^_ sehingga Anda dapat merujuknya secara keseluruhan di sisi
kanan aturan transformasi.
Di sini eksponen diberi nama n, sedangkan keseluruhan objek adalah x.
Saat Anda memberi nama yang sama pada dua bagian pola, Anda membatasi pola agar hanya cocok dengan
ekspresi di yang bagian-bagian yang bersesuaian adalah identik.
Di sini polanya cocok dengan kedua kasus.
Sekarang kedua argumen f dibatasi menjadi sama, dan hanya kasus pertama yang cocok
2.3.4 Menentukan Jenis Ekspresi dalam Pola

Anda dapat mengetahui banyak tentang "jenis" ekspresi apa itu dengan melihat kepalanya. Jadi, misalnya,
bilangan bulat memiliki kepala Integer, sedangkan daftar memiliki Daftar kepala.
Dalam sebuah pola, _h dan x_h mewakili ekspresi yang dibatasi untuk memiliki kepala h. Jadi, misalnya,
_Integer mewakili bilangan bulat apa pun, sementara _List mewakili daftar apa pun.
Ini hanya menggantikan elemen-elemen yang merupakan bilangan bulat.

Anda dapat menganggap membuat penugasan untuk f[x_Integer] seperti mendefinisikan fungsi f yang harus
mengambil argument dari "tipe" Integer.
Ini mendefinisikan nilai untuk fungsi gamma ketika argumennya adalah bilangan bulat.
Definisi ini hanya berlaku jika argumen gamma adalah bilangan bulat.
Objek 4. memiliki kepala Real, sehingga definisi tersebut tidak berlaku.
Ini mendefinisikan nilai untuk ekspresi dengan eksponen integer.
Definisi hanya digunakan jika eksponennya adalah bilangan bulat.
2.3.5 Menempatkan Batasan pada Pola

Mathematica menyediakan mekanisme umum untuk menentukan batasan pada pola. Yang perlu Anda
lakukan hanyalah meletakkan /; kondisi di akhir pola untuk menandakan bahwa itu hanya berlaku jika
kondisi yang ditentukan adalah Benar. Anda dapat membaca operator /; sebagai "slash-semi", "kapan pun"
atau "asalkan itu".
Ini memberikan definisi untuk fac yang hanya berlaku jika argumennya n positif.
Definisi untuk fac hanya digunakan jika argumennya positif.

Ini memberikan elemen negatif dalam daftar.
Anda dapat gunakan /; pada seluruh definisi dan aturan transformasi, serta pada pola individu. Secara umum,
Anda bisa taruh /; kondisi di akhir setiap := definisi atau :> aturan untuk memberi tahu Mathematica bahwa
definisi atau aturan hanya berlaku ketika kondisi yang ditentukan berlaku. Perhatikan bahwa /; kondisi
biasanya tidak boleh diletakkan di akhir = definisi atau -> aturan, karena mereka akan segera dievaluasi,
seperti yang dibahas dalam Bagian 2.5.8.
Berikut adalah cara lain untuk memberikan definisi yang hanya berlaku jika argumennya n positif.
Sekali lagi, fungsi faktorial hanya mengevaluasi jika argumennya positif
Anda dapat menggunakan /; operator untuk menerapkan kendala matematika sewenang-wenang pada
penerapan aturan. Secara tipikal kasus, Anda memberikan pola yang secara struktural cocok dengan berbagai
ekspresi, tetapi kemudian menggunakan batasan matematika untuk mengurangi rentang ekspresi ke set yang
jauh lebih kecil.
Aturan ini hanya berlaku untuk ekspresi yang memiliki struktur v[x_, 1 - x_].
Ekspresi ini memiliki struktur yang sesuai, jadi aturannya berlaku.
Ekspresi ini, meskipun secara matematis dari bentuk yang benar, tidak memiliki struktur yang sesuai,
sehingga aturannya tidak berlaku.
Aturan ini berlaku untuk ekspresi apa pun dalam bentuk w[x_, y_], dengan batasan tambahan bahwa y == 1
- x.
Aturan baru berlaku untuk ekspresi ini.
Dalam mengatur pola dan aturan transformasi, seringkali ada pilihan di mana harus meletakkan /; kondisi.
Misalnya, Anda dapat menempatkan /; kondisi di sisi kanan aturan dalam bentuk lhs :> rhs /; kondisi, atau
Anda dapat meletakkannya di sisi kiri dalam bentuk lhs /; kondisi -> rs. Anda mungkin juga dapat
memasukkan kondisi di dalam ekspresi lhs. Satu-satunya kendala adalah bahwa semua nama pola yang Anda
gunakan dalam kondisi tertentu harus muncul dalam pola yang syaratnya dilampirkan. Jika ini tidak terjadi,
maka beberapa nama yang diperlukan untuk mengevaluasi kondisi mungkin belum "terikat" dalam proses
pencocokan pola. Jika ini terjadi, maka Mathematica menggunakan nilai global untuk variabel yang sesuai,
bukan nilai yang ditentukan oleh pencocokan pola
Jadi, misalnya, kondisi di f[x_, y_] /; (x + y < 2) akan menggunakan nilai untuk x dan y yang ditemukan
dengan mencocokkan f[x_, y_], tetapi kondisi dalam f[x_ /; x + y < 2, y_] akan menggunakan nilai global
untuk y, bukan yang ditemukan dengan mencocokkan pola.
Selama Anda memastikan bahwa nama yang sesuai telah ditentukan, biasanya paling efisien untuk
meletakkan /; kondisi pada bagian terkecil dari pola. Alasan untuk ini adalah Mathematica mencocokkan
potongan pola secara berurutan, dan semakin cepat ia menemukan /; kondisi yang gagal, semakin cepat dapat
menolak pertandingan.
Menempatkan /; kondisi di sekitar x_ sedikit lebih efisien daripada meletakkannya di sekitar seluruh pola.
Anda harus meletakkan tanda kurung di sekitar /; bagian dalam kasus seperti ini.
Adalah umum untuk menggunakan /; untuk mengatur pola dan aturan transformasi yang hanya berlaku untuk
ekspresi dengan properti tertentu. Ada kumpulan fungsi yang dibangun ke dalam Mathematica untuk
menguji properti ekspresi. Ini adalah konvensi bahwa fungsi semacam ini memiliki nama yang diakhiri
dengan huruf Q, yang menunjukkan bahwa mereka "mengajukan pertanyaan".
Aturan ini berlaku untuk semua elemen daftar yang berupa angka.
Definisi ini hanya berlaku untuk vektor bilangan bulat.
Definisi sekarang hanya digunakan dalam kasus pertama
Sebuah fitur penting dari semua fungsi pengujian properti Mathematica yang namanya berakhiran Q adalah
bahwa mereka selalu kembali
Salah jika mereka tidak dapat menentukan apakah ekspresi yang Anda berikan memiliki properti tertentu.
4561 adalah bilangan bulat, jadi ini mengembalikan True.
Ini mengembalikan False, karena x tidak diketahui sebagai bilangan bulat.
Dalam beberapa kasus, Anda dapat secara eksplisit menentukan hasil yang harus diberikan oleh fungsi
pengujian properti. Jadi, dengan definisi seperti x /: IntegerQ[x] = Benar, seperti yang dibahas dalam Bagian
2.5.10, Mathematica akan mengasumsikan bahwa x adalah bilangan bulat.
Ini berarti bahwa jika Anda secara eksplisit meminta IntegerQ[x], Anda sekarang akan mendapatkan True,
bukan False. Namun, Mathematica tidak secara otomatis menyebarkan pernyataan, sehingga tidak dapat
menentukan misalnya bahwa IntegerQ[x^2] adalah Benar. Anda harus memuat paket Mathematica yang
sesuai untuk memungkinkan hal ini.
Dengan ==, persamaan tetap dalam bentuk simbolis; === menghasilkan False kecuali ekspresi secara nyata
sama
Ekspresi n bukan anggota daftar {x, x^n}
Namun, {x, x^n} tidak sepenuhnya bebas dari n.
Anda dapat menggunakan FreeQ untuk mendefinisikan aturan "linearitas" untuk h.
Istilah bebas dari x ditarik keluar dari setiap h
Pola konstruksi /; kondisi memungkinkan Anda untuk mengevaluasi kondisi yang melibatkan nama pola
untuk menentukan apakah ada kecocokan. Pola konstruksi? tes sebagai gantinya menerapkan tes fungsi ke
seluruh ekspresi dicocokkan dengan pola untuk menentukan apakah ada kecocokan. Menggunakan ? dari
pada /; terkadang mengarah ke lebih ringkas definisi.
Dengan definisi ini kecocokan untuk x_ diuji dengan fungsi NumberQ.
Definisi ini hanya berlaku jika p memiliki argumen numerik.
Berikut adalah definisi yang lebih rumit. Jangan lupa tanda kurung di sekitar fungsi murni.
Definisi tersebut hanya berlaku dalam kasus-kasus tertentu.
2.3.6 Pola yang Melibatkan Alternatif
Ini mendefinisikan h untuk memberikan p ketika argumennya adalah a atau b.
Dua kasus pertama memberikan p.
Anda juga dapat menggunakan alternatif dalam aturan transformasi
Berikut adalah contoh lain, di mana salah satu alternatif itu sendiri adalah sebuah pola.
Saat Anda menggunakan alternatif dalam pola, Anda harus memastikan bahwa rangkaian nama yang sama
muncul di setiap alternatif.
Ketika pola seperti (a[x_] | b[x_]) cocok dengan ekspresi, akan selalu ada ekspresi pasti yang sesuai dengan
objek x. Di sisi lain, jika Anda mencoba mencocokkan pola seperti (a[x_] | b[y_]), maka akan ada ekspresi
pasti yang sesuai dengan x, atau y, tetapi tidak keduanya. Akibatnya, Anda tidak dapat menggunakan x dan
y untuk merujuk ke ekspresi yang pasti, misalnya di sisi kanan aturan transformasi.
Di sini f digunakan untuk memberi nama kepala, yang dapat berupa a atau b.
2.3.7 Fungsi Datar dan Tanpa Urutan

Meskipun Mathematica mencocokkan pola dengan cara yang murni struktural, gagasannya tentang
kesetaraan struktural cukup rumit. Secara khusus, ini memperhitungkan sifat-sifat seperti komutatifitas dan
asosiatifitas dalam fungsi seperti Ditambah dan Waktu. Ini berarti, misalnya, Mathematica menganggap
ekspresi x + y dan y + x setara untuk tujuan pencocokan pola. Akibatnya, pola seperti g[x_ + y_, x_] tidak
hanya cocok dengan g[a + b, a], tetapi juga g[a + b, B].
Ekspresi ini memiliki bentuk yang persis sama dengan polanya.
Dalam hal ini, ekspresi harus dimasukkan ke dalam bentuk g[b + a, b] agar memiliki struktur yang sama
dengan polanya.
Kapanpun Mathematica menemukan fungsi tak beraturan atau komutatif seperti Plus atau Times dalam suatu
pola, itu secara efektif menguji semua kemungkinan urutan argumen untuk mencoba dan menemukan
kecocokan. Terkadang, mungkin ada beberapa pemesanan yang mengarah ke pertandingan. Dalam kasus
seperti itu, Mathematica hanya menggunakan urutan pertama yang ditemukannya. Misalnya, h[x_ + y_, x_
+ z_] dapat mencocokkan h[a + b, a + b] dengan xØa, yØb, zØb atau dengan xØb, yØa, zØa. Mathematica
mencoba kasusnya xØa, yØb, zØb terlebih dahulu, dan dengan demikian menggunakan kecocokan ini. Ini
bisa cocok dengan x a atau dengan x b. Mathematica mencoba x a terlebih dahulu, dan menggunakan
kecocokan ini.
ReplaceList menunjukkan kedua kemungkinan kecocokan

Seperti yang dibahas di Bagian 2.6.3, Mathematica memungkinkan Anda untuk menetapkan atribut tertentu
ke fungsi, yang menentukan caranya fungsi-fungsi tersebut harus diperlakukan dalam evaluasi dan
pencocokan pola. Fungsi misalnya dapat diberikan atribut Orderless, yang menentukan bahwa mereka harus
diperlakukan sebagai komutatif atau simetris, dan memungkinkan mereka argumen untuk diatur ulang dalam
mencoba mencocokkan pola.
Plus memiliki atribut Orderless dan Flat, serta lainnya.
Ini mendefinisikan q sebagai fungsi tak beraturan atau komutatif.
Argumen q secara otomatis diurutkan.
Mathematica mengatur ulang argumen fungsi q untuk menemukan kecocokan.
Selain tidak beraturan, fungsi seperti Plus dan Times juga memiliki sifat datar atau asosiatif. Ini berarti
Anda dapat secara efektif "mengkurung" argumen mereka dengan cara apa pun, sehingga, misalnya, x + (y
+ z) adalah ekuivalen dengan x + y + z, dan seterusnya.
Mathematica memperhitungkan kerataan dalam pola yang cocok. Akibatnya, pola seperti g[x_ + y_] dapat
cocok dengan g[a + b + c], dengan x a dan y (b + c).
Argumen dari g ditulis sebagai a + (b + c) agar sesuai dengan polanya.
Jika tidak ada kendala lain, Mathematica akan mencocokkan x_ dengan elemen pertama dari penjumlahan
Ini menunjukkan semua kemungkinan pertandingan
Di sini x_ dipaksa untuk mencocokkan b + d
Mathematica biasanya dapat menerapkan aturan transformasi ke suatu fungsi hanya jika pola dalam aturan
tersebut mencakup semua argumen dalam fungsi tersebut. Namun, jika Anda memiliki fungsi datar,
terkadang dimungkinkan untuk menerapkan aturan transformasi genap meskipun tidak semua argumen
tercakup.
Aturan ini berlaku meskipun tidak mencakup semua persyaratan dalam penjumlahan.
Ini menggabungkan dua istilah dalam jumlah.
2.3.8 Fungsi dengan Jumlah Variabel Argumen

Kecuali f adalah fungsi datar, pola seperti f[x_, y_] hanya mewakili instance fungsi dengan tepat dua
argumen. Terkadang Anda perlu menyiapkan pola yang memungkinkan sejumlah argumen. Anda dapat
melakukan ini menggunakan beberapa kosong. Sementara satu kosong seperti x_ singkatan dari ekspresi
Mathematica tunggal, a kosong ganda seperti x__ singkatan dari urutan satu atau lebih ekspresi.
"Kosong ganda" __ singkatan dari urutan satu atau lebih ekspresi. "Tiga kosong" ___ singkatan dari urutan
nol atau lebih ekspresi. Anda harus sangat berhati-hati setiap kali Anda menggunakan pola triple blank.
Sangat mudah untuk membuat kesalahan yang dapat menyebabkan loop tak terbatas. Misalnya, jika Anda
mendefinisikan p[x_, y___] := p[x] q[y], lalu ketik p[a] akan mengarah ke loop tak terbatas, dengan y
berulang kali mencocokkan urutan dengan elemen nol. Kecuali Anda yakin Anda ingin memasukkan kasus
elemen nol, Anda harus selalu menggunakan double blank daripada triple bl
2.3.9 Argumen Opsional dan Default

Terkadang Anda mungkin ingin mengatur fungsi di mana argumen tertentu, jika dihilangkan, diberi "nilai
default". NS pola x_:v adalah singkatan dari objek yang dapat dihilangkan, dan jika demikian, akan diganti
dengan nilai default v.
Ini mendefinisikan fungsi j dengan argumen yang diperlukan x, dan argumen opsional y dan z, masingmasing
dengan nilai default 1 dan 2
Di sini a cocok dengan pola x_ + y_. dengan y diambil untuk memiliki nilai default 0.
Karena Plus adalah fungsi datar, pola seperti x_ + y_ dapat mencocokkan jumlah dengan sejumlah suku apa
pun. pola ini tidak dapat, bagaimanapun, cocok dengan satu istilah seperti a. Namun, pola x_ + y_. berisi
bagian opsional, dan dapat cocok dengan jumlah eksplisit istilah di mana x_ dan y_ muncul, atau satu istilah
x_, dengan y diambil sebagai 0.
Menggunakan konstruksi seperti x_., Anda dapat dengan mudah membuat pola tunggal yang cocok dengan
ekspresi dengan beberapa yang berbeda struktur. Ini sangat berguna ketika Anda ingin mencocokkan
beberapa bentuk yang sama secara matematis yang tidak memiliki struktur yang sama.
Polanya cocok dengan g[a^2], tetapi tidak cocok dengan g[a + b].
Dalam hal ini, b-> 1.
2.3.10 Menyiapkan Fungsi dengan Argumen Opsional

Metode pertama adalah memiliki arti dari setiap argumen yang ditentukan oleh posisinya, dan kemudian
membiarkannya jatuh argumen, menggantinya dengan nilai default. Hampir semua fungsi Mathematica
bawaan yang menggunakan metode ini drop argumen dari akhir. Misalnya, fungsi bawaan Flatten [list, n]
memungkinkan Anda untuk menghapus argumen kedua, yang dianggap memiliki nilai default Infinity.
2.3.11 Pola Berulang
2.3.12 Pola Verbatim

2.3.13 Pola untuk Beberapa Jenis Ekspresi Umum
2.3.14 Contoh: Mendefinisikan Fungsi Integrasi Anda Sendiri

2.4 Memanipulasi Daftar
2. 4. 1 Membangun Daftar
2. 4. 2 Memanipulasi Daftar berdasarkan Indeksnya
2. 4. 3 Daftar Bersarang
2.4.4 Daftar Partisi dan Padding
Partisi ini dalam blok 3.

In[1]:= Partisi[{a, b, c, d, e, f}, 3]
Out[1]= { {a,b,c} , {d,e,f} }
Partisi ini dalam blok 3 dengan offset 1.

In[2]:= Partition[{a, b, c, d, e, f}, 3, 1]
Out[2]= { {a,b,d} , {b,c,d} , {c,d,e} }
Offset bisa lebih besar dari ukuran blok.
Ini terbagi menjadi elemen-elemen yang identik.
berlaku melalui daftar, pengelompokan elemen

berturut-turut ke dalam sublists. Secara default tidak
termasuk sublist apa pun yang akan "menggantung" daftar aslinya.
Ini berhenti sebelum terjadi overhang.
untuk menyertakan subdaftar yang menggantung di ujung daftar asli. Secara default, itu mengisi
tambahan elemen dengan memperlakukan daftar asli sebagai siklik. Itu juga dapat memperlakukannya
sebagai diisi dengan elemen yang Anda tentukan.
Ini termasuk sublist tambahan, memperlakukan daftar asli sebagai siklik.
Anda dapat menganggap Partisi sebagai mengekstrak subdaftar dengan menggeser template, dan
memilih elemen dari daftar asli. Anda dapat memberi tahu Partisi tempat memulai dan menghentikan proses
ini.
Ini memberikan semua subdaftar yang tumpang tindih dengan daftar asli.
Dalam beberapa kasus, mungkin lebih mudah untuk memasukkan padding eksplisit ke dalam daftar.
Anda dapat melakukan ini menggunakan PadLeft dan Padg Benar.
2.4.5 Sparse Arrays

Daftar biasanya ditentukan dalam Mathematica hanya dengan memberikan daftar eksplisit dari elemen
mereka. Tapi terutama dalam bekerja dengan array besar, seringkali berguna untuk dapat mengatakan apa
nilai elemen hanya pada posisi tertentu, dengan semua elemen lain diambil untuk memiliki nilai default,
biasanya nol. Anda dapat melakukan ini di Mathematica menggunakan SparseArg objek sinar.
Ini menentukan array yang jarang.

Ini menghasilkan versi daftar yang jarang.
Anda dapat menganggap SparseArray[rules] sebagai mengambil semua spesifikasi posisi yang
mungkin, lalu menerapkan aturan untuk menentukan nilai tambang dalam setiap kasus. Seperti biasa, aturan
yang diberikan sebelumnya dalam daftar akan dicoba terlebih dahulu.
Ini menghasilkan matriks diagonal acak.
Untuk banyak tujuan, Mathematica memperlakukan objek SparseArray seperti daftar biasa yang
sesuai. Jadi, misalnya, jika Anda meminta bagian dari objek array jarang, Mathematica akan beroperasi
seolah-olah Anda telah meminta bagian dalam daftar biasa yang sesuai.
Ini menghasilkan objek array yang jarang.
2.5 Aturan dan Definisi Transformasi

2.5.1 Menerapkan Aturan Transformasi
Anda dapat memberikan daftar aturan untuk diterapkan. Setiap aturan akan dicoba sekali pada setiap
bagian ekspresi.
Terkadang Anda mungkin harus terus menerapkan aturan berulang kali, sampai ekspresi yang Anda
kerjakan tidak perubahan yang lebih lama. Anda dapat melakukan ini menggunakan operasi penggantian
berulang expr //. aturan (atau Replaceg Berulang[expr, aturan]).
Dengan operator pengganti tunggal /. setiap aturan dicoba hanya sekali pada setiap bagian dari ekspresi.
Dengan operator penggantian berulang //. aturan dicoba berulang kali sampai ekspresi tidak lagi
berubah.
Jika Anda memberikan seperangkat aturan yang melingkar, maka //. dapat terus mendapatkan hasil
yang berbeda selamanya. Dalam prakteknya, maksimal jumlah ibu yang melewati itu //. membuat ekspresi
tertentu ditentukan oleh pengaturan untuk opsi MaxItergasi. Jika Anda ingin melanjutkan selama mungkin,
Anda dapat menggunakan ReplaceRepeated[expr, rules, MaxItg erasi -> Tak terhingga]. Anda selalu dapat
berhenti dengan menginterupsi Mathematica secara eksplisit.
Dengan menyetel opsi MaxIterations, Anda dapat secara eksplisit memberi tahu ReplaceRepeated
berapa kali untuk mencoba aturan yang Anda berikan.
2.5.2 Manipulating Sets of Transformation Rules

Anda dapat memanipulasi daftar aturan transformasi di Mathematica seperti ekspresi simbolik lainnya.
Hal ini umum untuk menetapkan nama untuk aturan atau seperangkat aturan.
Ini menetapkan sinexp "nama" ke aturan ekspansi trigonometri.
Untuk daftar aturan yang panjang, Anda akan menemukan bahwa menyiapkan tabel pengiriman
membuat operasi penggantian menjadi lebih cepat. Ini adalah terutama benar ketika aturan Anda adalah
untuk simbol individu atau ekspresi lain yang tidak melibatkan objek pola. Setelah Anda membuat tabel
pengiriman dalam kasus seperti itu, Anda akan menemukan bahwa /. operator membutuhkan waktu yang
kurang lebih Terlepas dari jumlah aturan yang Anda miliki. Namun, tanpa tabel pengiriman, /. akan memakan
waktu secara langsung sebanding dengan jumlah total aturan.
2.5.3 Membuat Definisi
Ini menerapkan aturan transformasi untuk x ke ekspresi tertentu.
2.5.4 Bentuk Penugasan Khusus

Khususnya ketika Anda menulis program prosedural di Mathematica, Anda akan sering perlu
memodifikasi nilai dari suatu partiku-variabel lar berulang kali. Anda selalu dapat melakukan ini dengan
membangun nilai baru dan secara eksplisit melakukan tugas seperti x = nilai. Mathematica, bagaimanapun,
memberikan notasi khusus untuk menambah nilai variabel, dan untuk beberapa kasus umum lainnya.
Ini memberikan nilai 7x ke variabel t.
Kode yang dikompilasi tidak mengharapkan bilangan kompleks, jadi Mathematica harus kembali
mengevaluasi secara eksplisit simbolik asli ekspresi.
Fitur penting dari Compile adalah ia tidak hanya dapat menangani ekspresi matematika, tetapi juga
berbagai hal sederhana program matematika. Jadi, misalnya, Kompilasi dapat menangani kondisional dan
mengontrol struktur aliran.
Dalam semua kasus, Compile[vars, expr] menganggap argumennya tidak dievaluasi. Ini berarti bahwa
Anda dapat secara eksplisit memberikan "program" sebagai ekspresi untuk dikompilasi.
Ini menciptakan versi terkompilasi dari program Mathematica yang mengimplementasikan pendekatan
Newton ke akar kuadrat.
Ini mengeksekusi kode yang dikompilasi.

2.6.16 Topik Lanjutan: Memanipulasi Kode Terkompilasi
Jika Anda menggunakan kode terkompilasi yang dibuat oleh Kompilasi hanya di dalam Mathematica
itu sendiri, maka Anda seharusnya tidak perlu tahu rincian bentuk internalnya. Namun demikian, kode yang
dikompilasi dapat diwakili oleh Mathematica biasa ekspresi, dan terkadang berguna untuk memanipulasinya.
Misalnya, Anda dapat mengambil kode terkompilasi yang dihasilkan oleh Kompilasi, dan
memasukkannya ke program atau perangkat eksternal. Anda juga dapat membuat objek CompiledFunction
sendiri, lalu menjalankannya di Mathematica.
Dalam semua kasus ini, Anda perlu mengetahui bentuk internal objek CompiledFunction. Elemen
pertama dari Objek CompiledFunction selalu berupa daftar pola yang menentukan jenis argumen yang
diterima oleh obyek. Elemen kelima dari objek CompiledFunction adalah fungsi murni Mathematica yang
digunakan jika aliran instruksi kode yang dikompilasi gagal karena alasan apa pun untuk memberikan hasil.
Ini menunjukkan bentuk eksplisit dari kode yang dikompilasi yang dihasilkan oleh Compile. Aliran
instruksi dalam objek CompiledFunction terdiri dari daftar instruksi untuk idealisasi sederhana komputer.
Komputer diasumsikan memiliki "register" bernomor, di mana operasi dapat dilakukan. Ada lima tipe dasar
register: logika, integer, real, kompleks, dan tensor. Untuk masing-masing tipe dasar ini maka dimungkinkan
memiliki register skalar tunggal atau larik register dengan peringkat apa pun. Daftar jumlah total register
masing-masing jenis yang diperlukan untuk mengevaluasi objek CompiledFunction tertentu diberikan
sebagai elemen kedua objek. Instruksi aktual dalam objek kode yang dikompilasi diberikan sebagai daftar.
Elemen pertama adalah “opcode” bilangan bulat yang menentukan operasi apa yang harus dilakukan.
Elemen-elemen selanjutnya adalah jumlah register tertentu jenis, atau konstanta literal. Biasanya elemen
terakhir dari daftar adalah nomor "daftar tujuan", di mana: hasil operasi harus diletakkan.
2.7 Modularitas dan Penamaan Benda
2.7.1 Modul dan Variabel Lokal
Mathematica biasanya mengasumsikan bahwa semua variabel Anda bersifat global. Ini berarti bahwa
setiap kali Anda menggunakan nama seperti x, Mathematica biasanya mengasumsikan bahwa Anda mengacu
pada objek yang sama.
Khususnya ketika Anda menulis program, bagaimanapun, Anda mungkin tidak ingin semua variabel
Anda menjadi global. Anda mungkin, misalnya, ingin menggunakan nama x untuk merujuk ke dua variabel
yang sangat berbeda dalam dua program yang berbeda. Dalam hal ini, Anda memerlukan x di setiap program
untuk diperlakukan sebagai variabel lokal.
Anda dapat mengatur variabel lokal di Mathematica menggunakan modul. Di dalam setiap modul,
Anda dapat memberikan daftar variabel yang akan diperlakukan sebagai lokal ke modul.
Ini mendefinisikan variabel global t memiliki nilai 17
t di dalam modul bersifat lokal, sehingga dapat diperlakukan secara independen dari t global.
t global masih mempunyai nilai 17
Cara paling umum modul digunakan adalah dengan mengatur variabel sementara atau menengah di
dalam fungsi Anda mendefinisikan. Penting untuk memastikan bahwa variabel tersebut tetap lokal. Jika
tidak, maka Anda akan mendapat masalah setiap kali nama mereka kebetulan bertepatan dengan nama
variabel lain.
Anda dapat memperlakukan variabel lokal dalam modul seperti simbol lainnya. Jadi, misalnya, Anda
dapat menggunakannya sebagai nama untuk fungsi lokal, Anda dapat menetapkan atribut untuknya, dan
seterusnya.
Saat Anda menyiapkan variabel lokal dalam modul, Mathematica awalnya tidak memberikan nilai pada
variabel. Ini berarti bahwa Anda dapat menggunakan variabel dengan cara simbolis murni, bahkan jika ada
nilai global yang ditentukan untuk variabel di luar modul.
Anda dapat menentukan nilai awal untuk variabel lokal mana pun dalam sebuah modul. Nilai awal
selalu dievaluasi sebelum modul dijalankan. Akibatnya, bahkan jika variabel x didefinisikan sebagai lokal
ke modul, x global akan digunakan jika: muncul dalam ekspresi untuk nilai awal.
Saat Anda mengatur /; kondisi untuk definisi, Anda sering perlu memasukkan variabel sementara.
Dalam banyak kasus, Anda mungkin ingin berbagi variabel sementara ini dengan isi sisi kanan definisi.
Mathematica memungkinkan Anda untuk menyertakan seluruh sisi kanan definisi Anda dalam sebuah
modul, termasuk kondisinya.
2.7.2 Konstanta Lokal
Dengan@ 8 x = x0 , y = y0, … <,
badan D tentukan konstanta lokal
x , y , … Mendefinisikan
konstanta lokal.
Modul memungkinkan Anda untuk mengatur variabel lokal, di mana Anda dapat menetapkan urutan
nilai apa pun. Seringkali, bagaimanapun, semua Anda yang benar-benar dibutuhkan adalah konstanta lokal,
yang Anda tetapkan nilainya hanya sekali.
Konstruk Mathematica With memungkinkan Anda untuk
mengatur konstanta lokal tersebut. Ini
mendefinisikan nilai global untuk t.
Dalam[1]:= t = 17
Keluar[1]= 17
Dicetak dari Mathematica Help Browser 3
© 1988-2003 Wolfram Research, Inc. Semua hak dilindungi undang-undang.
Ini mendefinisikan fungsi menggunakan t sebagai konstanta lokal.
Dalam[2]:= w[x_] := Dengan[{t = x + 1}, t + t^3] Ini
menggunakan definisi w.
Dalam[3]:= w[a]
Keluar[3]= 1 + a + H1 + aL3 t
masih memiliki nilai globalnya.
Dalam[4]:= t
Keluar[4]= 17
Sama seperti di Modul, nilai awal yang Anda definisikan di Dengan dievaluasi sebelum Dengan
dijalankan.
Ekspresi t + 1 yang memberikan nilai konstanta lokal t dievaluasi menggunakan t global.
Dalam[5]:= Dengan[{t = t + 1}, t^2]
Keluar[5]= 324
Cara kerja With[8x = x0, … <, body] adalah dengan mengambil body, dan mengganti setiap
kemunculan x, dst. di dalamnya dengan x0 , dst.
Anda dapat menganggap With sebagai generalisasi dari /. operator, cocok untuk aplikasi ke kode
Mathematica, bukan ekspresi
lainnya.
Ini menggantikan x dengan a.
Dalam[6]:= Dengan[{x = a}, x = 5]
Keluar[6]= 5
Setelah penggantian, tubuh With adalah a = 5, sehingga mendapatkan nilai global 5.
Dalam[7]:= a
Keluar[7]= 5
Ini menghapus nilai a.
Dalam[8]:= Hapus[a]
Dalam beberapa hal, Dengan seperti kasus khusus Modul, di mana setiap variabel lokal diberi nilai
tepat satu kali.
Salah satu alasan utama menggunakan With daripada Module adalah karena biasanya membuat
program Mathematica Anda menulis lebih mudah dipahami. Dalam modul, jika Anda melihat variabel lokal
x pada titik tertentu,
Anda berpotensi harus melacak melalui semua kode dalam modul untuk mengetahui nilai x pada saat itu.
Namun, dalam konstruksi
With, Anda dapat selalu cari tahu nilai konstanta lokal hanya dengan melihat daftar nilai awal, tanpa
harus menelusuri melalui kode tertentu.
Jika Anda memiliki beberapa konstruksi Dengan, selalu yang terdalam untuk variabel tertentu yang
berlaku. Kamu bisa campuran Modul dan Dengan. Aturan umumnya adalah bahwa variabel terdalam untuk
variabel
tertentu adalah variabel yang berlaku.
4 Dicetak dari Peramban Bantuan Mathematica
Dengan konstruksi Dengan bersarang, yang terdalam selalu yang berlaku.
Dalam[9]:= Dengan[{t = 8}, Dengan[{t = 9}, t^2]]
Keluar[9]= 81
Anda dapat mencampur Modul dan Dengan konstruksi.
Dalam[10]:= Modul[{t = 8}, Dengan[{t = 9}, t^2]]
Keluar[10]= 81
Variabel lokal dalam konstruksi dalam tidak menutupi yang di luar kecuali jika namanya bertentangan.
Dalam[11]:= Dengan[{t = a}, Dengan[{u = b}, t + u]]
Keluar[11]= a + b
Kecuali untuk pertanyaan kapan x dan body dievaluasi, With[8x = x0 <, body] pada dasarnya bekerja
seperti body /. x -> x0 . Namun, With berperilaku dengan cara khusus ketika badan ekspresi itu sendiri berisi
konstruksi With atau Modul.
Masalah utamanya adalah untuk mencegah konstanta lokal di berbagai konstruksi With agar tidak
saling bertentangan, atau dengan objek global. Rincian bagaimana hal ini dilakukan dibahas dalam Bagian
2.7.3.
Y di dalam With diganti namanya untuk mencegah konflik dengan global y.
Dalam[12]:= Dengan[{x = 2 + y}, Tahan[Dengan[{y = 4}, x + y]]]
Keluar[12]= Tahan@Dengan@8y$ = 4<, H2 + yL + y$DD
2.7.3 Cara Kerja Modul
Cara kerja modul di Mathematica pada dasarnya sangat sederhana. Setiap kali modul apa pun
digunakan, simbol baru adalah dibuat untuk mewakili setiap variabel lokalnya. Simbol baru diberi nama unik
yang tidak boleh
bertentangan dengan apapun nama lain. Nama dibentuk dengan mengambil nama yang Anda tentukan untuk
variabel lokal, diikuti
oleh $, dengan unik
"nomor seri" ditambahkan.
Nomor seri ditemukan dari nilai variabel global $ModuleNumber. Variabel ini menghitung total berapa
kali Modul dalam bentuk apa pun telah digunakan.
Modul menghasilkan simbol dengan nama bentuk x $nnn untuk mewakili setiap variabel lokal.
Prinsip dasar modul di Mathematica.
Ini menunjukkan simbol yang dihasilkan untuk t dalam
modul. Dalam[1]:= Modul[{t}, Cetak[t]] t$1
Dicetak dari Mathematica Help Browser 5
Simbolnya berbeda setiap kali modul apa pun
digunakan. Dalam[2]:= Modul[{t, u}, Cetak[t];
Cetak[u]] t$2 u$2
Untuk sebagian besar tujuan, Anda tidak perlu berurusan langsung dengan simbol aktual yang
dihasilkan di dalam modul. Namun, jika
misalnya Anda memulai dialog saat modul sedang dieksekusi, maka Anda akan melihat simbol-simbol
ini. Hal yang sama juga benar setiap kali Anda menggunakan fungsi seperti Trace untuk
melihat evaluasi modul. Anda melihat simbol yang dihasilkan di dalam modul saat
Anda menggunakan Trace.
Dalam[3]:= Jejak[ Modul[{t}, t = 3] ]
Keluar[3]= 8Modul@8t<, t = 3D, 8t$3 = 3, 3<, 3< Ini
memulai dialog di dalam modul.
Dalam[4]:= Modul[{t}, t = 6; Dialog[ ]]
Di dalam dialog, Anda melihat simbol yang dihasilkan untuk
2.7.5 Variabel Dummy dalam Matematika
Saat Anda membuat rumus matematika, Anda sering harus memperkenalkan berbagai jenis objek lokal
atau "boneka" variabel”. Anda dapat memperlakukan variabel dummy tersebut menggunakan modul dan
konstruksi
pelingkupan Mathematica lainnya.
Variabel integrasi adalah contoh umum dari variabel dummy dalam matematika. Saat Anda menulis
formal integral, notasi konvensional mengharuskan Anda untuk memperkenalkan variabel integrasi dengan
nama yang pasti. Variabel ini adalah dasarnya "lokal" untuk integral, dan namanya, meskipun sewenang-
wenang, tidak boleh bertentangan
dengan nama lain di Anda ekspresi
matematika.
Dalam banyak kasus, masalah yang paling penting adalah bahwa variabel dummy harus tetap lokal,
dan tidak boleh mengganggu variabel lain dalam ekspresi matematika Anda. Namun, dalam beberapa kasus,
yang lebih penting
adalah perbedaannya penggunaan variabel dummy yang sama tidak
boleh bertentangan.
Variabel dummy berulang sering muncul dalam produk vektor dan tensor. Dengan “konvensi
penjumlahan”, sembarang vektor atau indeks tensor yang muncul tepat dua kali dijumlahkan dengan semua
nilai yang mungkin.
Nama sebenarnya dari
indeks berulang tidak pernah penting, tetapi jika ada dua indeks berulang yang terpisah, penting agar
namanya tidak konflik.
Ada banyak situasi dalam matematika di mana Anda perlu memiliki variabel dengan nama yang unik.
Salah satu contohnya adalah di merepresentasikan solusi persamaan. Dengan persamaan seperti sin HxL =
0, ada banyak sekali solusi,
masing-masing dari bentuk x = n p, di mana n adalah variabel dummy yang dapat sama dengan sembarang
bilangan bulat. Jika Anda menghasilkan solusi persamaan pada dua kesempatan terpisah, tidak ada jaminan
bahwa nilai n harus sama dalam kedua kasus. Hasil dari,
Anda harus mengatur solusinya sehingga objek n berbeda setiap saat.
Tempat lain di mana objek unik diperlukan adalah dalam mewakili "konstanta integrasi". Saat Anda
mengerjakan integral, Anda secara efektif menyelesaikan persamaan untuk turunan. Secara umum, ada
banyak kemungkinan solusi untuk persamaan, berbeda dengan "konstanta integrasi" aditif. Fungsi Integral
Mathematica standar selalu mengembalikan solusi tanpa konstanta integrasi. Tetapi jika Anda ingin
memperkenalkan konstanta
integrasi, Anda perlu untuk menggunakan modul untuk memastikan bahwa
mereka selalu unik.
2.7.6 Blok dan Nilai Lokal

Modul di Mathematica memungkinkan Anda untuk memperlakukan nama variabel sebagai lokal.
Namun, terkadang Anda menginginkan nama
menjadi global, tetapi nilai-nilai untuk menjadi lokal. Anda dapat melakukan ini di Mathematica
menggunakan Block.
Berikut adalah ekspresi yang melibatkan x.
Ini mengevaluasi ekspresi sebelumnya, menggunakan nilai lokal untuk x.
Tidak ada nilai global untuk x.
Seperti yang dijelaskan pada bagian di atas, variabel x dalam modul seperti Modul[8x<, body] selalu
diatur untuk merujuk ke simbol unik, berbeda setiap kali modul digunakan, dan berbeda dari simbol global
x. X dalam blok seperti Blok[8x<, body], bagaimanapun, dianggap sebagai simbol global x. Apa yang
dilakukan blok adalah membuat nilai x lokal. Nilai x saat Anda memasuki blok selalu dikembalikan saat
Anda keluar dari blok. Dan selama pelaksanaan blok, x dapat mengambil nilai apapun.
Ini menetapkan simbol t untuk memiliki nilai 17.
Variabel dalam modul memiliki nama lokal yang unik.
Dalam blok, variabel mempertahankan nama globalnya, tetapi dapat memiliki nilai lokal
t diberikan nilai lokal di dalam blok.

Ketika eksekusi blok selesai, nilai t sebelumnya dikembalikan.
Blok di Mathematica secara efektif memungkinkan Anda untuk mengatur "lingkungan" di mana Anda
dapat mengubah sementara nilai-nilai variabel. Ekspresi yang Anda evaluasi pada titik mana pun selama
eksekusi blok akan menggunakan nilai saat ini didefinisikan untuk variabel dalam blok. Ini benar apakah
ekspresi muncul secara langsung sebagai bagian dari tubuh blok, atau diproduksi pada titik mana pun dalam
evaluasinya.
Ini mendefinisikan nilai tertunda untuk simbol u
Jika Anda mengevaluasi u di luar blok, nilai global untuk t digunakan.
Anda dapat menentukan nilai sementara untuk t digunakan di dalam blok.
Penggunaan implisit penting Blok di Mathematica adalah untuk konstruksi iterasi seperti Do, Sum dan
Tabel. Mathematica secara efektif menggunakan Blok untuk mengatur nilai lokal untuk variabel iterasi di
semua konstruksi ini.
Saat Anda mengatur fungsi di Mathematica, terkadang nyaman untuk memiliki "variabel global" yang
dapat mempengaruhi fungsi tanpa diberikan secara eksplisit sebagai argumen. Jadi, misalnya, Mathematica
sendiri memiliki variabel global $RecursionLimit yang mempengaruhi evaluasi semua fungsi, tetapi tidak
pernah secara eksplisit diberikan sebagai argumen.
Mathematica biasanya akan menyimpan nilai apa pun yang Anda tetapkan untuk variabel global
sampai Anda mengubahnya secara eksplisit. Namun, sering kali, Anda ingin menyetel nilai yang hanya
bertahan selama durasi komputasi tertentu, atau bagian dari komputasi. Anda dapat melakukan ini dengan
membuat nilai lokal ke blok Mathematica.
Ini mendefinisikan fungsi yang tergantung pada "variabel global" t.
Dalam hal ini, nilai global t digunakan.
Di dalam blok, Anda dapat mengatur nilai lokal untuk t.
Anda dapat menggunakan variabel global tidak hanya untuk mengatur parameter dalam fungsi, tetapi
juga untuk mengumpulkan hasil dari fungsi. Oleh mengatur variabel tersebut menjadi lokal ke blok, Anda
dapat mengatur untuk mengumpulkan hasil hanya dari fungsi yang dipanggil selama pelaksanaan blok.
Fungsi ini menambah variabel global t, dan mengembalikan nilainya saat ini
Jika Anda tidak menggunakan blok, mengevaluasi h[a] akan mengubah nilai global t.
Dengan blok, hanya nilai lokal t yang terpengaruh.
Nilai global t tetap tidak berubah.
Saat Anda memasukkan blok seperti Blok[8x<, body], nilai apa pun untuk x akan dihapus. Ini berarti
Anda pada prinsipnya bisa memperlakukan x sebagai "variabel simbolik" di dalam blok. Namun, jika Anda
secara eksplisit mengembalikan x dari blok, itu akan menjadi digantikan oleh nilainya di luar blok segera
setelah dievaluasi.
Nilai t dihapus saat Anda memasuki blok.
Jika Anda mengembalikan ekspresi yang melibatkan t, bagaimanapun, itu dievaluasi menggunakan
nilai global untuk t
2.7.7 Blok Dibandingkan dengan Modul

Saat Anda menulis program di Mathematica, Anda harus selalu mencoba mengaturnya sehingga
bagian-bagiannya sama independennya dengan mungkin. Dengan cara ini, program akan lebih mudah untuk
Anda pahami, pertahankan, dan tambahkan.
Salah satu cara utama untuk memastikan bahwa bagian yang berbeda dari suatu program tidak
mengganggu adalah dengan memberikan variabel tertentu saja "cakupan". Mathematica menyediakan dua
mekanisme dasar untuk membatasi ruang lingkup variabel: modul dan blok. Dalam menulis program yang
sebenarnya, modul jauh lebih umum daripada blok. Namun, ketika pelingkupan diperlukan dalam
perhitungan interaktif, blok seringkali nyaman.
Sebagian besar bahasa komputer tradisional menggunakan apa yang disebut mekanisme "pelingkupan
leksikal" untuk variabel, yang analog dengan: mekanisme modul di Mathematica. Beberapa bahasa komputer
simbolis seperti LISP juga memungkinkan "dinamis" scoping”, analog dengan blok Mathematica.
Ketika pelingkupan leksikal digunakan, variabel diperlakukan sebagai lokal ke bagian tertentu dari
kode dalam suatu program. dalam dinamis pelingkupan, nilai-nilai variabel lokal ke bagian dari sejarah
eksekusi program.
Dalam bahasa yang dikompilasi seperti C dan Java, ada perbedaan yang sangat jelas antara "kode" dan
"riwayat eksekusi". Sifat simbolis Mathematica membuat perbedaan ini sedikit kurang jelas, karena "kode"
pada prinsipnya dapat dibangun secara dinamis selama eksekusi program.
Apa yang dilakukan Module[vars, body] adalah memperlakukan bentuk badan ekspresi pada saat
modul dijalankan sebagai "kode" dari program Mathematica. Kemudian ketika salah satu vars secara
eksplisit muncul dalam "kode" ini, itu dianggap lokal.
Block[vars, body] tidak melihat bentuk ekspresi body. Sebaliknya, selama evaluasi tubuh, blok
menggunakan nilai lokal untuk vars.
2.7.8 Konteks
Itu selalu merupakan ide yang baik untuk memberikan nama variabel dan fungsi yang sejelas
mungkin.
Kadang-kadang, bagaimanapun, nama-nama seperti itu mungkin menjadi sangat panjang.
Di Mathematica, Anda dapat menggunakan gagasan "konteks" untuk mengatur nama-nama simbol.
Konteks khususnya penting dalam paket Mathematica yang memperkenalkan simbol yang namanya tidak
boleh bertentangan dengan simbol lainnya. Jika Anda menulis paket Mathematica, atau menggunakan paket
canggih yang telah ditulis orang lain, maka Anda perlu tahu tentang konteks.
Ide dasarnya adalah bahwa nama lengkap dari setiap simbol dipecah menjadi dua bagian: konteks dan
nama pendek. Nama lengkapnya adalah ditulis sebagai context`short, di mana ` adalah karakter backquote
atau aksen kuburan (kode desimal ASCII 96), disebut "tanda konteks" di Mathematica.
Biasanya memiliki semua simbol yang menghubungkan topik tertentu dalam konteks tertentu. Jadi,
misalnya, simbol yang mewakili unit fisik mungkin memiliki konteks PhysicalUnits`. Simbol seperti itu
mungkin memiliki nama lengkap seperti PhysicalUnits`Joule atau PhysicalUnits`Mole.
Meskipun Anda selalu dapat merujuk ke simbol dengan nama lengkapnya, sering kali lebih mudah
menggunakan nama yang lebih pendek.
Pada titik tertentu dalam sesi Mathematica, selalu ada konteks saat ini $Context. Anda dapat merujuk
ke simbol yang dalam konteks ini hanya dengan memberikan nama pendek mereka.
Konteks di Mathematica bekerja seperti direktori file di banyak sistem operasi. Anda selalu dapat
menentukan file tertentu dengan memberikan nama lengkapnya, termasuk direktorinya. Tetapi pada titik
tertentu, biasanya ada arus direktori kerja, analog dengan konteks Mathematica saat ini. File yang ada di
direktori ini kemudian dapat ditentukan hanya dengan memberikan nama pendek mereka. Seperti direktori
di banyak sistem operasi, konteks di Mathematica bisa hierarkis. Jadi, misalnya, penuhnama simbol dapat
melibatkan urutan nama konteks, seperti pada nama c1 `c2`c3`
Saat Anda memulai sesi Mathematica, konteks default saat ini adalah Global`. Simbol yang Anda
perkenalkan akan biasanya dalam konteks ini. Namun, simbol bawaan seperti Pi berada dalam konteks
System`.
Agar Anda dapat dengan mudah mengakses tidak hanya simbol dalam konteks Global`, tetapi juga
dalam konteks seperti Sistem`, Mathematica mendukung gagasan jalur pencarian konteks. Pada setiap titik
dalam sesi Mathematica, ada keduanya konteks saat ini $Context, dan juga jalur pencarian konteks saat ini
$ContextPath. Ide dari jalur pencarian adalah untuk memungkinkan Anda mengetikkan nama pendek simbol,
lalu minta Mathematica mencari dalam urutan konteks untuk menemukan simbol dengan nama pendek itu.
Jalur pencarian konteks untuk simbol di Mathematica analog dengan "jalur pencarian" untuk file
program yang disediakan di sistem operasi seperti Unix dan MS-DOS.
Saat Anda menggunakan konteks dalam Mathematica, tidak ada alasan bahwa dua simbol yang berada
dalam konteks yang berbeda tidak dapat memiliki nama pendek yang sama. Jadi, misalnya, Anda dapat
memiliki simbol dengan nama pendek Mole keduanya dalam konteks Satuan Fisik` dan dalam konteks
Organisme Biologis`.
Namun, ada pertanyaan tentang simbol mana yang sebenarnya Anda dapatkan ketika Anda
mengetikkan hanya nama pendek Mole. Jawaban atas pertanyaan ini ditentukan oleh konteks mana yang
muncul lebih dulu dalam urutan konteks yang tercantum dalam jalur pencarian konteks.
Secara umum, saat Anda mengetikkan nama pendek untuk sebuah simbol, Mathematica
mengasumsikan bahwa Anda menginginkan simbol tersebut dengan itu nama yang konteksnya muncul
paling awal di jalur pencarian konteks. Akibatnya, simbol dengan nama pendek yang sama yang konteks
muncul kemudian dalam jalur pencarian konteks secara efektif "dibayangi". Untuk merujuk ke simbolsimbol
ini, Anda perlu menggunakan nama lengkap mereka.
Mathematica selalu memperingatkan Anda ketika Anda memperkenalkan simbol baru yang
"membayangi" simbol yang ada dengan Anda saat ini pilihan untuk $ContextPath. Jika Anda menggunakan
ujung depan notebook, Mathematica biasanya akan membiarkan Anda memilih dalam kasus seperti itu
simbol mana yang ingin Anda simpan.
Jika Anda pernah memperkenalkan simbol yang membayangi simbol yang ada, itu akan terus berlanjut
sampai Anda mengatur ulang $ContextPath, atau hapus simbol secara eksplisit. Anda harus menyadari
bahwa tidak cukup untuk menghapus nilai dari simbol; anda harus benar-benar menghapus simbol
sepenuhnya dari Mathematica. Anda dapat melakukan ini menggunakan fungsi Hapus [s].
Ketika Mathematica mencetak nama simbol, ia harus memilih apakah akan memberikan nama lengkap,
atau hanya nama pendek nama. Apa yang dilakukannya adalah memberikan versi nama apa pun yang harus
Anda ketik untuk mendapatkan simbol tertentu, mengingat pengaturan Anda saat ini untuk $Context dan
$ContextPath.
Jika Anda mengetikkan nama pendek yang tidak memiliki simbol baik dalam konteks saat ini, atau
dalam konteks apa pun pada konteks jalur pencarian, maka Mathematica harus membuat simbol baru dengan
nama ini. Itu selalu menempatkan simbol baru semacam ini di konteks saat ini, seperti yang ditentukan oleh
$Context.
2.7.9 Konteks dan Paket

Paket tipikal yang ditulis dalam Mathematica memperkenalkan beberapa simbol baru yang
dimaksudkan untuk digunakan di luar paket. Ini simbol mungkin sesuai misalnya dengan fungsi baru atau
objek baru yang didefinisikan dalam paket. Ada konvensi umum bahwa semua simbol baru yang
diperkenalkan dalam paket tertentu dimasukkan ke dalam konteks yang nama terkait dengan nama paket.
Ketika Anda membaca dalam paket, itu menambahkan konteks ini di awal Anda jalur pencarian konteks
$ContextPath
Nama lengkap simbol yang didefinisikan dalam paket seringkali cukup panjang. Namun, dalam
kebanyakan kasus, Anda hanya perlu menggunakan nama pendek mereka. Alasan untuk ini adalah bahwa
setelah Anda membaca dalam sebuah paket, konteksnya ditambahkan ke $ContextPath, jadi konteksnya
secara otomatis dicari setiap kali Anda mengetikkan nama pendek.
Namun ada komplikasi, ketika dua simbol dengan nama pendek yang sama muncul dalam dua paket
yang berbeda. Di kasus seperti itu, Mathematica akan memperingatkan Anda ketika Anda membaca di paket
kedua. Ini akan memberi tahu Anda simbol mana yang akan menjadi“dibayangi” oleh simbol-simbol baru
yang diperkenalkan.
Konflik dapat terjadi tidak hanya antara simbol dalam paket yang berbeda, tetapi juga antara simbol
dalam paket dan simbol yang Anda perkenalkan langsung di sesi Mathematica Anda. Jika Anda
mendefinisikan simbol dalam konteks Anda saat ini, maka inisimbol akan membayangi simbol lain dengan
nama pendek yang sama dalam paket yang Anda baca. Alasannya adalah karena Mathematica selalu mencari
simbol dalam konteks saat ini sebelum mencari dalam konteks di jalur pencarian konteks.
Mendefinisikan pesan penggunaan di awal paket adalah cara standar untuk memastikan bahwa simbol
yang Anda inginkan ekspor dibuat dalam konteks yang sesuai. Cara kerjanya adalah dalam mendefinisikan
pesan-pesan ini, satu-satunya simbol yang Anda sebutkan adalah yang ingin Anda ekspor. Simbol-simbol ini
kemudian dibuat dalam konteks Package`, yaitu lalu saat ini.
Dalam definisi sebenarnya dari fungsi dalam sebuah paket, biasanya ada banyak simbol baru, yang
diperkenalkan sebagai parameter, variabel sementara, dan sebagainya. Konvensinya adalah meletakkan
semua simbol ini dalam konteks Package`Private`, yang tidak diletakkan di jalur pencarian konteks saat paket
dibaca.
Dalam paket Collatz, fungsi yang ditentukan hanya bergantung pada fungsi Mathematica bawaan.
Akan tetapi, seringkali fungsi yang didefinisikan dalam satu paket mungkin bergantung pada fungsi yang
didefinisikan dalam paket lain.
Dua hal yang diperlukan untuk membuat ini bekerja. Pertama, paket lain harus dibaca, sehingga fungsi
yang dibutuhkan adalah didefinisikan. Dan kedua, jalur pencarian konteks harus menyertakan konteks tempat
fungsi-fungsi ini berada.
Anda dapat secara eksplisit memberi tahu Mathematica untuk membaca dalam sebuah paket kapan saja
menggunakan perintah <<konteks`. (Bagian 2.12.5 membahas masalah rumit terjemahan dari nama konteks
yang tidak tergantung sistem ke nama file yang bergantung pada sistem.)
Namun, seringkali Anda ingin mengaturnya sehingga paket tertentu hanya dapat dibaca jika
diperlukan. Perintah Needs["context`"] memberitahu Mathematica untuk membaca dalam sebuah paket jika
konteks yang terkait dengan paket tersebut belumdalam daftar $Packages.
Jika Anda menggunakan BeginPackage["Package`"] dengan satu argumen, Mathematica hanya

menggunakan jalur pencarian kontekskonteks Package` dan konteks untuk simbol Mathematica bawaan. Jika
definisi yang Anda berikan dalam paket Anda melibatkan fungsi dari paket lain, Anda harus memastikan
bahwa konteks untuk paket ini juga disertakan dalam jalur pencarian konteks Anda. Anda dapat melakukan
ini dengan memberikan daftar konteks tambahan sebagai argumen kedua untuk BegingKemasan.
BeginPackage secara otomatis memanggil Kebutuhan pada konteks ini, membaca dalam paket yang sesuai
jika diperlukan, dan kemudian memastikan bahwa konteksnya berada di jalur pencarian konteks
Menjalankan fungsi seperti Begin yang memanipulasi konteks mengubah cara Mathematica
menginterpretasikan nama Anda ketik. Namun, Anda harus menyadari bahwa perubahan hanya efektif dalam
ekspresi berikutnya yang Anda ketik intinya adalah bahwa Mathematica selalu membaca dalam ekspresi
input yang lengkap, dan menafsirkan nama-nama di dalamnya, sebelum dieksekusi setiap bagian dari
ekspresi. Akibatnya, pada saat Begin dieksekusi dalam ekspresi tertentu, nama-nama dalam ekspresi telah
ditafsirkan, dan sudah terlambat untuk Mulai memiliki efek.
Fakta bahwa fungsi manipulasi konteks tidak berpengaruh sampai ekspresi lengkap berikutnya dibaca
dalam arti bahwa Anda harus yakin untuk memberikan fungsi-fungsi itu sebagai ekspresi terpisah, biasanya
pada baris terpisah, saat Anda menulis paket matematika.
2.7.11 Pemuatan Paket Otomatis

Bagian sebelumnya telah membahas pemuatan eksplisit paket Mathematica menggunakan <<paket dan
Kebutuhan[paket]. Namun terkadang, Anda mungkin ingin menyetel Mathematica agar secara otomatis
memuat paket tertentu ketika: paket diperlukan.
Anda dapat menggunakan DeclarePackage untuk memberikan nama simbol yang didefinisikan dalam
paket tertentu. Lalu kapan salah satu simbol ini benar-benar digunakan, Mathematica akan secara otomatis
memuat paket tempat simbol didefinisikan.
Saat Anda menyiapkan koleksi besar paket Mathematica, sering kali merupakan ide yang baik untuk
membuat "nama" tambahan file” yang berisi urutan perintah DeclarePackage, menentukan paket yang akan
dimuat saat tertentu nama digunakan. Dalam sesi Mathematica tertentu, Anda kemudian perlu memuat secara
eksplisit hanya file nama. Kapan Anda telah melakukan ini, semua paket lain akan secara otomatis dimuat
jika dan ketika dibutuhkan.
DeclarePackage bekerja dengan segera membuat simbol dengan nama yang Anda tentukan, tetapi
memberikan masing-masing ini simbol atribut khusus Stub. Kapanpun Mathematica menemukan simbol
dengan atribut Stub, secara otomatis memuat paket yang sesuai dengan konteks simbol, dalam upaya
menemukan definisi simbol.
2.7.12 Memanipulasi Simbol dan Konteks dengan Nama

Setelah Anda membuat tugas seperti x = 2, maka setiap kali x dievaluasi, itu diganti dengan 2.
Kadangkadang, namun, Anda mungkin ingin terus merujuk ke x itu sendiri, tanpa langsung mendapatkan
nilai x.
Anda dapat melakukan ini dengan merujuk ke x dengan nama. Nama simbol x adalah string "x", dan
meskipun x itu sendiri mungkin diganti dengan nilai, string "x" akan selalu tetap sama.
Anda dapat menentukan bentuk nama simbol menggunakan pola string dari jenis yang dibahas dalam
Bagian 2.8.3. "x*" berdiri, misalnya, untuk semua nama yang dimulai dengan x.
bagian dari ekspresi diganti ke dalam tubuh fungsi murni. Untuk keseragaman, bagaimanapun, Mathematica
masih mengganti nama parameter formal bahkan dalam kasus seperti itu.
In this case, the formal parameter x in the inner function shields the body of the function, so no renaming is needed.
In[6]:= Function[{x}, Function[{x}, x + y]] [a]
Out[6]= Function@8x<, x + yD
Here are three nested functions.
In[7]:= Function[{x}, Function[{y}, Function[{z}, x + y + z]]]
Out[7]= Function@8x<, Function@8y<, Function@8z<, x + y + zDDD
Both inner functions are renamed in this case.
In[8]:= %[a]
Out[8]= Function@8y$<, Function@8z$<, a + y$ + z$DD
Seperti disebutkan dalam Bagian 2.2.5, fungsi murni dalam Mathematica seperti ekspresi l dalam
logika formal. Penggantian nama parameter formal memungkinkan fungsi murni Mathematica untuk
mereproduksi semua semantik ekspresi standar l dengan setia.
Function@ 8 x, … <, body D local parameters lhs −> rhs and lhs :> rhs local pattern names lhs = rhs and
lhs := rhs local pattern names
With@ 8 x = x0 , … <, body D local constants
Module@ 8 x, … <, body D local variables
Scoping constructs in Mathematica.
Mathematica memiliki beberapa "konstruksi pelingkupan" di mana nama-nama tertentu diperlakukan

sebagai lokal. Saat Anda mencampur konstruksi ini dengan cara apa pun, Mathematica melakukan
penggantian nama yang sesuai untuk menghindari konflik.
Mathematica renames the formal parameter of the pure function to avoid a conflict.
In[9]:= With[{x = a}, Function[{a}, a + x]]
Out[9]= Function@8a$<, a$ + aD
Here the local constant in the inner With is renamed to avoid a conflict.
In[10]:= With[{x = y}, Hold[With[{y = 4}, x + y]]]
Out[10]= Hold@With@8y$ = 4<, y + y$DD

There is no conflict between names in this case, so no renaming is done.
In[11]:= With[{x = y}, Hold[With[{z = x + 2}, z + 2]]]
Out[11]= Hold@With@8z = y + 2<, z + 2DD
The local variable y in the module is renamed to avoid a conflict.
In[12]:= With[{x = y}, Hold[Module[{y}, x + y]]]
Out[12]= Hold@Module@8y$<, y + y$DD
If you execute the module, however, the local variable is renamed again to make its name unique.
In[13]:= ReleaseHold[%]
Out[13]= y + y$1
2.7.5 Variabel Dummy dalam Matematika

Saat Anda membuat rumus matematika, Anda sering kali harus memperkenalkan berbagai jenis objek
lokal atau "variabel dummy". Anda dapat memperlakukan variabel dummy tersebut menggunakan modul
dan konstruksi pelingkupan Mathematica lainnya.
Variabel integrasi adalah contoh umum dari variabel dummy dalam matematika. Saat Anda menuliskan
integral formal, notasi konvensional mengharuskan Anda untuk memasukkan variabel integrasi dengan nama
yang pasti. Variabel ini pada dasarnya adalah "lokal" untuk integral, dan namanya, meskipun arbitrer, tidak
boleh bertentangan dengan nama lain dalam ekspresi matematika Anda.
Here is a function for evaluating an integral.
In[1]:= p[n_] := Integrate[f[s] s^n, {s, 0, 1}]
The s here conflicts with the integration variable.
In[2]:= p[s + 1]
Out s1+s f@sD as

[2]= ‡
0
Here is a definition with the integration variable specified as local to a module.
In[3]:= pm[n_] := Module[{s}, Integrate[f[s] s^n, {s, 0, 1}]]
Since you have used a module, Mathematica automatically renames the integration variable to avoid a conflict.
In[4]:= pm[s + 1]
Out s$2421+s f@s$242D a s$242

[4]= ‡
Dalam banyak kasus, masalah yang paling penting adalah bahwa variabel dummy harus tetap lokal,
dan tidak boleh mengganggu variabel lain dalam ekspresi matematika Anda. Namun, dalam beberapa kasus,
yang lebih penting adalah penggunaan yang berbeda dari variabel dummy yang sama tidak boleh
bertentangan.
Variabel dummy berulang sering muncul dalam produk vektor dan tensor. Dengan "konvensi
penjumlahan", setiap vektor atau indeks tensor yang muncul tepat dua kali dijumlahkan dengan semua nilai
yang mungkin. Nama sebenarnya dari indeks berulang tidak pernah menjadi masalah, tetapi jika ada dua
indeks berulang yang terpisah, adalah penting bahwa nama mereka tidak bertentangan. 2.7.6 Blok dan Nilai
Lokal
Modul di Mathematica memungkinkan Anda untuk memperlakukan nama variabel sebagai lokal.
Namun, terkadang Anda ingin nama menjadi global, tetapi nilainya lokal. Anda dapat melakukan ini di
Mathematica menggunakan Block.
Block@ 8 x, y, … <, body D evaluate body using local values for x , y ,…

Block@ 8 x = x0 , assign initial values to x , y , … y
= y0 , … <, body D
Setting up local values.
Here is an expression involving x.
In[1]:= x^2 + 3
Out[1]= 3 + x2
This evaluates the previous expression, using a local value for x.
In[2]:= Block[{x = a + 1}, %]
Out[2]= 3 + H1 + aL2
There is no global value for x.
In[3]:= x
Out[3]= x
Seperti yang dijelaskan pada bagian di atas, variabel x dalam modul seperti Modul[8 x<, body] selalu
diatur untuk merujuk ke simbol unik, berbeda setiap kali modul digunakan, dan berbeda dari simbol global
x. Namun, x dalam blok seperti Blok[8 x<, body] dianggap sebagai simbol global x. Apa yang dilakukan
blok adalah membuat nilai x lokal. Nilai x saat Anda memasuki blok selalu dikembalikan saat Anda keluar
dari blok. Dan selama eksekusi blok, x dapat mengambil nilai apa pun.
This sets the symbol t to have value 17.
In[4]:= t = 17
Out[4]= 17
Variables in modules have unique local names.
In[5]:= Module[{t}, Print[t]]
t$1
In blocks, variables retain their global names, but can have local values.
In[6]:= Block[{t}, Print[t]]

t
t is given a local value inside the block.
In[7]:= Block[{t}, t = 6; t^4 + 1]
Out[7]= 1297
When the execution of the block is over, the previous value of t is restored.
In[8]:= t
Out[8]= 17
Blok di Mathematica secara efektif memungkinkan Anda untuk mengatur "lingkungan" di mana Anda
dapat mengubah nilai variabel untuk sementara. Ekspresi yang Anda evaluasi pada titik mana pun selama
eksekusi blok akan menggunakan nilai yang saat ini ditentukan untuk variabel di blok. Ini benar apakah
ekspresi muncul secara langsung sebagai bagian dari tubuh blok, atau diproduksi pada titik mana pun dalam
evaluasinya.
This defines a delayed value for the symbol u.
In[9]:= u := x^2 + t^2
If you evaluate u outside a block, the global value for t is used.
In[10]:= u
Out[10]= 289 + x2
You can specify a temporary value for t to use inside the block.
In[11]:= Block[{t = 5}, u + 7]

Out[11]= 32 + x2
2.7.7 Blok Dibandingkan dengan Modul

Ketika Anda menulis sebuah program di Mathematica, Anda harus selalu mencoba untuk mengaturnya
sehingga bagian-bagiannya sebebas mungkin. Dengan cara ini, program akan lebih mudah untuk Anda
pahami, pertahankan, dan tambahkan.
Salah satu cara utama untuk memastikan bahwa bagian yang berbeda dari suatu program tidak
mengganggu adalah dengan memberikan variabel mereka hanya "lingkup" tertentu. Mathematica
menyediakan dua mekanisme dasar untuk membatasi ruang lingkup variabel: modul dan blok.
Dalam menulis program yang sebenarnya, modul jauh lebih umum daripada blok. Ketika pelingkupan
diperlukan dalam perhitungan interaktif, bagaimanapun, blok seringkali nyaman.
Module@ vars, body D lexical scoping
Block@ vars, body D dynamic scoping

Mathematica variable scoping mechanisms.
This defines m in terms of i.
In[1]:= m = i^2
Out[1]= i2
The local value for i in the block is used throughout the evaluation of i + m.
In[2]:= Block[{i = a}, i + m]
Out[2]= a + a2
Here only the i that appears explicitly in i + m is treated as a local variable.
In[3]:= Module[{i = a}, i + m]
Out[3]= a + i2
2.7.8 Konteks
Itu selalu merupakan ide yang baik untuk memberikan nama variabel dan fungsi yang sejelas mungkin.
Namun, kadang-kadang, nama-nama seperti itu bisa menjadi sangat panjang.
Di Mathematica, Anda dapat menggunakan gagasan "konteks" untuk mengatur nama-nama simbol.
Konteks sangat penting dalam paket Mathematica yang memperkenalkan simbol yang namanya tidak boleh
bertentangan dengan nama lainnya
simbol. Jika Anda menulis paket Mathematica, atau menggunakan paket canggih yang telah ditulis
orang lain, maka Anda perlu mengetahui tentang konteksnya.
Ide dasarnya adalah bahwa nama lengkap dari setiap simbol dipecah menjadi dua bagian: konteks dan
nama pendek. Nama lengkap ditulis sebagai context`short, di mana ` adalah karakter backquote atau aksen
kuburan (kode desimal ASCII 96), yang disebut "tanda konteks" dalam Mathematica.
Here is a symbol with short name x, and context aaaa.
In[1]:= aaaa`x
Out[1]= aaaa`x
You can use this symbol just like any other symbol.
In[2]:= %^2 - %
Out[2]= −aaaa`x + aaaa`x2
You can for example define a value for the symbol.
In[3]:= aaaa`x = 78
Out[3]= 78
Mathematica treats a`x and b`x as completely different symbols.
In[4]:= a`x == b`x
Out[4]= a`x o b`x

Konteks di Mathematica bekerja seperti direktori file di banyak sistem operasi. Anda selalu dapat
menentukan file tertentu dengan memberikan nama lengkapnya, termasuk direktorinya. Tetapi pada titik
tertentu, biasanya ada direktori kerja saat ini, analog dengan konteks Mathematica saat ini. File yang ada di
direktori ini kemudian dapat ditentukan hanya dengan memberikan nama pendeknya.
Seperti direktori di banyak sistem operasi, konteks di Mathematica bisa hierarkis. Jadi, misalnya, nama
lengkap sebuah simbol dapat melibatkan urutan nama konteks, seperti pada nama c1 `c2 `c3 `.
context ` name or c1 ` c2 ` … a symbol in an explicitly specified

` name context a symbol in the current context
` name a symbol in a specific context relative to the current
` context ` name
a symbol in the current
or ` c ` c ` … ` context, or found on the context
Specifying symbols in various contexts.

Here is a symbol in the context a`b`.
In[7]:= a`b`x
Out[7]= a`b`x
2.7.9 Konteks dan Paket

Paket tipikal yang ditulis dalam Mathematica memperkenalkan beberapa simbol baru yang
dimaksudkan untuk digunakan di luar paket. Simbol-simbol ini mungkin berhubungan misalnya dengan
fungsi baru atau objek baru yang didefinisikan dalam paket.
Ada konvensi umum bahwa semua simbol baru yang diperkenalkan dalam paket tertentu dimasukkan
ke dalam konteks yang namanya terkait dengan nama paket. Saat Anda membaca dalam paket, itu
menambahkan konteks ini di awal jalur pencarian konteks Anda $ContextPath.
This reads in a package for finding Padé approximants.
In[1]:= <<Calculus`Pade`
The package prepends its context to $ContextPath.
In[2]:= $ContextPath
Out[2]= 8Calculus`Pade`, Global`, System`<

The symbol Pade is in the context set up by the package.
In[3]:= Context[Pade]
Out[3]= Calculus`Pade`
You can refer to the symbol using its short name.
In[4]:= Pade[Exp[x], {x, 0, 2, 4}]
1 + –x–– + –x–– –
Out––––––––––––––––––––––1 − –2–––x–– + –x––3––––––2– −– –––3x––––03–––––––––––– + ––x–4–––– – –
[4]=
Jika Anda masuk ke situasi di mana simbol yang tidak diinginkan membayangi simbol yang Anda
inginkan, hal terbaik yang harus dilakukan biasanya adalah menyingkirkan simbol yang tidak diinginkan
menggunakan Hapus[s]. Alternatif yang terkadang tepat adalah dengan mengatur ulang entri di $ContextPath
dan mengatur ulang nilai $Context sehingga membuat konteks yang berisi simbol yang Anda inginkan
menjadi konteks yang dicari terlebih dahulu.
$Packages
a list of the contexts corresponding to all packages
loaded into your Mathematica session
Getting a list of packages.
2.7.10 Menyiapkan Paket Mathematica

Dalam paket Mathematica yang khas, umumnya ada dua jenis simbol baru yang diperkenalkan. Jenis
pertama adalah yang ingin Anda "ekspor" untuk digunakan di luar paket. Jenis kedua adalah yang ingin Anda
gunakan hanya secara internal di dalam paket. Anda dapat membedakan kedua jenis simbol ini dengan
menempatkannya dalam konteks yang berbeda.
Konvensi yang biasa adalah meletakkan simbol yang dimaksudkan untuk ekspor dalam konteks dengan
nama Paket` yang sesuai dengan nama paket. Setiap kali paket dibaca, ia menambahkan konteks ini ke jalur
pencarian konteks, sehingga simbol dalam konteks ini dapat dirujuk dengan nama pendeknya.
Simbol yang tidak dimaksudkan untuk ekspor, tetapi dimaksudkan hanya untuk penggunaan internal
di dalam paket, secara konvensional dimasukkan ke dalam konteks dengan nama Package`Private`. Konteks
ini tidak ditambahkan ke jalur pencarian konteks. Akibatnya, simbol-simbol dalam konteks ini tidak dapat
diakses kecuali dengan memberikan nama lengkapnya.
Package ` symbols for export
Package `Private` symbols for internal use only

System` built-in Mathematica symbols
Needed , Needed ,… other contexts needed in the package 1`
2`
Contexts conventionally used in Mathematica packages.
Mendefinisikan pesan penggunaan di awal paket adalah cara standar untuk memastikan bahwa simbol
yang ingin Anda ekspor dibuat dalam konteks yang sesuai. Cara kerjanya adalah dalam mendefinisikan
pesan-pesan ini, satu-satunya simbol yang Anda sebutkan adalah simbol yang ingin Anda ekspor.
Simbolsimbol ini kemudian dibuat dalam konteks Package`, yang kemudian menjadi aktual.
Dalam definisi sebenarnya dari fungsi dalam sebuah paket, biasanya ada banyak simbol baru, yang
diperkenalkan sebagai parameter, variabel sementara, dan sebagainya. Konvensinya adalah meletakkan
semua simbol ini dalam konteks Package`Private`, yang tidak diletakkan di jalur pencarian konteks saat paket
dibaca.
This reads in the sample package given above.
In[1]:= <<Collatz.m
The EndPackage command in the package adds the context associated with the package to the context search path.
In[2]:= $ContextPath
Out[2]= 8Collatz`, Global`, System`<
The Collatz function was created in the context Collatz`.
In[3]:= Context[Collatz]
Out[3]= Collatz`
The parameter n is put in the private context Collatz`Private`.
In[4]:= ?Collatz`Private`*
Collatz`Private`n
2.7.11 Pemuatan Paket Otomatis

Bagian sebelumnya telah membahas pemuatan eksplisit paket Mathematica menggunakan <<paket dan
Kebutuhan[paket]. Namun terkadang, Anda mungkin ingin mengatur Mathematica agar secara otomatis
memuat paket tertentu saat paket tersebut dibutuhkan.
Anda dapat menggunakan DeclarePackage untuk memberikan nama simbol yang didefinisikan dalam
paket tertentu. Kemudian, ketika salah satu simbol ini benar-benar digunakan, Mathematica akan secara
otomatis memuat paket di mana simbol tersebut didefinisikan.
DeclarePackage@" context `", declare that a package should automatically be

8 " name1 ", " name2 ", … < D loaded if a symbol with any of the names namei is used
Arranging for automatic loading of packages.
This specifies that the symbols Div, Grad and Curl are defined in Calculus`VectorAnalysis`.
In[1]:= DeclarePackage["Calculus`VectorAnalysis`", {"Div", "Grad", "Curl"}]
Out[1]= Calculus`VectorAnalysis`
When you first use Grad, Mathematica automatically loads the package that defines it.
In[2]:= Grad[x^2 + y^2, Cartesian[x, y, z]]
Out[2]= 82 x, 2 y, 0<
2.7.12 Memanipulasi Simbol dan Konteks dengan Nama
Symbol@" name "D construct a symbol with a given name

SymbolName@ symb D find the name of a symbol
Converting between symbols and their names.

Here is the symbol x.
In[1]:= x // InputForm
Out[1]//InputForm=
x
Its name is a string.
In[2]:= SymbolName[x] // InputForm
Out[2]//InputForm=
"x"
This gives the symbol x again.
In[3]:= Symbol["x"] // InputForm
Out[3]//InputForm=
X
Setelah Anda membuat tugas seperti x = 2, maka setiap kali x dievaluasi, itu diganti dengan 2. Namun,
kadang-kadang, Anda mungkin ingin terus merujuk ke x itu sendiri, tanpa langsung mendapatkan nilai x.
Anda dapat melakukan ini dengan merujuk ke x dengan nama. Nama simbol x adalah string "x", dan
meskipun x itu sendiri dapat diganti dengan nilai, string "x" akan selalu tetap sama.
2.7.13 Topik Lanjutan: Mencegat Penciptaan Simbol Baru
Mathematica membuat simbol baru saat Anda pertama kali memasukkan nama tertentu. Terkadang
berguna untuk "mencegat" proses pembuatan simbol baru. Mathematica menyediakan beberapa cara untuk
melakukan ini
On@General::newsymD print a message whenever a new symbol is created

Off@General::newsymD switch off the message printed when new symbols are created
Printing a message when new symbols are created.
This tells Mathematica to print a message whenever a new symbol is created.

In[1]:= On[General::newsym]
Mathematica now prints a message about each new symbol that it creates.
In[2]:= sin[k]
General::newsym : Symbol sin is

new. General::newsym : Symbol k is
new.
Out[2]= sin@kD
This switches off the message.
In[3]:= Off[General::newsym]
This defines a function to be applied to each new symbol which is created.
In[4]:= $NewSymbol = Print["Name: ", #1, " Context: ", #2]&
Out[4]= Print@Name: , #1, Context: , #2D &
The function is applied once to v and once to w.
In[5]:= v + w
Name: v Context: Global`

Name: w Context: Global`
Out[5]= v + w
2.8 String dan Karakter
2.8.1 Sifat String

Banyak dari apa yang dilakukan Mathematica berkisar pada manipulasi ekspresi terstruktur. Tetapi
Anda juga dapat menggunakan Mathematica sebagai sistem untuk menangani string teks yang tidak
terstruktur.
" text " a string containing arbitrary text

Saat Anda memasukkan string teks ke Mathematica, Anda harus selalu menyertakannya dalam tanda
kutip. Namun, ketika Mathematica output string biasanya tidak secara eksplisit menunjukkan tanda kutip.
Anda dapat melihat tanda kutip dengan meminta bentuk input string. Selain itu, dalam buku catatan
Mathematica, tanda kutip biasanya akan muncul secara otomatis segera setelah Anda mulai mengedit string.
When Mathematica outputs a string, it usually does not explicitly show the quotes.
In[1]:= "This is a string."
Out[1]= This is a string.
You can see the quotes, however, by asking for the input form of the string.
In[2]:= InputForm[%]
Out[2]//InputForm=
"This is a string."
The fact that Mathematica does not usually show explicit quotes around strings makes it possible for you to use strings to
specify quite directly the textual output you want.
The strings are printed out here without explicit quotes.
In[3]:= Print["The value is ", 567, "."]
The value is 567.
2.8.2 Operasi pada String

Mathematica menyediakan berbagai fungsi untuk memanipulasi string. Sebagian besar fungsi ini
didasarkan pada tampilan string sebagai urutan karakter, dan banyak fungsi yang analog dengan fungsi untuk
memanipulasi daftar.
s1 <> s2 <> … or join several strings
give the number of characters in a

string
Operations on complete strings.
You can join together any number of strings using <>.

In[1]:= "aaaaaaa" <> "bbb" <> "cccccccccc"
Out[1]= aaaaaaabbbcccccccccc
StringLength gives the number of characters in a string.
In[2]:= StringLength[%]
Out[2]= 20
StringReverse reverses the characters in a string.
In[3]:= StringReverse["A string."]
Out[3]= .gnirts A
StringTake@ s, n D make a string by taking the first n characters from s

StringTake@ s, 8 n < D take the n th character from s
StringTake@ s, 8 n1 , n2 < take characters n1 through n2
D
StringDrop@ s, n D make a string by dropping the first n characters in s
StringDrop@ s, 8 n1 , n2 < drop characters n1 through n2
D
Taking and dropping substrings.
2.8.3 Pola String

Anda dapat menggunakan tes kesetaraan Mathematica standar s1 == s2 untuk menguji apakah dua
string identik. Namun, terkadang, Anda mungkin ingin mengetahui apakah string tertentu cocok dengan pola
string tertentu.
Mathematica memungkinkan Anda untuk menentukan pola string yang terdiri dari string biasa di mana
karakter tertentu ditafsirkan sebagai "karakter meta" khusus. Anda kemudian dapat menggunakan fungsi
StringMatchQ untuk mengetahui apakah string tertentu cocok dengan pola string yang telah Anda tetapkan.
Namun Anda harus menyadari bahwa pola string tidak ada hubungannya dengan pola Mathematica biasa
untuk ekspresi yang dibahas di Bagian 2.3.
Karakter * dapat digunakan dalam pola string sebagai metakarakter untuk mewakili urutan karakter
alfanumerik apa pun. Jadi, misalnya, pola string "a*b" akan cocok dengan string apa pun yang dimulai
dengan a, diakhiri dengan a b, dan memiliki sejumlah karakter alfanumerik di antaranya. Demikian pula,
"a*b*" akan cocok dengan string apa pun yang dimulai dengan a, dan memiliki sejumlah karakter lain,
termasuk setidaknya satu b.
The string matches the string pattern you have given.
In[1]:= StringMatchQ["aaaaabbbbcccbbb", "a*b*"]
Out[1]= True
2.8.4 Karakter dalam String
This gives a list of the characters in the string.

In[1]:= Characters["A string."]
Out[1]= 8A, , s, t, r, i, n, g, .<
You can apply standard list manipulation operations to this list.
In[2]:= RotateLeft[%, 3]
Out[2]= 8t, r, i, n, g, ., A, , s<
StringJoin converts the list of characters back to a single string.
In[3]:= StringJoin[%]
Out[3]= tring.A s
2.8.5 Karakter Khusus
Selain karakter biasa yang muncul pada papan ketik standar, Anda dapat menyertakan dalam string Mathematica karakter
khusus apa pun yang didukung oleh Mathematica.
Here is a string containing special characters.
In[1]:= "α β …"

Out[1]= α⊕β⊕…
You can manipulate this string just as you would any other.
In[2]:= StringReplace[%, " " -> " üü "]
Out[2]= α üü β üü …
Here is the list of the characters in the string.
In[3]:= Characters[%]
Out[3]= 8α, , ü, ü, , β, , ü, ü, , …<
Dalam buku catatan Mathematica, karakter khusus seperti a selalu dapat ditampilkan secara langsung. Tetapi jika Anda
menggunakan antarmuka berbasis teks, maka biasanya satu-satunya karakter yang dapat dengan mudah ditampilkan adalah
karakter yang muncul di keyboard Anda.
Akibatnya, apa yang dilakukan Mathematica dalam situasi seperti itu adalah mencoba memperkirakan karakter khusus
dengan urutan karakter biasa yang tampak serupa. Dan ketika ini tidak praktis, Mathematica hanya memberikan nama lengkap
dari karakter khusus.
2.8.6 Topik Lanjutan: Baris Baru dan Tab dalam String
în a newline Hline feedL to be included in a string

î t a tab to be included in a string
Explicit representations of newlines and tabs in strings.
This prints on two lines.
In[1]:= "First line.\nSecond line."
Out[1]= First line.
Second line.
In InputForm there is an explicit în to represent the newline.
Out[2]//InputForm=
"First line.\nSecond line."

Saat Anda memasukkan string panjang di Mathematica, seringkali lebih mudah untuk memecah input Anda menjadi
beberapa baris. Mathematica secara default akan mengabaikan jeda tersebut, sehingga jika Anda kemudian mengeluarkan string,
string tersebut dapat dipatahkan dengan cara apa pun yang sesuai.
Mathematica ignores the line break and any tabs that follow it.
In[3]:= "A string on

two lines."
Out[3]= A string on two lines.
There is no newline in the string.
Out[4]//InputForm=
"A string on two lines."
2.8.7 Topik Lanjutan: Kode Karakter
ToCharacterCode@" string "D give a list of the character codes for the characters in a string
FromCharacterCode@ n D construct a character from its character code
FromCharacterCode@ construct a string of characters from a list of character codes
8 n1 , n2 , … < D
Converting to and from character codes.

Mathematica memberikan setiap karakter yang dapat muncul dalam string sebuah kode karakter yang unik. Kode ini
digunakan secara internal sebagai cara untuk mewakili karakter.
This gives the character codes for the characters in the string.
In[1]:= ToCharacterCode["ABCD abcd"]
Out[1]= 865, 66, 67, 68, 32, 97, 98, 99, 100<
FromCharacterCode reconstructs the original string.
In[2]:= FromCharacterCode[%]
Out[2]= ABCD abcd

Special characters also have character codes.
In[3]:= ToCharacterCode["α⊕Γû∅"]
Out[3]= 8945, 8853, 915, 8854, 8709<
2.8.8 Topik Lanjutan: Pengodean Karakter Mentah

Mathematica selalu mengizinkan Anda untuk merujuk ke karakter khusus dengan menggunakan nama
seperti [Alpha] atau kode heksadesimal eksplisit seperti :03b1. Dan ketika Mathematica menulis file, secara
default menggunakan nama atau kode heksadesimal ini.
Namun terkadang Anda mungkin merasa nyaman menggunakan penyandian mentah untuk setidaknya
beberapa karakter khusus. Artinya, daripada mewakili karakter khusus dengan nama atau kode heksadesimal
eksplisit, Anda malah mewakilinya dengan pola bit mentah yang sesuai untuk sistem komputer tertentu atau
font tertentu.
Saat Anda menekan tombol atau kombinasi tombol pada keyboard Anda, sistem operasi komputer
Anda mengirimkan pola bit tertentu ke Mathematica. Bagaimana pola bit ini ditafsirkan sebagai karakter
dalam Mathematica akan tergantung pada pengkodean karakter yang telah diatur.
Ujung depan notebook untuk Mathematica biasanya menangani pengaturan pengkodean karakter yang
sesuai secara otomatis untuk font apa pun yang Anda gunakan. Tetapi jika Anda menggunakan Mathematica
dengan antarmuka berbasis teks atau melalui file atau pipa, maka Anda mungkin perlu mengatur
$CharacterEncoding secara eksplisit.
Dengan menetapkan nilai yang sesuai untuk $CharacterEncoding, Anda biasanya dapat membuat
Mathematica menangani teks mentah yang dihasilkan oleh editor teks khusus bahasa atau sistem operasi apa
pun yang Anda gunakan.
Anda harus menyadari, bagaimanapun, bahwa sementara representasi standar karakter khusus yang
digunakan dalam Mathematica benar-benar portabel di sistem komputer yang berbeda, representasi apa pun
yang melibatkan pengkodean karakter mentah pasti tidak akan.
Ini menulis string ke file tmp.
Dalam[1]:= "a b c \[EAcute] \[Alpha] \[Pi] \:2766" >> tmp
Karakter khusus secara default ditulis menggunakan nama lengkap atau kode heksadesimal eksplisit.
Dalam [2]:= !!tmp
"" a b c é <""
Ini memberitahu Mathematica untuk menggunakan pengkodean karakter mentah yang sesuai untuk
font roman Macintosh.
Dalam[3]:= $CharacterEncoding = "MacintoshRoman"
Keluar[3]= MacintoshRoman
Sekarang karakter khusus yang dapat ditulis dalam bentuk mentah.
In[4]:= "a b c \[EAcute] \[Alpha] \[Pi] \:2766" >> tmp

Anda hanya dapat membaca karakter mentah jika Anda memiliki sistem yang menggunakan
pengkodean roman Macintosh.
Dalam[5]:= !!tmp
"" a b c é <""
Ini memberitahu Mathematica untuk tidak menggunakan penyandian mentah secara default.
Di[6]:= $CharacterEncoding = Tidak Ada
Keluar[6]= Tidak ada
Anda masih dapat secara eksplisit meminta penyandian mentah untuk digunakan dalam
fungsi tertentu. Masuk[7]:= Dapatkan["tmp", CharacterEncoding->"MacintoshRoman"]
Keluar[7]= a b c é <
Namun, beberapa pengkodean karakter mentah tidak menyertakan ASCII dasar sebagai
subset. Contohnya adalah "Simbol" encoding, di mana kode karakter yang biasanya
digunakan untuk a dan b malah digunakan untuk a dan b.
Ini memberikan kode karakter ASCII biasa untuk beberapa huruf bahasa
.
Inggris
Di[8]:= ToCharacterCode["abcdefgh"]
Keluar[8]= 897, 98, 99, 100, 101, 102, 103, 104<
Dalam pengkodean "Simbol", kode karakter ini digunakan untuk huruf Yunani.
Di[9]:= FromCharacterCode[%, "Simbol"]
Keluar[9]=
ToCharacterCode@" string "D menghasilkan kode untuk karakter menggunakan standar
Pengkodean matematika
ToCharacterCode@" string "," encoding "D FromCharacterCode@ 8 n1 , n2 , … <
D DariCharacterCode@ 8 n1 , n2 , … <, " penyandian "D
menghasilkan kode untuk karakter menggunakan pengkodean yang
ditentukan
menghasilkan karakter dari kode menggunakan standar Pengkodean matematika
menghasilkan karakter dari kode menggunakan pengkodean yang ditentukan
Menangani kode karakter dengan penyandian yang berbeda.
Ini memberikan kode yang diberikan ke berbagai karakter oleh Mathematica. Masuk[10]:=
ToCharacterCode["abc\[EAcute]\[Pi]"] Keluar[10]= 897, 98, 99, 233, 960<
Berikut adalah kode yang ditetapkan untuk karakter yang sama dalam pengkodean roman
Macintosh. Masuk[11]:= ToCharacterCode["abc\[EAcute]\[Pi]", "MacintoshRoman"]
Keluar[11]= 897, 98, 99, 142, 185<

Berikut adalah kode dalam pengkodean standar Windows. Tidak ada kode untuk [Pi] dalam
pengkodean itu.
Di[12]:= ToCharacterCode["abc\[EAcute]\[Pi]", "WindowsANSI"]
Keluar[12]= 897, 98, 99, 233, Tidak Ada<
2.9 Input dan Output Tekstual
2.9.1 Bentuk Input dan Output
Berikut adalah salah satu cara untuk memasukkan ekspresi tertentu.
Dalam[1]:= x^2 + Kotak[y]
Keluar[1]= x2 + !y!!
Berikut adalah cara lain untuk memasukkan ekspresi yang sama.
Dalam[2]:= Plus[Daya[x, 2], Akar[y]]
Dengan ujung depan notebook, Anda juga dapat memasukkan ekspresi secara langsung
dengan cara ini.
Dalam[3]:= x2 + !!!
Mathematica memungkinkan Anda untuk menampilkan ekspresi dalam berbagai cara.

Di buku catatan Mathematica, ekspresi secara default adalah output di StandardForm.
Dalam[4]:= x^2 + Kotak[y]
OutputForm hanya menggunakan karakter keyboard biasa dan merupakan default
untuk antarmuka berbasis teks ke Mathematica. Dalam[5]:= OutputForm[ x^2 +
Sqrt[y] ]
Keluar[5]//OutputForm=
x^2 + Kotak[y]
Keluar[5]//OutputForm=
" 2 x +
kuadrat[y]"
InputForm menghasilkan formulir yang dapat diketik langsung pada keyboard.
Di[6]:= InputForm[ x^2 + Sqrt[y]
] Keluar[6]//InputForm= x^2 +
Kotak[y]
FullForm menunjukkan bentuk internal dari sebuah ekspresi dalam notasi fungsional
eksplisit.
Dalam[7]:= Bentuk Lengkap[ x^2 + Kotak[y] ]

Keluar[7]//Formulir Lengkap= Plus@Power@x,
2D, Power@y, Rational@1, 2DDD
TradisionalForm menggunakan kumpulan besar aturan ad hoc untuk menghasilkan perkiraan
notasi matematika tradisional.
Dalam[8]:= Bentuk Tradisional[ x^2 + Sqrt[y] + Gamma[z] EllipticK[z]
] Keluar[8]//Form Tradisional= x2 + KHzL GHzL + !y!!
TeXForm menghasilkan output yang cocok untuk diekspor ke TeX.
Dalam[9]:= TeXForm[ x^2 + Sqrt[y]
] Keluar[9]//TeXForm= x^2 +
{\sqrt{y}}
CForm menghasilkan output yang dapat dimasukkan dalam program C. Makro untuk
objek seperti Power disertakan dalam file header mdefs.h.
Dalam[10]:= CForm[ x^2 + Kotak[y] ]
Keluar[10]//CForm=
Daya(x,2) + Kuadrat(y)
FortranForm menghasilkan output yang cocok untuk diekspor ke Fortran.
Dalam[11]:= FortranForm[ x^2 + Sqrt[y] ]

Keluar[11]//FortranForm=
x**2 + kuadrat(y)
Formulir keluaran biasanya tidak digunakan untuk masukan Mathematica.
Bagian 2.9.17 akan membahas bagaimana Anda dapat membuat formulir keluaran Anda
sendiri. Namun Anda harus menyadari bahwa dalam berkomunikasi dengan program eksternal
seringkali lebih baik menggunakan MathLink untuk mengirim ekspresi secara langsung
daripada menghasilkan representasi tekstual untuk ekspresi ini.
2.9.3 Representasi Bentuk Tekstual
Seperti segala sesuatu yang lain di Mathematica, bentuk tekstual dari ekspresi itu
sendiri dapat direpresentasikan sebagai ekspresi. Bentuk tekstual yang terdiri dari
urutan karakter satu dimensi dapat direpresentasikan secara langsung sebagai string
matematika biasa. Bentuk tekstual yang melibatkan subskrip, superskrip dan konstruksi
dua dimensi lainnya, bagaimanapun, dapat diwakili oleh kumpulan kotak dua dimensi
bersarang.
Representasi khas dari bentuk tekstual.
Ini menghasilkan string yang sesuai dengan representasi tekstual dari ekspresi di
InputForm.
Dalam[1]:= ToString[x^2 + y^3, InputForm]
Keluar[1]= x^2 + y^3

FullForm menunjukkan string secara eksplisit.
Dalam[2]:= Formulir Lengkap[%]

Keluar[2]//Formulir Lengkap=
"x^2 + y^3"
Berikut adalah karakter individu dalam string.
Dalam[3]:= Karakter[%]
Keluar[3]= 8x, ^, 2, , +, , y, ^, 3<
Berikut adalah struktur kotak yang sesuai dengan ekspresi di StandardForm.
Dalam[4]:= ToBox[x^2 + y^3, StandardForm]
Keluar[4]= RowBox@8SuperscriptBox@x, 2D, +, SuperscriptBox@y, 3D<D
Berikut adalah InputForm dari struktur kotak. Dalam bentuk ini struktur secara efektif
diwakili oleh string biasa.
Di[5]:= ToBoxes[x^2 + y^3, StandardForm] // InputForm
Keluar[5]//InputForm=
$x\^2 + y\^3$
Jika Anda menggunakan ujung depan buku catatan untuk Mathematica, maka Anda dapat
melihat ekspresi yang sesuai dengan bentuk tekstual setiap sel dengan menggunakan item
menu Perlihatkan Ekspresi.
Berikut adalah sel yang berisi ekspresi dalam StandardForm.
Berikut adalah representasi yang mendasari ekspresi itu dalam bentuk kotak, yang
ditampilkan menggunakan item menu Perlihatkan Ekspresi.
Membuat string dan kotak dari ekspresi.
2.9.4 Interpretasi Bentuk Tekstual
Saat Anda menggunakan StandardForm di buku catatan Mathematica, Anda bisa memasukkan
langsung bentuk dua dimensi seperti x2 . Tetapi InputForm hanya mengizinkan bentuk
satu dimensi. Namun demikian, meskipun teks aktual yang Anda berikan di InputForm
harus satu dimensi, masih memungkinkan untuk membuatnya mewakili bentuk dua dimensi.
Jadi, misalnya, !î(xî^2î) mewakili bentuk dua dimensi x2 , dan ditafsirkan oleh
Mathematica sebagai Daya[x, 2].

Berikut adalah input satu dimensi biasa.
Dalam[7]:= x^2 + 1/y
Keluar[7]= x2 + –1–––
kamu
Berikut adalah input yang mewakili bentuk dua dimensi.
Dalam[8]:= \!$ x\^2 + 1\/y
$ Keluar[8]= x2 + –1––– kamu
Meskipun input yang diberikan berbeda, ekspresi yang diperoleh pada dua baris terakhir
sama persis.
Dalam[9]:= % == %%
Keluar[9]= Benar
Jika Anda menyalin bentuk dua dimensi dari Mathematica, biasanya diberikan dalam
bentuk !î( … ). Saat Anda menempelkan kembali formulir satu dimensi ini ke dalam buku
catatan Mathematica, formulir itu akan secara otomatis "terjepret" ke dalam bentuk dua
dimensi. Jika Anda cukup mengetik formulir !î( … ) ke dalam buku catatan, Anda bisa
membuatnya menjadi bentuk dua dimensi menggunakan item menu Make 2D.
Ini mengambil string dan menafsirkannya sebagai input TraditionalForm. In[10]:=
ToExpression["f(6)", TraditionalForm] Out[10]= f@6D
Dalam StandardForm string yang sama akan berarti produk dari istilah.
Dalam[11]:= ToExpression["f(6)", StandardForm]
Keluar[11]= 6f
2.9.5 Output Pendek dan Dangkal
Saat Anda menghasilkan ekspresi keluaran yang sangat besar di Mathematica, Anda sering
tidak ingin melihat seluruh ekspresi sekaligus. Sebaliknya, pertama-tama Anda ingin
mendapatkan gambaran tentang struktur umum ekspresi, dan kemudian, mungkin, masuk dan
melihat bagian-bagian tertentu secara lebih rinci .

Anda dapat menggunakan Dangkal untuk melihat garis besar struktur.
Dalam[9]:= Dangkal[tr]
Keluar[9]//Dangkal=
8fib@«1≈D, Plus@«2≈D, 88«2≈<, «1≈, «1≈, 8«7≈<, 8«7≈<, «1≈, «1≈<,
88«2≈<, «1≈, «1≈, 8«7≈<, 8«7≈<, «1≈, «1≈<, Ditambah@«2≈D, 34<
Singkat memberi Anda garis besar yang kurang seragam, yang bisa lebih sulit untuk dipahami.
Dalam[10]:= Pendek[tr, 4]
Keluar[10]//Pendek=
8fib@8D, fib@8 1D + fib@8 2D,
888 1, 7<, fib@7D, «3≈, 13 + 8, 21<, 8«1≈<, 21 + 13, 34<
2.9.6String-Oriented Output Formats
Kutipan tidak termasuk dalam bentuk keluaran Mathematica standar. Dalam[1]:= "Ini adalah string."
Keluar[1]= Ini adalah string.
Dalam formulir input, kutipan disertakan.

Di[2]:= InputForm[%]
Keluar[2]//InputForm=
"Ini adalah tali."
Menggunakan string teks dan fungsi seperti StringForm, Anda dapat menghasilkan potongan output
yang tidak selalu sesuai dengan ekspresi Mathematica yang valid. Namun, terkadang Anda ingin
menghasilkan keluaran yang sesuai dengan ekspresi Mathematica yang valid, tetapi hanya selama ekspresi
tersebut tidak dievaluasi. Fungsi HoldForm mempertahankan argumennya tidak dievaluasi, tetapi
memungkinkannya untuk diformat dalam bentuk keluaran Mathematica standar.
HoldForm mempertahankan 1 + 1 tidak dievaluasi. Masuk[11]:= TahanForm[1 + 1] Keluar[11]= 1 +
HoldForm mencegah tugas yang sebenarnya dilakukan.
Dalam[12]:= HoldForm[x = 3]
Keluar[12]= x = 3
Jika bukan karena HoldForm, kekuatannya akan dievaluasi.
Di[13]:= HoldForm[34^78]
Keluar[13]= 3478
These numbers are given in the default output format. Large numbers are given in scientific notation.
In[1]:= {6.7^-4, 6.7^6, 6.7^8}
Out[1]= 80.00049625, 90458.4, 4.06068 × 106<

This gives all numbers in scientific notation.
In[2]:= ScientificForm[%]
Out[2]//ScientificForm=
84.9625 × 10−4, 9.04584 × 104, 4.06068 × 106<
This gives the numbers in engineering notation, with exponents arranged to be multiples of three.
In[3]:=
EngineeringForm[%]
Out[3]//EngineeringForm
=
8496.25 × 10−6, 90.4584 × 103, 4.06068 × 106<
In accounting form, negative numbers are given in parentheses, and scientific notation is never used.
In[4]:= AccountingForm[{5.6, -6.7, 10.^7}]
Out[4]//AccountingForm
=
85.6, H6.7L, 10000000.<
Berikut adalah p9 sampai 30 tempat desimal.
Dalam[5]:= N[Pi^9, 30]
Keluar[5]= 29809.099333446211666594024012
Ini hanya mencetak 10 digit p9 .
Di[6]:= NumberForm[%, 10]
Keluar[6]//Bentuk Angka=
29809.09933
Ini memberikan 12 digit, dalam notasi teknik.
Dalam[7]:= Formulir Rekayasa[%, 12]
Keluar[7]//Formulir Teknik=
29.8090993334 × 103
Setting DigitBlock->n breaks digits into blocks of length n.
In[8]:= NumberForm[30!, DigitBlock->3]
Out[8]//NumberForm=
265,252,859,812,191,058,636,308,480,000,000
You can specify any string to use as a separator between blocks of digits.
In[9]:= NumberForm[30!, DigitBlock->5, NumberSeparator->" "]
Out[9]//NumberForm=
265 25285 98121 91058 63630 84800 00000
This gives an explicit plus sign for positive numbers, and uses |i n place of a decimal point.
In[10]:= NumberForm[{4.5, -6.8}, NumberSigns->{"-", "+"}, NumberPoint->"|"]
Out[10]//NumberForm=
8+4»5, −6»8<
The default is to use scientific notation for all numbers with exponents outside the range -5 to 5.
In[11]:= {8.^5, 11.^7, 13.^9}
Out[11]= 832768., 1.94872 × 107, 1.06045 × 1010<
This uses scientific notation only for numbers with exponents of 10 or more.
In[12]:= NumberForm[%, ExponentFunction -> (If[-10 < # < 10, Null, #]&)]
832768., 19487171., 1.06045 × 1010<
This forces all exponents to be multiples of 3.
In[13]:= NumberForm[%, ExponentFunction -> (3 Quotient[#, 3]&)]
832.768 × 103, 19.4872 × 106, 10.6045 × 109<
This gives the exponents in Fortran-like “e” format.
In[14]:= NumberForm[{5.6^10, 7.8^20}, NumberFormat -> (SequenceForm[#1, "e", #3]&) ]
83.03305e7, 6.94852e17<
You can use FortranForm to print individual numbers in Fortran format.
In[15]:= FortranForm[7.8^20]
Out[15]//FortranForm=
6.948515870862152e17
Anda dapat mengubah posisi angka dalam bentuk cetakan angka dengan "mengisi" dengan berbagai cara.
Anda dapat mengisi di sebelah kanan, biasanya menambahkan nol di suatu tempat setelah desimal.
Atau Anda dapat mengisi di sebelah kiri, biasanya menyisipkan spasi di tempat nol di depan.
This pads with spaces to make room for up to 7 digits in each integer.
In[16]:= PaddedForm[{456, 12345, 12}, 7]
Out[16]//PaddedForm=
8 456, 12345, 12<
This creates a column of integers.
In[17]:= PaddedForm[ColumnForm[{456, 12345, 12}], 7]
456
12345
12
This prints each number with room for a total of 7 digits, and with 4 digits to the right of the decimal
point.
In[18]:= PaddedForm[{-6.7, 6.888, 6.99999}, {7, 4}]
8 −6.7000, 6.8880, 7.0000<
In NumberForm, the 7 specifies the maximum precision, but does not make Mathematica pad with
spaces.
In[19]:= NumberForm[{-6.7, 6.888, 6.99999}, {7, 4}]
8−6.7, 6.888, 7.<
If you set the option SignPadding-> True, Mathematica will insert leading spaces after the sign.
In[20]:= PaddedForm[{-6.7, 6.888, 6.99999}, {7, 4}, SignPadding->True]
8− 6.7000, 6.8880, 7.0000<
Only the mantissa portion is aligned when scientific notation is used.
In[21]:= PaddedForm[ ColumnForm[{6.7 10^8, 48.7, -2.3 10^-16}], {4, 2}]
6.70 × 108
48.70
−2.30 × 10−16
This uses spaces instead of zeros for padding on the right.

In[22]:= PaddedForm[{-6.7, 6.888, 6.99999}, {7, 4}, NumberPadding -> {" ", " "}]
8 −6.7 , 6.888 , 7. <
This prints a number in base 2.
In[23]:= BaseForm[2342424, 2]
Out[23]//BaseForm=
10001110111110000110002
In bases higher than 10, letters are used for the extra digits.
In[24]:= BaseForm[242345341, 16]
Out[24]//BaseForm= e71e57d16
BaseForm also works with approximate real numbers.
In[25]:= BaseForm[2.3, 2]
Out[25]//BaseForm=
10.0100110011001100112
You can even use BaseForm for numbers printed in scientific notation.
In[26]:= BaseForm[2.3 10^8, 2]
Out[26]//BaseForm=
1.10110110101100001012 × 227
Berikut adalah daftarnya.
Dalam[1]:= Tabel[(i + 45)^j, {i, 3}, {j, 3}]
Keluar[1]= 8846, 2116, 97336<, 847, 2209, 103823<, 848, 2304, 110592<<
TableForm menampilkan daftar dalam format tabel.

Dalam[2]:= TabelForm[%]
Keluar[2]//TableForm=
46 2116 97336
47 2209 103823
48 2304 110592
MatrixForm menampilkan daftar sebagai matriks.
Dalam[3]:= Bentuk
Matriks[%] Keluar[3]//Bentuk
Matriks= ij 46 2116 97336 yz j
47 2209 103823 z
jz
j 48 2304 110592 z
k{
Ini menampilkan larik ekspresi aljabar sebagai matriks.
Dalam[4]:= MatrixForm[ Tabel[xî - y^j, {i, 3}, {j, 3}] ]
Keluar[4]//Bentuk
Matriks= ij x y x y2 x y3 yz
j22223zjxyxyxyzj
33233zkxyxyxy{
Here is a list of numbers.

In[5]:= fac = {10!, 15!, 20!}
Out[5]= 83628800, 1307674368000, 2432902008176640000<
TableForm displays the list in a column.
In[6]:= TableForm[fac]
Out[6]//TableForm=
3628800
1307674368000
2432902008176640000
Berikut adalah output ekspresi dalam gaya yang biasanya digunakan untuk judul bagian.
In[7]:= PaddedForm[TableForm[fac], 20]
Out[7]//PaddedForm=
3628800
1307674368000
2432902008176640000
In this particular case, you could also align the numbers using the TableAlignments option.
In[8]:= TableForm[fac, TableAlignments -> {Right}]
Out[8]//TableForm=
3628800
1307674368000
2432902008176640000
This lines up the numbers, padding each one to have room for 8 digits, with 5 digits to the right of the
decimal point.
In[9]:= PaddedForm[TableForm[{6.7, 6.888, 6.99999}], {8, 5}]
Out[9]//PaddedForm=
6.70000
6.88800
6.99999
You can use TableForm and MatrixFormt o format lists that are nested to any depth, corresponding to
arrays with any number of dimensions.
Here is the format for a 2 ä 2 array of elements a[i, j].
In[10]:= TableForm[ Array[a, {2, 2}] ]
Out[10]//TableForm=
a@1, 1D a@1,
2D a@2, 1D a@2,
2D
Here is a 2 ä 2 ä 2 array.
In[11]:= TableForm[ { Array[a, {2, 2}], Array[b, {2, 2}] } ]
Out[11]//TableForm=
a a@1, 2D
@1, 1D b@1, 1D b@1, 2D
a section headings.
In[4]:= StyleForm[x^2 + y^2,

"Section"]
@
2,
1 D O
a
@ ut[4]//St
2 , yleForm
2
b =
D
x2 + y2
@
2, 2.1.1 Representing Textual Forms by
1 Boxes
D Berikut adalah kotak yang sesuai dengan ekspresi a + b. b
@
2 Dalam[1]:= ToBox[a + b]
,
2 Keluar[1]= RowBox@8a, +, b<D
D
DisplayForm menunjukkan bagaimana kotak-kotak ini akan ditampilkan.
Di[2]:= DisplayForm[%]
2.9.9 Styles and Keluar[2]//DisplayForm= a
Fonts in Output +b
In[1]:=
{x^2,
StyleForm[x^
2,
FontWeight-
>"Bold"]}
Out[1]=
8x2, x2<
Here is
an expression
output in the
style
normally
used for
And here is a 2 ä 2 ä 2 ä 2 array.
In[12]:= TableForm[ { {Array[a, {2, 2}], Array[b, {2, 2}]}, {Array[c, {2, 2}], Array[d,
{2, 2}]} } ]
Out[12]//TableForm= a@1,
a@1, 2D b@1, 1D b@1, 2D
1D
a@2, a@2, 2D b@2, 1D b@2, 2D
1D
c@1, c@1, 2D d@1, 1D d@1, 2D
1D
c@2, c@2, 2D d@2, 1D d@2, 2D
1D
Ini menampilkan tiga string berturut-turut.
Dalam[3]:= RowBox[{"a", "+", "b"}] //
TampilanForm Keluar[3]//DisplayForm= a + b
Ini menampilkan satu string sebagai subskrip dari yang lain.
Dalam[4]:= SubscriptBox["a", "i"] // TampilanForm
Keluar[4]//Formulir Tampilan=
ai
Ini menempatkan dua kotak subskrip berturut-turut.
Di[5]:= RowBox[{SubscriptBox["a", "1"], SubscriptBox["b", "2"]}] //

DisplayForm Keluar[5]//DisplayForm= a1 b2
Sintaks Bahasa Mathematica
Mathematica menggunakan berbagai aturan sintaksis untuk menginterpretasikan input yang

Anda berikan, dan untuk mengubah string dan kotak menjadi ekspresi. Versi aturan ini
yang digunakan untuk StandardForm dan InputForm berlaku mendefinisikan
bahasa Mathematica dasar. Aturan yang digunakan untuk formulir lain, seperti
TraditionalForm, mengikuti prinsip keseluruhan yang sama, tetapi berbeda dalam
banyak detail.
Saat Anda memberikan teks sebagai input ke Mathematica, hal pertama yang dilakukan
Mathematica adalah memecah teks menjadi urutan token, dengan setiap token
mewakili unit sintaksis yang terpisah. Jadi, misalnya, jika Anda memberikan input
xx+yy-zzzz, Mathematica akan memecahnya menjadi urutan token xx, +, yy,
- dan zzzz. Di sini xx, yy dan zzzz adalah token yang sesuai dengan
simbol, sedangkan + dan - adalah operator.
Operator pada akhirnya menentukan struktur ekspresi yang dibentuk dari bagian input
tertentu. Bahasa Mathematica melibatkan beberapa kelas umum operator, dibedakan oleh
posisi yang berbeda di mana mereka muncul sehubungan dengan operan mereka.
Operator biasanya bekerja dengan mengambil operan dari posisi tertentu di sekitar mereka.
Tetapi ketika sebuah string berisi lebih banyak dari satu operator, hasilnya secara
umum dapat bergantung pada operator mana yang mengambil operandnya terlebih
dahulu. Jadi, misalnya, a*b+c berpotensi ditafsirkan sebagai (a*b)+c atau sebagai
a*(b+c) tergantung pada apakah * atau + mengambil operannya terlebih dahulu.
Untuk menghindari ambiguitas tersebut, Mathematica memberikan prioritas untuk

setiap operator yang dapat muncul. Operator dengan yang lebih tinggi didahulukan
kemudian diambil untuk mengambil operan mereka terlebih dahulu. Jadi, misalnya,
operator perkalian * diberi prioritas lebih tinggi daripada +, sehingga ia mengambil
operanoperannya pertama, dan a*b+c diinterpretasikan sebagai (a*b)+c daripada
a*(b+c)
Apa pun prioritas operator yang Anda gunakan, Anda selalu dapat menentukan struktur
ekspresi yang Anda gunakan ingin membentuk dengan secara eksplisit memasukkan tanda
kurung yang sesuai.
Sintaks bahasa Mathematica didefinisikan tidak hanya untuk karakter yang dapat Anda
ketik pada keyboard biasa, tetapi juga untuk semua karakter khusus yang didukung
Mathematica. Surat-surat seperti g , dan ¡dari alfabet mana pun diperlakukan seperti huruf
Inggris biasa, dan misalnya dapat muncul atas nama simbol. Hal yang sama berlaku untuk
bentuk seperti huruf seperti ¶, Ñ, dan — . Tetapi banyak karakter khusus lainnya
diperlakukan sebagai operator.
Input ke Mathematica dapat diberikan tidak hanya dalam bentuk string satu dimensi, tetapi
juga dalam bentuk kotak dua dimensi. Sintaks bahasa Mathematica tidak hanya mencakup
konstruksi satu dimensi tetapi juga yang dua dimensi.
Operator tanpa Makna Bawaan
Saat Anda memasukkan input seperti 2 + 2, Mathematica pertama-tama mengenali +

sebagai operator dan membuat ekspresi Plus[2, 2], lalu menggunakan aturan bawaan
untuk Plus untuk mengevaluasi ekspresi dan mendapatkan hasilnya 4. Tetapi tidak semua
operator yang dikenali oleh Mathematica dikaitkan dengan fungsi yang memiliki makna
bawaan. Mathematica juga mendukung beberapa ratus operator tambahan yang dapat
digunakan dalam membangun ekspresi, tetapi tidak aturan evaluasi awalnya ditentukan.
Anda dapat menggunakan operator ini sebagai cara untuk membangun notasi Anda sendiri
dalam bahasa Mathematica.
Anda harus menyadari bahwa meskipun fungsi CirclePlus dan CircleTimes tidak
memiliki evaluasi bawaan aturan, operator dan memang memiliki prioritas bawaan.
Mendefinisikan Format Output
Sama seperti Mathematica memungkinkan Anda untuk menentukan bagaimana ekspresi

harus dievaluasi, demikian juga memungkinkan Anda untuk menentukan bagaimana
ekspresi harus diformat untuk output. Ide dasarnya adalah bahwa setiap kali Mathematica
diberikan ekspresi untuk format untuk output, pertama-tama ia memanggil
Format[expr] untuk mengetahui apakah ada aturan khusus untuk memformat ekspresi
telah didefinisikan. Dengan menetapkan nilai ke Format[expr], Anda dapat memberi
tahu Mathematica bahwa Anda menginginkan yang tertentu jenis ekspresi yang akan
dihasilkan dengan cara khusus.
Ketika Anda memiliki formulir keluaran yang melibatkan operator, muncul pertanyaan
apakah argumen dari beberapa di antaranya harus di dalam kurung. Ketika kamu mengatur
formulir keluaran yang melibatkan operator, Anda dapat menggunakan
PrecedenceForm untuk menentukan prioritas untuk ditetapkan ke masing-masing
operator. Mathematica menggunakan bilangan bulat dari 1 hingga 1000 untuk mewakili
"tingkat prioritas". Semakin tinggi tingkat prioritas untuk operator, semakin sedikit yang
perlu diberi tanda kurung.
Topik Lanjutan: Aturan Input dan Output Tingkat Rendah
MakeExpression menafsirkan kotak tetapi menggunakan HoldComplete untuk

mencegah ekspresi yang dihasilkan dievaluasi.
Di dalam Mathematica terdapat sejumlah besar aturan untuk menghasilkan keluaran dan
menginterpretasikan masukan. Khususnya di StandardForm, aturan ini diatur dengan
hati-hati agar konsisten, dan untuk memungkinkan input dan output digunakan secara
bergantian. Sangat jarang Anda perlu mengubah aturan ini. Alasan utamanya adalah
Mathematica sudah memiliki aturan bawaan untuk input dan output dari banyak operator
yang tidak diberikan arti khusus. Jadi, jika Anda ingin menambahkan, misalnya, bentuk
penjumlahan yang digeneralisasi, Anda biasanya dapat menggunakan operator seperti
untuk yang Mathematica sudah memiliki aturan input dan output bawaan.
Dalam menangani output, Anda dapat membuat definisi untuk Format[expr] untuk
mengubah cara ekspresi tertentu akan diformat. Namun, Anda harus menyadari bahwa
segera setelah Anda melakukan ini, tidak ada jaminan bahwa formulir keluaran ekspresi
Anda akan ditafsirkan dengan benar jika diberikan sebagai input Mathematica. Jika Anda
mau, Mathematica memungkinkan Anda untuk mendefinisikan kembali aturan dasar yang
digunakannya untuk input dan output semua ekspresi. Anda bisa melakukan ini oleh
membuat definisi untuk MakeBox dan MakeExpression. Anda Sebaiknya menyadari,
Namun, bahwa kecuali Anda membuat definisi seperti itu dengan sangat hati-hati,
kemungkinan besar Anda akan mendapatkan hasil yang tidak konsisten.
Saat Anda memberikan definisi untuk MakeBox, Anda dapat menganggap ini sebagai versi
pemberian definisi tingkat rendah untuk Format. Perbedaan penting adalah bahwa
MakeBoxes tidak mengevaluasi argumennya, sehingga Anda dapat menentukan aturan
untuk memformat ekspresi tanpa khawatir tentang bagaimana ekspresi ini akan dievaluasi.
Selain itu, saat Format dipanggil kembali secara otomatis pada hasil apa pun yang diperoleh
dengan menerapkannya, hal yang sama tidak berlaku untuk MakeBox. Artinya, dalam
memberikan definisi untuk MakeBox Anda secara eksplisit harus memanggil MakeBox
lagi di subekspresi apa pun yang masih perlu diformat.
Menghasilkan Output Tidak Terstruktur
Fungsi yang dijelaskan sejauh ini di bagian ini menentukan bagaimana ekspresi harus
diformat saat dicetak, tetapi mereka tidak benar-benar menyebabkan apa pun untuk dicetak.
Dalam cara paling umum menggunakan Mathematica, Anda sebenarnya tidak pernah
secara eksplisit harus mengeluarkan perintah untuk menghasilkan keluaran. Biasanya,
Mathematica secara otomatis mencetak hasil akhir yang didapat dari pemrosesan input
yang Anda berikan. Namun, terkadang, Anda mungkin ingin Mathematica mencetak
ekspresi pada tahap menengah dalam operasinya. Anda dapat melakukan ini dengan
menggunakan fungsi Print.
Print hanya mengambil argumen yang Anda berikan, dan mencetaknya satu demi satu,
tanpa spasi di antaranya. Di dalam banyak kasus, Anda perlu mencetak output dalam format
yang lebih rumit. Anda dapat melakukan ini dengan memberikan formulir keluaran sebagai
argumen untuk Print
Menghasilkan Output Bergaya di Notebook

Requesting Input
Mathematica biasanya bekerja dengan mengambil input apa pun yang Anda berikan, dan
kemudian memprosesnya. Namun, terkadang Anda mungkin ingin memiliki program
yang Anda tulis secara eksplisit meminta lebih banyak masukan.
Anda dapat melakukan ini menggunakan Input dan InputString.
Messages
Mathematica memiliki mekanisme umum untuk menangani pesan yang dihasilkan selama
perhitungan. Banyak built-in Mathematica Fungsi gunakan mekanisme ini untuk
menghasilkan pesan kesalahan dan peringatan. Anda juga dapat menggunakan mekanisme
untuk pesan Terkait dengan fungsi yang Anda tulis. Ide dasarnya adalah bahwa setiap pesan
memiliki nama yang pasti, dalam bentuk simbol::tag. Anda dapat menggunakan nama ini
untuk merujuk ke pesan. (The Object Symbol::tag memiliki kepala MessageName.)
Anda dapat menggunakan On dan Off untuk mengontrol pencetakan pesan tertentu. Pesan
terbanyak terkait dengan fungsi bawaan diaktifkan secara default. Anda dapat
menggunakan Off untuk mematikannya jika Anda tidak mau meihat mereka.
Meskipun sebagian besar pesan yang terkait dengan fungsi bawaan diaktifkan secara
default, ada beberapa yang dimatikan secara default, dan yang hanya akan Anda lihat jika
Anda mengaktifkannya secara eksplisit. Contohnya adalah pesan General::newssym
Pesan selalu disimpan sebagai string yang cocok untuk digunakan dengan StringForm.
Ketika pesan dicetak, yang sesuai ekspresi adalah "disambung" ke dalamnya. Ekspresi
dibungkus dengan HoldForm untuk mencegah evaluasi.
Tambahan, fungsi apa pun yang ditetapkan sebagai nilai variabel global
$MessagePrePrint diterapkan ke hasil ekspresi sebelum diberikan ke StringForm.
Default untuk $MessagePrePrint adalah Short
Jika Anda memberikan jumlah argumen yang salah ke fungsi F, Mathematica akan
memperingatkan Anda dengan mencetak pesan seperti: F::argx. Jika Mathematica tidak
dapat menemukan pesan bernama F::argx, itu akan menggunakan teks dari pesan "umum"
General::argx sebagai gantinya. Anda dapat menggunakan Off[F::argx] untuk
menonaktifkan pesan jumlah argumen khusus untuk fungsi F. Anda juga dapat
menggunakan Off[General::argx] untuk menonaktifkan semua pesan yang
menggunakan teks general pesan.
Jika ada yang salah dengan perhitungan yang Anda lakukan, biasanya pesan peringatan
yang sama adalah dihasilkan berulang-ulang. Ini biasanya lebih membingungkan daripada
berguna. Akibatnya, Mathematica melacak semua pesan yang dihasilkan selama
perhitungan tertentu, dan berhenti mencetak pesan tertentu jika muncul lebih banyak dari
tiga kali. Kapan pun ini terjadi, Mathematica mencetak pesan General::stop untuk
memberi tahu Anda. Jika kamu benar-benar ingin melihat semua pesan yang Mathematica
coba cetak, Anda dapat melakukannya dengan mematikan General::stop.
Dalam setiap perhitungan yang Anda lakukan, Mathematica menyimpan daftar

$MessageList dari semua pesan yang dihasilkan. Di dalam sesi Mathematica standar,
daftar ini dihapus setelah setiap baris output dihasilkan. Selain itu, ketika 𝑛𝑡ℎ baris output
dalam sesi dihasilkan, nilai $MessageList ditetapkan ke MessageList[n]
Dalam menulis program, seringkali penting untuk dapat memeriksa secara otomatis apakah
ada pesan yang dihasilkan selama perhitungan tertentu. Jika pesan dihasilkan, katakan
sebagai konsekuensi dari menghasilkan numerik tak tentu hasil, maka hasil perhitungan
mungkin tidak ada artinya.
Check[expr, failexpr] tes untuk semua pesan yang benar-benar dicetak. Itu tidak menguji
pesan yang outputnya telah ditekan menggunakan Off.
Dengan menggunakan fungsi Pesan, Anda dapat meniru semua aspek fungsi Mathematica
bawaan menghasilkan pesan. Misalnya, Anda dapat mengaktifkan dan menonaktifkan
pesan menggunakan On dan Off, dan Pesan akan otomatis mencari General::tag
jika tidak menemukan pesan spesifik s::tag
International Messages
The standard set of messages for built-in Mathematica functions are written in American
English. In some versions of Mathematica, messages are also available in other languages.
In addition, if you set up messages yourself, you can give ones in other languages. Languages
in Mathematica are conventionally specified by strings. The languages are given in
English, in order to avoid the possibility of needing special characters. Thus, for example,
the French language is specified in Mathematica as "French".
Ketika fungsi Mathematica built-in menghasilkan pesan, mereka pertama-tama mencari
pesan dalam bentuk s::t::Language, di bahasa yang ditentukan oleh $Language. Jika
mereka gagal menemukan pesan seperti itu, maka mereka menggunakan formulir s::t tanpa
spesifikasi bahasa yang eksplisit
Prosedur yang digunakan oleh fungsi bawaan juga akan diikuti oleh fungsi yang Anda
tentukan jika Anda memanggil Message dengan nama pesan dalam bentuk s::t. Namun,
jika Anda memberikan bahasa eksplisit dalam nama pesan, hanya bahasa tersebut yang
akan digunakan.
Konstruksi Dokumentasi
Saat Anda menulis program di Mathematica, ada berbagai cara untuk mendokumentasikan
kode Anda. Seperti biasa, sejauh ini yang terbaik masalahnya adalah menulis kode yang
jelas, dan memberi nama objek yang Anda definisikan sejelas mungkin.
Namun, terkadang Anda mungkin ingin menambahkan beberapa "teks komentar" ke kode
Anda, untuk membuatnya lebih mudah dipahami. Anda dapat menambahkan teks seperti itu
kapan saja dalam kode Anda hanya dengan melampirkannya pada pencocokan (* dan *).
Perhatikan bahwa dalam Mathematica, "komentar" yang diapit (* dan *) dapat disarangkan
dengan cara apa pun
Saat Anda mendefinisikan fungsi f, Anda biasanya dapat menampilkan nilainya menggunakan ?f.
Namun, jika Anda memberikan pesan penggunaan untuk f, lalu ?f hanya memberikan pesan penggunaan.
Hanya ketika Anda mengetik ??f Anda mendapatkan semua detail tentang f, termasuk yang sebenarnya
definisi.
Struktur Grafik dan Suara

Ide dasarnya adalah bahwa Mathematica mewakili semua grafik dalam bentuk kumpulan
graphic primitives. Orang-orang primitif adalah benda-benda Suka Point, Line dan
Polygon, itu mewakili elemen dari sebuah grafis gambar, sebagai dengan baik sebagai
arahan seperti RGBColor, Thickness dan SurfaceColor.
Setiap bagian grafik yang lengkap di Mathematica direpresentasikan sebagai objek grafik.
Ada beberapa jenis yang berbeda objek grafis, sesuai dengan berbagai jenis grafis. Setiap
jenis objek grafis memiliki kepala tertentu yang mengidentifikasi jenisnya
Fungsi seperti Plot dan ListPlot semuanya bekerja dengan membangun grafik
Mathematica objek, dan kemudian menampilkannya
Anda dapat membuat jenis gambar grafis lain di Mathematica dengan membangun objek
grafik Anda sendiri. Sejak objek grafik di Mathematica hanyalah ekspresi simbolis, Anda
dapat menggunakan semua fungsi Mathematica standar untuk memanipulasi mereka.
Setelah Anda membuat objek grafis, Anda harus menampilkannya. Fungsi Show
memungkinkan Anda untuk menampilkan apapun objek grafik Mathematica.
Diberikan daftar tertentu dari grafik primitif, Mathematica menyediakan dua mekanisme
dasar untuk memodifikasi final bentuk grafik yang Anda dapatkan. Pertama, Anda dapat
memasukkan ke dalam daftar grafik primitif graphic directives tertentu, seperti
RGBColor, yang memodifikasi elemen grafis berikutnya dalam daftar. Dengan cara ini,
Anda dapat menentukan bagaimana set elemen grafis harus diberikan.
Anda dapat menentukan opsi grafik di Show. Akibatnya, mudah untuk mengambil satu
objek grafik, dan menunjukkannya dengan banyak pilihan pilihan grafis yang berbeda.
Namun perhatikan bahwa Show selalu mengembalikan objek grafis yang telah
ditampilkannya. Jika Anda menentukan opsi grafik di Show, lalu opsi ini secara otomatis
dimasukkan ke dalam objek grafik yang ditampilkan kembali. Akibatnya, jika Anda
menelepon Show lagi pada objek yang sama, opsi grafik yang sama akan digunakan,
kecuali jika Anda secara eksplisit menentukan yang lain. Catatan bahwa dalam semua
kasus, opsi baru yang Anda tentukan akan menimpa yang sudah ada.
Beberapa opsi grafik bekerja dengan mengharuskan Anda menentukan nilai tertentu untuk
parameter yang terkait dengan bagian grafik. Opsi lain memungkinkan Anda untuk
memberikan pengaturan Automatic, yang membuat Mathematica menggunakan
algoritme internal untuk memilih nilai yang sesuai untuk parameter. Dalam kasus seperti
itu, Anda dapat mengetahui nilai yang sebenarnya digunakan Mathematica oleh
menerapkan fungsi AbsoluteOptions.
Saat Anda menggunakan opsi grafik seperti Axes, Mathematica secara efektif harus
membuat daftar elemen grafik untuk mewakili objek seperti sumbu yang Anda minta.
Biasanya Mathematica tidak secara eksplisit mengembalikan daftar itu konstruksi dengan
cara ini. Namun, terkadang Anda mungkin merasa berguna untuk mendapatkan daftar ini.
Fungsi FullGraphics memberikan daftar lengkap grafik primitif yang diperlukan untuk
menghasilkan plot tertentu, tanpa opsi apa pun yang digunakan.
Dengan pengaturan opsi default, fungsi seperti Plot dan Show sebenarnya menyebabkan
Mathematica menghasilkan grafik keluaran. Secara umum, generasi sebenarnya dari output
grafis dikendalikan oleh opsi grafis DisplayFunction. Pengaturan default untuk opsi
ini adalah nilai variabel global $DisplayFunction. Dalam kebanyakan kasus,
$DisplayFunction dan opsi DisplayFunction disetel untuk menggunakan rendering
tingkat rendah function Tampilan untuk menghasilkan output, mungkin setelah beberapa
pra pemrosesan. Namun, terkadang Anda mungkin ingin mendapatkan berfungsi seperti
Plot untuk menghasilkan objek grafik, tetapi Anda mungkin tidak segera menginginkan
objek grafik itu sebenarnya dirender sebagai keluaran. Anda dapat memberi tahu
Mathematica untuk menghasilkan objek, tetapi tidak merendernya, dengan menyetel opsi
Display Function -> Identity.
Elemen Grafis Dua Dimensi

Anda dapat menggabungkan elemen grafis yang berbeda hanya dengan memberikannya
dalam daftar. Dalam grafik dua dimensi, Mathematica kan memberikan itu elemen dalam
tepat itu memesan Anda Memberi mereka. Nanti elemen adalah karena itu ditarik secara
efektif pada atas dari lebih awal yang.
Ini
menunjukkan dua lingkaran dengan radius 2. Mengatur opsi AspectRatio -> Automatic membuat lingkaran keluar
dengan rasio aspek alami
Mathematica memungkinkan Anda untuk menghasilkan busur lingkaran, dan segmen
elips. Dalam kedua kasus, objek ditentukan oleh sudut awal dan akhir. Sudut diukur
berlawanan arah jarum jam dalam radian dengan nol sesuai dengan arah x positif.
Dalam kasus default, Raster selalu menghasilkan larik sel abu-abu. Anda dapat
menggunakan opsi ColorFunction untuk menerapkan "fungsi pewarnaan" ke semua sel.
Anda juga dapat menggunakan RasterArray primitif grafis. Sementara Raster
mengambil array nilai, RasterArray mengambil serangkaian arahan grafis Mathematica.
Arahan yang terkait dengan setiap sel diambil untuk menentukan warna sel itu. Biasanya
arahan dipilih dari set GrayLevel, RGBColor atau Hue. Dengan menggunakan
RGBColor dan Hue, Anda dapat membuat raster warna menggunakan RasterArray.
Arahan dan Opsi Grafis

Saat Anda menyiapkan objek grafis di Mathematica, Anda biasanya memberikan daftar
elemen grafis. Anda dapat memasukkan yang mencantumkan graphic directives yang
menentukan bagaimana elemen selanjutnya dalam daftar harus dirender. Secara umum,
elemen grafis dalam objek grafis tertentu dapat diberikan dalam kumpulan daftar bersarang.
ketika kamu masukkan arahan grafik dalam struktur semacam ini, aturannya adalah arahan
grafik tertentu memengaruhi semua yang berikutnya elemen dari daftar itu, bersama dengan
semua elemen dari subdaftar yang mungkin terjadi. Arahan grafis tidak, namun, memiliki
efek di luar daftar yang ada.
Mathematica menyediakan berbagai macam arahan grafis. Satu set penting adalah untuk
menentukan warna elemen grafis. Bahkan jika Anda memiliki perangkat layar hitam-putih,
Anda masih dapat memberikan arahan grafis berwarna. Itu warna yang Anda tentukan akan
dikonversi ke tingkat abu-abu pada langkah terakhir dalam proses rendering grafis.
Perhatikan bahwa Anda bisa dapatkan tampilan tingkat abu-abu bahkan pada perangkat
berwarna dengan menyetel opsi ColorOutput -> GrayLevel.
Fungsi Hue[h] menyediakan cara mudah untuk menentukan rentang warna hanya
dengan menggunakan satu parameter. Karena h bervariasi dari 0 hingga 1, Hue[h] melewati
warna merah, kuning, hijau, cyan, biru, magenta, dan kembali ke merah lagi. Warna[h, s, b]
memungkinkan Anda untuk menentukan tidak hanya "rona", tetapi juga "saturasi" dan
"kecerahan" warna. Mengambil satu-tion menjadi sama dengan satu memberikan warna
terdalam; penurunan saturasi menuju nol mengarah ke semakin banyak warna-warna yang
“terhapus”. Untuk sebagian besar tujuan, Anda akan dapat menentukan warna yang Anda
butuhkan hanya dengan memberikan RGBColor atau Hue yang sesuai arahan. Namun, jika
Anda membutuhkan warna yang sangat presisi atau berulang, terutama untuk pencetakan
berwarna, ada beberapa: kehalusan yang muncul. Saat Anda memberikan arahan grafis
seperti RGBColor, itu memengaruhi semua elemen grafis berikutnya yang muncul di a
daftar tertentu. Mathematica juga mendukung berbagai arahan grafik yang hanya
memengaruhi jenis grafik tertentu elemen. Arahan grafis PointSize[d] menetapkan
bahwa semua elemen Titik yang muncul dalam objek grafis harus digambarkan sebagai
lingkaran dengan diameter d. Di PointSize, diameter d diukur sebagai sebagian kecil dari
lebar keseluruhan Anda merencanakan. Mathematica juga menyediakan direktif grafis
AbsolutePointSize[d], yang memungkinkan Anda untuk menentukan diameter titik
"mutlak", diukur dalam satuan tetap. Satuannya adalah 1 ÅÅÅÅÅÅÅ 72 inci, kira-kira poin
printer.
Arahan grafis Dashing memungkinkan Anda untuk membuat garis dengan berbagai
jenis dashing. Ide dasarnya adalah untuk menghancurkan garis menjadi segmen-segmen yang
ditarik dan dihilangkan secara bergantian. Dengan mengubah panjang segmen, Anda bisa
mendapatkan gaya garis yang berbeda. Dashing memungkinkan Anda untuk menentukan
urutan panjang segmen. Urutan ini diulang sebanyak kali seperlunya dalam menggambar
seluruh garis.
Salah satu cara untuk menggunakan direktif grafik Mathematica adalah dengan
memasukkannya langsung ke dalam daftar grafik primitif yang digunakan oleh objek grafis.
Namun, terkadang Anda ingin arahan grafis diterapkan lebih global, dan
misalnya untuk menentukan "gaya" keseluruhan yang dengannya jenis elemen grafis tertentu
harus dirender. Ada biasanya opsi grafik yang dapat diatur untuk menentukan gaya seperti
itu dalam hal daftar arahan grafik.

banyak detail.

a*(b+c)
kurung yang sesuai.
Sintaks bahasa Mathematica didefinisikan tidak hanya untuk karakter yang dapat Anda ketik
pada keyboard biasa, tetapi juga untuk semua karakter khusus yang didukung Mathematica.
Surat-surat seperti g , dan ¡dari alfabet mana pun diperlakukan seperti huruf Inggris biasa,
dan misalnya dapat muncul atas nama simbol. Hal yang sama berlaku untuk bentuk seperti
huruf seperti ¶, Ñ, dan — . Tetapi banyak karakter khusus lainnya diperlakukan sebagai
operator.



argumen untuk Print

Requesting Input
yang Anda tulis secara eksplisit meminta lebih banyak masukan.
Anda dapat melakukan ini menggunakan Input dan InputString.
Messages

akan digunakan.
dengan cara apa pun
definisi.


Ini

printer.
seluruh garis.
Namun, terkadang Anda ingin arahan grafis diterapkan lebih global, dan misalnya untuk
menentukan "gaya" keseluruhan yang dengannya jenis elemen grafis tertentu harus dirender.
Ada biasanya opsi grafik yang dapat diatur untuk menentukan gaya seperti itu dalam hal
daftar arahan grafik.

banyak detail.

a*(b+c)
kurung yang sesuai.
Sintaks bahasa Mathematica didefinisikan tidak hanya untuk karakter yang dapat Anda
ketik pada keyboard biasa, tetapi juga untuk semua karakter khusus yang didukung
Mathematica. Surat-surat seperti g , dan ¡dari alfabet mana pun diperlakukan seperti huruf
Inggris biasa, dan misalnya dapat muncul atas nama simbol. Hal yang sama berlaku untuk
bentuk seperti huruf seperti ¶, Ñ, dan — . Tetapi banyak karakter khusus lainnya
diperlakukan sebagai operator.



argumen untuk Print

Requesting Input
yang Anda tulis secara eksplisit meminta lebih banyak masukan. Anda dapat melakukan
ini menggunakan Input dan InputString.
Messages

akan digunakan.
dengan cara apa pun
definisi.


Ini

printer.
seluruh garis.
Namun, terkadang Anda ingin arahan grafis diterapkan lebih global, dan misalnya untuk
menentukan "gaya" keseluruhan yang dengannya jenis elemen grafis tertentu harus dirender.
Ada biasanya opsi grafik yang dapat diatur untuk menentukan gaya seperti itu dalam hal
daftar arahan grafik.
Dengan PlotRange default -> Otomatis, titik terluar tidak disertakan, tetapi memengaruhi rentang
koordinat yang dipilih.
Show[ Graphics[{obj, Point[{20, 20}]}] ]
Dengan PlotRange -> Semua, titik terluar disertakan, dan sistem koordinat dimodifikasi secara bersamaan.
Show[%, PlotRange -> All]
Opsi PlotRange memungkinkan Anda untuk menentukan wilayah persegi panjang dalam sistem
koordinat asli, dan untuk menjatuhkan elemen grafis yang terletak di luar wilayah ini. Namun, untuk
merender elemen yang tersisa, Matematika kemudian harus menentukan bagaimana memposisikan wilayah
persegi panjang ini sehubungan dengan area tampilan akhir. Opsi PlotRegion memungkinkan Anda untuk
menentukan di mana sudut-sudut wilayah persegi panjang berada dalam tampilan akhir daerah. Posisi sudut
ditentukan dalam koordinat skala, yang didefinisikan berjalan dari 0 hingga 1 melintasi area tampilan.
Standarnya adalah PlotRegion -> {{0, 1}, {0, 1}}, yang menetapkan bahwa wilayah persegi panjang harus
isi seluruh area tampilan.,
Dengan menentukan PlotRegion, Anda dapat secara efektif menambahkan "margin" di sekitar plot Anda.
Plot[ArcTan[x], {x, 0, 10}, PlotRegion -> {{0.2, 0.8}, {0.3, 0.7}}]
AspectRatio −> r = membuat rasio tinggi terhadap lebar untuk area tampilan sama
dengan r
AspectRatio −> Automatic = menentukan bentuk area tampilan dari sistem koordinat asli
Apa yang telah kita diskusikan sejauh ini adalah bagaimana Matematika menerjemahkan koordinat asli
yang Anda tentukan ke dalam posisi di area tampilan akhir. Namun, apa yang masih perlu didiskusikan
adalah seperti apa area tampilan akhir. Pada sebagian besar sistem komputer, ada area layar atau kertas
tertentu yang menjadi area tampilan Matematika harus sesuai. Kesesuaian dengan wilayah ini ditentukan
oleh "bentuk" atau rasio aspeknya. Secara umum, opsi AspectRatio menentukan rasio tinggi terhadap lebar
untuk area tampilan akhir. Penting untuk dicatat bahwa pengaturan AspectRatio tidak mempengaruhi arti
dari skala atau koordinat tampilan. Koordinat ini selalu berjalan dari 0 hingga 1 di seluruh area tampilan.
Apa yang dilakukan AspectRatio adalah mengubah hex = Graphics[Polygon[
Table[{Sin[n Pi/3], Cos[n Pi/3]}, {n, 6}] ]] ;
Show[hex, AspectRatio -> 3]
Untuk grafik dua dimensi, AspectRatio diatur secara default ke nilai tetap 1/GoldenRatio. Namun,
terkadang, Anda mungkin ingin menentukan rasio aspek untuk plot dari sistem koordinat asli yang digunakan
dalam plot. Biasanya yang Anda inginkan adalah agar satu unit dalam arah x dalam sistem koordinat asli
sesuai dengan yang sama jarak di tampilan akhir sebagai satu unit dalam arah y. Dengan cara ini, objek yang
Anda tentukan dalam koordinat asli sistem ditampilkan dengan "bentuk alami" mereka. Anda dapat
mewujudkannya dengan menyetel opsi AspectRatio -> Otomatis.
Dengan AspectRatio -> Otomatis, rasio aspek area tampilan akhir ditentukan dari sistem koordinat asli,
dan segi enam ditampilkan dengan "bentuk alaminya".
Show[hex, AspectRatio -> Automatic]
Menggunakan koordinat skala, Anda dapat menentukan ukuran elemen grafis sebagai pecahan dari
ukuran area tampilan. Namun, Anda tidak dapat memberi tahu Mathematica ukuran fisik sebenarnya di mana
elemen grafis tertentu harus dirender. Tentu saja, ukuran ini pada akhirnya tergantung pada detail perangkat
output grafis Anda, dan tidak dapat ditentukan secara pasti dalam Mathematica. Namun demikian, arahan
grafis seperti AbsoluteThickness yang dibahas dalam Bagian 2.10.3 memungkinkan Anda untuk
menunjukkan "ukuran absolut" yang akan digunakan untuk elemen grafis tertentu. Ukuran yang Anda minta
dengan cara ini akan dipatuhi oleh sebagian besar, tetapi tidak semua, perangkat keluaran. (Misalnya, jika
Anda memproyeksikan gambar secara optik, tidak mungkin atau tidak diinginkan untuk mempertahankan
ukuran absolut yang sama untuk elemen grafis di dalamnya.)
2.10.5 Labeling Two-Dimensional Graphics
Axes −> True = berikan sepasang sumbu
GridLines −> Automatic = menggambar garis grid di plot
Frame −> True = letakkan sumbu pada bingkai di sekitar plot
PlotLabel −> " text " = berikan label keseluruhan untuk plotnya
Berikut adalah plotnya, menggunakan Axes default -> True.
Frame -> True menghasilkan bingkai dengan sumbu, dan menghilangkan tanda centang dari sumbu biasa.
Ini termasuk garis kisi, yang ditampilkan dalam warna biru muda pada layar berwarna.
Axes −> False = menggambar tanpa sumbu
Axes −> True = gambar sumbu x dan y
Axes −> { False, True } = menggambar sumbu y tetapi tidak ada sumbu
x
AxesOrigin −> Automatic = pilih titik persimpangan untuk sumbu secara otomatis
AxesOrigin −> { x, y } = tentukan titik persimpangan
AxesStyle −> style = tentukan gaya untuk sumbu
AxesStyle −> {{ xstyle }, { ystyle }} = tentukan gaya individu untuk sumbu
AxesLabel −> None = tidak memberikan label sumbu
AxesLabel −> ylabel = beri label pada sumbu y

AxesLabel −> { xlabel, ylabel } = beri label pada sumbu x dan y
Ini membuat sumbu bersilangan di titik {5, 0}, dan memberi label pada setiap sumbu.
Ticks −> None = tidak menggambar tanda centang
Ticks −> Automatic = tempatkan tanda centang secara otomatis
Ticks −> {xticks, yticks} = spesifikasi tanda centang untuk setiap sumbu
Dengan pengaturan default Ticks -> Automatic, Mathematica membuat sejumlah tanda centang mayor
dan minor, dan menempatkannya pada sumbu pada posisi yang menghasilkan jumlah minimum digit desimal
pada label centang. Namun, dalam beberapa kasus, Anda mungkin ingin menentukan posisi dan properti
tanda centang secara eksplisit. Anda perlu melakukan ini, misalnya, jika Anda ingin memiliki tanda centang
pada kelipatan p, atau jika Anda ingin meletakkan skala nonlinier pada sumbu.
None = tidak menggambar tanda centang
Automatic = tempatkan tanda centang secara otomatis
{ x1, x2, ... } = menggambar tanda centang di posisi yang ditentukan
{ { x1, label1 <, 8 x2, label2 }, ... } = menggambar tanda centang dengan label yang ditentukan
{ { x1 , label1, len1 }, ... } = menggambar tanda centang dengan panjang skala
yang ditentukan
{ { x1, label1, { plen1, mlen1 } }, ... } =menggambar tanda centang dengan panjang yang ditentukan
dalam arah positif dan negatif
{ { x1, label1, len1, style1 }, ... } =menggambar tanda centang dengan gaya yang ditentukan berfungsi
sebagai fungsi untuk diterapkan ke xmin, xmax untuk mendapatkan opsi tanda centang
Ini memberikan tanda centang pada posisi tertentu pada sumbu x, dan memilih tanda centang secara
otomatis pada sumbu y.
Ini menambahkan tanda centang tanpa label pada kelipatan 𝜋

2
Khususnya ketika Anda ingin membuat spesifikasi tanda centang yang rumit, seringkali lebih mudah
untuk mendefinisikan "fungsi tanda centang" yang menciptakan spesifikasi tanda centang yang sesuai
dengan nilai minimum dan maksimum pada sumbu tertentu.
Ini mendefinisikan fungsi yang memberikan daftar posisi tanda centang dengan spasi 1.
units[xmin_, xmax_] := Range[Floor[xmin], Floor[xmax], 1]
Ini menggunakan fungsi unit untuk menentukan tanda centang untuk sumbu x.
Terkadang Anda mungkin ingin membuat tanda centang yang hanya sedikit berbeda dari yang
dihasilkan secara otomatis dengan pengaturan Ticks -> Automatic. Anda bisa mendapatkan spesifikasi
lengkap untuk tanda centang yang dihasilkan secara otomatis di plot tertentu dengan menggunakan
AbsoluteOptions[g, Ticks], seperti yang dibahas di Bagian 2.10.1.
Frame −> False = menggambar tanpa bingkai
Frame −> True = menggambar bingkai di sekitar plot
FrameStyle −> style = tentukan gaya untuk bingkai
FrameStyle −> { { xmstyle }, { ymstyle <}, ... } = tentukan gaya untuk setiap tepi
bingkai
FrameLabel −> None = tidak memberikan label bingkai
FrameLabel −> { xmlabel, ymlabel, ... } = letakkan label di tepi bingkai
RotateLabel −> False = jangan memutar teks dalam label
FrameTicks −> None = tidak menggambar tanda centang di tepi

bingkai
FrameTicks −> Automatic = posisi tanda centang secara otomatis
FrameTicks −> { { xmticks, ymticks, ... } } = tentukan tanda centang untuk tepi
bingkai
Opsi Sumbu memungkinkan Anda menggambar sepasang sumbu dalam sebuah plot. Namun,
terkadang, Anda mungkin ingin menunjukkan skala plot pada bingkai, biasanya digambar di sekitar
keseluruhan plot. Opsi Bingkai memungkinkan Anda menggambar empat sumbu secara efektif, sesuai
dengan empat tepi bingkai di sekitar plot. Keempat sumbu ini diurutkan searah jarum jam, dimulai dari yang
paling bawah.
Ini menggambar sumbu bingkai, dan memberi label masing-masing
GridLines −> None = tidak menggambar garis kisi
GridLines −> Automatic = posisikan garis kisi secara otomatis
GridLines −> { xgrid, ygrid } = tentukan garis kisi dalam analogi dengan tanda centang
Garis kisi di Mathematica bekerja sangat mirip dengan tanda centang. Seperti halnya tanda centang,
Anda dapat menentukan posisi eksplisit untuk garis kisi. Tidak ada label atau panjang yang ditentukan untuk
garis kisi. Namun, Anda dapat menentukan gaya.
Ini menghasilkan garis kisi x tetapi tidak y.
2.10.6 Making Plots within Plots

Bagian 1.9.3 menjelaskan bagaimana Anda dapat membuat array plot yang teratur menggunakan
Graphics Array. Namun, menggunakan grafik primitif Rectangle, Anda dapat menggabungkan dan
menempatkan plot dengan cara apa pun.
Rectangle[ { xmin, ymin }, { xmax, ymax }, graphics ] = membuat objek grafis dalam persegi panjang
yang ditentukan
Berikut adalah plot tiga dimensi.
Ini menciptakan objek grafik dua dimensi yang berisi dua salinan plot tiga dimensi.
Mathematica dapat merender objek grafik apa pun dalam Rectangle. Dalam semua kasus, apa yang
dimasukkan ke dalam persegi panjang adalah versi yang diperkecil dari apa yang akan diperoleh jika Anda
menampilkan objek grafisnya sendiri. Perhatikan bahwa secara umum area tampilan untuk objek grafis akan
berukuran sehingga menyentuh setidaknya satu pasang tepi persegi panjang.
2.10.7 Density and Contour Plots

DensityGraphics[ array ] = plot kepadatan
ContourGraphics[ array ] = petak kontur
Fungsi DensityPlot dan ContourPlot yang dibahas di Bagian 1.9.5 bekerja dengan membuat objek
ContourGraphics dan DensityGraphics yang berisi array nilai.
Sebagian besar opsi untuk plot kepadatan dan kontur sama dengan plot dua dimensi biasa. Namun, ada
beberapa opsi tambahan.
Dalam plot kepadatan, warna setiap sel mewakili nilainya. Secara default, setiap sel diberi tingkat
abuabu, berjalan dari hitam ke putih saat nilai sel meningkat. Namun, secara umum, Anda dapat menentukan
"peta warna" lain untuk hubungan antara nilai sel dan warnanya. Opsi ColorFunction memungkinkan Anda
menentukan fungsi yang diterapkan ke setiap nilai sel untuk menemukan warna sel. Dengan
ColorFunctionScaling->True nilai sel diskalakan sehingga berjalan antara 0 dan 1 dalam plot kepadatan
tertentu; dengan ColorFunctionScaling->Salah tidak seperti itu
cara menetapkan warna ke setiap

apakah akan menskalakan nilai
sebelum menerapkan fungsi warna
apakah akan menggambar jaring
gaya untuk jaring
Berikut adalah daftar poligon yang sesuai dengan tetrahedron yang berpusat di titik asal.
Ini menampilkan tetrahedron sebagai objek tiga dimensi.

Ini menunjukkan empat dodecahedra yang berpotongan.
Mathematica memungkinkan poligon dalam tiga dimensi memiliki sejumlah simpul. Namun, simpul
ini harus berbohong di pesawat, dan harus membentuk sosok cembung. Jika tidak, maka Mathematica akan
memecah poligon menjadi segitiga, yang planar menurut definisi, sebelum rendering itu.
Ini menarik 20 unit kubus acak dalam ruang tiga dimensi.

2. 10. 9 Arahan Grafis Tiga Dimensi
Dalam tiga dimensi, sama seperti dalam dua dimensi, Anda dapat memberikan berbagai arahan grafik
untuk menentukan bagaimana perbedaannya elemen dalam objek grafis harus dirender.
Semua arahan grafis untuk dua dimensi juga bekerja dalam tiga dimensi. Namun ada beberapa tambahan
arahan dalam tiga dimensi.
Sama seperti dalam dua dimensi, Anda dapat menggunakan arahan PointSize, Thickness, dan Dashing
untuk memberi tahu Mathematica cara membuat elemen Titik dan Garis. Perhatikan bahwa dalam tiga
dimensi, panjang yang muncul
dalam arahan ini adalah diukur sebagai pecahan dari total lebar area tampilan untuk plot Anda.
Ini menghasilkan daftar 20 titik acak dalam tiga dimensi
As in two dimensions, you can use AbsolutePointSize, AbsoluteThickness and AbsoluteDashing if you
want to measure length in absolute units.
Ini menghasilkan garis melalui 10 titik acak dalam tiga dimensi.

Untuk objek Titik dan Garis, arahan spesifikasi warna juga bekerja sama dalam tiga
dimensi seperti dalam dua ukuran. Untuk objek Polygon, bagaimanapun, mereka dapat
bekerja secara berbeda.
Dalam dua dimensi, poligon selalu diasumsikan memiliki warna intrinsik, ditentukan
langsung oleh arahan grafis seperti RGB Color. Dalam tiga dimensi, bagaimanapun,
Mathematica juga menyediakan pilihan untuk menghasilkan warna untuk poligon
menggunakan pendekatan yang lebih fisik berdasarkan iluminasi simulasi. Dengan
pengaturan opsi default Lighting -> Benar untuk objek Graphics3D, Mathematica
mengabaikan warna eksplisit yang ditentukan untuk poligon, dan sebaliknya menentukan
semua warna poligon menggunakan model iluminasi yang disimulasikan. Bahkan dalam
kasus ini, bagaimanapun, warna eksplisit digunakan untuk titik dan garis.
Ini menggambar icosahedron, menggunakan tingkat abu-abu yang sama untuk semua
wajah.
Saat Anda merender objek grafik tiga dimensi di Mathematica, ada dua jenis garis yang
bisa muncul. Itu jenis pertama adalah garis dari garis primitif eksplisit yang Anda sertakan
dalam objek grafik. Jenis kedua adalah garis yang dihasilkan sebagai tepi poligon.
Anda dapat memberi tahu Mathematica cara membuat semua baris jenis kedua dengan
memberikan daftar arahan grafis di dalamnya bentuk Tepi.
Aspek penting dari poligon dalam tiga dimensi adalah bahwa mereka memiliki wajah
depan dan belakang. Mathematica menggunakan konvensi berikut untuk menentukan "muka
depan" poligon: jika Anda melihat poligon dari depan, maka sudutnya poligon akan muncul
berlawanan arah jarum jam, ketika diambil dalam urutan yang Anda tentukan.
Ini membuat muka depan (luar) setiap poligon abu-abu muda, dan muka belakang
(dalam) abu-abu gelap.
2. 10. 10 Sistem Koordinat untuk Grafik Tiga Dimensi

Setiap kali Mathematica menggambar objek tiga dimensi, selalu efektif menempatkan
kotak kuboid di sekitar objek. Dengan pengaturan opsi default Boxed -> True, Mathematica
sebenarnya menggambar tepi kotak ini secara eksplisit. Tapi di umum, Mathematica secara
otomatis "menjepit" setiap bagian dari objek Anda yang memanjang di luar kotak kuboid.
Opsi PlotRange menentukan rentang koordinat x, y dan z yang harus disertakan
Mathematica di dalam kotak. Sebagai dalam dua dimensi pengaturan default adalah
PlotRange -> Otomatis, yang membuat Mathematica menggunakan internal algoritma untuk
mencoba dan memasukkan "bagian yang menarik" dari sebuah plot, tetapi membuang bagian-
bagian yang terpencil. Dengan PlotRange -> Semua, Mathematica akan mencakup semua
bagian.
Ini adalah icosahedron berbintang, digambar dalam sebuah kotak. In[3]:=
Show[Graphics3D[stel], Axes -> True]

Dengan pengaturan ini untuk PlotRange, banyak bagian dari icosahedron berbintang terletak di luar kotak, dan
terpotong.
In[4]:= Show[%, PlotRange -> {-1, 1}]
Sama seperti dalam dua dimensi, Anda dapat menggunakan koordinat "asli" atau "skala" untuk menentukan posisi
elemen
dalam objek tiga dimensi. Koordinat berskala, ditetapkan sebagai Scaled[8sx, sy, sz<] diambil untuk dijalankan dari
0 hingga
1 di setiap dimensi. Koordinat diatur untuk mendefinisikan sistem koordinat tangan kanan pada kotak.
Ini menempatkan sebuah balok di salah satu sudut kotak.
In[5]:= Show[Graphics3D[{stel, Cuboid[Scaled[{0, 0, 0}], Scaled[{0.2, 0.2, 0.2}]]}]]

Setelah Anda menentukan di mana berbagai elemen grafis masuk ke dalam kotak tiga dimensi, Anda harus
memberi tahu
Mathematica cara menggambar kotak. Langkah pertama adalah menentukan bentuk kotak yang seharusnya. Ini
analog dengan
menentukan rasio aspek plot dua dimensi. Dalam tiga dimensi, Anda dapat menggunakan opsi BoxRatios untuk
tentukan perbandingan panjang sisi kotak tersebut! Untuk objek Graphics3D, defaultnya adalah BoxRatios ->
Otomatis,
menentukan bahwa bentuk kotak harus ditentukan dari rentang koordinat aktual untuk isinya.
Ini menampilkan icosahedron berbintang dalam kotak tinggi.
In[6]:= Show[Graphics3D[stel], BoxRatios -> {1, 1, 5}]

Untuk menghasilkan gambar objek tiga dimensi, Anda harus memberi tahu Mathematica dari sudut pandang apa
yang Anda inginkan
melihat objek. Anda dapat melakukan ini menggunakan opsi ViewPoint.
Beberapa pengaturan umum untuk opsi ini diberikan di Bagian 1.9.6. Namun, secara umum, Anda dapat memberi
tahu Mathematica untuk
gunakan sudut pandang apa pun, asalkan terletak di luar kotak.
Titik pandang ditentukan dalam bentuk ViewPoint -> 8sx, sy, sz<. Nilai si diberikan dalam koordinat khusus
sistem, di mana pusat kotak adalah {0, 0, 0}. Koordinat khusus diskalakan sehingga sisi terpanjang dari
kotak sesuai dengan satu unit. Panjang sisi lain kotak dalam sistem koordinat ini ditentukan oleh:
pengaturan untuk opsi BoxRatios. Oleh karena itu, untuk kotak kubus, masing-masing koordinat khusus berjalan
dari -1 2 hingga
1 2 di seberang kotak. Perhatikan bahwa titik pandang harus selalu berada di luar kotak.
Ini menghasilkan gambar menggunakan titik pandang default {1.3, -2.4, 2}.
In[7]:= surf = Plot3D[(2 + Sin[x]) Cos[2 y], {x, -2, 2}, {y, -3, 3}, AxesLabel -> {"x",
"y", "z"}]
Inilah yang Anda dapatkan dengan titik pandang yang dekat dengan salah satu sudut kotak.
In[8]:= Show[surf, ViewPoint -> {1.2, 1.2, 1.2}]

Saat Anda menjauh dari kotak, efek perspektif menjadi lebih kecil.
In[9]:= Show[surf, ViewPoint -> {5, 5, 5}]
Dalam membuat gambar objek tiga dimensi Anda harus menentukan lebih dari sekadar di mana Anda ingin melihat
objek dari. Anda juga harus menentukan bagaimana Anda ingin "membingkai" objek di gambar akhir Anda. Anda
dapat melakukan ini menggunakan
opsi tambahan ViewCenter dan ViewVertical.
ViewCenter memungkinkan Anda memberi tahu Mathematica titik mana dalam objek yang akan muncul di tengah
gambar akhir Anda.
Titik ditentukan dengan memberikan koordinat skalanya, berjalan dari 0 hingga 1 di setiap arah melintasi kotak.
Dengan
pengaturan ViewCenter -> {1/2, 1/2, 1/2}, pusat kotak karena itu akan muncul di tengah akhir Anda
gambar. Namun, dengan banyak pilihan sudut pandang, kotak tidak akan terlihat simetris, jadi ini pengaturan
untuk ViewCeng
ter tidak akan memusatkan seluruh kotak di area gambar akhir. Anda dapat melakukan ini dengan mengatur
ViewCenter -> Otomatis.
ViewVertical menentukan ke arah mana objek akan muncul di gambar akhir Anda. Pengaturan untuk ViewVertig
cal memberikan arah dalam skala koordinat yang berakhir vertikal pada gambar akhir. Dengan pengaturan default
Viewg
Vertikal -> {0, 0, 1}, arah z dalam sistem koordinat asli Anda selalu berakhir vertikal di final
gambar.
Dengan pengaturan ViewCenter ini, sudut kotak muncul di tengah gambar Anda.
In[10]:= Show[surf, ViewCenter -> {1, 1, 1}]
Pengaturan untuk ViewVertical ini membuat sumbu x kotak tampak vertikal di gambar Anda.
In[11]:= Show[surf, ViewVertical -> {1, 0, 0}]

Saat Anda mengatur opsi ViewPoint, ViewCenter, dan ViewVertical, Anda dapat menganggapnya sebagai
menentukan bagaimana Anda akan melihat objek fisik. ViewPoint menentukan di mana kepala Anda relatif
terhadap objek. LihatCeng ter menentukan di mana Anda melihat (pusat pandangan Anda). Dan ViewVertical
menentukan arah mana Anda
kepala adalah.
Dalam hal sistem koordinat, pengaturan untuk ViewPoint, ViewCenter dan ViewVertical menentukan
bagaimana koordinat nates di kotak tiga dimensi harus diubah menjadi koordinat untuk gambar Anda di area
tampilan akhir.
Untuk beberapa tujuan, akan berguna untuk menganggap koordinat di area tampilan akhir sebagai tiga dimensi. x
dan y sumbu berjalan secara horizontal dan vertikal, masing-masing, sedangkan sumbu z menunjuk keluar dari
halaman.
Posisi yang ditentukan dalam ini
"sistem koordinat tampilan" tetap tetap saat Anda mengubah ViewPoint dan seterusnya. Posisi sumber cahaya
dibahas pada bagian selanjutnya didefinisikan dalam sistem koordinat tampilan ini.
Setelah Anda mendapatkan gambar dua dimensi dari objek tiga dimensi, masih ada beberapa masalah tentang
bagaimana gambar ini harus dirender. Namun masalahnya identik dengan yang terjadi pada grafik dua
dimensi.
Jadi, misalnya, Anda dapat memodifikasi bentuk akhir gambar Anda dengan mengubah opsi AspectRatio. Dan kamu
tentukan wilayah mana dari seluruh area tampilan yang harus diambil oleh gambar Anda dengan menyetel opsi
PlotRegion.
Ini mengubah rasio aspek gambar akhir.
In[12]:= Show[surf, Axes -> False, AspectRatio -> 0.3]
Mathematica biasanya membuat skala gambar objek tiga dimensi menjadi sebesar mungkin, mengingat area
tampilan
Anda tentukan. Meskipun dalam banyak kasus penskalaan ini adalah apa yang Anda inginkan, itu memiliki
konsekuensi bahwa ukuran di mana a
objek tiga dimensi tertentu yang digambar dapat berbeda dengan orientasi objek. Anda dapat mengatur opsi
Spherg
icalRegion -> Benar untuk menghindari variasi seperti itu. Dengan pengaturan opsi ini, Mathematica secara efektif
menempatkan bola
mengelilingi kotak pembatas tiga dimensi, dan menskalakan gambar akhir sehingga seluruh bola ini pas di dalam
area tampilan yang Anda tentukan. Bola memiliki pusatnya di tengah kotak pembatas, dan digambar sedemikian
rupa sehingga batasnya
kotak hanya cocok di dalamnya.
Ini menggambar versi plot yang agak memanjang.
In[13]:= Show[surf, BoxRatios -> {1, 5, 1}]

Dengan SphericalRegion -> True, gambar akhir diskalakan sehingga bola yang ditempatkan di sekitar kotak
pembatas akan muat di
area tampilan.
In[14]:= Show[%, SphericalRegion -> True]
Dengan menyetel SphericalRegion -> True, Anda dapat membuat penskalaan objek konsisten untuk semua
orientasi
obyek. Ini berguna jika Anda membuat urutan animasi yang menunjukkan objek tertentu dalam beberapa orientasi
berbeda.
2.10.11 Merencanakan Permukaan Tiga Dimensi

Dengan memberikan daftar primitif grafik yang sesuai, Anda pada dasarnya dapat mewakili objek tiga dimensi apa
pun di
Mathematica dengan Graphics3D. Anda dapat merepresentasikan permukaan tiga dimensi dengan Graphics3D
dengan memberikan eksplisit
daftar poligon dengan tepi yang berdekatan.
Jika Anda perlu mewakili permukaan sewenang-wenang yang dapat melipat dan mungkin berpotongan sendiri,
tidak ada pilihan selain

untuk menggunakan daftar poligon eksplisit dengan Graphics3D, seperti yang dilakukan ParametricPlot3D.
Namun, ada banyak kasus di mana Anda mendapatkan permukaan yang lebih sederhana. Misalnya, hasil Plot3D
dan ListPlot3D
permukaan yang tidak pernah melipat, dan memiliki ketinggian tertentu di setiap titik x,y. Anda dapat mewakili
permukaan sederhana seperti
ini di Mathematica tanpa memberikan daftar poligon secara eksplisit. Sebagai gantinya, yang perlu Anda lakukan
adalah memberikan array yang
menentukan tinggi z di setiap titik dalam kisi x, y. Objek grafis SurfaceGraphics[array] mewakili a
permukaan yang dibangun dengan cara ini.
Berikut adalah array nilai 4X4.
In[1]:= moda = Table[Mod[i, j], {i, 4}, {j, 4}]
Out[1]= 880, 1, 1, 1<, 80, 0, 2, 2<, 80, 1, 0, 3<, 80, 0, 1, 0<<
Ini menggunakan array untuk memberikan ketinggian setiap titik di permukaan.
In[2]:= Show[SurfaceGraphics[moda]]
Baik Plot3D dan ListPlot3D bekerja dengan membuat objek

SurfaceGraphics.
2.1.1 Merencanakan Permukaan Tiga Dimensi
Dengan memberikan daftar primitif grafis yang sesuai, Anda dapat mewakili objek tiga dimensi dalam
Mathematica dengan Graphics3D. Anda dapat mewakili permukaan tiga dimensi dengan Graphics3D
dengan memberikan daftar eksplisit poligon dengan tepi yang berdekatan..
Jika Anda perlu mewakili permukaan sewenang-wenang yang dapat melipat dan mungkin memotong
diri mereka sendiri, tidak ada pilihan selain menggunakan daftar eksplisit poligon dengan Graphics3D,
seperti yang dilakuk.
Namun, ada banyak kasus di mana Anda mendapatkan permukaan yang lebih sederhana. Misalnya,
plot3D dan ListPlot3D menghasilkan permukaan yang tidak pernah dilipat, dan memiliki ketinggian
yang pasti pada setiap titik x, y. Anda dapat mewakili permukaan sederhana seperti ini di Mathematica tanpa
memberikan daftar eksplisit poligon. Sebaliknya, yang perlu Anda lakukan adalah memberikan array yang
menentukan tinggi z di setiap titik dalam grid x, y. Objek grafis SurfaceGraphics mewakili permukaan
yang dibangun dengan cara ini.
Graphics3D@ primitives D objek tiga dimensi sewenang-wenang, termasuk
permukaan terlipat
SurfaceGraphicsThree-dimensional graphics objects. @ array D

Permukaan tiga dimensi sederhana
Berikut adalah array 4 x 4 nilai.
In[1]:= moda = Table[Mod[i, j], {i, 4}, {j, 4}]
Out[1]= {{0, 1, 1, 1}, {0, 0, 2, 2}, {0, 1, 0, 3}, {0, 0, 1, 0}}
Ini menggunakan array untuk memberikan ketinggian setiap titik di permukaan.
In[2]:= Show[SurfaceGraphics[moda]]
Out[2]= - SurfaceGraphics -
Kedua Plot3D dan ListPlot3D bekerja dengan membuat benda SurfaceGraphics.
Graphics3D@ surface D convert SurfaceGraphics to Graphics3D

Jika Anda menerapkan Graphics3D ke objek SurfaceGraphics, Mathematica akan
menghasilkan objek Graphics3D yang berisi daftar eksplisit poligon yang mewakili permukaan dalam
objek SurfaceGraphics. Setiap kali Anda meminta Mathematica untuk menggabungkan dua objek
SurfaceGraphics bersama-sama, secara otomatis mengkonversi keduanya ke objek Graphics3D.
Here is a surface represented by a SurfaceGraphics object.
In[3]:= Plot3D[(1 - Sin[x]) (2 - Cos[2 y]), {x, -2, 2}, {y, -2, 2}]
0
-1
0 -1
1
6
4 2
2
0
-2
2 -2
Berikut adalah permukaan lain.

In[4]:= Plot3D[(2 + Sin[x]) (1 + Cos[2 y]), {x, -2, 2}, {y, -2, 2}]
1
0
-1
0 -1
1
6
4 2
2
0
-2
2 -2
Mathematica menunjukkan dua permukaan bersama-sama dengan mengkonversi masing-masing ke

objek Graphics3D yang berisi daftar eksplisit poligon.
In[5]:= Show[%, %%]
2
0 1
-2
-1 0
0
-1
1
6
4
2
-2
2
Out[5]= - Graphics3D -
option name default value

Mesh True whether to draw a mesh on the surface
MeshStyle Automatic graphics directives
specifying how to render the mesh
MeshRange Automatic the original range of
coordinates corresponding to the mesh
Ketika Anda membuat permukaan menggunakan SurfaceGraphics, default adalah untuk

menggambar mesh persegi panjang di permukaan. Seperti yang dibahas dalam Bagian 1.9.6, termasuk mesh
ini biasanya memudahkan seseorang untuk melihat bentuk permukaan. Anda masih dapat menyingkirkan
mesh dengan mengatur opsi Mesh -> False. Anda juga dapat mengatur opsi MeshStyle ke daftar arahan
grafis yang menentukan ketebalan, warna, atau properti lain dari garis mesh.
Objek SurfaceGraphics berisi array nilai yang menentukan ketinggian permukaan pada titik-titik dalam grid x, y.
Dengan mengatur opsi MeshRange, Anda dapat memberikan kisaran koordinat x dan y asli yang sesuai dengan titik-titik
dalam grid ini. Ketika Anda menggunakan Plot3D [f, [ x, xmin, xmax], [ y, ymin, ymax} ] untuk menghasilkan objek
SurfaceGraph ; ics, pengaturan MeshRange -> {{ xmin, xmax}, 8 ymin, ymax}} secara otomatis dihasilkan.
Pengaturan untuk MeshRange digunakan dalam pelabelan sumbu x dan y dalam plot permukaan, dan dalam mengerjakan
koordinat poligon jika Anda mengubah objek SurfaceGraphics ke daftar eksplisit poligon dalam objek
Graphics3D.
None leave out clipped parts of the surface, so that you can see through
Automatic show the clipped part of the surface with the same shading as an
actual surface in the same position would have Hdefault settingL
GrayLevel@ i D , show the clipped part of the
RGBColor@ r, g, b D , etc. surface with a particular gray level, color, etc. 8
bottom, top < give different specifications
for parts that are clipped at the bottom and top

Pilihan PlotRange bekerja untuk SurfaceGraphics seperti halnya untuk objek grafis Mathematica
lainnya. Setiap bagian dari permukaan yang terletak di luar kisaran koordinat yang didefinisikan oleh
PlotRange akan "dipotong". Opsi Clip : Fill memungkinkan Anda untuk menentukan apa yang
harus terjadi pada bagian permukaan yang terpotong..
Berikut adalah plot tiga dimensi di mana bagian atas dan bawah permukaan dipotong. Dengan pengaturan default untuk
ClipFill, bagian-bagian yang terpotong ditampilkan seperti jika mereka adalah bagian dari permukaan yang sebenarnya.
In[6]:= Plot3D[Sin[x y], {x, 0, 3}, {y, 0, 3}, PlotRange -> {-.5, .5}]
2
0
1 1
2
0.4
0.2
0
-0.2
-0.4
3 0
Dengan ClipFill->None, bagian permukaan yang terpotong ditinggalkan, sehingga Anda dapat "melihat
melalui" permukaan di sana. Mathematica selalu meninggalkan bagian permukaan yang sesuai dengan tempat-tempat di mana
nilai fungsi yang Anda rencanakan bukanlah bilangan real.
In[7]:= Show[%, ClipFill -> None]

3
2
0
1 1
2
0.4
0.2
0
-0.2
-0.4
3 0
Hal ini membuat bagian bawah dipotong wajah putih (tingkat abu-abu 1), dan yang
atas
In[8]:= Show[%, ClipFill -> {GrayLevel[1],

GrayLevel[0]}]
0.4
0.2
0
-
2
0
1 1
2
0.2
-0.4
3 0
Setiap kali Mathematica menggambar permukaan, ia harus tahu tidak hanya ketinggian, tetapi juga warna
permukaan di setiap titik. Dengan pengaturan default Pencahayaan -> True, Mathematica mewarnai
permukaan menggunakan model yang diterangi simulasi. Namun, dengan Pencahayaan -> False,
Mathematica menggunakan "fungsi warna" untuk menentukan cara mewarnai permukaan.
Fungsi warna default mengambil ketinggian permukaan, dinormalisasi untuk berjalan dari 0 hingga 1, dan warna
setiap bagian permukaan dengan tingkat abu-abu yang sesuai dengan ketinggian ini. Ada dua cara untuk mengubah
default.
Pertama, jika Anda mengatur opsi ColorFunction -> c, maka Mathematica akan menerapkan fungsi c ke
setiap nilai tinggi untuk menentukan warna yang akan digunakan pada saat itu. Dengan ColorFunction ->
Hue, Mathematica misalnya akan mewarnai permukaan dengan berbagai warna..
Plot3D@ f , … , apply c to the normalized values of f

ColorFunction –> c D to determine the color of each point on a surface ListPlot3D@ array, apply
c to the elements of array to determine color
ColorFunction –> c D
SurfaceGraphics
@ array, apply c to the elements of array to determine color
ColorFunction –> c D
Dengan Pencahayaan -> False, default adalah untuk mewarnai permukaan dengan sisik abu-abu ditentukan oleh
tinggi.
In[9]:= exp = Plot3D[Exp[-Sqrt[x^2 + y^2]], {x, -2, 2}, {y, -2, 2}, Lighting -> False]
0
-1
0 -1
1
0.6
0.4 2
0.2
0
-2
2 -2
Ini mendefinisikan fungsi yang memetakan rentang nilai bergantian menjadi hitam dan putih.
In[10]:= stripes[f_] := If[Mod[f, 1] > 0.5, GrayLevel[1], GrayLevel[0]]
Ini menunjukkan permukaan yang diwarnai dengan garis-garis hitam dan putih.
In[11]:= Show[exp, ColorFunction -> (stripes[5 #]&)]

1
0
-1
0 -1
1
0.6
0.4 2
0.2
0
-2
2 -2
Cara kedua untuk mengubah pewarnaan permukaan default adalah dengan menyediakan array kedua yang eksplisit
bersama dengan susunan ketinggian. ColorFunction kemudian diterapkan pada elemen array kedua ini, bukan
array ketinggian, untuk menemukan arahan warna untuk digunakan. Dalam array kedua, Anda dapat secara efektif
menentukan nilai koordinat lain untuk setiap titik di permukaan. Koordinat ini akan diplot menggunakan warna,
bukan posisi.
Anda dapat menghasilkan array nilai warna secara otomatis menggunakan Plot3D[{ f, s},...]. Jika Anda
memberikan array secara eksplisit di ListPlot3D atau SurfaceGraphics, Anda harus menyadari
bahwa dengan n ä n array ketinggian, Anda memerlukan array (n – 1) x (n – 1) untuk menentukan warna.
Alasannya adalah bahwa ketinggian ditentukan untuk titik-titik pada grid, sedangkan warna yang ditentukan
untuk kotak pada grid.
Saat Anda menyediakan fungsi atau array kedua ke Plot3D, ListPlot3D, dan seterusnya, pengaturan default
untuk opsi Fungsi Warna $ otomatis. Ini berarti bahwa fungsi atau array harus berisi arahan warna Mathematica
eksplisit, seperti GrayLevel atau RGBColor. Namun, jika Anda memberikan pengaturan lain, seperti
ColorFunction -> Hue, maka fungsi atau array dapat menghasilkan angka murni atau data lain yang
dikonversi ke arahan warna ketika fungsi yang ditentukan oleh ColorFunction diterapkan.
Plot3D@ 8 f , s <, 8 x, xmin, plot a surface whose height is determined by

xmax <, 8 y, ymin, ymax < D f and whose color is determined by s
ListPlot3D@ height, color D generate a colored surface plot from an array of heights and colors
SurfaceGraphics@ height, color D a graphics object representing a surface with a specified array of
heights and colors
Ini plot permukaan dengan tingkat abu-abu ditentukan oleh koordinat y.
In[12]:= Plot3D[{Sin[x] Sin[y]^2, GrayLevel[y/3]}, {x, 0, 3}, {y, 0, 3}]
0 2
0
1 1
2
1
0.75
0.5
0.25
3 0
Ini menempatkan tingkat abu-abu acak di setiap kotak kotak. Perhatikan bahwa array kotak grid adalah 9 ä 9, sedangkan array titik grid
adalah
10 x 10.
In[13]:= ListPlot3D[ Table[i/j, {i, 10}, {j, 10}], Table[GrayLevel[Random[ ]], {i, 9},
{j, 9}] ]
4 10
8
0 6
2
4 4
6
8 2
2
10
2.1.2 Pencahayaan dan Properti Permukaan
Dengan pengaturan opsi default Pencahayaan -> True, Mathematica menggunakan model pencahayaan
simulasi untuk menentukan cara mewarnai poligon dalam grafik tiga dimensi.
Mathematica memungkinkan Anda untuk menentukan dua komponen untuk penerangan suatu objek. Yang pertama
adalah "pencahayaan ambient", yang menghasilkan bayangan seragam di seluruh objek. Yang kedua adalah cahaya
dari kumpulan sumber titik, masing-masing dengan posisi dan warna tertentu. Mathematica menambahkan
bersamasama cahaya dari semua sumber ini dalam menentukan pencahayaan total poligon tertentu.
AmbientLight –> color diffuse isotropic lighting

LightSources –> 8 8 pos1 , point light sources with specified positions and colors
col1 <, 8 pos2 , col2 <, … <
Pencahayaan default yang digunakan oleh Mathematica melibatkan sumber cahaya tiga titik, dan tidak ada komponen
ambient. Sumber cahaya berwarna masing-masing merah, hijau dan biru, dan ditempatkan pada sudut 45é di sisi kanan objek.
Berikut adalah permukaan, dinaungi menggunakan pencahayaan simulasi menggunakan set lampu default.
In[1]:= Plot3D[Sin[x + Sin[y]], {x, -3, 3}, {y, -3, 3}, Lighting -> True]
1
0.5
0 2
-0.5
-1
0
-2
0
-2
2
Ini menunjukkan hasil dari menambahkan cahaya ambient, dan menghapus semua sumber cahaya titik.
In[2]:= Show[%, AmbientLight -> GrayLevel[0.5], LightSources -> {}]
1
0.5
0 2
-0.5
-1
0
-2
0
-2
2
Ini menambahkan sumber cahaya titik tunggal di sisi kiri gambar.
In[3]:= Show[%, LightSources -> {{{-1, 0, 0.5}, GrayLevel[0.5]}}]
1
0.5
0 2
-0.5
-1
0
-2
0
-2
2
Posisi sumber cahaya dalam Mathematica ditentukan dalam sistem koordinat tampilan. Koordinat x dan y berada
di bidang tampilan akhir, dan koordinat z keluar dari pesawat. Menggunakan sistem koordinat ini memastikan
bahwa sumber cahaya tetap tetap sehubungan dengan penampil, bahkan ketika posisi relatif pemirsa dan objek
berubah.
Meskipun titik pandang berubah, sumber cahaya tetap di sisi kiri gambar.
In[4]:= Show[%, ViewPoint -> {2, 2, 6}]
-2 -2
0 0
2 2
0.150
-0.-51
Warna poligon yang dirasakan tidak hanya tergantung pada cahaya yang jatuh pada poligon, tetapi juga pada
bagaimana poli-gon mencerminkan cahaya itu. Anda dapat menggunakan arahan grafis SurfaceColor untuk
menentukan cara poligon memantulkan cahaya.
Jika Anda tidak secara eksplisit menggunakan arahan SurfaceColor, Mathematica secara efektif
mengasumsikan bahwa semua poligon memiliki permukaan putih matte. Dengan demikian poligon
memantulkan cahaya dari setiap insiden warna pada mereka, dan melakukannya sama ke segala arah. Ini
adalah model yang tepat untuk bahan-bahan seperti kertas putih uncoated.
Namun, dengan menggunakan SurfaceColor, Anda dapat menentukan model yang lebih rumit. Ide dasarnya
adalah untuk membedakan dua jenis refleksi: menyebar dan specular.
Dalam refleksi difus, insiden cahaya di permukaan tersebar sama ke segala arah. Ketika refleksi semacam ini terjadi,
permukaan memiliki penampilan "kusam" atau "matte". Reflektor difus mematuhi Hukum Refleksi Cahaya Lambert,
yang menyatakan bahwa intensitas cahaya yang dipantulkan adalah cosHaL kali intensitas cahaya insiden, di mana a
adalah sudut antara arah cahaya insiden dan vektor normal permukaan. Perhatikan bahwa ketika a> 90é, tidak ada
cahaya yang dipantulkan.
Dalam refleksi specular, permukaan memantulkan cahaya dengan cara seperti cermin. Akibatnya, permukaan
memiliki penampilan "mengkilap" atau "gloss". Dengan cermin yang sempurna, insiden cahaya pada sudut tertentu
tercermin pada sudut yang persis sama. Sebagian besar bahan, bagaimanapun, menyebarkan cahaya sampai batas
tertentu, dan menyebabkan cahaya yang dipantulkan yang didistribusikan melalui berbagai sudut. Mathematica
memungkinkan Anda untuk menentukan seberapa luas distribusinya dengan memberikan eksponen specular,
didefinisikan sesuai dengan model pencahayaan Phong. Dengan eksponen specular n, intensitas cahaya pada sudut q
jauh dari arah refleksi cermin diasumsikan bervariasi seperti cos HqLn. Sebagai n Ø ¶, oleh karena itu, permukaan
berperilaku seperti cermin yang sempurna. Sebagai n menurun, bagaimanapun, permukaan menjadi kurang
"mengkilap", dan untuk n = 0, permukaan adalah reflektor benar-benar menyebar. Nilai khas n untuk bahan aktual
berkisar dari sekitar 1 hingga beberapa ratus.
Sebagian besar bahan yang sebenarnya menunjukkan campuran refleksi difus dan specular. Selain itu, mereka
biasanya berperilaku seolah-olah mereka memiliki warna intrinsik tertentu. Ketika cahaya insiden berwarna putih,
cahaya yang dipantulkan memiliki warna material. Ketika cahaya insiden tidak putih, setiap komponen warna dalam
cahaya yang dipantulkan adalah produk dari komponen yang sesuai dalam cahaya insiden dan dalam warna intrinsik
dari bahan.
Dalam Mathematica, Anda dapat menentukan sifat refleksi dengan memberikan warna intrinsik yang
terkait dengan refleksi difus, dan satu lagi yang terkait dengan refleksi specular. Untuk tidak mendapatkan
refleksi dari jenis tertentu, Anda harus memberikan warna intrinsik corre-sponding sebagai hitam, atau
GrayLevel. Untuk bahan yang secara efektif "putih", Anda dapat menentukan warna intrinsik dari
bentuk GrayLevel, di mana a adalah reflektansi atau albedo permukaan.
In[5]:= <<Graphics`Shapes`
Sphere membuat objek grafis yang mewakili bola.
In[6]:= s = Sphere[ ] ;
Ini menunjukkan bola dengan permukaan putih matte default.
In[7]:= Show[Graphics3D[s]]
Hal ini membuat bola memiliki reflektansi difus rendah, tetapi reflektansi specular tinggi. Akibatnya, bola memiliki "cahaya tinggi
specular" di dekat sumber cahaya, dan cukup gelap di tempat lain.
In[8]:= Show[Graphics3D[{ SurfaceColor[GrayLevel[0.2], GrayLevel[0.8], 5], s}]]
Ketika Anda mengatur sumber cahaya dan warna permukaan, penting untuk memastikan bahwa intensitas total
cahaya yang dipantulkan dari poligon tertentu tidak pernah lebih besar dari 1. Anda akan mendapatkan efek aneh
jika intensitasnya lebih besar dari 1.
2.1.3 Pelabelan Grafik Tiga Dimensi

Mathematica menyediakan berbagai pilihan untuk memberi label grafis tiga dimensi. Beberapa opsi
ini secara langsung analog dengan yang untuk grafik dua dimensi, dibahas dalam Bagian 2.10.5. Lainnya
berbeda
Boxed –> True draw a cuboidal bounding box around the graphics HdefaultL
Axes –> True draw x , y and z
axes on the edges of the box Hdefault for SurfaceGraphicsL
Axes –> {False, False, True} draw the z axis only
FaceGrids –> All draw grid lines on the faces of the box
PlotLabel –> text give an overall label for the plot
Ini memuat paket yang berisi berbagai polyhedra.

In[1]:= <<Graphics`Polyhedra`
Default untuk Graphics3D adalah untuk menyertakan kotak, tetapi tidak ada bentuk pelabelan lainnya.
In[2]:= Show[Graphics3D[Dodecahedron[ ]]]
Pengaturan Sumbu -> True menambahkan sumbu x, y dan z.

In[3]:= Show[%, Axes -> True]
0 Graphics3D -
0.5
Out[3]=
- 1
Ini menambahkan garis kisi ke setiap wajah

kotak.
In[4]:= Show[%, FaceGrids ->

All]
1
0.5
0
-0.5
0.5 -1
-0.5
0
-0.5 0
0.5
Out[4]= - 1 -
1
Graphics3D -
BoxStyle –> style specify the style for the box

AxesStyle –> style specify the style for axes
AxesStyle –> 8 8 specify separate styles for each axis
xstyle <, 8 ystyle <, 8 zstyle
<<
Hal ini membuat kotak itu melesat, dan menarik sumbu yang lebih tebal dari biasanya.
In[5]:= Show[Graphics3D[Dodecahedron[ ]], BoxStyle -> Dashing[{0.02, 0.02}], Axes -
> True, AxesStyle -> Thickness[0.01]]
1
0.5
0
-0.5
-1
O ics3D -
ut[5]=
0.5
-0.5
-
Graph
-1
-0.5
0
0.5
1
Dengan mengatur opsi Axes -> True, Anda memberi tahu Mathematica untuk menggambar sumbu
di tepi kotak tiga dimensi. Namun, untuk setiap sumbu, pada prinsipnya ada empat tepi yang mungkin di
mana ia dapat ditarik. Opsi AxesEdge memungkinkan Anda untuk menentukan di tepi mana untuk
menggambar masing-masing sumbu.
AxesEdge –> Automatic use an internal algorithm to choose where to draw all axes
AxesEdge –> 8 xspec, yspec, zspec < give separate specifications for each of the x , y and z axes
None do not draw this axis
Automatic decide automatically where to draw this axis
8 diri , dir j < specify on which of the four possible edges to draw this axis
Ini menarik x di tepi dengan koordinat y dan z yang lebih besar, tidak menarik sumbu y, dan memilih secara
otomatis di mana untuk menggambar z.sumbu.
In[6]:= Show[Graphics3D[Dodecahedron[ ]], Axes -> True, AxesEdge -> {{1, 1}, None,
Automatic}]
-1 -0.5
0
0.5
1
0.5
-0.5
Ketika Anda menggambar sumbu x pada kotak tiga dimensi, ada empat tepi yang mungkin di mana sumbu dapat
ditarik. Tepi ini dibedakan dengan memiliki koordinat y dan z yang lebih besar atau lebih kecil. Ketika Anda
menggunakan spesifikasi 8 diry, dirz < tempat menggambar sumbu x, Anda dapat mengatur diri menjadi +1 atau -1
untuk mewakili nilai yang lebih besar atau lebih kecil untuk koordinat y dan z.
AxesLabel –> None give no axis labels

AxesLabel –> zlabel put a label on the z axis
AxesLabel –> put labels on all three axes
8 xlabel, ylabel, zlabel <
Anda dapat menggunakan AxesLabel untuk memberi label tepi kotak, tanpa harus menggambar sisik pada mereka.
In[7]:= Show[Graphics3D[Dodecahedron[ ]], Axes -> True, AxesLabel -> {"x", "y", "z"}, Ticks
-> None]
Ticks –> None draw no tick marks

Ticks –> Automatic place tick marks automatically
Ticks –> 8 xticks, yticks, zticks < tick mark specifications for each axis
Anda dapat memberikan spesifikasi tanda centang yang sama dalam tiga dimensi seperti yang dijelaskan untuk
grafik dua dimensi di Bagian 2.10.5.
FaceGrids –> None draw no grid lines on faces

FaceGrids –> All draw grid lines on all faces
FaceGrids –> 8 face1 , face2 , … < draw grid lines on the faces specified by the facei
FaceGrids –> 8 8 face1 , use xgridi , ygridi
8 xgrid1 , ygrid1 < <, … < to determine where and how to draw grid lines on each face
Mathematica memungkinkan Anda untuk menggambar garis grid pada wajah kotak yang mengelilingi objek
tiga dimensi. Jika Anda mengatur FaceGrids -> All, garis grid digambar abu-abu di setiap wajah. Dengan
mengatur FaceGrids -> { face1, face2, ... < Anda dapat memberitahu Mathematica untuk menggambar
garis grid hanya pada wajah tertentu. Setiap wajah ditentukan oleh daftar 8 dirx, diry, dirz <, di mana dua dari
diri harus 0, dan yang ketiga adalah +1 atau -1. Untuk setiap wajah, Anda juga dapat secara eksplisit memberi
tahu Mathematica di mana dan bagaimana menggambar garis grid, menggunakan spesifikasi yang sama seperti
yang Anda berikan untuk opsi GridLines dalam grafik dua dimensi.
Ini menarik garis grid hanya di wajah atas dan bawah kotak.
In[8]:= Show[Graphics3D[Dodecahedron[ ]], FaceGrids -> {{0, 0, 1}, {0, 0, -1}}]
2.1.4 Topik Lanjutan:Rendering Grafis Tingkat Rendah

Semua fungsi grafis Mathematica seperti Show and Plot memiliki opsi DisplayFunction, yang
menentukan bagaimana objek grafis Mathematica yang mereka hasilkan harus benar-benar ditampilkan. Cara
kerjanya adalah bahwa pengaturan yang Anda berikan untuk DisplayFunction secara otomatis
diterapkan pada setiap objek grafis yang dihasilkan.
DisplayFunctio default
n
generate no display
–> $DisplayFunction
apply f to graphics objects to produce
DisplayFunction –> Identity
Dalam kernel Mathematica, grafis selalu diwakili oleh objek grafis yang melibatkan grafis primitif. Namun, ketika
Anda benar-benar membuat grafik, mereka harus dikonversi ke bentuk tingkat yang lebih rendah yang dapat diproses
oleh ujung depan Mathematica, seperti antarmuka notebook, atau oleh program eksternal lainnya.
Bentuk tingkat rendah standar yang digunakan Mathematica untuk grafik adalah PostScript. Fungsi Mathematica
Display mengambil objek grafis Mathematica, dan mengubahnya menjadi blok kode PostScript. Kemudian
dapat mengirim kode ini ke file, program eksternal, atau secara umum setiap aliran output..
Display@" file ", graphics D store the PostScript for a piece of Mathematica graphics in a file
Display@"! program ", graphics D send the PostScript to an external program
Display@ stream, graphics D send the PostScript to an arbitrary stream
DisplayString@ graphics D generate a string of PostScript
Nilai default dari variabel global $DisplayFunction adalah Function[ Display[$Display,

#]
]. Dengan default ini, objek grafis yang dihasilkan oleh fungsi seperti Tampilkan dan Plot secara otomatis
dikonversi ke PostScript, dan dikirim ke aliran apa pun yang ditentukan oleh nilai variabel global $Display.
Variabel $Display biasanya diatur selama inisialisasi sesi Mathematica tertentu.
PostScript@" a two-dimensional graphics primitive

string1 ", " string2 ", … D giving PostScript code to include verbatim
Dengan primitif grafis dua dimensi standar dalam Mathematica Anda dapat menghasilkan sebagian besar efek yang
dapat diperoleh dengan PostScript. Kadang-kadang, bagaimanapun, Anda mungkin merasa perlu untuk memberikan
kode PostScript secara langsung. Anda dapat melakukan ini dengan menggunakan grafik dua dimensi khusus
PostScript primitif.
String yang Anda tentukan dalam primitif PostScript akan dimasukkan kata demi kata ke dalam gener kode
PostScript akhir yang diintip oleh Display. Anda harus menggunakan PostScript primitif dengan hati-
hati. Misalnya, sangat penting bahwa kode yang Anda berikan mengembalikan tumpukan PostScript ke keadaan
aslinya ketika selesai. Selain itu, untuk menentukan posisi objek, Anda harus memahami penskalaan koordinat
yang dilakukan Mathematica dalam output PostScript-nya.Akhirnya, setiap primitif PostScript yang Anda
sisipkan hanya dapat berfungsi jika didukung dalam penerjemah PostScript akhir yang Anda gunakan untuk
menampilkan grafik Anda.
PostScript primitif memberikan kode PostScript mentah yang menarik kurva Bézier.
In[1]:= Show[Graphics[ { PostScript[".008 setlinewidth"], PostScript[".1 .1 moveto"],
PostScript["1.1 .6 -.1 .6 .9 .1 curveto stroke"] }, Frame -> True]]
1
0.8
0.6
0.4
0.2
0
0 0.2 0.4 0.6 0.8 1
Out[1]= - Graphics -
Dalam kebanyakan kasus, objek grafis Mathematica tertentu selalu menghasilkan PostScript dari bentuk tertentu.
Bagi Objek Graphics3D, opsi RenderAll memungkinkan Anda untuk memilih di antara dua bentuk yang
berbeda.
Masalah utamanya adalah bagaimana poligon yang membentuk objek tiga dimensi harus diberikan. Dengan
pengaturan default RenderAll -> True, semua poligon yang Anda tentukan digambar secara penuh, tetapi
yang di belakang digambar terlebih dahulu. Ketika semua poligon ditarik, hanya yang di depan yang terlihat.
Namun, sementara sebuah objek sedang digambar pada layar, Anda biasanya dapat melihat poligon di dalamnya.
Masalah dengan pendekatan ini adalah bahwa untuk objek dengan banyak lapisan, Anda dapat
menghasilkan sejumlah besar kode PostScript palsu yang terkait dengan poligon yang tidak terlihat pada
gambar akhir. Anda berpotensi menghindari hal ini dengan mengatur RenderAll -> False. Dalam hal
ini, Mathematica bekerja persis poligon atau bagian dari poligon akan
Benar-benar terlihat dalam gambar akhir Anda, dan hanya membuat ini. Selama ada cukup sedikit
persimpangan antara poligon, pendekatan ini biasanya akan menghasilkan lebih sedikit kode PostScript,
meskipun mungkin jauh lebih lambat.
RenderAll –> True draw all polygons, starting from the back HdefaultL
RenderAll –> False draw only those polygons or parts
of polygons that are visible in the final image
Ketika Anda menghasilkan representasi PostScript dari objek tiga dimensi, Anda kehilangan semua informasi
tentang kedalaman bagian-bagian objek. Terkadang, Anda mungkin ingin mengirim ke program eksternal
representasi yang mencakup informasi mendalam. Seringkali, objek Graphics3D asli dalam bentuk
Mathematica kemudian merupakan representasi yang sesuai. Tetapi beberapa program eksternal tidak dapat
menangani poligon yang berpotongan.Untuk mengatasi hal ini, Graphics3D menyertakan opsi
PolygonIntersections. Jika Anda mengatur PolygonIntersections -> False, maka Tampilkan bukan
objek Graphics3D asli Anda, melainkan yang di mana poligon berpotongan telah dipecah menjadi
potonganpotongan terputus-putus, setidaknya dengan pengaturan untuk ViewPoint dan seterusnya yang telah
Anda berikan.
2.1.5 Format untuk Teks dalam Grafik
$TextStyle = value set the default text style for all graphics
$FormatType = value set the default text format type for all graphics
TextStyle –> value an option for the text style in a particular graphic
FormatType –> value an option for the text format type in a particular graphic
Berikut adalah plot dengan pengaturan default untuk semua format.
In[1]:= Plot[Sin[x]^2, {x, 0, 2 Pi}, PlotLabel->Sin[x]^2]
.8
.6
1 2 3 4 5 6
Berikut adalah plot yang sama, tetapi sekarang menggunakan font miring 7
poin.
In[2]:= Plot[Sin[x]^2, {x, 0, 2 Pi}, PlotLabel->Sin[x]^2,

TextStyle->{FontSlant->"Italic", FontSize->7}]
Sin[x]2
0.8
0.6
0.4
0.2
1 2 3 4 5 6
Out[2]= -
Graphics -
Ini menggunakan TraditionalForm daripada StandardForm.
In[3]:= Plot[Sin[x]^2, {x, 0, 2 Pi}, PlotLabel->Sin[x]^2, FormatType -> TraditionalForm]
sin2(x)
1
0
.8
0
.6
1 2 3 4 5 6
Ini memberi tahu Mathematica gaya teks default apa yang digunakan untuk semua
plot berikutnya.
In[4]:= $TextStyle = {FontFamily -> "Times", FontSize -> 7}
Out[4]= {FontFamily c Times, FontSize c 7}
Sekarang semua teks ada dalam font Times 7 poin.
In[5]:= Plot[Sin[x]^2, {x, 0, 2 Pi}, PlotLabel->Sin[x]^2]

Sin(x)2
0.8
0.6
0.4
0.2
12 3 4 5 6
Out[5]= -
Graphics -
" style " a cell style in your current notebook

FontSize –> n the size of font to use in printer's points
FontSlant –> "Italic" use an italic font
FontWeight –> "Bold" use a bold font
FontFamily –> " name " specify the name of the font family to use He.g.
"Times" , "Courier" , "Helvetica" L
Jika Anda menggunakan ujung depan buku catatan standar untuk Mathematica, maka Anda dapat mengatur
$TextStyle atau TextStyle menjadi nama gaya sel di buku catatan Anda saat ini. Ini memberitahu
Mathematica untuk menggunakan gaya sel itu sebagai default untuk memformat teks apa pun yang muncul dalam
grafik.
Anda juga dapat secara eksplisit menentukan bagaimana teks harus diformat dengan menggunakan opsi seperti
FontSize dan FontFamily. Perhatikan bahwa FontSize memberikan ukuran absolut font untuk digunakan,
diukur dalam satuan poin printer, dengan satu titik menjadi Åå1åå å inches. Jika Anda mengubah ukuran plot, teks di
dalamnya tidak akan secara default mengubah ukuran: untuk mendapatkan teks dengan ukuran yang berbeda harus
secara eksplisit menentukan nilai baru untuk opsi FontSize.
StyleForm@ expr, " style "D output expr in the specified cell style
StyleForm@ expr, options D output expr using the specified font and style options
@ expr D output expr in

TraditionalForm TraditionalForm
Ini menghasilkan label plot menggunakan gaya judul bagian di buku catatan Anda saat ini.
In[6]:= Plot[Sin[x]^2, {x, 0, 2 Pi}, PlotLabel->StyleForm[Sin[x]^2, "Section"]]
Sin[x]2
1
0.8
0.6
0.4
0.2
12 3 4 5 6
Out[6]= -
Graphics -
Ini menggunakan gaya judul bagian, tetapi dimodifikasi menjadi miring.
In[7]:= Plot[Sin[x]^2, {x, 0, 2 Pi}, PlotLabel->StyleForm[Sin[x]^2, "Section", FontSlant-

>"Italic"]]
Sin[x ]2
1
0.8
0.6
0.4
0.2
12 3 4 5 6
Out[7]= -
Graphics -
Ini menghasilkan output TraditionalForm, dengan font 12 poin.
In[8]:= Plot[Sin[x]^2, {x, 0, 2 Pi}, PlotLabel->StyleForm[TraditionalForm[Sin[x]^2],

FontSize->12]]
sin2(x)
1
0.8
0.6
0.4
0.2
12 3 4 5 6
Out[8]= -
Graphics -
Anda harus menyadari bahwa kemampuan untuk merujuk ke gaya sel seperti "Bagian" tergantung pada penggunaan
ujung depan notebook Mathemat-ica standar. Bahkan jika Anda hanya menggunakan antarmuka berbasis teks ke
Mathematica, Anda masih dapat menentukan pemformatan teks dalam grafik menggunakan opsi seperti FontSize.
Koleksi lengkap opsi yang dapat Anda gunakan diberikan di Bagian 2.11.10.
2.1.6 Primitif Grafis untuk Teks
Dengan grafis Teks primitif, Anda dapat menyisipkan teks pada posisi apa pun dalam grafik
Mathematica dua atau tiga dimensi. Kecuali Anda secara eksplisit menentukan gaya atau font menggunakan
StyleForm, teks akan diberikan dalam gaya default Anda saat ini.
Text@ expr, 8 x, y < D text centered at the point 8 x, y <
Text@ expr, 8 x, y <, 8 –1, 0 < D text with its left-hand end at 8 x, y < , 0
Text@ expr, 8 x, y <, 8 1, 0 < D right-hand end at 8 x, y < Text@ <D
expr, 8 x, y <, 8 0, –1 < D centered above 8 x, y <
Text@ expr, 8 x, y <, 8 0, 1 < D centered below 8 x, y <
Text@ expr, 8 x, y <, 8 dx, dy < D text positioned so that 8 x, y < is at relative coordinates
8 dx , dy < within the box that bounds the text
Text@ expr, 8 x, Text@ expr, 8 x, y
y <, 8 dx, dy <, 8 –1

<, 8 dx, dy <, 8 0, 1 < D
Text@ expr, 8 x, y
<, 8 dx, dy <, 8 0, –1 < D

text oriented vertically from bottom to top text that reads from top to
to read bottom text that is upside-down
Two-dimensional text.
Ini menghasilkan lima potongan teks, dan menampilkannya dalam plot.
In[1]:= Show[Graphics[ Table[ Text[Expand[(1 + x)^n], {n, n}], {n, 5} ] ], PlotRange ->
All]
1 + 5x + 10 x2 + 10 x3 + 5 x4 + x5
1 + 4x + 6 x2 + 4 x3 + x4
1 + 3x + 3 x2 + x3
1 + 2x + x2
1+x
Out[1]= - Graphics
Berikut adalah beberapa teks berorientasi vertikal dengan sisi kirinya pada titik 8 2, 2<.
In[2]:= Show[Graphics[Text[ StyleForm["Some text", FontSize->14, FontWeight->"Bold"], {2,

2}, {-1, 0}, {0, 1}]], Frame -> True]
4
0 1 2 3 4
Ketika Anda menentukan offset untuk teks, koordinat relatif yang digunakan diambil untuk berjalan
dari -1 ke 1 di setiap direc-tion di seluruh kotak yang membatasi teks. Titik 8 0, 0< dalam sistem koordinat
ini didefinisikan sebagai pusat teks. Perhatikan bahwa offset yang Anda tentukan tidak perlu terletak pada
rentang -1 hingga 1.
Perhatikan bahwa Anda dapat menentukan warna sepotong teks dengan sebelum grafik Teks primitif dengan
RGBColor atau arahan grafis lainnya.
Text@ expr, 8 x, y, z < D text centered at the point 8 x, y, z <

Text@ expr, 8 x, y, z <, 8 sdx, sdy < D text with a two-dimensional offset
Ini memuat paket yang berisi definisi polyhedra.
In[3]:= <<Graphics`Polyhedra`
Ini menempatkan teks pada posisi yang ditentukan dalam tiga dimensi.
In[4]:= Show[Graphics3D[{Dodecahedron[ ], Text["a point", {2, 2, 2}, {1, 1}]}]]
point
Perhatikan bahwa ketika Anda menggunakan teks dalam grafik tiga dimensi, Mathematica mengasumsikan bahwa
teks tidak pernah disembunyikan oleh poligon atau objek lainnya.
option name default value

Background None background color
TextStyle {} style or font specification
FormatType StandardForm format type
Options for Text.
Secara default teks hanya diletakkan langsung di atas grafis apa pun yang telah digambar.
In[5]:= Show[Graphics[{{GrayLevel[0.5], Rectangle[{0, 0}, {1, 1}]}, Text["Some text",
{0.5, 0.5}]}]]
Some text
Sekarang ada persegi panjang dengan warna latar belakang seluruh plot yang melampirkan teks.
In[6]:= Show[Graphics[{{GrayLevel[0.5], Rectangle[{0, 0}, {1, 1}]}, Text["Some text",
{0.5, 0.5}, Background->Automatic]}]]
Some text
2.1.7 Topik Lanjutan:Output Warna

Monochrome displays gray levels
Color displays red, green and blue mixtures
Color printing cyan, magenta, yellow and black mixtures
Ketika Anda menghasilkan output grafis di Mathematica, ada spesifikasi warna yang berbeda yang
alami untuk berbagai jenis perangkat output. Terkadang perangkat output dapat secara otomatis
mengkonversi dari satu bentuk color specifica.
tion ke yang lain. Tapi Mathematica menyediakan arahan grafis yang memungkinkan Anda langsung
untuk menghasilkan spesifikasi warna yang sesuai untuk perangkat tertentu.
GrayLevel@ i D gray level H setgray in PostScriptL

RGBColor@ r, g, b D red, green and blue components for a display H setrgbcolorL
Hue@ h, s, b D hue, saturation and brightness components for a display H
setrgbcolor L
CMYKColor@ c, m, y, k D cyan, magenta, yellow and black components for
four-color process printing H setcmykcolor L
Setiap arahan warna dalam Mathematica menghasilkan arahan warna yang pasti dalam kode PostScript
yang dikirim Mathematica ke perangkat output Anda. Jadi, misalnya, arahan RGBColor dalam Mathematica
menghasilkan setrgbcolor di PostScript. Perlakuan akhir dari arahan warna PostScript ditentukan oleh
perangkat output Anda, dan interpreter PostScript yang digunakan.
Namun demikian, dalam banyak kasus, parameter yang ditentukan dalam arahan warna Mathematica
akan digunakan cukup langsung untuk mengatur intensitas atau kepadatan komponen output warna.
Ketika ini dilakukan, penting untuk menyadari bahwa satu set parameter tertentu dalam arahan warna
Mathematica dapat menghasilkan warna yang dirasakan berbeda pada perangkat output yang berbeda.
Misalnya, intensitas sebenarnya dari kompo-nent merah, hijau dan biru akan sering berbeda antara tampilan
warna yang berbeda bahkan ketika pengaturan untuk komponen ini sama. Perbedaan tersebut juga terjadi
ketika kecerahan atau kontras dari tampilan warna tertentu berubah.
Selain itu, Anda harus menyadari bahwa "keseluruhan" lengkap warna yang dapat Anda hasilkan
dengan berbagai parameter pada perangkat output tertentu lebih kecil, seringkali secara substansial begitu,
daripada keseluruhan warna yang dapat dirasakan oleh sistem visual manusia. Meskipun ruang warna yang
dapat kita rasakan dapat dijelaskan dengan tiga parameter, tidak mungkin untuk mencapai semua bagian
ruang ini dengan campuran sejumlah tetap "warna primer".
Pilihan warna primer yang berbeda biasanya dibuat untuk berbagai jenis perangkat output. Tampilan warna, yang
bekerja dengan cahaya yang dipancarkan atau ditransmisikan, biasanya menggunakan warna primer merah, hijau dan
biru. Namun, pencetakan warna, yang bekerja dengan cahaya yang dipantulkan, biasanya menggunakan cyan,
magenta, kuning dan hitam sebagai warna primer. Ketika gambar warna dicetak, empat pass terpisah biasanya
dibuat, setiap kali meletakkan salah satu warna utama ini.
Jadi, sementara RGBColor dan Hue adalah spesifikasi warna alami untuk tampilan warna, CMYKColor adalah
specifi-cation alami untuk pencetakan warna.
Secara default, Mathematica mengambil spesifikasi warna apa pun yang Anda berikan, dan menggunakannya
secara langsung. Pilihan ColorOut put, bagaimanapun, memungkinkan Anda untuk membuat Mathematica selalu
mengkonversi spesifikasi warna yang Anda berikan kepada yang sesuai untuk jenis perangkat output tertentu.
ColorOutput –> Automatic use color specifications as given HdefaultL

ColorOutput –> None convert to monochrome
ColorOutput –> GrayLevel convert all color specifications to gray levels
ColorOutput –> RGBColor convert to RGBColor form
ColorOutput –> CMYKColor convert to CMYKColor form
ColorOutput –> f apply f to each color directive
Salah satu masalah yang paling rumit dalam output warna adalah melakukan "pemisahan warna" yang
diperlukan untuk mengambil warna yang ditentukan menggunakan primer merah, hijau dan biru, dan
membuat warna menggunakan tinta pencetakan cyan, magenta, kuning dan hitam. Mathematica memiliki
algoritma built-in untuk melakukan konversi ini. Algoritma ini didasarkanpadapendekatan untuk
tipikalmemantau warna dan set standar tinta pencetakan proses empat warna. Perhatikan bahwa warna tinta
cetak ini bahkan tidak dekat dengan pelengkap warna monitor yang khas, dan transformasi sebenarnya cukup
nonlinier.
Sementara Mathematica memiliki kemampuan built-in untuk berbagai konversi warna, Anda juga dapat menentukan
warna Anda sendiri conver-sions menggunakan ColorOutput -> f. Dengan pengaturan opsi ini, fungsi f secara
otomatis diterapkan pada setiap warna direc-tive yang dihasilkan oleh Mathematica.
Perhatikan bahwa sementara salah satu arahan warna yang diberikan di atas dapat digunakan dalam menyiapkan
objek grafis, perhitungan pencahayaan simulasi di Mathematica selalu dilakukan menggunakan RGBColor, sehingga
semua arahan warna secara otomatis dikonversi ke bentuk ini ketika simulasi pencahayaan digunakan.
Ini mendefinisikan transformasi pada objek RGBColor, yang mengekstrak komponen merah, dan men kuadratnya.
In[1]:= red[RGBColor[r_, g_, b_]] = GrayLevel[r^2]
Out[1]= GrayLevel@r2D
Ini menentukan bahwa merah hanya harus kuadrat setiap spesifikasi GrayLevel.
In[2]:= red[GrayLevel[g_]] = GrayLevel[g^2]
Out[2]= GrayLevel@g2D
Ini plot komponen merah kuadrat, daripada menggunakan transformasi biasa dari warna ke hitam dan putih.
In[3]:= Plot3D[Sin[x + y], {x, -3, 3}, {y, -3, 3}, ColorOutput -> red]
1
0
5
-0
Perhatikan bahwa jika Anda memberikan transformasi ColorOutput Anda sendiri, Anda harus menentukan
bagaimana transformasi bertindak pada setiap arahan warna yang muncul dalam gambar yang Anda hasilkan. Untuk
plot tiga dimensi yang dinaungi dengan pencahayaan simulasi, Anda biasanya harus menentukan transformasi
setidaknya untuk RGBColor dan GrayLevel.
2.1.8 Representasi Suara
Bagian 1.9.12 menjelaskan bagaimana Anda dapat mengambil fungsi dan daftar data dan
menghasilkan suara dari mereka. Subbagian ini membahas bagaimana suara diwakili dalam Mathematica.
Mathematica memperlakukan terdengar seperti grafis. Bahkan, Mathematica memungkinkan Anda untuk
menggabungkan grafis dengan suara untuk membuat gambar dengan "trek suara".
Dalam analogi dengan grafis, suara dalam Mathematica diwakili oleh objek suara simbolis. Objek suara memiliki
suara kepala, dan berisi daftar primitif suara, yang mewakili suara yang akan dimainkan secara berurutan .
Sound@ 8 s1 , s2 , … < D a sound object containing a list of sound primitives
Fungsi Play dan ListPlay dibahas di Bagian 1.9.12 mengembalikan objek Suara.
Putar mengembalikan objek Suara. Pada sistem komputer yang sesuai, itu juga menghasilkan
suara.
In[1]:= Play[Sin[300 t + 2 Sin[400 t]], {t, 0, 2}]
Out[1]= -Sound-
Objek Suara berisi SampledSoundFunction primitif yang menggunakan fungsi dikompilasi untuk menghasilkan sampel amplitudo untuk suara.
In[2]:= Short[ InputForm[%] ]
Out[2]//Short=
Sound[SampledSoundFunction[<<3>>]]
a sound with a sequence of amplitude levels, sampled at
a sound whose amplitude levels sampled at rate r

are found by applying the function f to n successive
Pada tingkat terendah, semua suara dalam Mathematica direpresentasikan sebagai urutan sampel amplitudo. Dalam
SampledSound List, sampel amplitudo ini diberikan secara eksplisit dalam daftar. Namun, dalam
SampledSoundFunction, mereka dihasilkan ketika suara adalah output, dengan menerapkan fungsi yang ditentukan
ke urutan argumen integer. Dalam kedua kasus, semua nilai amplitudo yang diperoleh harus antara -1 dan 1.
ListPlay menghasilkan primitif SampledSoundList, sementara Play menghasilkan SampledSoundFunction

primitives. Dengan pengaturan opsi default Dikompilasi -> True, Play akan menghasilkan objek
SampledSoundFunction yang berisi CompiledFunction.
Setelah Anda menghasilkan objek suara yang berisi berbagai suara primitif, Anda kemudian harus output sebagai
suara. Sama seperti grafis, skema dasarnya adalah mengambil representasi Mathematica dari suara, dan
mengubahnya menjadi bentuk tingkat yang lebih rendah yang dapat ditangani oleh program eksternal, seperti ujung
depan Mathematica.
Representasi suara tingkat rendah yang digunakan oleh Mathematica terdiri dari urutan angka heksadesimal yang
menentukan tingkat amplitudo. Dalam Mathematica, tingkat amplitudo diberikan sebagai perkiraan bilangan real
antara -1 dan 1. Dalam menghasilkan bentuk tingkat rendah, tingkat amplitudo "terkuantisasi". Anda dapat
menggunakan opsi SampleDepth untuk menentukan berapa banyak bit yang harus digunakan untuk setiap
sampel. Default adalah SampleDepth -> 8, yang menghasilkan 256 tingkat amplitudo yang mungkin, cukup untuk
sebagian besar tujuan.
Anda dapat menggunakan opsi SampleDepth di salah satu fungsi Play, ListPlay, dan PlaySound.
Dalam primi-tives suara, Anda dapat menentukan kedalaman sampel dengan mengganti argumen laju sampel
dengan tingkat daftar 8, kedalaman< .
Karena grafik dan suara dapat dikombinasikan dalam Mathematica, representasi tingkat rendah mereka tidak
boleh bertentangan. Seperti yang dibahas dalam Bagian 2.10.14, semua grafik dalam Mathematica dihasilkan
dalam bahasa PostScript. Suara juga dihasilkan sebagai fungsi PostScript khusus, yang dapat diabaikan oleh
interpreter PostScript pada perangkat yang tidak mendukung output suara.
Display@ stream, sound D output sound to a stream
Display@ stream, output graphics and sound to a stream

8 graphics, sound < D
Mathematica menggunakan fungsi yang sama Display untuk output suara, grafis, dan kombinasi dari keduanya.
Di Play, ListPlay dan Sound, opsi DisplayFunction menentukan bagaimana suara pada akhirnya harus dihasilkan.
Default untuk opsi ini adalah variabel global $SoundDisplayFunction. Biasanya, ini diatur ke panggilan yang
sesuai ke Display.
2.1.9 Mengekspor Grafik dan Suara
export graphics in a format deduced from the file

name
export a sequence of graphics for an

animation
graphics, " format "D
Exporting graphics and sounds.

"EPS" Encapsulated PostScript H .eps L
"PDF" Adobe Acrobat portable document format H .pdf L
"SVG" Scalable Vector Graphics H .svg L
"PICT" Macintosh PICT
"WMF" Windows metafile format H .wmf L
"TIFF" TIFF H .tif , .tiff L

"GIF" GIF and animated GIF H .gif L
"JPEG" JPEG H .jpg , .jpeg L
"PNG" PNG format H .png L
"BMP" Microsoft bitmap format H .bmp L
"EPSI" Encapsulated PostScript with device-independent preview H
.epsi L
"EPSTIFF" Encapsulated PostScript with TIFF preview
"XBitmap" X window system bitmap H .xbm L
"PBM" portable bitmap format H .pbm L
"PPM" portable pixmap format H .ppm L
"PGM" portable graymap format H .pgm L
"PNM" portable anymap format H .pnm L
"DICOM" DICOM medical imaging format H .dcm , .dic L
Ketika Anda mengekspor grafik di luar Mathematica, Anda biasanya harus menentukan ukuran absolut di mana
grafik harus diberikan. Anda dapat melakukan ini menggunakan opsi ImageSize untuk Ekspor.
ImageSize->x membuat lebar grafik menjadi titik printer x; ImageSize->72 xi sehingga membuat lebar xi inci.
Defaultnya adalah menghasilkan gambar yang lebarnya empat inci. ImageSize->8 x, y< menskalakan grafik
sehingga cocok di wilayah x ä y.
ImageSize Auto absolute image size in printer's points

ImageRotat matic
resolution in dpi for the image
ed Fals
Dalam Mathematica, grafis dimanipulasi dengan cara yang benar-benar independen dari resolusi layar com-puter
atau perangkat output lainnya di mana grafis akhirnya akan diberikan.
Banyak program dan perangkat menerima grafis dalam format resolusi-independen seperti Encapsulated
PostScript (EPS). Tetapi beberapa mengharuskan grafik dikonversi menjadi raster atau bitmap dengan resolusi
tertentu. Opsi ImageResolu $ tion untuk Ekspor memungkinkan Anda menentukan resolusi apa dalam titik per
inci (dpi) yang harus digunakan.Semakin rendah Anda mengatur resolusi ini, semakin rendah kualitas gambar
yang akan Anda dapatkan, tetapi juga semakin sedikit memori yang akan diambil gambar untuk disimpan. Untuk
tampilan layar, resolusi khas adalah 72 dpi ke atas; untuk printer, 300 dpi ke atas.
"DXF" AutoCAD drawing interchange format H .dxf L

"STL" STL stereolithography format H .stl L
"WAV" Microsoft wave format H .wav L
"AU" m law encoding H .au L
"SND" sound file format H .snd L
"AIFF" AIFF format H .aif , .aiff L
2.1.10 Mengimpor Grafik dan Suara

Mathematica memungkinkan Anda tidak hanya untuk mengekspor grafik dan suara, tetapi juga untuk
mengimpornya. Dengan Impor Anda dapat membaca grafik dan suara dalam berbagai format, dan
membawanya ke Mathematica sebagai ekspresi Mathematica.
Import@" name.ext "D import graphics from the file name.
ext in a format deduced from the file name

Import@" file ", " format "D import graphics in the specified format
ImportString@" import graphics from a string string ",
" format "D
This imports an image stored in JPEG format.
In[3]:= g = Import["ocelot.jpg"] Out[3]=
- Graphics -
Here is the image.
In[4]:= Show[g]
This shows an array of four copies of the image.
In[5]:= Show[GraphicsArray[{{g, g}, {g, g}}]]
Out[5]= - GraphicsArray -
Impor menghasilkan ekspresi dengan struktur yang berbeda tergantung pada jenis data yang
dibacanya.
Biasanya Anda perlu mengetahui struktur jika Anda ingin memanipulasi data yang dikembalikan.
Graphics@ primitives, opts D resolution-independent graphics
Graphics@Raster@ data D, opts D resolution-dependent bitmap images

8 graphics1 , graphics2 , … < animated graphics
Sound@SampledSoundList@ sounds
data, r DD
Ini menunjukkan struktur keseluruhan objek grafis yang diimpor di atas.

In[6]:= Shallow[InputForm[g]]
Out[6]//Shallow=
Graphics@Raster@<< 4 >>D, Rule@<< 2 >>D, Rule@<< 2 >>D, Rule@<< 2 >>DD
Ini mengekstrak array nilai piksel yang digunakan.

In[7]:= d = g[[1, 1]] ;
Berikut adalah dimensi array.

In[8]:= Dimensions[d]
Out[8]= {200, 200}
Ini menunjukkan distribusi nilai piksel.

In[9]:= ListPlot[Sort[Flatten[d]]]
250
200
150
100
50
10000 20000 30000 40000
2.2 Memanipulasi Note Book

2.2.1 Sel sebagai Ekspresi Matematika
Seperti objek lain dalam Mathematica, sel-sel dalam buku catatan, dan pada kenyataannya seluruh buku catatan
itu sendiri, semuanya pada akhirnya direpresentasikan sebagai ekspresi Mathematica. Dengan ujung depan buku
catatan standar, Anda dapat menggunakan perintah Tampilkan Ekspresi untuk melihat teks ekspresi Mathematica
yang sesuai dengan sel tertentu.
Show Expression menu item toggle between displayed form and underlying
Mathematica expression
‚ Î ∗ Ï or ‚ Î 8Ï Hbetween existing cellsL put up a dialog box to allow input of a cell in
Mathematica expression form
Berikut adalah sel yang ditampilkan dengan cara yang biasa di ujung depan.
Berikut adalah ekspresi Mathematica yang mendasari yang sesuai dengan sel.
Cell@ contents, " style "D a cell with a specific style
Cell@ contents, " style ", options D a cell with additional options specified
Dalam buku catatan tertentu, selalu ada koleksi gaya yang dapat digunakan untuk menentukan penampilan dan
perilaku sel. Biasanya gaya diberi nama untuk mencerminkan sel peran apa yang akan dimainkannya di buku
catatan.
"Title" the title of the notebook

"Section" a section heading
"Subsection" a subsection heading
"Text" ordinary text
"Input" Mathematica input
"Output" Mathematica output
Berikut adalah beberapa sel dalam gaya yang berbeda.
Berikut adalah ekspresi yang sesuai dengan sel-sel ini.
Gaya tertentu seperti "Bagian" atau "Teks" mendefinisikan berbagai pengaturan untuk opsi yang terkait dengan
sel. Anda dapat mengganti pengaturan ini dengan secara eksplisit mengatur opsi dalam sel tertentu.
Berikut adalah ekspresi untuk sel di mana opsi diatur untuk menggunakan latar belakang abu-abu dan untuk menempatkan bingkai di
sekitar sel.
Begitulah tampilan sel di buku catatan.
option default value

CellFrame False whether to draw a frame around the cell
Background GrayLevel@1D what color to draw the background for the cell
Editable True whether to allow the
contents of the cell to be edited
TextAlignment Left how to align text in the cell
FontSize 12 the point size of the font for text
CellTags 8< tags to be associated with the cell
Ujung depan notebook standar untuk Mathematica menyediakan beberapa cara untuk mengubah opsi sel. Dalam
kasus sederhana, seperti mengubah ukuran atau warna teks, akan sering ada item menu tertentu untuk tujuan
tersebut. Tetapi secara umum Anda dapat menggunakan inspektur opsi yang dibangun di ujung depan. Ini
biasanya diakses menggunakan item menu Pemeriksa Opsi di menu Format.
■ Change settings for specific options with menus.

■ Look at and modify all options with the option inspector.
■ Edit the textual form of the expression corresponding to the cell.
■ Change the settings for all cells with a particular style.
Ways to manipulate cells in the front end.
Terkadang Anda hanya ingin mengubah opsi yang terkait dengan sel tertentu. Tetapi seringkali Anda mungkin
ingin mengubah opsi yang terkait dengan semua sel di buku catatan Anda yang memiliki gaya tertentu. Anda
dapat melakukan ini dengan menggunakan perintah Edit Lembar Gaya di ujung depan untuk membuka lembar
gaya yang terkait dengan buku catatan Anda, lalu memodifikasi opsi untuk sel dalam style sheet ini yang
mewakili gaya yang ingin Anda ubah .
CellPrint[Cell[…]] insert a cell into your currently selected notebook

CellPrint[ { Cell[… insert a sequence of cells into your currently selected notebook
], Cell[…] , … } ]
Ini menyisipkan sel bagian ke dalam buku catatan saat ini.
In[1]:= CellPrint[Cell["The heading", "Section"]]

Ini menyisipkan sel teks dengan bingkai di sekitarnya.
In[2]:= CellPrint[Cell["Some text", "Text", CellFrame->True]]
CellPrint memungkinkan Anda untuk mengambil ekspresi Sel mentah dan memasukkannya ke dalam buku
catatan Anda saat ini. Kadang-kadang, bagaimanapun, Anda mungkin merasa lebih nyaman untuk memberikan
ekspresi Mathematica biasa, dan kemudian memiliki Mathematica mengubahnya menjadi Sel dengan gaya
tertentu, dan memasukkan sel ini ke dalam buku catatan. Anda dapat melakukan ini dengan menggunakan
fungsi StylePrint.
StylePrint@ expr, " style "D create a new cell of the specified style, and write expr into it
StylePrint@ contents, use the specified options for the new cell
" style ", options D
Ini menyisipkan gaya sel dalam bagian ke dalam buku catatan Anda saat ini.
In[3]:= StylePrint["The heading", "Section"]
Ini menciptakan beberapa sel dalam gaya output.
In[4]:= Do[StylePrint[Factor[xî - 1], "Output"], {i, 7, 10}]

Anda dapat menggunakan opsi sel apa pun di StylePrint.
In[5]:= StylePrint["Another heading", "Section", CellFrame->True, FontSize->28]
CellPrint dan StylePrint menyediakan cara sederhana untuk memodifikasi notebook terbuka di ujung depan
dari dalam kernel. Nantinya pada bagian ini kita akan membahas cara-cara yang lebih canggih dan fleksibel
untuk melakukan hal ini.
2.2.2 Buku catatan sebagai Ekspresi Matematika
Notebook@ 8 cell , cell , … < D a notebook containing a sequence of cells

1 2
Notebook@ cells, options D a notebook with options specified
Berikut adalah buku catatan Mathematica sederhana.
Berikut adalah ekspresi yang sesuai dengan buku catatan ini.
Notebook[8
Cell["Section heading",
"Section"], Cell["Some text.",
"Text"],
Cell["More text.", "Text"]<]
Sama seperti sel individu, notebook di Mathematica juga dapat memiliki pilihan. Anda dapat melihat
dan memodifikasi opsi ini menggunakan inspektur opsi di ujung depan buku catatan standar.
option default value

WindowSize 8 nx, ny < the size in pixels of the
window used to display the notebook
WindowFloating False whether the window should
float on top of others
WindowToolbars 8< what toolbars to
include at the top of the window
ShowPageBreaks False whether to show where page breaks
would occur if the notebook were printed
CellGrouping Automatic how to group cells in the notebook
Evaluator "Local" what kernel should be used to do
evaluations in the notebook
Selain opsi notebook, Anda juga dapat mengatur opsi sel apa pun di tingkat notebook. Melakukan hal ini
memberitahu Mathematica untuk menggunakan pengaturan opsi itu sebagai default untuk semua sel di buku catatan.
Anda dapat mengganti default dengan secara eksplisit mengatur opsi dalam sel tertentu.
Berikut adalah ekspresi yang sesuai dengan buku catatan dengan penggaris ditampilkan di toolbar di bagian atas jendela.
Notebook[8
"Text"]<,
WindowToolbars->8 "RulerBar"<]
This is what the notebook looks like in the front end.
Ini mengatur warna latar belakang default untuk semua sel di buku catatan.
Notebook[8
"Text"]<,
Background->GrayLevel[.7]]
Now each cell has a gray background.
Jika Anda pergi ke luar Mathematica dan melihat teks mentah dari file yang sesuai dengan buku catatan
Mathematica, Anda akan menemukan bahwa apa yang ada dalam file hanyalah bentuk tekstual dari ekspresi yang
mewakili notebook. Salah satu cara untuk membuat buku catatan Mathematica adalah dengan membangun ekspresi
yang tepat dan memasukkannya ke dalam file.
Dalam file notebook yang ditulis oleh Mathematica, beberapa informasi tambahan biasanya disertakan untuk
membuatnya lebih cepat bagi Mathematica untuk membaca file lagi. Informasi tersebut dilampirkan dalam
komentar Mathematica yang ditunjukkan oleh (*...*) sehingga tidak mempengaruhi ekspresi aktual yang
tersimpan dalam file.
NotebookOpen@" file .nb"D open a notebook file in the front end

NotebookPut@ expr D create a notebook corresponding to expr in the front end
NotebookGet@ obj D get the expression corresponding
to an open notebook in the front end
Ini menulis ekspresi buku catatan ke file sample.nb.
In[1]:= Notebook[{Cell["Section heading", "Section"], Cell["Some text.", "Text"]}] >>

"sample.nb"
This reads the notebook expression back from the file.
In[2]:= <<sample.nb
Out[2]= Notebook@8Cell@Section heading, SectionD, Cell@Some text., TextD<D
This opens sample.nb as a notebook in the front end.
In[3]:= NotebookOpen["sample.nb"]
Setelah Anda menyiapkan buku catatan di ujung depan menggunakan NotebookOpen, Anda kemudian dapat
memanipulasi buku catatan secara interaktif seperti halnya notebook lainnya. Tetapi untuk menggunakan
NotebookOpen, Anda harus secara eksplisit memiliki ekspresi buku catatan dalam file. Namun, dengan
NotebookPut, Anda dapat mengambil ekspresi buku catatan yang telah Anda buat di kernel, dan segera
menampilkannya sebagai buku catatan di ujung depan.
Berikut adalah ekspresi buku catatan di kernel.

In[5]:= Notebook[{Cell["Section heading", "Section"], Cell["Some text.", "Text"]}]
Out[4]= Notebook@8Cell@Section heading, SectionD, Cell@Some text., TextD<D

Ini menggunakan ekspresi untuk mengatur buku catatan di ujung depan.
In[6]:= NotebookPut[%]
Out[5]= -NotebookObject-
Anda dapat menggunakan NotebookGet untuk mendapatkan notebook yang sesuai dengan NotebookObject tertentu kembali ke
kernel.
In[7]:= NotebookGet[%]
Out[6]= Notebook@8Cell@CellGroupData@8Cell@TextData@Section headingD, SectionD,

Cell@TextData@Some text.D, TextD<, OpenDD<D
2.11.3 Memanipulasi Notebook dari Kernel

Jika Anda ingin melakukan operasi sederhana pada notebook Mathematica, maka Anda
biasanya akan merasa nyaman hanya dengan menggunakan kemampuan interaktif dari front end
Mathematica standar. Tetapi jika Anda ingin melakukan operasi yang lebih rumit dan sistematis,
maka Anda akan sering merasa lebih baik menggunakan kernel.
Di dalam kernel Mathematica, buku catatan yang telah Anda buka di ujung depan dirujuk
oleh objek buku catatan dalam bentuk NotebookObject[fe, id]. Argumen pertama NotebookObject
menentukan FrontEndObject untuk ujung depan tempat notebook berada, sedangkan argumen
kedua memberikan nomor seri unik untuk notebook.
Jika Anda ingin melakukan manipulasi ekstensif pada notebook tertentu, Anda biasanya akan
merasa nyaman menggunakan Note bookGet untuk memasukkan seluruh notebook ke dalam kernel
sebagai ekspresi tunggal. Tetapi jika sebaliknya Anda ingin melakukan urutan operasi kecil pada
notebook, maka seringkali lebih baik meninggalkan notebook di front end, dan kemudian mengirim
perintah spesifik dari kernel ke front end untuk memberi tahu operasi apa yang harus dilakukan. .
Mathematica diatur sehingga apa pun yang dapat Anda lakukan secara interaktif ke notebook
di front end juga dapat Anda lakukan dengan mengirimkan perintah yang sesuai ke front end dari
kernel.
Dalam notebook terbuka mana pun, ujung depan selalu mempertahankan pilihan saat ini.
Pemilihan dapat terdiri misalnya dari wilayah teks dalam sel atau sel lengkap. Biasanya pemilihan
ditunjukkan pada layar dengan beberapa bentuk penyorotan. Pemilihan juga dapat antara dua
karakter teks, atau antara dua sel, dalam hal ini biasanya ditunjukkan di layar dengan bilah
penyisipan vertikal atau horizontal.
Anda dapat mengubah pilihan saat ini di buku catatan yang terbuka dengan mengeluarkan perintah
dari kernel.
Dalam menyiapkan buku catatan besar, seringkali lebih mudah untuk menyisipkan tag yang
biasanya tidak ditampilkan, tetapi menandai sel tertentu sedemikian rupa sehingga dapat ditemukan
menggunakan NotebookFind. Anda dapat mengatur tag untuk sel baik secara interaktif di ujung
depan, atau dengan secara eksplisit mengatur opsi CellTags untuk sel.
NotebookLocate adalah fungsi dasar yang dipanggil Mathematica saat Anda mengikuti
hyperlink di buku catatan. Item menu Buat Hyperlink mengatur NotebookLocate yang sesuai
sebagai bagian dari skrip untuk tombol hyperlink tertentu.
NotebookWrite[obj, data] mirip dengan operasi Tempel di ujung depan: ini menggantikan
pilihan saat ini di buku catatan Anda dengan data. Jika pilihan saat ini adalah sel
NotebookWrite[obj, data] akan mengganti sel dengan data. Namun, jika pilihan saat ini terletak di
antara dua sel, maka NotebookWrite[obj, data] akan membuat sel atau sel baru yang sesuai.
Ini mengevaluasi pilihan saat ini di tempat.
SelectionEvaluate memungkinkan Anda mengambil materi dari buku catatan dan

mengirimkannya melalui kernel untuk evaluasi. Namun, dengan sendirinya, SelectionEvaluate
selalu menimpa materi yang Anda ambil. Tetapi dengan menggunakan fungsi seperti
SelectionCreateCell, Anda dapat menyimpan catatan urutan formulir yang dihasilkan—seperti
dalam sesi Mathematica standar
Ini membuat pilihan saat ini menjadi seluruh sel.
Ini membuat sel baru, dan menyalin pilihan saat ini ke dalamnya.
Ini membungkus Factor di sekitar konten sel saat ini.
Ini mengevaluasi isi sel saat ini, dan membuat sel baru untuk memberikan hasilnya
Fungsi seperti NotebookWrite dan SelectionEvaluate secara default meninggalkan pilihan

saat ini tepat setelah materi apa pun yang mereka masukkan ke dalam buku catatan Anda. Anda
kemudian dapat selalu memindahkan pilihan dengan secara eksplisit menggunakan Select
tionMove. Tetapi fungsi seperti NotebookWrite dan SelectionEvaluate juga dapat mengambil
argumen tambahan yang menentukan di mana pilihan saat ini harus dibiarkan setelah mereka
melakukan pekerjaannya.
Jika Anda memanggil NotebookCreate[ ], buku catatan kosong baru akan muncul di layar
Anda.
Dengan menjalankan perintah seperti SetSelectedNotebook dan NotebookOpen, Anda
memberi tahu ujung depan Mathematica untuk mengubah jendela yang Anda lihat. Terkadang Anda
mungkin ingin memanipulasi buku catatan tanpa pernah menampilkannya di layar. Anda dapat
melakukan ini dengan menggunakan pengaturan opsi Terlihat->Salah di NotebookOpen atau
NotebookCre makan
2.11.4 Memanipulasi Front End dari Kernel

Sama seperti sel dan notebook, ujung depan Mathematica lengkap memiliki berbagai opsi, yang
dapat Anda lihat dan manipulasi dari kernel.
Dengan menggunakan NotebookWrite, Anda dapat secara efektif memasukkan teks biasa
yang dapat Anda masukkan ke keyboard ke ujung depan. FrontEndTokenExecute memungkinkan
Anda untuk mengirim dari kernel perintah apa pun yang dapat dijalankan oleh front end. Perintah
ini mencakup item menu dan urutan control
2.11.5 Topik Lanjutan: Menjalankan Perintah Notebook Langsung di Front End

Saat Anda menjalankan perintah seperti NotebookWrite[obj, data], operasi sebenarnya untuk
memasukkan data ke dalam notebook Anda dilakukan di bagian depan. Biasanya, bagaimanapun,
kernel diperlukan untuk mengevaluasi perintah asli, dan untuk membuat permintaan yang sesuai
untuk dikirim ke front end. Tapi ternyata front end diatur untuk mengeksekusi kumpulan perintah
terbatas secara langsung, tanpa pernah melibatkan kernel.
Cara dasar Mathematica membedakan antara perintah yang akan dieksekusi di kernel dan
dieksekusi langsung di front end adalah dengan menggunakan konteks. Perintah kernel berada
dalam konteks System` biasa, tetapi perintah ujung depan berada dalam konteks FrontEnd`
Jika Anda menulis program canggih untuk memanipulasi notebook, maka Anda tidak punya pilihan
selain menjalankan program ini terutama di kernel. Tetapi untuk jenis operasi yang biasanya dilakukan
oleh tombol sederhana, Anda mungkin menemukan bahwa semua perintah yang Anda perlukan dapat
dijalankan secara langsung di front end—tanpa kernel bahkan perlu dijalankan.
2.11.6 Kotak Tombol dan Elemen Aktif di Notebook

Di dalam sel mana pun di buku catatan, dimungkinkan untuk mengatur objek ButtonBox yang
melakukan tindakan setiap kali Anda mengkliknya. Objek ButtonBox adalah cara tombol palet,
hyperlink, dan elemen aktif lainnya diimplementasikan dalam notebook Mathematica.
Saat Anda pertama kali memasukkan objek ButtonBox ke dalam sel, itu akan berperilaku
seperti ekspresi lainnya, dan dengan mengkliknya Anda dapat memilihnya, mengeditnya, dan
seterusnya. Tetapi jika Anda mengatur opsi Aktif untuk sel, katakanlah dengan memilih item Aktif
Sel di menu Properti Sel, maka ButtonBox akan menjadi aktif, dan ketika Anda mengkliknya, ia
akan melakukan tindakan apa pun yang telah Anda tentukan untuknya.
Dengan menyetel ButtonStyle Anda dapat menentukan default baik untuk bagaimana tombol akan
ditampilkan, dan apa tindakannya. Ujung depan notebook menyediakan sejumlah pengaturan
ButtonStyle standar, yang dapat Anda akses dari item menu Create Button dan Edit Button
Pengaturan ButtonStyle tertentu akan menentukan default untuk semua opsi tombol lainnya.
Beberapa opsi ini akan mempengaruhi tampilan tombol, seperti yang dibahas dalam Bagian 2.9.11.
Lainnya memengaruhi tindakan yang dilakukannya.
Yang pada akhirnya menentukan aksi sebuah tombol adalah pengaturan untuk opsi
ButtonFunction. Pengaturan ini memberikan fungsi Mathematica yang akan dijalankan setiap kali
tombol diklik. Biasanya fungsi ini akan menjadi kombinasi dari berbagai perintah manipulasi notebook.
Jadi, misalnya, dalam bentuk paling dasar, tombol Tempel akan memiliki Fungsi Tombol
yang diberikan secara efektif oleh NotebookApply[SelectedNotebook[ ], #]&, sedangkan tombol
Hyperlink akan memiliki Fungsi Tombol yang diberikan secara efektif oleh NotebookLocate[#2]&.
Ketika sebuah tombol diklik, dua argumen diberikan ke ButtonFunction-nya. Yang pertama
ditentukan oleh Button Source, dan yang kedua oleh ButtonData
Biasanya ButtonData diatur menjadi ekspresi tetap, yang ditentukan saat tombol pertama kali
dibuat. ButtonSource, di sisi lain, biasanya berubah dengan isi tombol, atau lingkungan di mana
tombol muncul.
Untuk tombol Tempel sederhana, pengaturan untuk ButtonSource biasanya adalah

ButtonContents. Ini berarti bahwa apa pun yang ditampilkan di tombol akan menjadi apa yang
dilewatkan sebagai argumen pertama dari fungsi tombol. Fungsi tombol kemudian dapat
mengambil argumen ini dan memasukkannya ke NotebookApply, sehingga benar-benar
menempelkannya ke dalam notebook.
Dengan menggunakan pengaturan selain ButtonContents untuk ButtonSource, Anda dapat
membuat tombol yang secara efektif menarik berbagai aspek lingkungannya untuk diproses. Jadi,
misalnya, dengan pengaturan ButtonSource->Cell, argumen pertama untuk fungsi tombol akan
menjadi ekspresi yang mewakili seluruh sel tempat tombol muncul. Dengan memiliki fungsi tombol
memanipulasi ekspresi ini, Anda kemudian dapat membuat tombol memiliki efek global pada
seluruh sel, katakanlah dengan merestrukturisasinya dengan cara tertentu.
Setelah argumen ke ButtonFunction telah ditemukan, dan ekspresi telah dibangun, ada
pertanyaan di mana ekspresi itu harus dikirim untuk evaluasi. Opsi ButtonEvaluator untuk Button
Box memungkinkan Anda untuk menentukan ini.
Secara umum, jika ekspresi melibatkan berbagai fungsi Mathematica, maka tidak ada pilihan
selain mengevaluasinya dalam kernel Mathematica yang sebenarnya. Tetapi jika ekspresi hanya
melibatkan perintah manipulasi buku catatan sederhana, maka dimungkinkan untuk mengeksekusi
ekspresi secara langsung di ujung depan, tanpa pernah melibatkan kernel. Anda dapat menentukan
bahwa ini harus dilakukan dengan menyetel opsi ButtonEvaluator->None.
Seperti yang telah dibahas di bagian sebelumnya, ujung depan notebook standar hanya dapat
menangani serangkaian perintah terbatas, semuanya diidentifikasi dalam konteks FrontEnd`. Tetapi
perintah ini cukup untuk dapat mengimplementasikan semua tindakan yang terkait dengan gaya
tombol standar seperti Tempel, EvaluateCell, dan Hyperlink.
Perhatikan bahwa bahkan jika ekspresi dikirim ke ujung depan, itu akan dieksekusi hanya jika
dibungkus dengan lucu FrontEndExe.
2.11.7 Topik Lanjutan: Struktur Sel
Ini adalah ekspresi yang sesuai dengan sel. Input Mathematica ada di dalam sel yang disematkan di
dalam teks.
2.11.8 Gaya dan Warisan Pengaturan Opsi
Di ujung depan notebook standar, Anda dapat memeriksa dan mengatur opsi di tingkat mana
pun dengan menggunakan item menu Pemeriksa Opsi. Jika Anda tidak menetapkan opsi pada level
tertentu, maka nilainya akan selalu diwarisi dari level di atasnya. Jadi, misalnya, jika sel tertentu
tidak mengatur opsi CellFrame, maka nilai yang digunakan akan diwarisi dari pengaturannya untuk
gaya sel atau untuk seluruh buku catatan yang berisi sel.
Akibatnya, jika Anda mengatur CellFrame->True pada tingkat seluruh buku catatan, maka
semua sel di buku catatan akan memiliki bingkai yang digambar di sekitarnya—kecuali gaya sel
tertentu, atau sel itu sendiri, secara eksplisit menimpa pengaturan ini .
Tergantung pada tujuan Anda menggunakan buku catatan Mathematica, Anda mungkin ingin
memilih gaya default dasar yang berbeda untuk buku catatan tersebut. Di ujung depan notebook
standar, Anda dapat melakukan ini menggunakan item menu Edit Style Sheet.
Dengan setiap pilihan gaya default dasar, gaya yang disediakan akan berubah. Jadi, misalnya,
hanya dalam gaya default Buku terdapat gaya Kotak yang mengatur kotak abu-abu yang digunakan
dalam buku ini.
Berikut adalah buku catatan yang menggunakan gaya default Buku.

Dalam kumpulan gaya default dasar tertentu, Mathematica memungkinkan dua lingkungan
gaya yang berbeda: satu untuk tampilan di layar, dan satu lagi untuk output ke printer. Adanya
lingkungan layar dan gaya pencetakan yang terpisah memungkinkan Anda untuk mengatur gaya
yang dioptimalkan secara terpisah baik untuk tampilan resolusi rendah di layar, dan pencetakan
resolusi tinggi
Ini adalah notebook dengan lingkungan gaya layar Kerja biasa.
Ini adalah notebook yang sama dengan lingkungan gaya Layar kental.
Cara Mathematica benar-benar menyiapkan definisi untuk gaya adalah dengan menggunakan
sel definisi gaya. Sel-sel ini dapat diberikan dalam buku catatan definisi gaya terpisah, atau dapat
disertakan dalam opsi buku catatan tertentu. Dalam kedua kasus tersebut, Anda dapat mengakses
definisi gaya dengan menggunakan item menu Edit Style Sheet di ujung depan notebook standar.
2.11.9 Opsi untuk Sel

Mathematica menyediakan sejumlah besar pilihan untuk sel. Semua opsi ini dapat diakses
melalui item menu Option Inspector di bagian depan. Mereka dapat diatur baik secara langsung
pada tingkat sel individu atau pada tingkat yang lebih tinggi, untuk diwarisi oleh sel individu
Opsi CellMargins memungkinkan Anda menentukan margin horizontal dan vertikal untuk
diletakkan di sekitar sel. Anda dapat mengatur margin horizontal secara interaktif dengan
menggunakan penghentian margin di penggaris yang ditampilkan saat Anda memilih item menu
Perlihatkan Penggaris di ujung depan.
Kapan pun sebuah opsi dapat merujuk ke keempat tepi sel, Mathematica mengikuti konvensi
bahwa pengaturan untuk opsi mengambil bentuk (left), (right), (bottom), (top). Dengan memberikan
nilai bukan nol untuk elemen atas dan bawah, CellMargins dapat menentukan celah untuk
ditinggalkan di atas dan di bawah sel tertentu. Nilai selalu dianggap dalam poin printer.
Hampir setiap aspek notebook Mathematica dapat dikontrol oleh beberapa opsi atau lainnya.
Aspek yang lebih rinci biasanya ditangani oleh "opsi agregat" seperti CellElementSpacings.
Pengaturan untuk opsi ini adalah daftar aturan Mathematica, yang secara efektif memberikan nilai
untuk urutan subopsi. Nama-nama subopsi ini biasanya berupa string, bukan simbol.
Ini menunjukkan pengaturan untuk semua subopsi yang terkait dengan CellElementSpacings.
Mathematica memungkinkan Anda untuk menyematkan sel di dalam potongan teks. Opsi
CellBaseline menentukan bagaimana "sel sebaris" tersebut akan disejajarkan secara vertikal
sehubungan dengan teks di sekitarnya. Dalam analogi langsung dengan opsi Grid Baseline untuk
GridBox, opsi CellBaseline menentukan aspek sel apa yang harus dianggap sebagai dasarnya.
Selain isi sel yang sebenarnya, seringkali berguna untuk mengaitkan berbagai jenis data tambahan
dengan sel.
Dalam sesi Mathematica standar, sel yang berisi baris input dan output kernel yang berurutan
diberi label dalam bentuk In[n]:= dan Out[n]=. Opsi ShowCellLabel menentukan apakah label
tersebut harus ditampilkan. CellLabelAutoDelete menentukan apakah label pada sel harus dihapus
jika konten sel diubah. Melakukan hal ini memastikan bahwa label In[n]:= dan Out[n]= hanya
terkait dengan bagian input dan output kernel yang tidak dimodifikasi.
Tag sel biasanya digunakan untuk mengaitkan kata kunci atau atribut lain dengan sel, yang
dapat dicari menggunakan fungsi seperti NotebookFind. Tujuan untuk hyperlink di notebook
Mathematica biasanya diimplementasikan menggunakan tag sel.
Opsi ConversionRules memungkinkan Anda memberikan daftar yang berisi entri seperti
"TeX" -> data yang menentukan bagaimana konten sel harus dikonversi ke format eksternal. Ini
sangat relevan jika Anda ingin menyimpan salinan bentuk asli sel yang telah dikonversi dalam
format notebook Mathematica dari beberapa format eksternal.
Opsi Dihapus, Dapat Disalin, Dapat Dipilih, dan Dapat Diedit memungkinkan Anda
mengontrol operasi interaktif apa yang harus diizinkan pada sel. Dengan menyetel opsi ini ke False
di tingkat buku catatan, Anda dapat melindungi semua sel dalam buku catatan.
Bahkan jika Anda mengizinkan sel tertentu untuk diedit, Anda dapat mengatur
CellEditDuplicate->True agar Mathematica membuat salinan konten sel sebelum benar-benar
diubah. Gaya untuk sel yang berisi keluaran dari evaluasi kernel Mathematica biasanya
menggunakan opsi ini.
Mathematica memungkinkan untuk menentukan evaluator yang berbeda untuk setiap sel
dalam buku catatan. Tetapi paling sering, opsi Evaluasi diatur hanya pada tingkat notebook,
biasanya menggunakan item menu Kernel di ujung depan.
Opsi CellAutoOverwrite biasanya diatur ke True untuk gaya yang mewakili keluaran
Mathematica. Melakukan ini berarti bahwa ketika Anda mengevaluasi kembali bagian tertentu dari
input, Mathematica secara otomatis akan menghapus output yang sebelumnya dihasilkan dari input
tersebut, dan akan menimpanya dengan output baru.
Opsi GeneratedCell diatur setiap kali sel dihasilkan oleh permintaan eksternal ke ujung depan
daripada oleh operasi interaktif di ujung depan. Jadi, misalnya, setiap sel yang diperoleh sebagai
keluaran dari evaluasi kernel, atau dibuat menggunakan fungsi seperti CellPrint atau
NotebookWrite, akan memiliki GeneratedCell->True.
Saat Anda menampilkan buku catatan di layar, Anda dapat menggulirnya terus menerus.
Tetapi jika Anda mencetak buku catatan, Anda harus memutuskan di mana jeda halaman akan
terjadi. Pengaturan opsi Automatic for a page break memberitahu Mathematica untuk membuat
page break jika perlu; True menentukan bahwa page break harus selalu dibuat, sedangkan False
menentukan bahwa itu tidak boleh
2.11.10 Opsi Teks dan Font
Jika Anda memiliki blok teks besar yang tidak mengandung karakter Return eksplisit, maka
Mathematica akan secara otomatis memecah teks Anda menjadi urutan baris. Opsi PageWidth
menentukan berapa lama setiap baris harus diizinkan
Opsi TextAlignment memungkinkan Anda untuk menentukan bagaimana Anda ingin baris
teks yang berurutan disejajarkan. Karena Mathematica biasanya memecah teks hanya pada spasi
atau karakter tanda baca, biasanya berakhir dengan garis dengan panjang yang berbeda. Biasanya
variasi panjang akan memberi teks Anda batas yang tidak rata. Tetapi Mathematica memungkinkan
Anda untuk menyesuaikan spasi dalam baris teks yang berurutan sehingga membuat garis lebih
hampir sama panjangnya. Pengaturan untuk Pembenaran Teks memberikan fraksi ruang ekstra yang
diizinkan untuk ditambahkan oleh Mathematica. TextJustifica tion->1 mengarah ke "pembenaran
penuh" di mana semua baris teks yang lengkap disesuaikan agar sama panjangnya.
Saat Anda memasukkan blok teks dalam buku catatan Mathematica, Mathematica akan
memperlakukan setiap karakter Pengembalian eksplisit yang Anda ketikkan sebagai pemisah
paragraf. Opsi ParagraphIndent memungkinkan Anda menentukan seberapa banyak Anda ingin
membuat indentasi baris pertama di setiap paragraf. Dengan memberikan pengaturan negatif untuk
ParagraphIndent, Anda dapat membuat baris pertama menonjol ke kiri relatif terhadap baris
berikutnya
Mathematica memungkinkan Anda untuk menentukan font yang ingin Anda gunakan dengan
cukup detail. Namun, terkadang kombinasi tertentu dari kelompok font dan variasi yang Anda minta
mungkin tidak tersedia di sistem komputer Anda. Dalam kasus seperti itu, Mathematica akan
mencoba menemukan pendekatan terdekat yang bisa dilakukan. Ada berbagai opsi tambahan,
seperti FontPostScriptName, yang dapat Anda atur untuk membantu Mathematica menemukan font
yang sesuai. Selain itu, Anda dapat mengatur FontSubstitusi menjadi daftar aturan yang
memberikan penggantian untuk mencoba nama keluarga font.
Ada banyak sekali font yang tersedia untuk teks biasa. Tetapi untuk karakter teknis khusus,
dan bahkan untuk huruf Yunani, font yang tersedia jauh lebih sedikit. Sistem Mathematica
mencakup font yang dibangun untuk mendukung semua berbagai karakter khusus yang digunakan
oleh Mathematica. Ada tiga versi font ini: biasa (seperti Times), monospace (seperti Courier), dan
sans serif (seperti Helvetica).
Untuk font teks tertentu, Mathematica mencoba memilih font karakter khusus yang paling
cocok. Anda dapat membantu Mathematica untuk membuat pilihan ini dengan memberikan aturan
untuk "FontSerifed" dan "FontMonospaced" dalam pengaturan untuk opsi FontProperties. Anda
juga dapat memberikan aturan untuk "FontEncoding" untuk menentukan secara eksplisit dari font
apa setiap karakter akan diambil
2.11.11 Topik Lanjutan: Opsi untuk Input dan Output Ekspresi
Opsi SingleLetterItalics dan ZeroWidthTimes biasanya disetel setiap kali sel menggunakan
Tradition alForm.
Dibangun ke Mathematica adalah sejumlah besar alias untuk karakter khusus umum.
InputAliases memungkinkan Anda untuk menambahkan alias Anda sendiri untuk karakter khusus
lebih lanjut atau untuk jenis input Mathematica lainnya. Aturan bentuk "nama"->expr menetapkan
bahwa namaÇ harus segera diganti pada input dengan expr.
Alias dibatasi oleh karakter Â eksplisit. Opsi InputAutoReplacements memungkinkan Anda
untuk menentukan bahwa jenis urutan input tertentu harus segera diganti meskipun tidak memiliki
pembatas eksplisit. Secara default, misalnya, -> segera diganti dengan . Anda dapat memberikan
aturan bentuk "seq"->"rhs" untuk menentukan bahwa setiap kali seq muncul sebagai token di input
Anda, itu harus segera diganti dengan rhs
Opsi LanguageCategory memungkinkan Anda memberi tahu Mathematica jenis konten apa
yang seharusnya dimiliki sel. Ini menentukan bagaimana ejaan dan struktur harus diperiksa, dan
bagaimana tanda hubung harus dilakukan.
Mathematica biasanya memungkinkan Anda untuk memilih bagian mana pun dari ekspresi
yang Anda lihat di layar. Namun, kadang-kadang, Anda mungkin merasa berguna untuk membuat
Mathematica hanya mengizinkan pilihan yang sesuai dengan subekspresi lengkap. Anda dapat
melakukan ini dengan mengatur opsi StructuredSelection->True
Seperti yang dibahas dalam Bagian 2.9, Mathematica menyediakan banyak opsi untuk
menentukan bagaimana ekspresi harus ditampilkan. Dengan menggunakan StyleBox[box, opts]
Anda dapat menerapkan opsi tersebut ke koleksi kotak. Tetapi Mathematica diatur sehingga opsi
apa pun yang dapat Anda berikan ke StyleBox juga dapat diberikan ke objek Sel lengkap, atau
bahkan Notebook lengkap. Jadi, misalnya, opsi seperti Background dan LineIndent dapat diberikan
untuk melengkapi sel serta objek StyleBox individual.
Ada beberapa opsi yang hanya berlaku untuk jenis kotak tertentu, seperti GridBox. Biasanya
opsi ini paling baik diberikan secara terpisah di setiap GridBox di mana mereka dibutuhkan. Namun
terkadang Anda mungkin ingin menentukan pengaturan default untuk diwarisi oleh semua objek
GridBox yang muncul di sel tertentu. Anda dapat melakukan ini dengan memberikan pengaturan
default ini sebagai nilai opsi GridBoxOptions untuk seluruh sel.
Untuk setiap jenis kotak bernama XXXBox, Mathematica menyediakan opsi sel
XXXBoxOptions yang memungkinkan Anda menentukan pengaturan opsi default untuk jenis kotak
tersebut.
2.11.12 Opsi untuk Sel Grafik

Mathematica memungkinkan Anda untuk menentukan ukuran akhir grafik dengan mengatur
opsi ImageSize dalam fungsi grafik kernel seperti Plot dan Display. Setelah grafik ada di buku
catatan, Anda biasanya dapat mengubah ukuran atau memindahkannya hanya dengan menggunakan
mouse
Mathematica menghasilkan grafik animasi dengan mengambil urutan sel grafik, dan
kemudian memperlakukannya seperti bingkai dalam film. Opsi AnimationDisplayTime
menentukan berapa lama sel tertentu harus ditampilkan sebagai bagian dari film.
2.11.13 Opsi untuk Notebook

 Gunakan menu Option Inspector untuk mengubah opsi secara interaktif.
 Gunakan SetOptions@ obj, opsi dari kernel
 Gunakan opsi NotebookCreate untuk membuat buku catatan baru dengan opsi tertentu
Dalam memberikan definisi gaya untuk buku catatan tertentu, Mathematica memungkinkan
Anda untuk mereferensikan buku catatan lain, atau secara eksplisit menyertakan ekspresi Buku
Catatan yang mendefinisikan gaya.
WindowSize memungkinkan Anda untuk menentukan seberapa besar jendela yang Anda
inginkan; WindowMargins memungkinkan Anda menentukan di mana Anda ingin menempatkan
jendela di layar Anda. Pengaturan WindowMargins-(kiri), (kanan), (bawah), (atas) memberikan
margin dalam poin printer untuk ditinggalkan di sekitar jendela Anda di layar. Seringkali hanya dua
dari margin yang akan ditetapkan secara eksplisit; yang lainnya akan Otomatis, menunjukkan
bahwa margin ini akan ditentukan dari ukuran layar tertentu yang Anda gunakan.
Mathematica memungkinkan berbagai jenis jendela. Detail bagaimana jendela tertentu

dirender mungkin sedikit berbeda dari satu sistem komputer ke sistem komputer lainnya, tetapi
bentuk umumnya selalu sama. WindowFrame menentukan jenis bingkai untuk menggambar di
sekitar jendela. WindowElements memberikan daftar elemen tertentu untuk dimasukkan ke dalam
jendela.
2.11.14 Topik Lanjutan: Opsi Global untuk Front End

Di ujung depan notebook standar, Mathematica memungkinkan Anda mengatur sejumlah
besar opsi global. Nilai dari semua opsi ini secara default disimpan dalam "file preferensi", dan
secara otomatis digunakan kembali saat Anda menjalankan Mathematica lagi
Seperti yang dibahas di Bagian 2.11.4, Anda dapat mengakses opsi front end global dari
kernel dengan menggunakan Opsi[Front End, nama]. Tetapi lebih sering, Anda ingin mengakses
opsi ini secara interaktif menggunakan Option Inspector di bagian depan.
2.12 File dan Aliran

2.12.1 Membaca dan Menulis File Mathematica
Khususnya jika Anda menggunakan antarmuka Mathematica berbasis teks, Anda akan sering
perlu membaca dan menulis file yang berisi definisi dan hasil dari Mathematica. Bagian 1.11.1
memberikan diskusi umum tentang bagaimana melakukan ini. Bagian ini memberikan beberapa
detail lebih lanjut
File input Mathematica dapat berisi sejumlah ekspresi. Namun, setiap ekspresi harus dimulai
pada baris baru. Namun ekspresi dapat berlanjut untuk baris sebanyak yang diperlukan. Sama
seperti dalam sesi Mathematica interaktif standar, ekspresi diproses segera setelah selesai. Namun,
perhatikan bahwa dalam file, tidak seperti sesi interaktif, Anda dapat menyisipkan baris kosong
kapan saja tanpa efek.
Saat Anda membaca dalam file dengan <<file, Mathematica mengembalikan ekspresi terakhir
yang dievaluasi dalam file. Anda dapat menghindari mendapatkan hasil yang terlihat dari membaca
file dengan mengakhiri ekspresi terakhir dalam file dengan titik koma, atau dengan menambahkan
Null secara eksplisit setelah ekspresi itu.
Jika Mathematica menemukan kesalahan sintaks saat membaca file, itu melaporkan
kesalahan, melewatkan sisa file, lalu mengembalikan Gagal. Jika kesalahan sintaks terjadi di
tengah-tengah paket yang menggunakan BeginPackage dan fungsi manipulasi konteks lainnya,
maka Mathematica mencoba mengembalikan konteks ke keadaan sebelum paket dibaca.
Saat Anda menggunakan file expr >>>, Mathematica menambahkan setiap ekspresi baru yang
Anda berikan ke akhir file Anda. Namun, jika Anda menggunakan file expr >>, maka Mathematica
akan menghapus semua yang ada di file sebelumnya, dan kemudian memasukkan expr ke dalam
file.
Saat Anda menggunakan >> atau >>> untuk menulis ekspresi ke file, ekspresi biasanya
diberikan dalam format input Mathematica, sehingga Anda dapat membacanya kembali ke
Mathematica. Namun, terkadang Anda mungkin ingin menyimpan ekspresi dalam format lain.
Anda dapat melakukan ini dengan secara eksplisit membungkus direktif format seperti OutputForm
di sekitar ekspresi yang Anda tulis
Salah satu alasan paling umum untuk menggunakan file adalah untuk menyimpan definisi
objek Mathematica, untuk dapat membacanya lagi di sesi Mathematica berikutnya. Operator >>
dan >>> memungkinkan Anda untuk menyimpan ekspresi Mathematica dalam file. Anda dapat
menggunakan fungsi Simpan untuk menyimpan definisi lengkap objek Mathematica, dalam bentuk
yang sesuai untuk dieksekusi di sesi Mathematica berikutnya.
Saat Anda mendefinisikan objek baru di Mathematica, definisi Anda akan sering bergantung
pada objek lain yang Anda definisikan sebelumnya. Jika Anda akan dapat merekonstruksi definisi
objek baru Anda dalam sesi Mathematica berikutnya, penting bagi Anda untuk menyimpan tidak
hanya definisinya sendiri, tetapi juga definisi objek lain yang menjadi sandarannya. Fungsi Simpan
melihat melalui definisi objek yang Anda minta untuk disimpan, dan secara otomatis juga
menyimpan semua definisi objek lain yang dapat dilihat bahwa ini bergantung. Namun, untuk
menghindari menyimpan sejumlah besar materi yang tidak perlu, Simpan tidak pernah menyertakan
definisi untuk simbol yang memiliki atribut Dilindungi. Diasumsikan bahwa definisi untuk
simbolsimbol ini juga dibangun di dalamnya. Namun demikian, dengan definisi seperti itu, harus
selalu terjadi bahwa membaca output yang dihasilkan oleh Simpan kembali ke sesi Mathematica
baru akan mengatur definisi objek Anda dengan tepat seperti yang Anda miliki sebelumnya.
Saat Anda membuat file untuk input ke Mathematica, Anda biasanya ingin file tersebut hanya
berisi "teks biasa", yang dapat dibaca atau dimodifikasi secara langsung. Namun terkadang, Anda
mungkin ingin konten file "dikodekan" sehingga tidak dapat dibaca atau dimodifikasi secara
langsung sebagai teks biasa, tetapi dapat dimuat ke Mathematica. Anda dapat membuat file yang
disandikan menggunakan fungsi Mathematica Encode
Jika Anda harus membaca dalam definisi yang sangat besar atau rumit, Anda akan sering
merasa lebih efisien untuk menyimpan definisi ini dalam format Mathematica internal, daripada
sebagai teks. Anda dapat melakukan ini menggunakan DumpSave
<< mengenali ketika file berisi definisi dalam format Mathematica internal, dan beroperasi
sesuai dengan itu. Satu kehalusan adalah bahwa format Mathematica internal berbeda dari satu
sistem komputer ke sistem komputer lainnya. Akibatnya, file .mx yang dibuat di satu komputer
biasanya tidak dapat dibaca di komputer lain.
Jika Anda menggunakan DumpSave["package`", … ] maka Mathematica akan menulis
definisi ke file dengan nama seperti package.mx/system/package.mx, di mana sistem
mengidentifikasi jenis sistem komputer Anda
2.12.2 Program Eksternal

Pada kebanyakan sistem komputer, Anda dapat menjalankan program atau perintah eksternal
dari dalam Mathematica. Seringkali Anda ingin mengambil ekspresi yang telah Anda buat di
Mathematica, dan mengirimkannya ke program eksternal, atau mengambil hasil dari program
eksternal, dan membacanya ke Mathematica.
Mathematica mendukung dua bentuk dasar komunikasi dengan program eksternal: terstruktur dan
tidak terstruktur
Ide komunikasi terstruktur adalah untuk menukar ekspresi Mathematica lengkap ke program
eksternal yang secara khusus diatur untuk menangani objek tersebut. Dasar untuk komunikasi
terstruktur adalah sistem MathLink, yang dibahas dalam Bagian 2.13.
Komunikasi tidak terstruktur terdiri dari pengiriman dan penerimaan teks biasa dari program
eksternal. Ide dasarnya adalah memperlakukan program eksternal sangat mirip dengan file, dan
untuk mendukung jenis operasi membaca dan menulis yang sama
Secara umum, di mana pun Anda mungkin menggunakan nama file biasa, Mathematica
memungkinkan Anda untuk memberikan pipa, yang ditulis sebagai perintah eksternal, diawali
dengan tanda seru. Saat Anda menggunakan pipa, Mathematica akan menjalankan perintah
eksternal, dan mengirim atau menerima teks darinya.
Satu hal yang perlu diperhatikan adalah Anda dapat menghilangkan tanda kutip ganda di
sekitar nama pipa di sisi kanan << atau >> jika nama tersebut tidak mengandung spasi atau karakter
khusus lainnya.
Pipa di Mathematica menyediakan mekanisme yang sangat umum untuk komunikasi tidak
terstruktur dengan program eksternal. Pada banyak sistem komputer, pipa Mathematica
diimplementasikan menggunakan mekanisme pipa di sistem operasi yang mendasarinya; dalam
beberapa kasus, bagaimanapun, mekanisme komunikasi antarproses lainnya digunakan. Salah satu
batasan komunikasi tidak terstruktur di Mathematica adalah bahwa pipa yang diberikan hanya dapat
digunakan untuk input atau output, dan tidak untuk keduanya secara bersamaan. Untuk melakukan
komunikasi dua arah yang asli, Anda perlu menggunakan MathLink.
Bahkan dengan komunikasi yang tidak terstruktur, Anda tetap dapat mengatur pengaturan
yang agak lebih rumit dengan menggunakan file-file sementara. Ide dasarnya adalah menulis data
ke file, lalu membacanya sesuai kebutuhan
OpenTemporary [ ] membuka file sementara dengan nama yang unik
Khususnya ketika Anda bekerja dengan file-file sementara, Anda mungkin merasa berguna
untuk dapat menjalankan perintah eksternal yang tidak secara eksplisit mengirim atau menerima
data dari Mathematica. Anda dapat melakukan ini menggunakan fungsi Mathematica Run
Perhatikan bahwa saat Anda menggunakan Run, Anda tidak boleh mengawali perintah
dengan tanda seru. Run hanya mengambil bentuk tekstual dari argumen yang Anda tentukan, lalu
menggabungkannya dengan spasi di antaranya, dan mengeksekusi string yang dihasilkan sebagai
perintah eksternal.
Penting untuk disadari bahwa Run tidak pernah "menangkap" output apa pun dari perintah
eksternal. Akibatnya, ke mana arah keluaran ini murni ditentukan oleh sistem operasi Anda.
Demikian pula, Run tidak menyediakan input ke perintah eksternal. Ini berarti bahwa perintah bisa
mendapatkan input melalui mekanisme apa pun yang disediakan oleh sistem operasi Anda.
Terkadang perintah eksternal mungkin dapat mengakses aliran input dan output yang sama yang
digunakan oleh Mathematica itu sendiri. Dalam beberapa kasus, ini mungkin yang Anda inginkan.
Tetapi terutama jika Anda menggunakan Mathematica dengan ujung depan, ini dapat menyebabkan
banyak masalah
!memerintah mencegat garis Mathematica
masukan, dan jalankan sebagai perintah eksternal
Jika Anda menggunakan Mathematica dengan antarmuka berbasis teks, biasanya ada
mekanisme khusus untuk mengeksekusi perintah eksternal. Dengan antarmuka seperti itu,
Mathematica mengambil baris input apa pun yang dimulai dengan tanda seru, dan mengeksekusi
teks pada sisa baris sebagai perintah eksternal.
Cara Mathematica menggunakan !command adalah tipikal cara kerja "shell escapes" dalam
program yang berjalan di bawah sistem operasi Unix. Di sebagian besar versi Mathematica, Anda
akan dapat memulai shell interaktif dari Mathematica hanya dengan mengetikkan satu tanda seru
pada satu baris.
RunThrough[" perintah", expr] menjalankan perintah, menggunakan expr
sebagai input, dan membaca output kembali ke Mathematica
Seperti dibahas di atas, << dan >> tidak dapat digunakan untuk mengirim dan menerima data
dari program eksternal secara bersamaan. Namun demikian, dengan menggunakan file sementara,
Anda dapat secara efektif mengirim dan menerima data dari program eksternal sambil tetap
menggunakan komunikasi tidak terstruktur.
Fungsi RunThrough menulis teks ekspresi ke file sementara, kemudian memasukkan file ini
sebagai input ke program eksternal, dan menangkap output sebagai input ke Mathematica.
Perhatikan bahwa di RunThrough, seperti Run, Anda tidak boleh mengawali nama perintah
eksternal dengan tanda seru.
2.12.3 Topik Lanjutan: Aliran dan Input dan Output Tingkat Rendah
File dan pipa keduanya adalah contoh objek Mathematica umum yang dikenal sebagai stream.
Aliran di Mathematica adalah sumber input atau output. Ada banyak operasi yang dapat Anda
lakukan di stream.
Anda dapat menganggap >> dan << sebagai fungsi input-output Mathematica “tingkat
tinggi”. Mereka didasarkan pada seperangkat primitif input-output tingkat rendah yang bekerja
secara langsung dengan aliran. Dengan menggunakan primitif ini, Anda dapat melakukan kontrol
lebih besar atas bagaimana Mathematica melakukan input dan output. Anda akan sering perlu
melakukan ini, misalnya, jika Anda menulis program Mathematica yang menyimpan dan
mengambil data perantara dari file atau pipa.
Skema tingkat rendah dasar untuk menulis output ke aliran di Mathematica adalah sebagai
berikut. Pertama, Anda memanggil OpenWrite atau OpenAppend untuk "membuka aliran",
memberi tahu Mathematica bahwa Anda ingin menulis output ke file atau program eksternal
tertentu, dan dalam bentuk apa output harus ditulis. Setelah membuka aliran, Anda kemudian dapat
memanggil Tulis atau Tulis String untuk menulis urutan ekspresi atau string ke aliran. Setelah
selesai, Anda memanggil Tutup untuk "menutup aliran".
Saat Anda membuka file atau pipa, Mathematica membuat "objek aliran" yang menentukan
aliran terbuka yang terkait dengan file atau pipa. Secara umum, objek aliran berisi nama file atau
perintah eksternal yang digunakan dalam pipa, bersama dengan nomor unik.
Alasan mengapa objek aliran perlu menyertakan nomor unik adalah karena secara umum
Anda dapat memiliki beberapa aliran yang terhubung ke file yang sama atau program eksternal pada
saat yang bersamaan. Misalnya, Anda dapat memulai beberapa contoh berbeda dari program
eksternal yang sama, masing-masing terhubung ke aliran yang berbeda.
Namun demikian, ketika Anda telah membuka aliran, Anda masih dapat merujuknya
menggunakan nama file sederhana atau nama perintah eksternal selama hanya ada satu aliran yang
terkait dengan
objek ini.
Saat Anda memanggil Write[stream, expr], ia menulis ekspresi ke stream yang ditentukan.
Standarnya adalah menulis ekspresi dalam formulir input Mathematica. Jika Anda memanggil Tulis
dengan urutan ekspresi, itu akan menulis ekspresi ini satu demi satu ke aliran. Secara umum, itu
tidak meninggalkan ruang antara ekspresi berturut-turut. Namun, setelah selesai menulis semua
ekspresi, Write selalu mengakhiri outputnya dengan baris baru
Write menyediakan cara untuk menuliskan ekspresi Mathematica yang lengkap. Namun,
terkadang Anda mungkin ingin menulis data yang kurang terstruktur. WriteString memungkinkan
Anda untuk menulis string karakter apa pun. Tidak seperti Write, WriteString tidak menambahkan
baris baru atau karakter lain
Fitur penting dari fungsi Write dan WriteString adalah mereka memungkinkan Anda untuk menulis
output tidak hanya ke satu aliran, tetapi juga ke daftar aliran.
Dalam menggunakan Mathematica, seringkali lebih mudah untuk mendefinisikan saluran
yang terdiri dari daftar aliran. Anda kemudian dapat dengan mudah memberi tahu Mathematica
untuk menulis ke saluran, dan membuatnya secara otomatis menulis objek yang sama ke beberapa
aliran.
Dalam sesi Mathematica interaktif standar, ada beberapa saluran keluaran yang biasanya
ditentukan. Ini menentukan di mana jenis output tertentu harus dikirim. Jadi, misalnya, $Output
menentukan ke mana output standar harus pergi, sementara $Messages menentukan ke mana pesan
harus pergi. Fungsi Print kemudian bekerja pada dasarnya dengan memanggil Write dengan saluran
$Output. Message bekerja dengan cara yang sama dengan memanggil Write dengan saluran
$Messages. Bagian 2.14.1 mencantumkan saluran yang digunakan dalam sesi Mathematica biasa.
Perhatikan bahwa ketika Anda menjalankan Mathematica melalui MathLink, pendekatan
yang berbeda biasanya digunakan. Semua keluaran biasanya ditulis ke satu tautan MathLink, tetapi
setiap bagian keluaran muncul dalam "paket" yang menunjukkan jenisnya.
Dalam kebanyakan kasus, nama file atau perintah eksternal yang Anda gunakan di
Mathematica sama persis dengan yang digunakan oleh sistem operasi komputer Anda. Namun, pada
beberapa sistem, Mathematica mendukung berbagai aliran dengan nama khusus.
Aliran khusus "stdout" memungkinkan Anda memberikan output ke "output standar" yang
disediakan oleh sistem operasi. Namun perhatikan bahwa Anda dapat menggunakan aliran ini hanya
dengan antarmuka berbasis teks sederhana ke Mathematica. Jika interaksi Anda dengan
Mathematica lebih rumit, aliran ini tidak akan berfungsi, dan mencoba menggunakannya dapat
menyebabkan banyak masalah.
Anda dapat mengaitkan sejumlah opsi dengan aliran keluaran. Anda dapat menentukan opsi ini
saat pertama kali membuka streaming menggunakan OpenWrite atau OpenAppend.
Perhatikan bahwa Anda selalu dapat mengganti format output yang ditentukan untuk aliran
tertentu dengan membungkus ekspresi tertentu yang Anda tulis ke aliran dengan direktif format
Mathematica eksplisit, seperti OutputForm atau TeXForm.
Opsi PageWidth memberikan lebar halaman yang tersedia untuk keluaran tekstual dari
Mathematica. Semua jalur keluaran dipatahkan sehingga pas dengan lebar ini. Jika Anda tidak ingin
ada garis yang terputus, Anda dapat mengatur PageWidth -> Infin ity. Namun, biasanya Anda ingin
menyetel PageWidth ke nilai yang sesuai untuk perangkat keluaran khusus Anda. Pada banyak
sistem, Anda harus menjalankan program eksternal untuk mengetahui nilai ini. Menggunakan
SetOptions, Anda dapat membuat aturan default untuk PageWidth menjadi, misalnya, PageWidth
:> <<"!devicewidth", sehingga program eksternal dijalankan secara otomatis untuk menemukan
nilai opsi.
Opsi CharacterEncoding memungkinkan Anda untuk menentukan pengkodean karakter yang
akan digunakan untuk semua string yang berisi karakter khusus yang dikirim ke aliran keluaran
tertentu, baik dengan Write atau WriteString. Anda biasanya perlu menggunakan
CharacterEncoding jika Anda ingin memodifikasi rangkaian karakter internasional, atau mencegah
perangkat keluaran tertentu menerima karakter yang tidak dapat ditanganinya.
Di setiap titik dalam sesi Anda, Mathematica menyimpan daftar Streams[ ] dari semua aliran
input dan output yang saat ini terbuka, bersama dengan opsinya. Dalam beberapa kasus, Anda
mungkin perlu melihat daftar ini secara langsung. Mathematica tidak akan, bagaimanapun,
mengizinkan Anda untuk mengubah daftar, kecuali secara tidak langsung melalui OpenRead dan
seterusnya.
2.12.4 Memberi Nama dan Menemukan File

Detail yang tepat dari penamaan file berbeda dari satu sistem komputer ke sistem komputer
lainnya. Namun demikian, Mathematica menyediakan beberapa mekanisme yang cukup umum
yang bekerja pada semua sistem.
Seperti disebutkan di Bagian 1.11.2, Mathematica mengasumsikan bahwa semua file Anda
diatur dalam hierarki direktori. Untuk menemukan file tertentu, Mathematica harus mengetahui
nama file tersebut, dan urutan direktorinya.
Namun, pada waktu tertentu, Anda memiliki direktori kerja saat ini, dan Anda dapat merujuk
ke file atau direktori lain dengan menentukan di mana mereka relatif terhadap direktori ini. Biasanya
Anda dapat merujuk ke file atau direktori yang sebenarnya ada di direktori ini hanya dengan
memberikan namanya, tanpa informasi direktori.
Saat Anda memanggil SetDirectory, Anda dapat memberikan nama direktori apa pun yang
dikenali oleh sistem operasi Anda. Jadi, misalnya, pada sistem berbasis Unix, Anda dapat
menentukan direktori satu tingkat di hierarki direktori menggunakan notasi .., dan Anda dapat
menentukan direktori "rumah" Anda sebagai ~.
Setiap kali Anda membuka direktori baru menggunakan SetDirectory, Mathematica selalu
mengingat apa direktori sebelumnya. Anda dapat kembali ke direktori sebelumnya menggunakan
ResetDirectory. Secara umum, Mathematica memelihara tumpukan direktori, yang diberikan oleh
DirectoryStack[ ]. Setiap kali Anda memanggil SetDirectory, itu menambahkan direktori baru ke
tumpukan, dan setiap kali Anda memanggil ResetDirectory itu menghapus direktori dari tumpukan
Setiap kali Anda meminta file tertentu, Mathematica secara umum melewati beberapa
langkah untuk mencoba dan menemukan file yang Anda inginkan. Langkah pertama adalah
menggunakan mekanisme standar apa pun yang ada di sistem operasi atau shell Anda.
Mathematica memindai nama lengkap yang Anda berikan untuk sebuah file, dan melihat
apakah file tersebut berisi salah satu "metacharacters" *, $, ~, ?, [, ", dan '. Jika menemukan karakter
seperti itu, maka ia akan melewati nama lengkap ke sistem operasi atau shell Anda untuk
interpretasi. Ini berarti bahwa jika Anda menggunakan sistem berbasis Unix, maka konstruksi
seperti name* dan $VAR akan diperluas pada titik ini. Namun secara umum, Mathematica
mengambil apa pun yang dikembalikan oleh Anda sistem operasi atau shell, dan memperlakukan
ini sebagai nama file lengkap.
Untuk file keluaran, ini adalah akhir dari pemrosesan yang dilakukan Mathematica. Jika
Mathematica tidak dapat menemukan file unik dengan nama yang Anda tentukan, maka
Mathematica akan melanjutkan untuk membuat file.
Namun, jika Anda mencoba mendapatkan input dari file, maka ada putaran pemrosesan lain
yang dilakukan Mathematica. Apa yang terjadi adalah bahwa Mathematica melihat nilai opsi Path
untuk fungsi yang Anda gunakan untuk menentukan nama direktori relatif yang seharusnya mencari
file. Pengaturan default untuk opsi Path adalah variabel global $Path
Secara umum, variabel global $Path didefinisikan sebagai daftar string, dengan setiap string
mewakili direktori. Setiap kali Anda meminta file input, apa yang secara efektif dilakukan
Mathematica adalah membuat setiap direktori ini menjadi direktori kerja Anda saat ini, dan
kemudian dari direktori itu untuk mencoba dan menemukan file yang Anda minta
FileNames mengembalikan daftar string yang sesuai dengan nama file. Ketika
mengembalikan file yang tidak ada di direktori Anda saat ini, itu memberikan nama file relatif
terhadap direktori saat ini. Perhatikan bahwa semua nama diberikan dalam format yang sesuai untuk
sistem komputer tertentu tempat nama tersebut dibuat
Anda harus menyadari bahwa sistem komputer yang berbeda dapat memberikan nama file
dengan cara yang berbeda. Jadi, misalnya, sistem Windows biasanya memberi nama dalam bentuk
dir:\dir\#dir\name, sistem Unix dalam bentuk dir/dir/name dan sistem Macintosh dalam bentuk
:dir:dir:name. Fungsi ToFileName merakit nama file dengan cara yang sesuai untuk sistem
komputer tertentu yang Anda gunakan.
Jika Anda ingin mengatur kumpulan file terkait, sering kali lebih mudah untuk dapat merujuk
ke satu file saat Anda membaca yang lain. Variabel global $Input memberikan nama file dari mana
input saat ini sedang diambil. Menggunakan DirectoryName dan ToFileName Anda kemudian
dapat dengan mudah menentukan nama file terkait lainnya.
$Masukkan nama file atau aliran
dari mana input sedang diambil
2.12.5 File untuk Paket

Saat Anda membuat atau menggunakan paket Mathematica, Anda akan sering ingin merujuk
ke file dengan cara yang tidak bergantung pada sistem. Anda dapat menggunakan konteks untuk
melakukan ini.
Ide dasarnya adalah bahwa pada setiap sistem komputer ada konvensi tentang bagaimana file
yang sesuai dengan konteks Mathematica harus dinamai. Kemudian, ketika Anda merujuk ke file
menggunakan konteks, versi tertentu dari Mathematica yang Anda gunakan akan mengubah nama
konteks menjadi nama file yang sesuai untuk sistem komputer yang Anda gunakan.
<< konteks `baca dalam file yang sesuai dengan konteks yang ditentukan
Mathematica diatur sehingga <<name` akan secara otomatis mencoba memuat versi file yang
sesuai. Ini pertama-tama akan mencoba memuat file name.mx yang dioptimalkan untuk sistem
komputer khusus Anda. Jika tidak menemukan file seperti itu, maka ia akan mencoba memuat file
name.m yang berisi input Mathematica sistem-independen biasa.
Jika nama adalah direktori, maka Mathematica akan mencoba memuat file inisialisasi init.m
di direktori tersebut. Tujuan dari file init.m adalah untuk menyediakan cara yang nyaman untuk
mengatur paket Mathematica yang melibatkan banyak file terpisah. Idenya adalah untuk
memungkinkan Anda memberikan perintah <<name` saja, tetapi kemudian memuat init.m untuk
menginisialisasi seluruh paket, membaca file lain apa pun yang diperlukan.
2.12.6 Memanipulasi File dan Direktori
Sistem operasi yang berbeda memiliki perintah yang berbeda untuk memanipulasi file.
Mathematica menyediakan satu set sederhana fungsi manipulasi file, dimaksudkan untuk bekerja
dengan cara yang sama di bawah semua sistem operasi.
Perhatikan bahwa CopyFile dan RenameFile memberikan file terakhir tanggal modifikasi
yang sama dengan yang asli. File Date mengembalikan tanggal modifikasi dalam format 8 tahun,
bulan, hari, jam, menit, detik yang digunakan oleh Date
Aturan ini “List”, mengatur daftar di sekitar hasil anda.
MLPutFunction(stdlink, "List", 1);{
(dalam kondisi sementara, akan menghasilkan elemen) Buat

objek Urutan pada “Tingkatan” berikutnya.
MLPutFunction(stdlink, "Sequence", 2);} Letakkan
faktornya.
MLPutInteger(stdlink, i );
Aturan ini menutup objek urutan terakhir Anda.

MLPutFunction(stdlink, "Sequence", 0);
MLGetInteger (stdlink, int i) dapatkan bilangan bulat, simpan di

alamat i dapatkan nomor floating-point, simpan di alamat
MLGetReal (stdlink, x
x)
double
Sama seperti MathLink menyediakan fungsi seperti MLPutInteger() untuk mengirim data dari
program eksternal ke Mathematica, begitu juga MathLink menyediakan fungsi seperti MLGetInteger()
yang memungkinkan Anda untuk mendapatkan data dari Mathematica ke dalam program eksternal.
Daftar yang Anda berikan untuk : ArgumentTypes : dalam template MathLink dapat diakhiri
dengan “Manual”, yang menunjukkan bahwa setelahnya argumen lain telah diterima, Anda akan
memanggil fungsi MathLink untuk mendapatkan ekspresi tambahan.
Fungsi f di Mathematica membutuhkan 3 argumen.
:Pattern: f[i_Integer, x_Real, y_Real]
Semua argumen ini diteruskan langsung ke program eksternal.

:Arguments: (i, x, y)
Hanya argumen pertama yang dikirim langsung ke fungsi eksternal.

:ArgumentTypes: 8Integer, Manual<
:ReturnType: Real :End:
Fungsi eksternal hanya membutuhkan satu argumen eksplisit.

double f(int i) {
Ini mendeklarasikan variabel x dan y.
double f(int i) {
MLGetReal() secara eksplisit mendapatkan data dari tautan.
MLGetReal(stdlink, &x);
MLGetReal(stdlink, &y); kembali
i+x+y;}
Dalam kasus sederhana, biasanya dimungkinkan untuk memastikan di sisi Mathematica

bahwa data yang Anda kirim ke program eksternal memiliki struktur yang diharapkan. Tetapi secara
umum nilai kembalian dari MLCheckFunction() akan menjadi bukan nol saja jika data terdiri dari
fungsi dengan nama yang Anda tentukan.
Perhatikan bahwa jika Anda ingin mendapatkan kumpulan daftar atau objek lain yang
bersarang, Anda dapat melakukannya dengan membuat yang sesuai urutan panggilan ke
MLCheckFunction().
Ketika program eksternal mendapatkan data dari Mathematica, ia harus menyiapkan tempat
untuk menyimpan data. Jika data terdiri dari integer tunggal, seperti pada MLGetInteger (stdlink,
&n), maka cukuplah untuk mendeklarasikan integer ini menggunakan int n.
Tetapi ketika data terdiri dari daftar bilangan bulat dengan panjang yang berpotensi berapa
pun, memori harus dialokasikan untuk menyimpan daftar ini di waktu ketika program eksternal
benar-benar dipanggil.
MLGetIntegerList (stdlink, &a, &n) akan secara otomatis melakukan alokasi ini, menyetel a
menjadi pointer ke hasil. Perhatikan bahwa memori yang dialokasikan oleh fungsi seperti
MLGetIntegerList() selalu berada di area khusus yang dicadangkan, jadi Anda tidak dapat mengubah
atau membebaskannya secara langsung.
Jika Anda menggunakan IntegerList sebagai spesifikasi : ArgumentTypes :, maka MathLink

akan secara otomatis menolak memori yang digunakan untuk daftar setelah fungsi eksternal Anda
keluar. Tetapi jika Anda mendapatkan daftar bilangan bulat secara eksplisit menggunakan
MLGetIntegerList(), maka Anda tidak boleh lupa untuk menyangkal memori yang digunakan untuk
menyimpan daftar setelah Anda selesai dengannya.
MLGetIntegerList() mengekstrak larik bilangan bulat satu dimensi dari satu daftar
Mathematica. MLGetIntegerArray() mengekstrak array bilangan bulat dari kumpulan daftar atau
fungsi Mathematica lainnya yang disarangkan ke sembarang kedalaman.
Nama fungsi Mathematica pada level i dalam struktur disimpan sebagai string di heads[i].
Ukurannya struktur pada tingkat i disimpan dalam redup[i], sedangkan kedalaman total disimpan
dalam d.
Jika Anda meneruskan daftar bilangan kompleks ke program eksternal Anda, maka
MLGetRealArray() akan membuat a array dua dimensi yang berisi urutan pasangan bagian nyata
dan imajiner. Dalam hal ini, heads[0] akan menjadi "Daftar" sementara kepala[1] akan menjadi
"Kompleks".
Perhatikan bahwa Anda dapat dengan mudah bertukar nomor presisi arbitrer dengan
program eksternal dengan mengonversinya ke daftar digit di Mathematica menggunakan
IntegerDigits dan RealDigits.
menyangkal memori yang terkait dengan dia.
Jika Anda menggunakan String sebagai spesifikasi : ArgumentTypes :, maka MathLink akan
secara otomatis menolak memori yang digunakan untuk menyimpan string setelah fungsi Anda
keluar. Ini berarti bahwa jika Anda ingin terus merujuk ke string, Anda harus mengalokasikan
memori untuk itu, dan secara eksplisit menyalin setiap karakter di dalamnya.
Namun, jika Anda mendapatkan string menggunakan MLGetString(), maka MathLink tidak akan
secara otomatis menyangkal memori yang digunakan untuk string saat fungsi Anda keluar.
Akibatnya, Anda dapat terus merujuk ke string. Ketika Anda tidak lagi membutuhkan string, Anda tetap
harus secara eksplisit memanggil MLDisownString() untuk
Jika Anda mengetahui fungsi apa yang diharapkan dalam program eksternal Anda, maka
biasanya lebih mudah untuk memanggil MLCheckFunction(). Tetapi jika Anda tidak tahu fungsi
apa yang diharapkan, Anda tidak punya pilihan selain memanggil MLGetFunction(). Jika kamu
melakukan ini, Anda harus yakin untuk memanggil MLDisownSymbol() untuk menyangkal memori
yang terkait dengan nama fungsi yang ditemukan oleh MLGetFunction().
2.13.5 Topik Khusus: Portabilitas Program MathLink

Sisi Mathematica dari koneksi MathLink diatur untuk bekerja sama persis di semua sistem
komputer. Tetapi mau tidak mau ada perbedaan antara program eksternal pada sistem komputer
yang berbeda. Sebagai permulaan, sistem komputer yang berbeda hampir selalu membutuhkan
binari eksekusi yang berbeda
Install["prog"], oleh karena itu, Anda harus yakin bahwa prog sesuai dengan program yang dapat
dijalankan di komputer Anda.
Mathematica mengikuti konvensi bahwa jika prog adalah file biasa, maka Install["prog"]
hanya akan mencoba mengeksekusi dia. Tetapi jika prog adalah sebuah direktori, maka
Mathematica akan mencari subdirektori dari direktori tersebut yang namanya sesuai dengan nilai
$SystemID saat ini, dan kemudian akan mencoba mengeksekusi file bernama prog di dalam
subdirektori itu.
Meskipun biner yang dapat dieksekusi dari program eksternal pasti berbeda pada sistem
komputer yang berbeda, ia dapat masih terjadi bahwa kode sumber dalam bahasa seperti C dari
mana biner ini diperoleh pada dasarnya adalah sama.
Tetapi untuk mencapai portabilitas dalam kode sumber C Anda ada beberapa poin yang perlu Anda
perhatikan.
Sebagai permulaan, Anda tidak boleh menggunakan fitur tambahan dari bahasa C atau
pustaka run-time C yang terjadi disediakan pada sistem tertentu, tetapi bukan bagian dari standar
C. Selain itu, Anda harus mencoba menghindari berurusan dengan tersegmentasi atau model
memori khusus.
File include mathlink.h berisi prototipe C standar untuk semua fungsi di library MathLink.
Jika Anda compiler tidak mendukung prototipe tersebut, Anda dapat mengabaikannya dengan
memberikan arahan #define MLPROTOTYPES 0 sebelum #include "mathlink.h". Tetapi dengan
asumsi bahwa itu mendukung prototipe, kompiler Anda akan selalu dapat untuk memeriksa apakah
panggilan yang Anda lakukan ke fungsi di pustaka MathLink memiliki argumen dengan tipe yang
sesuai.
Gambar
Pada beberapa sistem komputer dan dengan beberapa kompiler, int bahasa C mungkin setara
dengan long. Tapi standar untuk bahasa C sama baiknya memungkinkan int menjadi setara dengan
short. Dan jika Anda akan menelepon MathLink perpustakaan berfungsi dengan cara yang portabel,
penting bagi Anda untuk menggunakan jenis yang sama seperti yang mereka lakukan.
Setelah Anda memasukkan data Anda ke fungsi perpustakaan MathLink, fungsi-fungsi ini
akan menangani semua masalah lebih lanjut terkait dengan perbedaan antara representasi data pada
sistem komputer yang berbeda. Jadi, misalnya, MathLink secara otomatis menukar byte saat
mengirim data antara mesin big dan little endian, dan mengonversi floating-point format kehilangan
presisi sesedikit mungkin.
Dalam program C sederhana, biasanya menggunakan string yang hanya berisi karakter
ASCII biasa. Tapi di Mathematica itu memungkinkan untuk memiliki string yang berisi semua jenis
karakter khusus. Karakter ini ditentukan dalam Mathematica menggunakan kode karakter Unicode,
seperti yang dibahas dalam Bagian 2.8.8.
Bahasa C char * string biasanya hanya menggunakan 8 bit untuk menyimpan kode untuk
setiap karakter. Kode karakter Unicode, Namun, membutuhkan 16 bit. Akibatnya, fungsi
MLPutUnicodeString() dan MLGetUnicodeString() bekerja dengan array bilangan bulat pendek
yang tidak ditandatangani.
Jika Anda tahu bahwa program Anda tidak harus menangani karakter khusus, maka Anda
mungkin merasa nyaman menggunakannya MLPutByteString() dan MLGetByteString().
Fungsifungsi ini mewakili semua karakter secara langsung menggunakan 8-bit kode karakter. Jika
karakter khusus dikirim dari Mathematica, maka karakter tersebut akan dikonversi oleh
MLGetByteString() ke kode tetap yang Anda tentukan.
2.13.6 Menggunakan MathLink untuk Berkomunikasi antar Sesi Mathematica
LinkCreate[" name "] membuat tautan untuk program lain agar terhubung
LinkConnect [" name "] terhubung ke tautan yang dibuat oleh program
lain
LinkClose[link ] menutup koneksi MathLink

LinkWrite [ link, expr ] menulis ekspresi ke koneksi MathLink
LinkRead [ link ] membaca ekspresi dari koneksi MathLink
LinkRead [ link , Hold ] membaca ekspresi dan segera membungkusnya dengan
hold
LinkReadyQ [ link ]
untuk mencari tahu apakah ada sebuah data yang siap dibaca
dari sebuah link
2.13.7 Memanggil Proses Subsidiary Mathematica
LinkLaunch [" prog "] memulai program eksternal dan membuka koneksi ke
sana
Ini memulai proses Mathematica anak perusahaan pada sistem komputer yang digunakan di sini.
In[1]:= link = LinkLaunch["math -mathlink"]
Out[1]= LinkObject[math -mathlink, 4, 4]
Berikut adalah paket yang mewakili prompt input pertama dari proses Mathematica anak
perusahaan.
In[2]:= LinkRead[link]
Out[2]= InputNamePacket[In[1]:= ]
Ini menulis sebuah paket yang mewakili teks untuk masuk dalam proses Mathematica anak
perusahaan.
In[3]:= LinkWrite[link, EnterTextPacket["10!"]]
Berikut adalah paket yang mewakili prompt output dari proses Mathematica anak
perusahaan.
Out[4]= OutputNamePacket[Out[1]= ]
Dan inilah hasil aktual dari perhitungan tersebut.

Out[5]= ReturnTextPacket[3628800]
Cara dasar agar berbagai objek berbeda yang terlibat dalam sesi Mathematica tetap
terorganisir adalah dengan menggunakan paket MathLink. Paket MathLink hanyalah sebuah
ekspresi dengan kepala tertentu yang menunjukkan peran atau maknanya.
2.13.8 Topik Khusus: Komunikasi dengan Mathematica Front Ends

Kernel Mathematica menggunakan MathLink untuk berkomunikasi dengan ujung depan
Mathematica. Jika Anda memulai Mathematica kernel dari dalam front end, oleh karena itu, kernel
akan dikontrol melalui koneksi MathLink ke front end ini.
$ParentLink koneksi MathLink yang akan digunakan untuk input dan

output Kernel
Variabel global $ParentLink menentukan koneksi MathLink yang akan digunakan kernel tertentu
untuk input dan keluaran.
Terkadang berguna untuk mereset $ParentLink di tengah sesi Mathematica, sehingga secara
efektif mengubah ujung depan tempat kernel terhubung.
Sama seperti kernel Mathematica, ujung depan notebook standar untuk Mathematica diatur untuk
menangani serangkaian paket MathLink.
Biasanya yang terbaik adalah menggunakan fungsi seperti NotebookWrite dan
FrontEndExecute jika Anda ingin mengontrol Mathematica ujung depan dari kernel. Tetapi dalam
beberapa kasus Anda mungkin merasa nyaman untuk mengirim paket langsung ke front end
menggunakan Link Write.
2.13.9 Komunikasi Dua Arah dengan Program Eksternal
Saat Anda menginstal program eksternal yang kompatibel dengan MathLink menggunakan
Instal, program diatur untuk berperilaku agak seperti kernel Mathematica yang disederhanakan.
Setiap kali Anda memanggil fungsi di program eksternal, CallPacket dikirim ke program, dan
program merespons dengan mengirimkan kembali hasil yang dibungkus dengan ReturnPacket.
Jika Anda menggunakan Instal beberapa kali pada satu program eksternal, Mathematica
akan membuka beberapa koneksi MathLink ke program. Namun setiap koneksi akan selalu sesuai
dengan LinkObject yang unik. Perhatikan bahwa pada beberapa sistem komputer, Anda mungkin
perlu membuat salinan eksplisit dari file yang berisi program eksternal agar dapat dapat
memanggilnya berkali-kali.
Jika program eksternal menyimpan informasi tentang statusnya, maka Anda dapat
menggunakan instance program yang berbeda untuk mewakili negara bagian yang berbeda.
$CurrentLink kemudian menyediakan cara untuk merujuk ke setiap contoh program.
Nilai $CurrentLink disetel sementara setiap kali instance tertentu dari program dipanggil, serta
ketika setiap contoh program pertama kali diinstal.
MLEvaluateString (stdlink, kirim input ke Mathematica tetapi tidak

mengembalikan hasil
" string ")
Sifat koneksi MathLink dua arah memungkinkan Anda tidak hanya membuat Mathematica
memanggil program eksternal, tetapi juga agar program eksternal itu memanggil kembali ke
Mathematica.
Dalam kasus yang paling sederhana, Anda dapat menggunakan fungsi MathLink
MLEvaluateString() untuk mengirim string ke Mathematica. Mathematica akan mengevaluasi
string ini, menghasilkan efek apa pun yang ditentukan string, tetapi tidak akan mengembalikan hasil
apa pun dari evaluasi kembali ke program eksternal.
Untuk mendapatkan hasil kembali, Anda perlu secara eksplisit mengirim EvaluatePacket ke
Mathematica, dan kemudian membaca konten ReturnPacket yang kembali.
Ketika Anda dapat mengirim Mathematica sebuah EvaluatePacket[input], secara umum
mungkin menghasilkan banyak paket sebagai tanggapan, tetapi paket terakhir harus
ReturnPacket[output]. Bagian 2.13.12 akan membahas bagaimana menangani urutan dari paket dan
ekspresi yang strukturnya tidak Anda ketahui sebelumnya
2.13.10 Topik Khusus: Menjalankan Program di Komputer Jarak Jauh

MathLink memungkinkan Anda untuk memanggil program eksternal dari dalam
Mathematica bahkan ketika program itu berjalan pada komputer remot. Biasanya, Anda perlu
memulai program langsung dari sistem operasi di komputer jarak jauh. Tetapi kemudian Anda dapat
menghubungkannya menggunakan perintah dalam sesi Mathematica Anda.
Program eksternal yang dibuat menggunakan mcc atau mprep selalu berisi kode yang
diperlukan untuk menyiapkan MathLink koneksi. Jika Anda memulai program tersebut langsung
dari sistem operasi Anda, mereka akan meminta Anda untuk menentukan jenisnya koneksi yang
Anda inginkan. Atau, jika sistem operasi Anda mendukungnya, Anda juga dapat memberikan
informasi ini sebagai argumen baris perintah ke program eksternal.
prog −linkcreate program tautan memerintah sistem operasi untuk

menjalankan program dan membuatnya membuat
tautan
Perintah Mathematica untuk terhubung ke program
Install [LinkConnect[" eksternal
port@host "]]
2.13.11 Topik Khusus: Menjalankan Program Eksternal di bawah Debugger

MathLink memungkinkan Anda untuk menjalankan program eksternal di bawah debugger apa
pun yang disediakan di lingkungan perangkat lunak Anda.
Program yang kompatibel dengan MathLink biasanya diatur untuk mengambil argumen,
biasanya pada baris perintah, yang menentukan : koneksi MathLink apa yang harus mereka
gunakan.
Pada Debugger : run −linkcreate

Pada Mathematica : Install [LinkConnect [" port "]]
Perhatikan bahwa untuk mendapatkan versi program eksternal yang dapat dijalankan di bawah
debugger, Anda mungkin perlu menentukan -g atau flag lain saat Anda mengkompilasi program.
2.13.12 Memanipulasi Ekspresi dalam Program Eksternal

Ekspresi Mathematica menyediakan cara yang sangat umum untuk menangani semua jenis
data, dan terkadang Anda mungkin ingin menggunakan ekspresi seperti itu di dalam program
eksternal Anda. Bahasa seperti C, bagaimanapun, tidak menawarkan cara langsung untuk
menyimpan general ekspresi matematika. Namun tetap dimungkinkan untuk melakukan ini dengan
menggunakan tautan loopback yang disediakan oleh Math-Tautan perpustakaan. Tautan loopback
adalah koneksi MathLink lokal di dalam program eksternal Anda, yang dapat Anda tulis ekspresi
yang nantinya dapat dibaca kembali.
2.13.13 Topik Lanjutan: Penanganan Kesalahan dan Interupsi
Saat Anda meletakkan dan mendapatkan data melalui MathLink, berbagai jenis kesalahan
dapat terjadi. Setiap kali terjadi kesalahan, MathLink masuk ke status tidak aktif sama sekali, dan
semua fungsi MathLink yang Anda panggil akan segera mengembalikan ke 0.
Ketika Anda melakukan operasi yang rumit, seringkali lebih mudah untuk memeriksa
kesalahan hanya di akhir. Jika Anda menemukan kesalahan itu terjadi, Anda harus memanggil
MLClearError() untuk mengaktifkan MathLink lagi.
int MLNewPacket (MLINK link) lewati ke akhir paket untuk saat ini
Setelah kesalahan, biasanya ingin membuang sisa paket atau ekspresi yang sedang Anda proses.
Anda dapat melakukan ini menggunakan MLNewPacket().
Dalam beberapa kasus, Anda mungkin ingin mengaturnya sehingga jika terjadi kesalahan
saat Anda memproses data tertentu, Anda dapat kemudian kembali dan memproses ulang data
dengan cara yang berbeda. Anda dapat melakukan ini dengan memanggil MLCreateMark() untuk
membuat tandai sebelum Anda memproses data terlebih dahulu, dan kemudian memanggil
MLSeekMark() untuk mencari kembali ke tanda jika Anda perlu memproses ulang datanya. Anda
tidak boleh lupa untuk memanggil MLDestroyMark() ketika Anda akhirnya selesai dengan data—
jika tidak, MathLink akan terus menyimpannya.
int MLAbort Install set variabel global saat program diatur oleh Instal
dikirim interupsi yang dibatalkan
Jika Anda menginterupsi Mathematica saat sedang menjalankan fungsi eksternal, biasanya
akan memberi Anda kesempatan untuk mencoba menggugurkan fungsi eksternal. Jika Anda
memilih untuk melakukan ini, apa yang akan terjadi adalah variabel global MLAbort akan disetel
ke 1 di dalam program eksternal Anda.
MathLink tidak dapat secara otomatis mundur dari panggilan fungsi eksternal yang telah
dibuat. Jadi jika Anda memiliki fungsi yang bisa memakan waktu lama, Anda harus sering
memeriksa MLAbort secara eksplisit, kembali dari fungsi jika Anda menemukannya variabel telah
ditetapkan.
2.13.14 Menjalankan Mathematica dari Dalam Program Eksternal
Untuk menjalankan Mathematica dari dalam program eksternal memerlukan penggunaan
banyak fitur umum MathLink. Masalah pertama adalah bagaimana membuat koneksi MathLink ke
Mathematica.
Saat Anda menggunakan templat MathLink untuk membuat program eksternal yang dapat
dipanggil dari Mathematica, kode sumber ke membuat koneksi MathLink dibuat secara otomatis,
dan yang harus Anda lakukan di program eksternal Anda adalah menelepon MLMain(argc, argv).
Tetapi secara umum Anda perlu memanggil beberapa fungsi untuk membuat koneksi MathLink.
Seringkali argv yang Anda berikan ke MLOpenArgv() akan datang langsung dari argv yang
diteruskan ke main() ketika seluruh program Anda dimulai. Perhatikan bahwa MLOpenArgv()
mengambil pointer ke awal dan akhir array argv. Dengan tidak menggunakan argc secara langsung,
ia menghindari keharusan mengetahui ukuran int.
Elemen dalam array argv adalah string karakter yang mencerminkan argumen dan opsi yang
digunakan dalam Mathematica fungsi LinkLaunch, LinkCreate dan LinkConnect.
Sebagai alternatif MLOpenArgv() Anda dapat menggunakan MLOpenString(), yang mengambil
parameter yang digabungkan menjadi string karakter tunggal dengan spasi di antaranya.
Setelah Anda berhasil membuka koneksi MathLink ke kernel Mathematica, Anda dapat
menggunakan standar MathLink berfungsi untuk bertukar data dengannya.
Setelah Anda mengirim semua bagian paket menggunakan MLPutFunction() dll., MathLink
mengharuskan Anda untuk memanggil MLEndPacket() untuk memastikan sinkronisasi dan
konsistensi.
Salah satu masalah utama dalam menulis program eksternal yang berkomunikasi langsung dengan
kernel Mathematica adalah menangani semua jenis paket yang dapat dihasilkan oleh kernel.
Fungsi MLNextPacket() menemukan kepala paket berikutnya yang berasal dari kernel, dan
mengembalikan sebuah konstanta yang menunjukkan jenis paket.
Jika Anda ingin menulis front end lengkap ke Mathematica, Anda harus menangani semua
kemungkinan jenis paket yang dapat dihasilkan oleh kernel. Biasanya Anda dapat melakukan ini
dengan mengatur sakelar yang sesuai pada nilai yang dikembalikan oleh MLNextPacket().
Kit Pengembang MathLink berisi contoh kode sumber untuk beberapa ujung depan yang
sederhana namun lengkap.
int MLReady (MLINK link) menguji apakah ada data yang menunggu untuk dibaca
pada tautan
int MLFlush (MLINK link) menghapus buffer yang berisi data yang menunggu
untuk dikirim melalui tautan
Salah satu fitur dari program eksternal yang lebih canggih seperti ujung depan adalah bahwa
mereka mungkin perlu melakukan operasi sementara mereka menunggu data dikirim kepada
mereka oleh Mathematica. Saat Anda memanggil fungsi perpustakaan MathLink standar seperti
MLNextPacket() program Anda biasanya akan memblokir sampai semua data yang dibutuhkan oleh
fungsi ini tersedia.
Anda dapat menghindari pemblokiran dengan berulang kali memanggil MLReady(), dan hanya
memanggil fungsi seperti MLNextPacket() ketika MLReady() tidak lagi mengembalikan 0.
In [n] ekspresi pada baris input ke-n
InString [ n ] bentuk tekstual dari baris input ke-n % n or Out [ n ]
eskpresi pada jalur keluaran ke-n n1, n2, … }] daftar ekspresi keluaran
Out [{
… % [ n times ( or Out)− n ] eskpresi pada baris keluaran ke-n sebelumnya %%

daftar pesan yang dihasilkan saat memproses
MessageList [ n ]
baris ke-n
$Line nomor baris saat ini
MLReady() adalah analog dari fungsi Mathematica LinkReadyQ.

Perhatikan bahwa MathLink terkadang menyangga data yang Anda suruh untuk dikirim.
Untuk memastikan bahwa semua data yang diperlukan telah dikirim, Anda harus memanggil
MLflush(). Hanya setelah melakukan ini, masuk akal untuk memanggil MLReady() dan menunggu
data menjadi dikirim kembali.
2.14 Aspek Global dari Sesi Mathematica

2.14.1 Loop Utama
Dalam setiap sesi interaktif, Mathematica secara efektif beroperasi dalam satu lingkaran. Itu
menunggu input Anda, memproses input, mencetak hasilnya, lalu kembali menunggu input lagi.
Sebagai bagian dari "loop utama" ini, Mathematica memelihara dan menggunakan berbagai objek
global. Anda akan sering merasa berguna untuk bekerja dengan objek-objek ini.
Anda harus menyadari, bagaimanapun, bahwa jika Anda menggunakan Mathematica
melalui ujung depan khusus, ujung depan Anda dapat mengaturnya loop utama sendiri, dan apa
yang dikatakan di bagian ini mungkin tidak berlaku.
Dalam sesi interaktif standar, ada urutan jalur input dan output. Mathematica menyimpan nilai
dariekspresi pada baris ini di In[n] dan Out[n].
Seperti yang ditunjukkan oleh perintah In[n]:= biasa, ekspresi input disimpan dengan
penugasan yang tertunda. Ini berarti bahwa setiap kali Anda meminta In[n], ekspresi input akan
selalu dievaluasi ulang di lingkungan Anda saat ini.
$HistoryLength jumlah baris input dan output sebelumnya yang harus disimpan
Mathematica secara default menyimpan semua jalur input dan output Anda selama sesi
berlangsung. Dalam sesi yang sangat panjang, ini mungkin memakan banyak memori komputer.
Anda tetap dapat menyingkirkan jalur input dan output dengan secara eksplisit menghapus nilai In
dan Out, menggunakan Unprotect[In, Out], diikuti oleh Clear[In, Out]. Kamu bisa juga beri tahu
Mathematica untuk menyimpan hanya sejumlah baris sejarah dengan mengatur variabel global
$HistoryPanjang.
Perhatikan bahwa setiap saat dalam suatu sesi, Anda dapat mengatur ulang penghitung
nomor baris $Line, sehingga misalnya baris baru adalah diberi nomor untuk menimpa yang
sebelumnya.
$PreRead sebuah fungsi yang diterapkan ke setiap string input sebelum
diumpankan ke matematika
$Pre fungsi yang diterapkan ke setiap ekspresi input sebelum

evaluasi
$Post fungsi yang diterapkan ke setiap ekspresi setelah
evaluasi
$PrePrint sebuah fungsi yang diterapkan setelah Out [ n ]

ditugaskan, tetapi sebelum hasilnya dicetak
$SyntaxHandler fungsi yang diterapkan ke baris input apa pun yang
menghasilkan kesalahan sintaks

Mathematica menyediakan berbagai "kait" yang memungkinkan Anda menyisipkan fungsi
untuk diterapkan ke ekspresi di berbagai tahapan dalam loop utama. Jadi, misalnya, fungsi apa pun
yang Anda tetapkan sebagai nilai variabel global $Pre akan secara otomatis diterapkan sebelum
evaluasi ke ekspresi apa pun yang Anda berikan sebagai input.
Untuk jalur input tertentu, loop utama standar dimulai dengan mendapatkan input string
teks. Terutama jika Anda perlu berurusan dengan karakter khusus, Anda mungkin ingin
memodifikasi string teks ini sebelum diproses lebih lanjut oleh Mathematica. Anda dapat
melakukan ini dengan menetapkan fungsi sebagai nilai variabel global $PreRead. Fungsi ini akan
diterapkan ke string teks, dan hasilnya akan digunakan sebagai string input aktual untuk baris input
tertentu.
Setelah pemrosesan $PreRead pada string input selesai, string dibaca oleh Mathematica.
Pada saat ini, Mathematica mungkin menemukan bahwa ada kesalahan sintaks dalam string. Jika
ini terjadi, maka Mathematica memanggil apa pun fungsi yang telah Anda tentukan sebagai nilai
$SyntaxHandler. Ini memasok dua argumen: string input, dan posisi karakter di mana kesalahan
sintaks terdeteksi. Dengan $SyntaxHandler Anda dapat, misalnya, menghasilkan analisis kesalahan
sintaks, atau hubungi editor. Jika fungsi Anda mengembalikan string, maka Mathematica akan
menggunakan string ini sebagai string masukan baru.
$Output standar dan teks yang dihasilkan oleh Print
$Echo gema dari setiap baris input (Telah disimpan di InString [ n ])
$Urgent masukan mendesak dan keluaran mendesak lainnya
$Messages pesan standar dan output yang dihasilkan oleh Message

$Display output grafik yang dihasilkan oleh $DisplayFunction default
default
$SoundDisplay keluaran suara yang dihasilkan secara default

$SoundDisplayFunction
Setelah Mathematica berhasil membaca ekspresi input, ia kemudian mengevaluasi ekspresi

ini. Sebelum melakukan evaluasi, Mathematica menerapkan fungsi apa pun yang telah Anda
tentukan sebagai nilai $Pre, dan setelah evaluasi, itu menerapkan fungsi apa pun yang ditentukan
sebagai nilai $Post. Perhatikan bahwa kecuali fungsi $Pre menahan argumennya tidak dievaluasi,
fungsi akan memiliki efek yang persis sama dengan $Post.
$Post memungkinkan Anda untuk menentukan "pemrosesan pasca" sewenang-wenang yang
harus dilakukan pada hasil yang diperoleh dari Mathematica. Jadi, untuk contoh, untuk membuat
Mathematica mendapatkan perkiraan numerik untuk setiap hasil yang dihasilkannya, yang perlu
Anda lakukan hanyalah mengatur $Post = N.
Segera setelah Mathematica menghasilkan hasil, dan menerapkan fungsi $Post apa pun yang
telah Anda tentukan, ia mengambil hasilnya, dan menetapkannya sebagai nilai Out[$Line]. Langkah
selanjutnya adalah Mathematica mencetak hasilnya. Namun, sebelum melakukan ini, itu
menerapkan fungsi apa pun yang telah Anda tentukan sebagai nilai $PrePrint.
Ada berbagai macam output yang dihasilkan dalam sesi Mathematica yang khas. Secara
umum, setiap jenis output dikirim ke saluran keluaran tertentu, seperti yang dibahas dalam Bagian
2.12.3. Terkait dengan setiap saluran keluaran, ada variabel global yang memberikan daftar aliran
keluaran untuk dimasukkan dalam saluran keluaran itu.
Dengan memodifikasi daftar aliran dalam saluran keluaran tertentu, Anda dapat
mengarahkan ulang atau menyalin jenis Mathematica . tertentu keluaran. Jadi, misalnya, dengan
membuka aliran keluaran ke file, dan memasukkan aliran itu ke dalam daftar $Echo, Anda dapat
dapatkan setiap input yang Anda berikan ke Mathematica disimpan dalam file
Streams [ ] daftar semua aliran terbuka
Streams [" name "] daftar semua aliran terbuka dengan nama yang ditentukan
$Input nama aliran input saat ini
Fungsi Streams menunjukkan kepada Anda semua input, output, dan aliran lain yang
terbuka pada titik tertentu disesi matematika. Variabel $Input memberikan nama aliran saat ini dari
mana input Mathematica berasal diambil pada titik tertentu. $Input direset, misalnya, selama
eksekusi perintah Get.
$MessagePrePrint fungsi yang akan diterapkan ke ekspresi yang diberikan ke

dalam pesan
daftar bahasa default yang digunakan untuk pesan $Language
Ada berbagai parameter global yang menentukan bentuk pesan yang dihasilkan oleh
Mathematica. Seperti yang dibahas dalam Bagian 2.9.21, pesan tipikal mencakup urutan ekspresi
yang digabungkan dengan teks pesan melalui StringForm. $MessagePrePrint memberikan fungsi
untuk diterapkan ke ekspresi sebelumnya mereka dicetak. Nilai default $MessagePrePrint adalah
Pendek.
Seperti yang dibahas di Bagian 2.9.22, Mathematica memungkinkan Anda untuk
menentukan bahasa yang Anda inginkan untuk pesan diproduksi. Dalam sesi Mathematica tertentu,
Anda dapat menetapkan daftar nama bahasa sebagai nilai $Language.
Exit [ ] or [ Quit ] mengakhiri sesi matematika anda
$Epilog variebel global untuk dievaluasi sebelum penghentian
Mathematica akan melanjutkan loop utamanya sampai Anda secara eksplisit menyuruhnya keluar.
Sebagian besar antarmuka Mathematica menyediakan cara khusus untuk melakukannya.
Namun demikian, Anda selalu dapat melakukannya dengan memanggil Exit atau Quit secara eksplisit.
Mathematica memungkinkan Anda untuk memberikan nilai ke variabel global $Epilog
untuk menentukan operasi yang akan dilakukan sebelum Mathematica benar-benar keluar. Dengan
cara ini, misalnya Anda dapat membuat Mathematica selalu menyimpan objek tertentu sebelumnya
keluar.
$IgnoreEOF apakah akan mengabaikan karakter akhir sebuah file
Seperti yang dibahas dalam Bagian 2.8.5, Mathematica biasanya tidak memperlakukan
karakter khusus dengan cara khusus. ada satu pengecualian potensial, namun. Dengan pengaturan
default $IgnoreEOF = False, Mathematica mengenali file akhir karakter. Jika Mathematica
menerima karakter akhir file sebagai satu-satunya hal pada baris input tertentu dalam standar sesi
Mathematica interaktif, maka akan keluar dari sesi.
Bagaimana tepatnya Anda memasukkan karakter akhir file tergantung pada sistem komputer
yang Anda gunakan. Dibawah Unix, misalnya, Anda biasanya menekan Control-D. Perhatikan
bahwa jika Anda menggunakan Mathematica dalam "mode batch", dengan semua inputnya berasal
dari file, maka secara otomatis akan keluar ketika mencapai akhir file, terlepas dari nilai
$IgnoreEOF.
2.14.2 Dialog
Dalam sesi interaktif standar, Anda dapat membuat "subsesi" atau dialog menggunakan
perintah Mathematica Dialog. Dialog seringkali berguna jika Anda ingin berinteraksi dengan
Mathematica saat sedang melakukan perhitungan.
Seperti disebutkan dalam Bagian 2.6.11, TraceDialog misalnya secara otomatis memanggil
Dialog pada titik-titik tertentu di evaluasi ekspresi tertentu. Selain itu, jika Anda menginterupsi
Mathematica selama perhitungan, Anda dapat biasanya "memeriksa" statusnya menggunakan
dialog.
Dialog [ ] memulai dialog matematika

Dialog [ expr ] memulai dialog dengan expr sebagai nilai saat ini
dari %
Return [ ] kembali dari dialog, mengambil nilai saat ini dari %
sebagai nilai pengambilan
Return [ expr ] kembali dari dialog, mengambil expr sebagai nilai
pengambilan
Part 3
Bagian ini membahas berbagai fungsi dan metode matematika. Beberapa perhitungan dapat dilakukan hanya
dengan menggunakan kemampuan matematika bawaan ini. Namun, untuk banyak perhitungan khusus, Anda perlu
menggunakan paket aplikasi yang dibangun di atas kemampuan yang dibahas di Bagian ini, tetapi tambahkan
fungsi baru untuk melakukan jenis perhitungan khusus.
3.1 Angka
Empat jenis angka yang mendasari dibangun ke Matematika. Integral, bilangan bulat eksak dengan panjang
arbitrer. Bilangan bulat rasional dalam istilah terendah. Perkiraan nyata bilangan real, dengan presisi tertentu.
Bilangan kompleks kompleks berbentuk bilangan + bilangan I.
• 3.1.1 Tipe-tipe Angka

Contoh : 123 (bilangan bulat), 123. (perkiraan bilangan real), 123.0000000 (perkiraan bilangan real dengan presisi
tertentu), 123. + 0.1 (bilangan kompleks dengan perkiraan komponen bilangan real).
Anda dapat membedakan berbagai jenis angka di Mathematica dengan melihat kepalanya. (Meskipun angka dalam
mathematika memiliki kepala seperti ekspresi lainnya, mereka tidak memiliki elemen eksplisit yang dapat Anda
ekstrak.)
Angka Q[x] menguji bilangan x adalah bilangan apapun. Bilangan

bulat Q[x] menguji apakah x bilangan bulat.
Bilangan Genap Q[x] menguji apakah x genap. Bilangan
Ganjil Q[x] menguji apakah x ganjil.
Bilangan Perdana Q[x] menguji apakah x bilangan bulat prima Head [x]
ketik tes tipe angka
Jika Anda menggunakan bilangan kompleks secara ekstensif, ada satu kehalusan yang harus Anda ketahui. Ketika
Anda memasukkan nomor seperti 123., Mathematica memperlakukannya sebagai perkiraan bilangan real, tetapi
mengasumsikan bahwa bagian imajinernya persis nol. Kadang-kadang Anda mungkin ingin memasukkan
perkiraan bilangan kompleks dengan bagian imajiner yang nol, tetapi hanya untuk bagian tertentu presisi.
Perbedaan antara bilangan kompleks yang bagian imajinernya tepat nol, atau hanya nol sampai ketelitian tertentu,
mungkin tampak seperti orang yang bertele-tele. Namun, ketika kita membahas, misalnya, interpretasi kekuatan
dan akar dari bilangan kompleks di Bagian 3.2.7, perbedaannya akan menjadi signifikan.
Salah satu cara untuk mengetahui jenis bilangan di Mathematica adalah dengan memilih kepalanya menggunakan
Head[expr]. Untuk banyak tujuan, bagaimanapun, lebih baik menggunakan fungsi seperti bulat Q yang secara
eksplisit menguji tipe tertentu. Fungsi seperti ini diatur untuk mengembalikan True jika argumen mereka secara
nyata dari tipe yang diperlukan, dan untuk mengembalikan False sebaliknya. Sebagai hasilnya, bulat Q[x] akan
memberikan False, kecuali x memiliki nilai integer eksplisit.
• 3.1.2 Kuantitas Numerik
Angka Q [expr] menguji apakah expr secara eksplisit merupakan angka.A ngka Q [expr]
menguji apakah expr memiliki nilai numerik.
Matematika tahu bahwa konstanta seperti Pi adalah kuantitas numerik. Ia juga mengetahui bahwa fungsi matematika
standar seperti Log dan Sin memiliki nilai numerik ketika argumennya numerik.
Contoh : NumerikQ[Pi + 3]
N[Pi + 3] = 6.14159
Min[Exp[2], Log[2], Sqrt[2]] = Log[2]
Secara umum, Mathematica mengasumsikan bahwa setiap fungsi yang memiliki atribut NumericFunction akan
menghasilkan numerik nilai ketika argumennya numerik. Semua fungsi matematika standar di Mathematica sudah
memiliki ini atribut. Tetapi ketika Anda mendefinisikan fungsi Anda sendiri, Anda dapat secara eksplisit mengatur
atribut untuk memberi tahu Mathematica untuk mengasumsikan bahwa fungsi-fungsi ini akan memiliki nilai
numerik ketika argumennya numerik.
• 3.1.3 Digit dalam Angka
Digit Integer [n] daftar angka desimal dalam bilangan bulat n Digit
Integer [n, b] digit n di basis b
Digit Integer [n, b, len] daftar digit yang diisi di sebelah kiri dengan nol untuk memberikan panjang total len
Eksponen Integer [n, b] jumlah nol di akhir n di basis b
Digit Real [x] daftar angka desimal dalam perkiraan bilangan real x, bersama dengan jumlah digit di sebelah kiri titik
desimal
Digit Real [x, b] digit x di basis b
Digit Real [x, b, len] digit len pertama x di basis b
Digit Real [x, b, len, n] digit len pertama dimulai dengan koefisien bn Dari Digit
[list] merekonstruksi angka dari urutan digit desimalnya
Dari Digit [daftar, b] merekonstruksi angka dari urutan digitnya di basis b
b ^^ nnnn angka di basis b
Bentuk Dasar [x, b] cetak dengan x di basis b
-Berikut adalah daftar basis 16 digit untuk bilangan bulat

Digit Integer [1234135634, 16]
[4, 9, 8, 15, 6, 10, 5, 2]
- Ini memberikan daftar digit, bersama dengan jumlah digit yang muncul di sebelah kiri titik desimal.
Digit Asli [123. 4567890123456]
[{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6} 3]
- Angka 1001012 di basis 2 adalah 37 di basis 10.

[2^^100101]3 7
Bagian 2.9.7 menjelaskan cara mencetak angka dalam berbagai format. Jika Anda ingin membuat format sendiri,
Anda akan sering perlu menggunakan Eksponen Mantissa untuk memisahkan potongan bilangan real.
MantissaExponent [x] memberikan daftar yang berisi

mantissa dan eksponen x
MantissaExponent [x, b] berikan mantissa dan eksponen

di basis b
Ini memberikan daftar di mana mantissa dan eksponen dari nomor tersebut dipisahkan
Eksponen Mantissa[3.45 10^125]
[0.345, 126]
• 3.1.4 Presisi Numerik

Seperti yang dibahas dalam Bagian 1.1.2, Mathematica dapat menangani perkiraan bilangan real dengan sejumlah
digit. Di dalam umum, ketepatan perkiraan bilangan real adalah jumlah efektif angka desimal di dalamnya yang
diperlakukan sebagai : signifikan untuk komputasi. Akurasi adalah jumlah efektif dari angka-angka ini yang
muncul di sebelah kanan titik desimal. Perhatikan bahwa untuk mencapai konsistensi penuh dalam penanganan
angka, presisi dan akurasi sering kali harus : nilai yang tidak sesuai dengan bilangan bulat angka.
Presisi [x] jumlah total angka desimal
signifikan dalam x
Akurasi [x] jumlah desimal penting digit di

sebelah kanan titik desimal di x
-Ini menghasilkan angka dengan presisi 30 digit x =

N[Pi^10, 30]
93648.0474760830209737166901849
- Akurasinya lebih rendah karena hanya beberapa digit yang berada disebelah kanan titik desimal.
Accur
acy[x]
25.0285
- Angka ini memiliki semua digitnya di sebelah kanan titik desimal.

[x / 10^6]
0.0936480474760830209737166901849
Perkiraan bilangan real selalu memiliki beberapa ketidakpastian dalam nilainya, terkait dengan angka di luar yang
diketahui. Satu dapat menganggap presisi sebagai ukuran ukuran relatif dari ketidakpastian ini. Akurasi
memberikan ukuran ukuran mutlak ketidakpastian. Mathematica diatur sedemikian rupa sehingga jika suatu
bilangan x memiliki ketidakpastian d , maka nilai sebenarnya dapat terletak dimana saja dalam interval ukuran d
dari x – d/ 2 ke x + d /2. Suatu bilangan aproksimasi dengan ketelitian a didefinisikan memiliki ketidakpastian 10a
, sedangkan a angka perkiraan bukan nol dengan presisi p didefinisikan memiliki ketidakpastian [ x ] 10 -p
Precision [x] -log10 (ê » xl)
Accuracy [x] -log10 (d)
N [expr, n] mengevaluasi expr ke n-digit presisi

menggunakan angka presisi arbitrer
N [expr] mengevaluasi expr secara numerik

menggunakan angka presisi mesin
Mathematica membedakan dua jenis perkiraan bilangan real: bilangan presisi arbitrer, dan nomor presisi mesin
atau nomor mesin. Angka presisi arbitrer dapat berisi sejumlah digit, dan mempertahankan informasi tentang
presisi mereka. Nomor mesin, di sisi lain, selalu berisi nomor yang sama dari digit, dan tidak menyimpan informasi
tentang presisinya.
- Berikut ini adalah pendekatan nomor mesin untuk π

N
[Pi]
3.14159
Seperti yang dibahas secara lebih rinci di bawah ini, nomor mesin bekerja dengan memanfaatkan langsung
kemampuan numerik dari Anda sistem komputer yang mendasarinya. Akibatnya, perhitungan dengan mereka
seringkali dapat dilakukan lebih cepat. Mereka bagaimanapun jauh lebih fleksibel daripada angka presisi
sewenang-wenang, dan analisis numerik yang sulit dapat diperlukan untuk menentukan apakah hasil yang
diperoleh dengan mereka benar.
Presisi Mesin Spesifikasi presisi yang digunakan
untuk menunjukkan nomor mesin
Mesin Presisi presisi yang efektif untuk nomor

mesin di sistem komputer Anda
Nomor Mesin Q [x] menguji apakah x adalah nomor mesin
Saat Anda memasukkan perkiraan bilangan real, Mathematica harus memutuskan apakah akan
memperlakukannya sebagai bilangan mesin atau nomor presisi sewenang-wenang. Kecuali jika Anda menentukan
sebaliknya, maka jika Anda memberikan angka kurang dari Machine Precision, Mathematica akan
memperlakukan nomor sebagai presisi mesin, dan jika Anda memberikan lebih banyak digit, itu akan
memperlakukan nomor sebagai arbitrer presisi.
123.4 nomor presisi mesin
123.45678901234567890 angka presisi arbitrer pada beberapa

sistem komputer
123.45678901234567890’ nomor presisi mesin di semua sistem

komputer
123.456`200 angka presisi arbitrer dengan presisi

200 digit
123.456``200 angka presisi arbitrer dengan akurasi

200 digit
1.234*^6 angka presisi mesin dalam notasi

ilmiah H 1.234ä106 L
1.234`200 x 106 angka dalam notasi ilmiah dengan

presisi 200 digit
2^^101.111`200 angka dalam basis 2 dengan presisi 200

digit biner
2^^101.111`200*^6 bilangan dengan notasi ilmiah basis

(101.1112 x 26)
Ketika Mathematica mencetak angka, biasanya Mathematica mencoba memberikannya dalam bentuk yang
semudah mungkin untuk dibaca. Tetapi jika Anda ingin mengambil angka yang dicetak oleh Mathematica, dan
kemudian menggunakannya sebagai input ke Mathematica, Anda perlu memastikan bahwa tidak ada informasi
yang hilang.
InputForm [expr, Tanda Angka −> Benar] gunakan tanda ` di semua angka perkiraan
InputForm [expr, Tanda Angka−>Otomatis] gunakan `hanya dalam angka presisi

sewenang-wenang
InputForm [expr, Tanda Angka−>False] jangan pernah menggunakan tanda `
Pengaturan default untuk opsi NumberMarks, baik di InputForm maupun dalam fungsi seperti ToString dan
OpenWrite diberikan oleh nilai NumberMarks. Oleh karena itu, dengan menyetel ulang NumberMarks, Anda
dapat secara global ubah cara angka dicetak di InputForm.
Dalam melakukan perhitungan numerik, tidak dapat dihindari bahwa Anda terkadang akan mendapatkan hasil
yang kurang tepat daripada kamu ingin. Khususnya ketika Anda mendapatkan hasil numerik yang sangat
mendekati nol, Anda mungkin ingin berasumsi bahwa:
hasilnya harus tepat nol. Fungsi Chop memungkinkan Anda mengganti perkiraan bilangan real yang mendekati nol
dengan bilangan bulat tepat 0.
Chop [expr] ganti semua perkiraan bilangan real

di expr dengan magnitudo kurang dari
10-10 sebesar 0
Potong [expr, dx] ganti angka dengan besaran kurang dari

dx dengan 0
• 3.1.5 Angka Presisi Sewenang-wenang
Saat Anda melakukan perhitungan dengan angka presisi arbitrer, Mathematica melacak presisi di semua titik. Di
dalam umum, Mathematica mencoba memberi Anda hasil yang memiliki presisi setinggi mungkin, mengingat
presisi masukan yang Anda berikan.
Mathematica memperlakukan angka presisi arbitrer sebagai mewakili nilai kuantitas di mana sejumlah digit
diketahui, dan sisanya tidak diketahui. Secara umum, angka presisi arbitrer x diambil untuk memiliki Digit[x]
presisi yang diketahui dengan tepat, diikuti oleh jumlah digit tak terhingga yang seluruhnya tidak dikenal.
= N[Pi, 10]
= 3.141592654
Saat Anda melakukan perhitungan, Mathematica melacak digit mana dalam hasil Anda yang dapat dipengaruhi
oleh yang tidak diketahui digit dalam input Anda. Ini mengatur ketepatan hasil Anda sehingga tidak ada digit yang
terpengaruh yang pernah disertakan. Prosedur ini memastikan bahwa semua digit yang dikembalikan oleh
Mathematica benar, berapa pun nilai digit yang tidak diketahui.
= N[Gamma[1/7], 30]
= 6.54806294024782443771409334943
Dalam banyak perhitungan, ketepatan hasil yang Anda peroleh semakin menurun sebagai akibat dari “kesalahan
pembulatan”. kasus khas ini terjadi jika Anda mengurangi dua angka yang berdekatan. Hasil yang Anda dapatkan
tergantung pada pesanan tinggi digit di setiap nomor, dan biasanya memiliki digit presisi yang jauh lebih sedikit
daripada salah satu nomor aslinya.
• 3.1.6 Nomor Mesin-Presisi
Setiap kali angka presisi mesin muncul dalam perhitungan, seluruh perhitungan biasanya dilakukan di mesin presisi.
Mathematica kemudian akan memberikan angka presisi mesin sebagai hasilnya.
Setiap kali input berisi nomor presisi mesin apa pun, Mathematica melakukan perhitungan ke presisi mesin.
= 1.444444444444444444 ^ 5.7
8.13382
Saat Anda melakukan perhitungan dengan angka presisi arbitrer, seperti yang dibahas di bagian sebelumnya,
Mathematica selalu melacak ketepatan hasil Anda, dan hanya memberikan angka- angka yang diketahui benar,
mengingat ketepatan masukan Anda. Namun, ketika Anda melakukan perhitungan dengan angka presisi mesin,
Mathematica selalu memberi Anda hasil presisi mesin, apakah semua digit dalam hasil dapat, pada kenyataannya,
ditentukan benar atau tidak berdasarkan masukan Anda. diff = 1.11111111 - 1.11111000
1.11 × 10−6
Fakta bahwa Anda bisa mendapatkan angka palsu dalam perhitungan numerik presisi mesin dengan Mathematica
ada di banyak respek cukup tidak memuaskan. Alasan utama, bagaimanapun, bahwa Mathematica menggunakan
presisi tetap untuk perhitungan ini adalah masalah efisiensi komputasi.
Mathematica biasanya diatur untuk melindungi Anda sebanyak mungkin dari detail sistem komputer Anda
menggunakan. Dalam berurusan dengan nomor presisi mesin, Anda akan kehilangan terlalu banyak, namun, jika
Mathematica tidak membuat penggunaan beberapa fitur khusus komputer Anda.
Poin pentingnya adalah hampir semua komputer memiliki perangkat keras atau mikrokode khusus untuk
melakukan perhitungan floating-point untuk presisi tetap tertentu. Mathematica memanfaatkan fitur-fitur ini saat
melakukan numerik presisi mesin perhitungan.
Susunan tipikalnya adalah bahwa semua angka presisi mesin di Mathematica direpresentasikan sebagai "presisi
ganda" bilangan floating-point” dalam sistem komputer yang mendasarinya. Pada sebagian besar komputer saat
ini, angka tersebut berisi total 64 bit biner, biasanya menghasilkan 16 digit desimal mantissa.
Keuntungan utama menggunakan kemampuan floating-point bawaan komputer Anda adalah kecepatan.
Sewenang-wenang-presisi perhitungan numerik, yang tidak menggunakan kemampuan ini secara langsung,
biasanya berkali-kali lebih lambat daripada perhitungan presisi mesin.
Ada beberapa kelemahan menggunakan built-in kemampuan floating-point. Yang sudah disebutkan adalah bahwa
itu memaksa semua angka untuk memiliki presisi tetap, terlepas dari presisi apa yang dapat dibenarkan untuk
mereka.
Kerugian kedua adalah bahwa perlakuan terhadap angka presisi mesin dapat sedikit berbeda dari satu sistem
komputer ke yang lainnya. Dalam bekerja dengan angka presisi mesin, Mathematica bergantung pada aritmatika
titik-mengambang sistem dari setiap komputer tertentu. Jika aritmatika titik-mengambang dilakukan secara
berbeda pada dua komputer, Anda
mungkin mendapatkan hasil yang sedikit berbeda untuk perhitungan Mathematica presisi mesin pada komputer tersebut.
$MachinePrecision jumlah digit desimal presisi
$MachineEpsilon nomor presisi mesin positif minimum yang

dapat ditambahkan ke 1.0 untuk memberikan
hasil yang dapat dibedakan dari 1.0
$MaxMachineNumber nomor presisi mesin maksimum
$MinMachineNumber angka presisi mesin positif minimum
$MaxNumber besarnya maksimum angka presisi arbitrer
$MinNumber besarnya minimum angka presisi arbitrer

positif
Karena angka presisi mesin pada sistem komputer tertentu diwakili oleh sejumlah biner tertentu bit, angka yang
terlalu berdekatan akan memiliki pola bit yang sama, sehingga tidak dapat dibedakan. Parameternya
$MachineEpsilon memberikan jarak antara 1.0 dan angka terdekat yang memiliki representasi biner yang berbeda.
• 3.1.7 Topik Lanjutan: Aritmatika Interval
Interval [ min, max < ] interval dari min ke max
Interval [ mnt1, maks1 <, 8 min 2, maks 2 <, … penyatuan interval dari min1 ke max1, min2 ke
] max2, …
= Interval [{-2, 5}]^2
Interval [{0.25}]
= Interval [{-2, 5}]
Interval [{- }]
Anda dapat menggunakan interval tidak hanya dengan jumlah yang tepat tetapi juga dengan angka perkiraan.
Bahkan dengan presisi mesin angka, Mathematica selalu berusaha melakukan pembulatan sedemikian rupa untuk
menjaga validitas hasil.
= Interval[100.] – 100
Interval[{−1.42109× 10−14, 1.42109 × 10−14}]
• 3.1.8 Topik Lanjutan: Hasil Tak tentu dan Tak Terbatas
Ekspresi seperti 0/0 adalah contoh dari hasil numerik tak tentu. Jika Anda mengetik 0/0, tidak ada cara untuk
Mathematica untuk mengetahui jawaban apa yang Anda inginkan. Jika Anda mendapatkan 0/0 dengan mengambil
limit dari x x sebagai x > 0, maka Anda mungkin menginginkan jawaban 1. Sebaliknya, jika Anda mendapatkan
0/0 sebagai batas dari 2 x / x, maka Anda mungkin menginginkan jawaban 2.
Ekspresi 0/0 sendiri tidak mengandung informasi yang cukup untuk memilih antara kasus ini dan kasus lainnya. Sebagai
hasilnya, nilainya harus dianggap tak tentu.
Setiap kali hasil tak tentu dihasilkan dalam perhitungan aritmatika, Mathematica mencetak pesan peringatan, dan
kemudian mengembalikan Indeterminate sebagai hasil perhitungan. Jika Anda pernah mencoba menggunakan
Indeterminate dalam perhitungan aritmatika, Anda selalu mendapatkan hasil Tak tentu. Ekspresi tak tentu tunggal
secara efektif "meracuni" perhitungan aritmatika apa pun. (Simbol Tak tentu memainkan peran dalam
Mathematica mirip dengan objek "bukan angka" dalam Standar Titik Mengambang IEEE.)
Ada banyak situasi di mana nyaman untuk dapat melakukan perhitungan dengan jumlah tak terbatas. Simbol
Infinity di Mathematica mewakili kuantitas tak terbatas positif. Anda dapat menggunakannya untuk menentukan
hal-hal seperti batas penjumlahan dan integral. Anda juga dapat melakukan beberapa perhitungan aritmatika
dengannya.
Berikut adalah integral dengan limit tak hingga
= Integrate[1/x^3, {x, 1, Infinity}]
1
=
2
Ada sejumlah poin halus yang muncul dalam menangani jumlah tak terbatas. Salah satunya menyangkut "arah"
dari kuantitas yang tak terbatas. Ketika Anda melakukan integral tak hingga, Anda biasanya berpikir untuk
melakukan integrasi di sepanjang jalan di bidang kompleks yang menuju tak terhingga dalam beberapa arah.
Dalam hal ini, penting untuk membedakan versi yang berbeda dari tak terhingga yang sesuai dengan arah yang
berbeda di bidang kompleks. +¶ dan -¶ adalah dua contoh, tetapi untuk beberapa tujuan seseorang juga
membutuhkan i dan seterusnya.
Dalam Mathematica, jumlah tak terbatas dapat memiliki "arah", yang ditentukan oleh bilangan kompleks. Saat
Anda mengetik simbol Infinity, mewakili kuantitas tak terbatas positif, ini diubah secara internal ke bentuk
Diarahkan
Infinity[1], yang mewakili kuantitas tak terbatas dalam arah +1. Demikian pula, -Infinity menjadi
DirectedInfinity[-1], dan I Infinity menjadi DirectedInfinity[I]. Meskipun DirectedInfinity form selalu digunakan
secara internal, format output standar untuk DirectedInfinity[r] adalah r Infinity.
• 3.1.9 Topik Lanjutan: Mengontrol Evaluasi Numerik
NHoldAll mencegah argumen fungsi apa pun agar tidak

terpengaruh oleh N
NHoldFirst mencegah argumen pertama terpengaruh
NHoldRest mencegah semua kecuali argumen pertama

terpengaruh
= N[f[2/3, Pi]]
F [0.666667, 3.14159]
= N[f[2/3, Pi]] F[2/3,
3.14159}
3.2 Fungsi Matematika
3.2.1 Konvensi Penamaan
Fungsi matematika di Mathematica diberi nama sesuai dengan aturan yang pasti. Seperti kebanyakan Mathematica
fungsi, nama biasanya kata-kata bahasa Inggris lengkap, dieja lengkap. Untuk beberapa fungsi yang sangat umum, Mathe
matica menggunakan singkatan tradisional. Jadi fungsi modulo, misalnya, adalah Mod, bukan Modul
Fungsi matematika yang biasanya disebut dengan nama seseorang memiliki nama dalam Mathematica dalam bentuk
Simbol Orang. Jadi, misalnya, polinomial Legendre Pn HxL dilambangkan LegendreP[n, x]. Meskipun konvensi ini
menghasilkan nama fungsi yang lebih panjang, konvensi ini menghindari ambiguitas atau kebingungan.
Ketika notasi standar untuk fungsi matematika melibatkan subskrip dan superskrip, subskripnya adalah: diberikan sebelum
superskrip dalam bentuk Mathematica. Jadi, misalnya, polinomial Legendre terkait 𝑃𝑚(x) dilambangkan LegendreP[n, m,
x].
IntegerPart (x) bagian bilangan bulat dari x Bagian pecahan (x) bagian pecahan dari x Bulat (x) bilangan bulat [x]
terdekat dengan x
Lantai (x) bilangan bulat terbesar [x] tidak lebih besar dari x
Plafon (x) bilangan bulat terkecil [x] tidak lebih kecil dari x
Tanda (x) 1 untuk x > 0 , 1 untuk x < 0

UnitStep (x) 1 untuk x 0 , 0 untuk x < 0
Abs (x) nilai absolut » x » dari x
Maks [x1, x2, … ] atau maksimum x1, x2, … Maks [(x1, x2, …), … ]
Min [x1, x2, …] atau minimal x1, x2, …
Min [(x1, x2, … ), … ]
Beberapa fungsi numerik dari variabel nyata.
X Bagian Integer [x] pecahan Bulat Floor [x] Ceiling [x ]

alBagian [x]
[x]
2.4 2 0.4 2 2 3
2.5 2 0.5 2 2 3
2.6 2 0.6 3 2 3
-2.4 -2 -0.4 -2 -3 -2
-2.5 -2 -0.5 -2 -3 -2
-2.6 -2 -0.6 -3 -3 -2
Mengekstrak bagian bilangan bulat dan pecahan.
IntegerPart[x] dan FractionalPart[x] dapat dianggap sebagai mengekstraksi digit ke kiri dan kanan dari titik
desimal.
Round[x] sering digunakan untuk memaksa bilangan yang mendekati bilangan bulat menjadi bilangan bulat.
Floor[x] dan Ceiling[x] sering muncul dalam menghitung berapa banyak elemen yang akan ada dalam urutan angka
dengan spasi bukan bilangan bulat.
x + I y bilangan kompleks x + i y
Re [z] bagian yang sebenarnya Re z Im [z] bagian imajiner Im z
Conjugate [z] konjungsi kompleks 𝑧∗ atau z Abs [z] nilai absolut [z] Arg [z] argumen ∅ sedemikian rupa sehingga z =
|𝑧|𝑒𝑖∅
Fungsi numerik dari variabel kompleks.
Rationalize [ x ] pendekatan bilangan rasional untuk x

Rationalize [x, dx ] pendekatan rasional dalam toleransi dx
Menemukan pendekatan rasional.
Angka Pseudorandom
Random [ ] pseudorandom nyata antara 0 dan 1

Random [Real, xmax] pseudorandom nyata antara 0 dan xmax Random [Real, { xmin, xmax }] pseudorandom
nyata antara xmin dan xmax
Random [Complex] bilangan kompleks pseudorandom dalam satuan persegi Random [Complex, {zmin, zmax} ]
bilangan kompleks pseudorandom dalam persegi panjang yang didefinisikan oleh zmin dan zmax Random [type, range,
n ] nomor pseudorandom n –digit 1
Random [Integer] 0 atau 1 dengan probabilitas 2
Random [Integer, {imin, imax} ] bilangan bulat pseudorandom antara imin dan imax , inklusif
SeedRandom [ ] reseed generator pseudorandom, dengan waktu hari SeedRandom

[s] reseed dengan bilangan bulat s
$RandomState keadaan generator pseudorandom saat ini
Pembuatan nomor pseudorandom.
Berikut adalah bilangan real pseudorandom 30 digit dalam rentang 0 hingga 1. In[2]:= Random[Real, {0, 1}, 30]
Out[2]= 0.748823044099679773836330229338
Ini memberikan daftar 8 bilangan bulat pseudorandom antara 100 dan 200 (inklusif) In[3]:= Table[Random[Integer, {100,
200}], {8}]
Out[3]= {120, 108, 109, 147, 146, 189, 188, 187}
Jika Anda memanggil Random[ ] berulang kali, Anda akan mendapatkan urutan angka yang “khas”, tanpa
pola tertentu. Di sana banyak cara untuk menggunakan nomor tersebut.
Salah satu cara umum untuk menggunakan nomor pseudorandom adalah dalam membuat tes numerik hipotesis. Misalnya,
jika Anda percaya bahwa dua ekspresi simbolis sama secara matematis, Anda dapat mengujinya dengan memasukkan
angka "khas" nilai untuk parameter simbolik, dan kemudian membandingkan hasil numerik. (Jika Anda melakukan ini,
Anda harus berhati-hati tentang masalah akurasi numerik dan tentang fungsi variabel kompleks yang mungkin tidak
memiliki nilai unik.)
Berikut adalah persamaan simbolis. In[4]:= Sin[Cos[x]] == Cos[Sin[x]]

Out[4]= Sin [Cos[x]] ==Cos [Sin[x] ]
Mengganti dalam nilai numerik acak menunjukkan bahwa persamaan tidak selalu Benar. In[5]:= % /. x -> Random[ ]
Out[5]= False
Penggunaan umum lainnya dari nomor pseudorandom termasuk simulasi proses probabilistik, dan pengambilan sampel
ruang besar dari kemungkinan. Bilangan pseudorandom yang dihasilkan Mathematica selalu terdistribusi secara merata di
atas rentang yang Anda tentukan.
Acak tidak seperti hampir semua fungsi Mathematica lainnya karena setiap kali Anda memanggilnya, Anda berpotensi
mendapatkan yang berbeda hasil. Jika Anda menggunakan Acak dalam perhitungan, oleh karena itu, Anda mungkin
mendapatkan jawaban yang berbeda pada kesempatan yang berbeda.
Urutan yang Anda dapatkan dari Acak[ ] dalam banyak hal tidak "benar-benar acak", meskipun seharusnya"cukup acak"
untuk tujuan praktis. Urutan sebenarnya dihasilkan dengan menerapkan matematika yang pasti algoritma, mulai dari
"benih" tertentu. Jika Anda memberikan benih yang sama, maka Anda mendapatkan urutan yang sama.
Ketika Mathematica dimulai, dibutuhkan waktu dalam sehari (diukur dalam sepersekian detik) sebagai benih untuk
pembangkit bilangan pseudorandom. Oleh karena itu, dua sesi Mathematica yang berbeda hampir selalu memberikan hasil
yang berbeda urutan bilangan pseudorandom.
Jika Anda ingin memastikan bahwa Anda selalu mendapatkan urutan angka pseudorandom yang sama, Anda dapat secara
eksplisit memberikan a seed untuk generator pseudorandom, menggunakan SeedRandom.
Ini me-reseed generator pseudorandom. In[6]:= SeedRandom[143]

Berikut adalah tiga nomor pseudorandom. In[7]:= Table[Random[ ], {3}]
Out[7]= {0.952312, 0.93591, 0.813754}
Penggunaan umum lainnya dari nomor pseudorandom termasuk simulasi proses probabilistik, dan pengambilan sampel
ruang besar dari kemungkinan. Bilangan pseudorandom yang dihasilkan Mathematica selalu terdistribusi secara merata di
atas rentang yang Anda tentukan.
Acak tidak seperti hampir semua fungsi Mathematica lainnya karena setiap kali Anda memanggilnya, Anda berpotensi
mendapatkan yang berbedahasil. Jika Anda menggunakan Acak dalam perhitungan, oleh karena itu, Anda mungkin
mendapatkan jawaban yang berbeda pada kesempatan yang berbeda.
Urutan yang Anda dapatkan dari Acak[ ] dalam banyak hal tidak "benar-benar acak", meskipun seharusnya"cukup acak"
untuk tujuan praktis. Urutan sebenarnya dihasilkan dengan menerapkan matematika yang pastialgoritma, mulai dari
"benih" tertentu. Jika Anda memberikan benih yang sama, maka Anda mendapatkan urutan yang sama. Ketika
Mathematica dimulai, dibutuhkan waktu dalam sehari (diukur dalam sepersekian detik) sebagai benih untukpembangkit
bilangan pseudorandom. Oleh karena itu, dua sesi Mathematica yang berbeda hampir selalu memberikan hasil yang
berbedaurutan bilangan pseudorandom.
Jika Anda ingin memastikan bahwa Anda selalu mendapatkan urutan angka pseudorandom yang sama, Anda dapat secara
eksplisit memberikan a seed untuk generator pseudorandom, menggunakan SeedRandom.
Ini me-reseed generator pseudorandom. In[6]:= SeedRandom[143]

Berikut adalah tiga nomor pseudorandom. In[7]:= Table[Random[ ], {3}]
Out[7]= {0.952312, 0.93591, 0.813754}
Jika Anda menyemai ulang generator pseudorandom dengan benih yang sama, Anda mendapatkan urutan nomor
pseudorandom yang sama.
In[8]:= SeedRandom[143]; Table[Random[ ],
{3}] Out[8]= {0.952312, 0.93591, 0.813754}
Setiap kali Random dipanggil, keadaan internal generator pseudorandom yang digunakannya berubah. Ini berarti bahwa
panggilan ke Acak yang dilakukan dalam perhitungan tambahan akan berpengaruh pada angka yang dikembalikan oleh
Acak dalam perhitungan utama Anda. Untuk menghindari masalah yang terkait dengan ini, Anda dapat menyimpan nilai
$RandomState sebelumnya Anda melakukan perhitungan tambahan, dan kemudian mengembalikannya setelah itu.
In[9]:= {Block[{$RandomState}, {Random[ ], Random[ ]}], {Random[ ], Random[ ]}} Out[9]= {{0.1169, 0.783447},
{0.1169, 0.783447}}
Fungsi Integer dan Teoretis Bilangan
Mod [k, n ] k modulo n Hremainder from dividing k by n L Quotient[ m, n ] bilangan hasil bagi m dan n (bagian
bulat dari m/n )
GCD [n1 , n2, … ] pembagi persekutuan terbesar dari n1 , n2 , …
LCM [n1 , n2, … ] kelipatan persekutuan terkecil dari n1 , n2 ,
… KroneckerDelta [ n1 , n2, … ] delta Kronecker 𝛿𝑛1 𝑛2 … sama
dengan 1 jika semua ni sama, dan 0 sebaliknya
IntegerDigits [ n, b ] digit n di basis b
IntegerExponent [ n, b ] pangkat tertinggi dari b yang membagi n
Beberapa fungsi bilangan bulat

Mod [ k, n ] menghasilkan kisaran 0 hingga n – 1 Mod [k, n, 1]
menghasilkan kisaran 1 hingga n
Mod [ k, n, − n /2] menghasilkan kisaran [-n /2] hingga [+n
/2] Mod [k, n, d ] menghasilkan rentang d hingga d + n - 1
Sisa bilangan bulat dengan offset.
Khususnya ketika Anda menggunakan Mod untuk mendapatkan indeks untuk bagian-bagian objek, Anda akan sering
merasa nyaman untuk menentukan suatu mengimbangi.
Ini secara efektif mengekstrak bagian ke-18 dari daftar, dengan daftar diperlakukan secara siklis.
Fungsi pembagi persekutuan terbesar GCD[n1, n2, … ] memberikan bilangan bulat terbesar yang membagi semua ni
dengan tepat.Saat Anda memasukkan rasio dua bilangan bulat, Mathematica secara efektif menggunakan GCD
untuk meniadakan faktor persekutuan, dan memberikan a bilangan rasional dalam istilah terendah. Fungsi kelipatan
persekutuan terkecil KPK[n1, n2, … ] memberikan bilangan bulat terkecil yang memuat semua faktor dari masing-
masing dari 𝑛𝑖
Bilangan bulat terbesar yang membagi 24 dan 15 adalah 3.

Kronecker delta atau simbol Kronecker KroneckerDelta[𝑛1 , 𝑛2 ,… ] sama dengan 1 jika semua ni sama, dan 0 sebaliknya.
dn1 n2 … dapat dianggap sebagai tensor yang benar-benar simetris. Ini memberikan tensor peringkat 3 yang benar-benar
simetris.
FactorInteger [ n ] daftar faktor prima dari n , dan eksponennya Divisors [n ] daftar bilangan bulat yang
membagi n
Prime [k ] bilangan prima ke-k
PrimePi [x ] jumlah bilangan prima yang kurang dari atau sama dengan x
PrimeQ [n ] berikan Benar jika n adalah bilangan prima, dan Salah jika sebaliknya FactorInteger [ n, daftar faktor
prima Gaussian dari bilangan bulat Gaussian GaussianIntegers−>True] n , dan eksponennya PrimeQ [n,
berikan Benar jika n adalah prima Gaussian, dan Salah jika sebaliknya GaussianIntegers−>True]
Anjak bilangan bulat dan fungsi terkait
Ini memberikan faktor dari 24 sebagai 23, 31 . Elemen pertama dalam setiap daftar adalah faktor; yang kedua
adalah eksponennya.
Berikut adalah faktor-faktor dari bilangan bulat yang lebih besar.
Anda harus menyadari bahwa menurut pemikiran matematika saat ini, pemfaktoran bilangan bulat pada dasarnya sulit
masalah komputasi. Akibatnya, Anda dapat dengan mudah mengetikkan bilangan bulat yang tidak dapat diperhitungkan
oleh Mathematica sesuatu yang pendek dari waktu astronomis. Tetapi selama bilangan bulat yang Anda berikan kurang
dari sekitar 50 digit,FactorInteger seharusnya tidak mengalami kesulitan. Dan dalam kasus khusus itu akan dapat
menangani bilangan bulat yang lebih panjang. (Anda dapat membuat beberapa masalah pemfaktoran berjalan lebih cepat
dengan menyetel opsi FactorComplete->False, sehingga Factorg Integer[n] mencoba menarik hanya faktor mudah dari n.)
Ini adalah bilangan bulat panjang yang agak khusus.
Mathematica dapat dengan mudah memfaktorkan bilangan bulat khusus ini.

Meskipun Mathematica mungkin tidak dapat memfaktorkan bilangan bulat besar, sering kali masih dapat menguji apakah
bilangan bulat itu a utama. Selain itu, Mathematica memiliki cara cepat untuk menemukan bilangan prima ke-𝑘𝑡ℎ.
Seringkali jauh lebih cepat untuk menguji apakah suatu bilangan prima daripada memfaktorkannya.
Berikut adalah plot dari 100 bilangan prima pertama.
Ini adalah bilangan prima ke sejuta.
Khususnya dalam teori bilangan, seringkali lebih penting untuk mengetahui distribusi bilangan prima daripada
nilai sebenarnya.Fungsi PrimePi[x] memberikan jumlah bilangan prima 𝜋(x) yang kurang dari atau sama dengan
x.
Ini memberikan jumlah bilangan prima kurang dari satu miliar.
Secara default, FactorInteger hanya mengizinkan bilangan bulat nyata. Tetapi dengan pengaturan opsi GaussianIntegers
> True,itu juga menangani bilangan bulat Gaussian, yang merupakan bilangan kompleks dengan bagian real dan
imajiner bilangan bulat. Seperti itu mungkin untuk memfaktorkan secara unik dalam hal bilangan prima nyata, juga
memungkinkan untuk memfaktorkan secara unik dalam hal bilangan prima Gaussian. Namun demikian ada beberapa
ambiguitas potensial dalam pemilihan bilangan prima Gaussian. Di Mathematica, mereka selalu dipilih memiliki bagian
real positif, dan bagian imajiner non-negatif, kecuali untuk kemungkinan faktor awal -1 atau ±i. Di atas bilangan bulat
Gaussian, 2 dapat difaktorkan sebagai ( -i )( 1 + 𝑖)2
Berikut adalah faktor-faktor dari bilangan bulat Gaussian.
PowerMod [a, b, n ] daya 𝑎𝑏 modulo n

EulerPhi [ n ] fungsi totien Euler ∅ (𝑛)
MoebiusMu [ n ] fungsi Möbius 𝜇 (𝑛)
DivisorSigma [ k, n ] fungsi pembagi 𝜎𝑘 (n)
𝑛
JacobiSimbol [ n, m ] simbol Jacobi ( )
𝑚
ExtendedGCD [𝑛1 , 𝑛2, … ] perpanjangan gcd dari 𝑛1 , 𝑛2, …
MultiplicativeOrder [ k, n ] orde perkalian k modulo n MultiplicativeOrder [ urutan perkalian umum dengan residu
𝑟𝑖 k, n, {𝑟1, 𝑟2, … }]
CarmichaelLambda [ n ] fungsi Carmichael 𝜆(n)

LatticeReduce [ { 𝑣1, 𝑣2, … }] basis kisi tereduksi untuk himpunan vektor bilangan bulat 𝑣𝑖
Beberapa fungsi dari teori bilangan.

Fungsi daya modular PowerMod[a, b, n] memberikan hasil yang persis sama dengan Mod[a^b, n] untuk b > 0.PowerMod
jauh lebih efisien, karena menghindari menghasilkan bentuk penuh dari a^b.
Anda dapat menggunakan PowerMod tidak hanya untuk menemukan kekuatan modular positif, tetapi juga untuk
menemukan kebalikan modular. Untuk b negatif, PowerMod[a, b, n] memberikan, jika mungkin, bilangan bulat k
sedemikian rupa sehingga k a-b 1 mod n. (Setiap kali bilangan bulat seperti itu ada, itu adalah dijamin menjadi modulo
n yang unik.) Jika tidak ada bilangan bulat k seperti itu, Mathematica membiarkan PowerMod tidak dievaluasi.
PowerMod setara dengan menggunakan Power, lalu Mod, tetapi jauh lebih efisien.
Ini memberikan kebalikan modular dari 3 modulo 7.
Mengalikan kebalikannya dengan 3 modulo 7 menghasilkan 1, seperti yang diharapkan.
Fungsi totient Euler ∅ (𝑛)memberikan jumlah bilangan bulat kurang dari n yang relatif prima ke
n. Penting hubungan (Teorema Kecil Fermat) adalah bahwa 𝑎∅(𝑛) ≡ 1 mod n untuk semua 𝑎 relatif
prima ke n.
Fungsi Möbius 𝜇 (𝑛) didefinisikan sebagai (−1)𝑘 jika n adalah produk dari k bilangan prima yang berbeda, dan 0 jika n
berisi kuadrat faktor (selain 1). Hubungan penting adalah rumus inversi Möbius, yang menyatakan bahwa jika g (𝑛) = ∑𝑑
| 𝑛 𝑓 (𝑑) untuk semua n, maka 𝑓 (𝑛) =
∑𝑑| 𝑛 𝜇(𝑑) g (𝑛⁄𝑑)di mana jumlahnya adalah semua bilangan bulat positif d yang membagi n.
Fungsi pembagi 𝜎𝑘 (𝑛) adalah jumlah pangkat 𝑘𝑡ℎdari pembagi n. Fungsi s0 HnL memberikan totaljumlah pembagi n, dan
sering dilambangkan d (n). Fungsi 𝜎1 (𝑛), sama dengan jumlah pembagi n, sering kali dilambangkan𝜎 (𝑛).
Untuk prima n, f𝜎 (𝑛) = n - 1.
Hasilnya adalah 1, seperti yang dijamin oleh Teorema Kecil Fermat.
Ini memberikan daftar semua pembagi dari 24.
𝜎0 (𝑛) memberikan jumlah total pembagi yang berbeda dari 24.
𝑛
Simbol Jacobi Simbol Jacobi[n, m] direduksi menjadi simbol Legendre [ ] ketika m adalah
𝑚 bilangan prima ganjil. Simbol Legendre sama dengan nol jika n habis dibagi m, selain itu sama dengan 1 jika n adalah
modulo residu kuadratik prima m, dan ke -1 jika tidak. Suatu bilangan bulat n yang relatif prima terhadap m dikatakan
sebagai residu kuadratik modulo m jika adaada bilangan bulat k sedemikian rupa sehingga 𝑘2 ≡ n mod m. Simbol penuh
Jacobi adalah produk
𝑛
dari simbol Legendre ( )untuk masing-masing dari faktor prima pi sedemikian rupa sehingga m
𝑝𝑖
= 𝑀𝑖𝑝𝑖
Extended gcd ExtendedGCD [n1, n2, … ] memberikan daftar { g, {r1, r2, … }} di mana g adalah persekutuan terbesar
pembagi ni , dan ri adalah bilangan bulat sehingga g = r1 n1 + r2 n2 + …. Gcd yang diperluas penting dalam
menemukan solusi integer untuk persamaan Diophantine linier. Angka pertama dalam daftar adalah gcd dari 105 dan
196.
Pasangan bilangan kedua memenuhi g = r m + s n.

Fungsi orde perkalian MultiplicativeOrder [k, n] memberikan bilangan bulat terkecil m sedemikian sehingga 𝑘𝑚 ≡ 1 mod
n. Fungsi ini kadang-kadang dikenal sebagai indeks atau log diskrit dari k . Notasi 𝑜𝑟𝑑𝑛 (k) kadang-kadang digunakan.
Fungsi orde perkalian umum MultiplicativeOrder[k, n, {r1, r2, … }] memberikan yang terkecil bilangan bulat m sehingga
𝑘𝑚 ≡ 𝑟𝑖 mod n untuk beberapa i. Orde Perkalian [k, n, {-1, 1}] kadang-kadang dikenal sebagai fungsi subordo k modulo n,
dinotasikan s𝑠𝑜𝑟𝑑𝑛 (k).
Fungsi Carmichael atau eksponen universal terkecil 𝜆(𝑛)memberikan bilangan bulat terkecil m sedemikian rupa sehingga
𝑘𝑚 ≡ 1 mod n untuk semua bilangan bulat k relatif prima ke n.
Fungsi reduksi kisi LatticeReduce [{v1 , v2, … }] digunakan dalam beberapa jenis algoritma modern. NS ide dasarnya
adalah memikirkan vektor 𝑣𝑘 bilangan bulat sebagai mendefinisikan kisi matematika. Setiap vektor yang mewakili
suatu titik di kisi dapat ditulis sebagai kombinasi linier dari bentuk ∑𝑐𝑘𝑣𝑘, di mana ck adalah bilangan bulat. Untuk kisi
tertentu,ada banyak kemungkinan pilihan dari "vektor dasar"𝑣𝑘. Apa yang dilakukan LatticeReduce adalah menemukan
himpunan tereduksi dari vektor dasar 𝑣𝑘 untuk kisi, dengan sifat khusus tertentu. Tiga vektor satuan di sepanjang tiga
sumbu koordinat sudah membentuk basis tereduksi.
Ini memberikan dasar tereduksi untuk kisi dalam ruang empat dimensi yang ditentukan oleh tiga vector.
Perhatikan bahwa pada contoh terakhir, LatticeReduce menggantikan vektor yang hampir sejajar dengan vektor yang
lebih besar tegak lurus. Dalam prosesnya, ia menemukan beberapa vektor basis yang cukup pendek.
ContinuedFraction [ x, n ] menghasilkan n . pertama suku-suku dalam representasi merekonstruksi angka dari

pecahan lanjutan dari x FromContinuedFraction [ list ] representasi pecahan
lanjutannya
Rasionalkan [ x, dx] temukan pendekatan rasional untuk x dengan toleransi dx
Pecahan lanjutan.
Ini menghasilkan 10 suku pertama dalam representasi pecahan lanjutan untuk 𝜋.
merekonstruksi nomor yang diwakili oleh daftar istilah pecahan lanjutan.
Hasilnya mendekati hal.
Ini memberikan secara langsung pendekatan rasional untuk 𝜋.
Pecahan lanjutan muncul di banyak pengaturan teori bilangan. Bilangan rasional telah berakhir terus representasi
pecahan. Bilangan irasional kuadrat memiliki representasi pecahan lanjutan yang berulang-ulang
ContinuedFraction [x] representasi pecahan lanjutan yang lengkap
untuk bilangan irasional rasional atau kuadrat
RealDigits [x] urutan digit lengkap untuk bilangan rasional RealDigits [ x, b ] urutan digit lengkap dalam basis
b
Representasi lengkap untuk angka.
Representasi pecahan lanjutan dari √79 dimulai dengan istilah 8, kemudian melibatkan urutan istilah yang
berulang selamanya.
Ini merekonstruksi √79 dari representasi fraksi lanjutannya.
Ini menunjukkan urutan berulang angka desimal dalam 3⁄7
FromDigits merekonstruksi nomor aslinya
DigitCount [n, b, d] jumlah digit d di basis b representasi dari n

Fungsi penghitungan angka.
Berikut adalah angka-angka dalam representasi basis 2 dari angka 77.
Ini secara langsung menghitung jumlah angka dalam representasi basis 2.
Plot dari fungsi hitungan digit adalah self-mirip.

BitAnd [n1 , n2, … ] bitwise AND dari bilangan bulat ni
BitOr [n1 , n2, … ] bitwise OR dari bilangan bulat ni
BitXor [n1 , n2, … ] bitwise XOR bilangan bulat ni BitNot [n
] bitwise BUKAN dari bilangan bulat n
Operasi bitwise.
Operasi bitwise bekerja pada bilangan bulat yang direpresentasikan sebagai bit biner. BitAnd[𝑛1, 𝑛2 , ….,] menghasilkan
bilangan bulat yang binernya representasi bit memiliki posisi di mana representasi bit biner dari semua ni memilikinya.
BitOr[𝑛1, 𝑛2,… ] menghasilkan bilangan bulat dengan yang pada posisi di mana salah satu ni memilikinya. BitXor[𝑛1,
𝑛2,] menghasilkan bilangan bulat dengan yang pada posisi di mana 𝑛1atau 𝑛2 tetapi tidak keduanya memilikinya.
BitXor[𝑛1 , 𝑛2 , … ] memiliki yang di mana angka ganjil aku punya.
Ini menemukan AND bitwise dari angka 23 dan 29 yang dimasukkan di basis 2.
Fungsi Kombinatorial
n! faktorial 𝑛(𝑛 − 1)(𝑛 − 2)𝑥 … . 𝑥1 n !!

faktorial ganda 𝑛(𝑛 − 2)(𝑛 − 4)𝑥 ….
Binomial [n, m] koefisien binomial ( 𝑛) = 𝑛!⁄[𝑚! (𝑛 − 𝑚)!]
𝑚
Multinomial [𝑛1, 𝑛2 , … ] koefisien multinomial (𝑛1 + 𝑛2 + ⋯ )!⁄(𝑛1! 𝑛2! … )
Fibonacci [n] Angka Fibonacci 𝐹𝑛
Fibonacci [n, x] Polinomial Fibonacci 𝐹𝑛(𝑥)
HarmonicNumber [n ] bilangan harmonik 𝐻𝑛
HarmonicNumber [n, r ] bilangan harmonic 𝐻(𝑟) pesanan r
𝑛
BernoulliB [n] Nomor Bernoulli 𝐵𝑛
BernoulliB [n, x] Polinomial Bernoulli 𝐵𝑛 (𝑥)
EulerE [n] Bilangan Euler
EulerE [n, x] Polinomial Euler En HxL
StirlingS1 [n, m] Bilangan stirling jenis pertama 𝑆(𝑚)

𝑛
StirlingS2 [n, m] Bilangan stirling jenis kedua 𝑆(𝑚)
𝑛
PartisiP [n] jumlah 𝑝 (𝑛) dari partisi tak terbatas dari bilangan bulat 𝑛
PartisiQ [n] jumlah 𝑞 (𝑛) dari partisi n menjadi bagian yang berbeda
Tanda tangan [{ i1, i2, … }] tanda tangan permutasi
Fungsi kombinatorial
Fungsi faktorial n! memberikan banyak cara untuk mengurutkan n objek. koefisien binomial Binomial [n, m] dapat ditulis
sebagai (𝑛 ) = 𝑛!⁄{𝑚! (𝑛 − 𝑚)!]
Koefisien multinomial Multinomial [n1, n2, … ], dinotasikan
(𝑁; 𝑛1, 𝑛2, … . . 𝑛𝑚) = 𝑁!⁄(𝑛1! 𝑛2! … . . 𝑛𝑚), memberikan jumlah cara untuk mempartisi N objek yang berbeda menjadi m
set ukuran ni (dengan𝑁 = ∑𝑚 𝑛𝑖).
Mathematica memberikan hasil bilangan bulat yang tepat untuk faktorial bilangan bulat.
Polinomial Bernoulli BernoulliB [n, x] memenuhi hubungan fungsi pembangkitt
𝑡 𝑒𝑥 𝑡⁄(𝑒1 − 1) = ∑∞ 𝐵𝑛 (𝑥) 𝑡𝑛⁄𝑛!
Bilangan Stirling ini memenuhi hubungan fungsi pembangkit 𝑥(𝑥 − 1) … (𝑥 − 𝑛 + 1) =

∑∞ 𝑆(𝑚) 𝑥𝑚. Perhatikan bahwa beberapa definisi dari 𝑆(𝑚)berbeda dengan faktor
𝑛=0 𝑛=0 𝑛
(−1)𝑛−𝑚dari apa yang digunakan di Mathematica.
Fungsi partisi 𝑝 (𝑛) meningkat secara asimtotik seperti𝑒√𝑛. Perhatikan bahwa Anda tidak bisa begitu saja menggunakan
Plot untuk menghasilkan plot aberfungsi seperti PartitionsP karena fungsi hanya dapat dievaluasi dengan argumen
integer.
Fungsi tanda tangan Signature [{i1, i2, … }] memberikan tanda tangan permutasi. Itu sama dengan +1 untuk genap
permutasi (terdiri dari jumlah transposisi genap), dan ke -1 untuk permutasi ganjil. Fungsi tanda tangan dapat dianggap
sebagai tensor yang benar-benar antisimetris, simbol Levi-Civita atau simbol epsilon.
Fungsi Transendental Dasar

Fungsi Transendental Dasar
Mathematica memberikan hasil yang tepat untuk logaritma kapan pun itu bisa. Ini log2 1024.
Mathematica dapat mengevaluasi logaritma dengan argumen yang kompleks.
Berikut adalah plot dari fungsi tangen hiperbolik. Ini memiliki bentuk "sigmoidal" yang khas.
Fungsi Yang Tidak Memiliki Nilai Unik
Ketika menanyakan akar kuadrat s dari sebuah bilangan a, secara efektif meminta solusi untuk persamaan s2 =
a.Persamaan ini, bagaimanapun, secara umum memiliki dua solusi yang berbeda. Baik s = 2 dan s = -2, misalnya, adalah
solusi untukpersamaan s2 = 4.
Sebenarnya tidak ada cara untuk memilih √𝑧 sehingga kontinu untuk semua nilai kompleks z. Harus ada
"cabang"potong”—sebuah garis pada bidang kompleks di mana fungsi √𝑧 terputusputus. Mathematica mengadopsi yang
biasakonvensi mengambil potongan cabang untuk √𝑧 berada di sepanjang sumbu real negatif.
Diskontinuitas sepanjang sumbu real negatif cukup jelas dalam gambar tiga dimensi dari bagian imajiner bujur sangkar
ini.fungsi akar.
Ini mengambil pangkat kesepuluh dari bilangan kompleks. Hasilnya unik.
Gambar tiga dimensi, menunjukkan dua potongan cabang untuk fungsi sin-1 (z).
Konstanta Matematika
Konstanta Euler EulerGamma diberikan oleh limit𝛾 = 𝑙𝑖𝑚𝑚→∞ (∑ 𝑚 1

− log 𝑚). Itu muncul
2 dalam banyak integral, dan
formula asimtotik. Kadang-kadang dikenal sebagai konstanta Euler- Mascheroni, dan dilambangkan dengan C.
Konstanta matematika dapat dievaluasi dengan presisi yang berubah-ubah
Perhitungan yang tepat juga dapat dilakukan dengan mereka.
Polinomial Ortogonal
Polinomial Legendre LegendreP[n, x] muncul dalam studi sistem dengan simetri bola tiga dimensi.Mereka memenuhi
persamaan diferensial (1 − 𝑥2)𝑦′′ − 2𝑥𝑦′ + 𝑛(𝑛 + 1)𝑦 = 0 dan hubungan ortogonalitas-∫ 1 𝑃 (𝑥)𝑃 (𝑥)𝑑𝑥 = 0 untuk m ≠
𝑛
−1 𝑚 𝑛
Polinomial Legendre tingkat tinggi berosilasi dengan cepat.
Ini memberikan kerapatan untuk keadaan tereksitasi dari osilator harmonik mekanika kuantum. Rata-rata goyangannya
kira-kira adalah hasil fisika klasik.
Fungsi Khusus
Mathematica memberikan hasil eksak untuk beberapa nilai fungsi khusus.

Namun, hasil numerik, dengan ketepatan yang sewenang-wenang, dapat ditemukan.
Gamma dan Fungsi Terkait
Banyak hasil eksak untuk fungsi gamma dan poligamma dibangun ke dalam Mathematica.
Berikut adalah plot kontur fungsi gamma pada bidang kompleks.
Zeta dan Fungsi Terkait

Fungsi zeta Riemann Zeta[s] didefinisikan oleh relasi z (𝑠) = ∑∞ 𝑘−𝑠 (untuk s > 1). Zeta berfungsi dengan argumen
integer muncul dalam mengevaluasi berbagai jumlah dan integral. Mathematica memberikan hasil yang tepat bila
memungkinkan untukfungsi zeta dengan argumen integer.
Berikut adalah gambar tiga dimensi dari fungsi zeta Riemann pada bidang kompleks.
Ini adalah plot nilai absolut dari fungsi zeta Riemann pada garis kritis Re 𝑧 = 1:. Anda dapat melihat beberapa nol
pertama dari fungsi zeta. 2
Integral Eksponensial dan Fungsi Terkait
Fungsi Kesalahan dan Fungsi Terkait

erf(𝑧) =
Fungsi kesalahan Erf[z] adalah integral dari distribusi Gaussian, yang diberikan oleh erf
2⁄√𝜋 𝑧 −12
∫ . fungsi kesalahan komplementer Erfc[z] diberikan secara sederhana
𝑒
oleh 𝑒𝑟𝑓𝑐 (𝑧) = 1 − erf(𝑧). Fungsi kesalahan imajiner Erfi[z] diberikan oleh erfi
(𝑧) = erf(𝑖 𝑧)⁄𝑖 = erf Hi zL i. Fungsi kesalahan umum Erf[z0, z1] didefinisikan oleh integral
2⁄√𝜋 ∫𝑧 𝑒−12 𝑑𝑡 Fungsi kesalahan adalah pusat dari banyak perhitungan dalam statistic
Bessel dan Fungsi Terkait
Fungsi Airy yang diplot di sini memberikan amplitudo mekanika kuantum untuk partikel dalam potensial yang meningkat
secara linier dari kirike kanan. Amplitudo teredam secara eksponensial di wilayah yang secara klasik tidak dapat diakses
di sebelah kanan.
Legendre dan Fungsi Terkait
Fungsi Legendre muncul dalam studi proses hamburan mekanika kuantum.
Fungsi Hipergeometrik Konfluen
Fungsi dan Generalisasi Hipergeometrik
Fungsi Log Produk

Integral Elips dan Fungsi Elliptik
Integral Elips
Berikut adalah plot integral elips lengkap jenis kedua E (m).

Integral eliptik memiliki struktur yang rumit pada bidang kompleks.
Fungsi Elips
Fungsi Modular Elips
Integral dan Fungsi Elips Umum

Mathieu dan Fungsi Terkait
Hal ini menunjukkan lima nilai karakteristik pertama ar sebagai fungsi dari q.
Bekerja dengan Fungsi Khusus
Mathematica secara otomatis menulis ini dalam bentuk konstanta matematika standar.
Di sini lagi Mathematica mereduksi kasus khusus fungsi Airy menjadi ekspresi yang melibatkan fungsi gamma.
Ini menggunakan rumus refleksi untuk fungsi gamma.
Ini menggunakan rumus refleksi untuk fungsi gamma.
Distribusi Statistik dan Fungsi Terkait

Ini memuat paket yang mendefinisikan distribusi statistik berkelanjutan.
Manipulasi Aljabar
Operasi Struktural pada Polinomial
Berikut adalah polynomial dalam satu variabel In[1]:= (2 + 4 x^2)^2 (x - 1)^3

Out[1]= (−1 + x)^3 (2 + 4 x2)^2
Ada beberapa cara untuk menulis polinomial. Fungsi Expand, FactorTerms dan Factor memberikan tiga cara umum.
Perluas menulis polinomial sebagai jumlah istilah sederhana, dengan semua produk diperluas. Faktor Istilah menarik
keluar faktor-faktor umum dari setiap istilah. Faktor melakukan anjak pimpis lengkap, menulis polinomial sebagai
produk istilah, masing-masing serendah mungkin.
Ketika Anda memiliki polinomial di lebih dari satu variabel, Anda dapat menempatkan polinomial dalam bentuk
different dengan pada dasarnya memilih variabel yang berbeda untuk menjadi "dominan". Collect[poly, x] mengambil
polinomial dalam beberapa variabel dan menulis ulang sebagai jumlah istilah yang mengandung kekuatan yang
berbeda dari "variabel dominan" x.
Berikut adalah polynomial dalam dua variabel In[5]:= Expand[ (1 + 2x + y)^3 ]
Out[5]= 1 + 6 x + 12 x2 + 8 x3 + 3 y + 12 x y + 12 x2 y + 3 y2 + 6 x y2 + y3
Mathematica tidak secara otomatis memperluas ekspresi bentuk (a b)^c kecuali ketika c adalah bilangan bulat.
Secara umum hanya benar untuk melakukan ekspansi ini jika a dan b adalah nyata positif. Namun demikian, fungsi
PowerExpand melakukan ekspansi, secara efektif dengan asumsi bahwa a dan b memang nyata positif.
Mathematica tidak secara otomatis memperluas ekspresi ini. In[10]:= (x y)^n Out[10]= (x y)^n
Berikut adalah ekspresi yang melibatkan berbagai fungsi f. In[14]:= t = 3 + x f[1] + x^2 f[1] + y f[2]^2 + z f[2]^2
Out[14]= 3 + x f[1] + x2 f[1] + y f[2]^] + z f[2]^2
Menemukan Struktur Polinomial
Berikut adalah polinomial dalam dua variabel. In[1]:= t = (1 + x)^3 (1 - y - x)^2

Out[1]= (1 + x)^3 (1 − x – y)^2
Operasi Struktural pada Ekspresi Rasional
Untuk polinomial biasa, Faktor dan Memperluas memberikan bentuk yang paling penting. Untuk ekspresi rasional,
ada banyak bentuk berbeda yang dapat berguna.
Berikut adalah ekspresi rasional.

Ini menghindari memperluas istilah yang tidak mengandung z.
Berikut adalah ekspresi rasional.
Dalam istilah matematika, Apart menguraikan ekspresi rasional menjadi "pecahan parsial".
Dalam ekspresi dengan beberapa variabel, Anda dapat menggunakan Apart[expr, var] untuk melakukan
dekomposisi fraksi parsial sehubungan dengan variabel yang berbeda.
Berikut adalah ekspresi rasional dalam dua variabel.
Operasi Aljabar pada Polinomial
Untuk berbagai jenis perhitungan praktis, satu-satunya operasi yang perlu Anda lakukan pada polinomial pada
dasarnya adalah yang struktural yang dibahas di bagian sebelumnya.
Namun, jika Anda melakukan aljabar yang lebih maju dengan polinomial, Anda harus menggunakan operasi aljabar
yang dibahas di bagian ini.
Anda harus menyadari bahwa sebagian besar operasi yang dibahas dalam bagian ini hanya bekerja pada polinomial
biasa, dengan eksponen integer dan koefisien bilangan rasional untuk setiap istilah.
PolynomialMod pada dasarnya adalah analog untuk polinomial dari fungsi Mod untuk bilangan bulat. Ketika
modulus m adalah bilangan bulat, PolynomialMod [poly, m] hanya mengurangi setiap koefisien dalam modulo
poli bilangan bulat
m. Jika m adalah polinomial, maka PolynomialMod [poly, m] secara efektif mencoba untuk mendapatkan tingkat
serendah polinomial mungkin dengan mengurangi dari poli yang sesuai kelipatan q m. Pengganda q itu sendiri bisa
menjadi polinomial, tetapi derajatnya selalu kurang dari tingkat poli. PolynomialMod menghasilkan polinomial
akhir yang derajat dan koefisien terkemuka keduanya sekecil mungkin.
Ini mengurangi x2 modulo x + 1 . Hasilnya hanyalah sisa dari membagi polinomial.
In[6]:= PolynomialMod[x^2, x+1] Out[6]= 1

Perbedaan utama antara PolynomialMod dan PolynomialRemainder adalah bahwa sementara yang pertama bekerja
hanya dengan mengalikan dan mengurangi polinomial, yang terakhir menggunakan pembagian dalam mendapatkan
hasilnya. Selain itu, PolynomialMod memungkinkan pengurangan dengan beberapa moduli pada saat yang sama.
Kasus yang khas adalah modulo reduksi baik polinomial dan
integer.
Ini mengurangi polinomial x2 + 1 modulo baik x + 1 dan 2. In[8]:= PolynomialMod[x^2 + 1, {x + 1, 2}] Out[8]=
0
Fungsi Resultant [poly 1, poly2, x] digunakan dalam sejumlah algoritma aljabar klasik. Hasil dari dua polinomial a
dan b, keduanya dengan koefisien utama satu, diberikan oleh produk dari semua perbedaan ai - bj antara akar
polinomial. Ternyata untuk setiap pasang polinomial, yang dihasilkan selalu polinomial dalam koefisien mereka.
Dengan melihat kapan hasilnya nol, seseorang dapat mengetahui nilai parameter apa yang dimiliki dua polinomial
memiliki akar yang sama. Dua nomial poli dengan koefisien utama satu memiliki k akar umum jika tepat elemen k
pertama dalam daftar Subresultants [poly1, poly2, x] adalah nol.
Berikut adalah hasil sehubungan dengan y dari dua polinomial dalam x dan y. Polinomial asli memiliki akar umum
dalam y hanya untuk nilai-nilai x di mana yang dihasilkan menghilang.
In[9]:= Resultant[(x-y)^2-2, y^2-3, y] Out[9]= 1 − 10 x2 + x4

Basis Gröbner muncul di banyak algoritma dan aplikasi aljabar modern. Fungsi Groebnerg Basis[8 poly1, poly2,
... < , 8 x1 , x2 , ... <] mengambil satu set polinomial, dan mengurangi set ini ke bentuk kanonik dari mana
banyak sifat mudah dapat disimpulkan. Fitur penting adalah bahwa set polinomial yang diperoleh dari
GroebnerBasis selalu memiliki koleksi akar umum yang persis sama dengan set aslinya.
(x + y)^2 secara efektif berlebihan, dan karenanya tidak muncul dalam basis In[10]:= GroebnerBasis[{(x+y),
(x+y)^2}, {x, y}]
Out[10]= {8x + y}
Faktor, FactorTerms dan FactorSquareFree melakukan berbagai tingkat anjak pikun pada polinomial. Faktor
melakukan anjak penuh atas bilangan bulat. FactorTerms mengekstrak "konten" polinomial. FactorSquareg Free
mengeluarkan beberapa faktor yang muncul.
Berikut adalah polinomial, dalam bentuk yang diperluas In[14]:= t = Expand[ 2 (1 + x)^2 (2 + x) (3 + x) ] Out[14]=
12 + 34 x + 34 x^2 + 14 x^3 + 2 x^4
Terutama ketika Anda menulis program yang bekerja dengan polinomial, Anda akan sering merasa nyaman untuk
memilih potongan polinomial dalam bentuk standar. Fungsi FactorList memberikan daftar semua faktor polinomial,
bersama dengan eksponen mereka. Elemen pertama dari daftar selalu merupakan faktor numerik keseluruhan untuk
polinomial.
Bentuk yang dikembalikan FactorList adalah analog untuk polinomial dari bentuk yang dihasilkan oleh
FactorInteger untuk bilangan bulat.
Berikut adalah daftar faktor-faktor polinomial dalam serangkaian contoh sebelumnya. Setiap elemen dari daftar
memberikan faktor, bersama dengan eksponennya.
In[18]:= FactorList[t]
Out[18]= {{2, 1}, {1 + x, 2}, {2 + x, 1}, {3 + x, 1}}
Faktor dan fungsi terkait biasanya hanya menangani polinomial dengan integer biasa atau bilangan rasional
coefficients. Jika Anda mengatur opsi GaussianIntegers -> True, bagaimanapun, maka Faktor akan memungkinkan
polinomial dengan coeffi-cientsyang merupakan bilangan kompleks dengan bagian nyata dan imajiner rasional. Hal
ini sering memungkinkan anjakalisasi yang lebih luas untuk dilakukan.
Polinomial ini tidak dapat direduksi ketika hanya bilangan bulat biasa yang diizinkan.
In[19]:= Faktor[1 + x^2] Out[19]= 1+x2
Polinomial siklonik muncul sebagai "polinomial dasar" dalam berbagai algoritma aljabar. Polinomi-als siktomik
didefinisikan oleh Cn (x) = ℿk (x - e^2nikln), di mana k berjalan di atas semua bilangan bulat positif kurang dari n
yang relatif prima terhadap n.
This is the cyclotomic polynomial C6 (x). In[21]:= Cyclotomic[6, x]

Out[21]= 1 − x + x2
Faktorisasi adalah salah satu cara penting untuk memecah polinomial menjadi bagian yang lebih sederhana. Cara
lain, sangat berbeda, adalah dekomposisi. Ketika salah satu faktor polinomial P (x), seseorang menulisnya sebagai
produk p1 (x) p2 (x) ... dari polinomials pi (x) . Dekolonisasi Q (x) polinomial terdiri dari menulisnya sebagai
komposisi polinomial dari bentuk q1 (q2 ( . (x)... )) .
Berikut adalah contoh sederhana dari Decompose. Polinomial asli x^4 + x^2 + 1 dapat ditulis sebagai polinomial
x^2 + x + 1, dimana x adalah polynomial x^2 In[23]:= Decompose[x^4 + x^2 + 1, x]
Out[23]= {1 + x + x^2, x^2}
Polinomial Modulo Primes
Mathematica dapat bekerja dengan polinomial yang koefisiennya berada di bidang terbatas Zp bilangan bulat
modulo p utama p.
Berikut adalah polinomial biasa. In[1]:= Expand[ (1 + x)^6 ]
Out[1]= 1 + 6 x + 15 x^2 + 20 x^3 + 15 x^4 + 6 x^5 + x^6
Topik Lanjutan: Polinomial atas Bidang Nomor Aljabar
Fungsi seperti Faktor biasanya mengasumsikan bahwa semua koefisien dalam polinomial yang mereka hasilkan
harus hanya melibatkan bilangan rasional. Tetapi dengan menetapkan opsi Ekstensi Anda dapat memperluas domain
coefficients yang akan diizinkan.
Hanya memungkinkan koefisien bilangan rasional, polinomial ini tidak dapat diperhitungkan.
In[1]:= Factor[1 + x^4] Out[1]= 1 + x^4
Ekspresi Trigonometri
Ini memperluas ekspresi trigonometri
.In[1]:= TrigExpand[Sin[2 x] Cos[2 y]]
Out[1]= 2 Cos[x] Cos[y]^2 Sin[x] − 2 Cos[x] Sin[x] Sin[y]^2
TrigToExp menulis fungsi trigonometri dalam hal eksponensial
Ekspresi yang Melibatkan Variabel Kompleks

Mathematica biasanya tidak memperhatikan apakah variabel seperti x berdiri untuk bilangan real atau kompleks.
Kadang-kadang, bagaimanapun, Anda mungkin ingin membuat transformasi yang sesuai hanya jika variabel tertentu
diasumsikan baik nyata atau kompleks.
Fungsi ComplexExpand memperluas ekspresi aljabar dan trigonometri, membuat asumsi yang pasti tentang variabel
yang muncul.
Ini memperluas ekspresi, dengan asumsi bahwa x dan y keduanya nyata.
Ada beberapa cara untuk menulis variabel z yang kompleks dalam hal parameter nyata. Seperti di atas, misalnya, z
dapat ditulis dalam "bentuk Cartesian" Re [z]
+ I Im [z]. Tapi itu sama-sama dapat ditulis dengan baik dalam "bentuk polar" Abs[z]
Exp[I Arg[z].
Opsi TargetFunctions di ComplexExpand memungkinkan Anda untuk menentukan bagaimana variabel kompleks
harus ditulis. TargetFunctions dapat diatur ke daftar fungsi dari set {Re, Im, Abs, Arg, Conjugate, Sign} .
ComplexExpand akan mencoba memberikan hasil dalam hal fungsi apa pun yang Anda minta. Default biasanya
untuk memberikan hasil dalam hal Re dan Im.
Ini memberikan ekspansi dalam bentuk Cartesian.

In[4]:= ComplexExpand[Re[z^2], {z}] Out[4]= −Im[z]^2 + Re[z]^2
Penyederhanaan
Mathematica tidak secara otomatis menyederhanakan ekspresi aljabar seperti ini.

Berikut adalah ekspresi yang melibatkan fungsi trigonometri dan akar kuadrat.
Dalam menyederhanakan dan FullSimplify selalu ada masalah dari apa yang dianggap sebagai bentuk
"paling sederhana" dari ekspresi. Anda dapat
menggunakan opsi ComplexityFunction -> c untuk menyediakan fungsi untuk menentukan hal ini. Fungsi ini akan
diterapkan pada setiap bentuk kandidat dari ekspresi, dan salah satu yang memberikan nilai numerik terkecil akan
dianggap paling sederhana.
Dengan definisi kesederhanaan defaultnya, Simplify meninggalkan ini tidak berubah.
In[9]:= Simplify[4 Log[10]] Out[9]= 4 Log[10]

Menggunakan Asumsi
Mathematica biasanya membuat asumsi sesedikit mungkin tentang objek yang Anda minta untuk dimanipulasi. Ini
berarti bahwa hasil yang diberikannya se- umum mungkin. Tetapi kadang-kadang hasil ini jauh lebih rumit daripada
jika lebih banyak asumsi dibuat.
Sederhanakan secara default pada dasarnya tidak melakukan apa-apa dengan ekspresi ini.
Dengan menerapkan Sederhanakan dan Penyederhanaan Penuh dengan asumsi yang tepat untuk persamaan dan
ketidaksetaraan Anda dapat pada dasarnya menetapkan berbagai teorema.
Tanpa membuat asumsi tentang x kebenaran atau kepalsuan persamaan ini tidak dapat ditentukan.
In[6]:= Simplify[Abs[x] == x] Out[6]= x = Abs[x]
Sederhanakan dan Perkuat selalu mencoba menemukan bentuk ekspresi yang paling sederhana. Kadang-kadang,
bagaimanapun, Anda mungkin hanya ingin Mathematica mengikuti proses evaluasi biasa, tetapi dengan asumsi
tertentu dibuat. Anda dapat melakukan ini dengan menggunakan Refine. Cara kerjanya adalah bahwa Refine[expr,
assum] melakukan transformasi yang sama seperti Mathematica akan melakukan secara otomatis jika variabel
dalam expr digantikan oleh ekspresi numerik yang memuaskan asumsi assum.
Tidak ada bentuk sederhana yang dapat ditemukan oleh In[10]:= Simplify[Log[x], x < 0]
Out[10]= Log[x]
Kelas asumsi yang penting adalah yang menyatakan bahwa beberapa objek adalahe lemen dari domain tertentu.
Anda dapat mengatur asumsi tersebut menggunakan x dom,di mana "karakter dapat dimasukkan sebagai :eld:
atau \[Element].
Ini menegaskan bahwa pi adalah elemen dari domain bilangan real. In[12]:= Pi Reals
Out[12]= True
Jika n diasumsikan sebagai bilangan bulat, sin (n pi) adalah nol. In[17]:= Simplify[Sin[n Pi], n Integers]
Out[17]= 0
Dalam sesuatu seperti Simplify [expr, assum] atau Refine[expr, assum] Anda secara eksplisit memberikan asumsi
yang ingin Anda gunakan. Tetapi terkadang Anda mungkin ingin menentukan satu set asumsi untuk digunakan
dalam seluruh koleksi operasi. Anda dapat melakukan ini dengan menggunakan Asumsi.
Ini memberitahu Simplify untuk menggunakan asumsi default x > 0. In[26]:= Assuming[x > 0, Simplify[Sqrt[x^2]]]
Out[26]= x
Fungsi seperti Sederhanakan dan Perbaiki mengambil opsi Asumsi,yang menentukan asumsi default apa yang harus
mereka gunakan. Secara default, pengaturan untuk opsi ini adalah Asumsi: > $Assumptions. Cara Asumsi kemudian
bekerja adalah untuk menetapkan nilai lokal untuk $Assumptions,seperti di Blok.
Selain Menyederhanakan dan Memperbaiki,sejumlah fungsi lain mengambil opsi Asumsi, dan dengan demikian
dapat memiliki asumsi yang ditentukan untuk mereka dengan Mengasumsikan. Contohnya adalah FunctionExpand,
Integrate, Limit, Laplaceg Transform.
Asumsi ini secara otomatis digunakan dalam Integrasi.
Memanipulasi Persamaan dan Ketidaksetaraan
Representasi Persamaan dan Solusi

Anda dapat memanipulasi persamaan simbolis dalam Mathematica dalam banyak cara. Salah satu tujuan umum
adalah untuk mengatur ulang persamaan sehingga dapat "memecahkan" untuk satu set variabel tertentu.
Berikut adalah persamaan symbolic. In[1]:= x^2 + 3x == 2

Out[1]= 3 x + x^2 = 2
Anda dapat menggunakan fungsi Kurangi untuk mengurangi persamaan sehingga memberikan "solusi" untuk x.
Hasilnya, seperti persamaan asli, dapat dilihat sebagai pernyataan logis.
Persamaan kuadrat x ^ 2 + 3x == 2 dapat dianggap sebagai pernyataan implisit tentang nilai x. Seperti yang
ditunjukkan pada contoh di atas, Anda dapat menggunakan fungsi Kurangi untuk mendapatkan pernyataan yang
lebih eksplisit tentang nilai x. Ekspresi yang dihasilkan oleh Reduce memiliki bentuk x == r 1
|| x == r2 . Ekspresi ini sekali lagi merupakan pernyataan logis, yang menegaskan bahwa x sama dengan r 1, atau x
sama dengan r2. Nilai-nilai x yang konsisten dengan pernyataan ini persis sama dengan yang konsisten dengan
persamaan kuadrat asli. Namun, untuk banyak tujuan, bentuk yang diberikan Reduce jauh lebih berguna daripada
persamaan aslinya.
Anda dapat menggabungkan dan memanipulasi persamaan seperti pernyataan logis lainnya. Anda dapat
menggunakan koneksi logis seperti || dan untuk menentukan kondisi alternatif atau simultan. Anda dapat
menggunakan fungsi seperti LogicalExpand,serta FullSimplify,untuk menyederhanakan koleksi persamaan.
Untuk banyak tujuan, Anda akan merasa nyaman untuk memanipulasi persamaan hanya sebagai pernyataan logis.
Kadang-kadang, bagaimanapun, Anda benar-benar akan ingin menggunakan solusi eksplisit untuk persamaan dalam
perhitungan lain.
Dalam kasus seperti itu, adalah conve-nient untuk mengubah persamaan yang dinyatakan dalam bentuk lhs == rhs
menjadi aturan transformasi dari bentuk lhs
-> rhs. Setelah Anda memiliki solusi untuk persamaan dalam bentuk aturan transformasi eksplisit, Anda dapat
mengganti solusi menjadi ekspresi dengan menggunakan / . Operator.
Reduce menghasilkan pernyataan logis tentang nilai-nilai x yang sesuai dengan akar persamaan kuadratratic.
Persamaan dalam Satu Variabel
Persamaan utama yang memecahkan dan fungsi Mathematica terkait berurusan dengan adalah persamaan
polinomial.
Sangat mudah untuk memecahkan persamaan linear dalam x.
Untuk persamaan kubik dan quartic hasilnya sering rumit, tetapi untuk semua persamaan dengan derajat hingga
empat Mathe-matica selalu mampu memberikan rumus eksplisit untuk solusi.
Fitur penting dari rumus-rumus ini adalah bahwa mereka hanya melibatkan radikal:kombinasi aritmatika akar
kuadrat, akar kubus dan akar yang lebih tinggi.
Ini adalah fakta matematika mendasar, bagaimanapun, bahwa untuk persamaan derajat lima atau lebih tinggi, tidak
mungkin lagi secara umum untuk memberikan rumus eksplisit untuk solusi dalam hal radikal.
Ada beberapa persamaan spesifik yang ini masih possible, tetapi dalam sebagian besar kasus itu tidak.
Ini membangun polinomial tingkat enam

In[4]:= Expand[ Product[x^2 - 2 i, {i, 3}] ] Out[4]= −48 + 44 x2 − 12 x4 + x6
Polinomial tidak memperhitungkan, tetapi dapat terurai menjadi polinomial bersarang, sehingga Solve dapat
kembali menemukan rumus eksplisit untuk akar.
Tidak ada rumus eksplisit untuk solusi untuk persamaan ini dapat diberikan dalam hal radikal, sehingga
Mathematica menggunakan representasi simbolis implisit.
Objek akar memberikan representasi yang tepat, meskipun implisit, untuk akar polinomial. Anda dapat bekerja
dengan mereka sebanyak Anda akan bekerja dengan Sqrt [2] atau ekspresi lain yang mewakili kuantitas numerik
yang tepat.
Berikut adalah objek Root yang mewakili akar pertama polinomial yang dibahas di atas.
In[11]:= r = Root[#^5 - # + 11 &, 1] Out[11]= Root[11 − #1 + #15 &, 1]

Jika satu-satunya parameter simbolis yang ada dalam persamaan adalah variabel yang Anda pecahkan, maka semua
solusi untuk persamaan hanya akan menjadi angka. Tetapi jika ada parameter simbolis lainnya dalam persamaan,
maka solusi biasanya akan menjadi fungsi dari parameter ini.
Solusi untuk persamaan ini dapat kembali diwakili oleh objek Root, tetapi sekarang setiap objek Root melibatkan
parameter a
Ini menunjukkan perilaku akar pertama sebagai fungsi dari a

Persamaan polinomial dalam satu variabel hanya pernah memiliki jumlah solusi yang terbatas. Tetapi persamaan
transendental often memiliki angka yang tak terbatas. Biasanya alasan untuk ini adalah bahwa fungsi-fungsi seperti
Dosa yang berlaku memiliki banyak kemungkinan invers. Dengan pengaturan opsi default InverseFunctions->True,
Solve akan tetap berasumsi bahwa ada invers yang pasti untuk fungsi tersebut. Solve kemudian dapat
mengembalikan solusi tertentu dalam hal fungsi terbalik ini.
Mathematica mengembalikan solusi tertentu dalam hal ArcSin, tetapi mencetak peringatan yang menunjukkan
bahwa solusi lain hilang
In[28]:= Solve[Sin[x] == a, x]
Solve::ifun : Inverse functions are being used by Solve, so some solutions may not be found; use Reduce for
complete solution information.
Out[28]= {{x → ArcSin[a]}}
Jika Anda meminta Solve untuk memecahkan persamaan yang melibatkan fungsi sewenang-wenang seperti f,secara
default akan mencoba untuk membangun solusi formal dalam hal fungsi terbalik.
Solve secara default menggunakan formal inverse untuk fungsi f. In[30]:= Solve[f[x] == a, x]
InverseFunction::ifun :
Inverse functions are being used. Values may be lost for multivalued inverses. Out[30]= {{x →
f{−1}[a]}} Ini adalah struktur fungsi terbalik In[31]:= InputForm[%] Out[31]//InputForm= {{x ->
InverseFunction[f, 1, 1][a]}}
Ini mengembalikan fungsi invers eksplisit.

In[32]:= InverseFunction[Tan] Out[32]= ArcTan
Mathematica dapat melakukan operasi formal pada fungsi
Sementara Solve hanya dapat memberikan solusi spesifik untuk persamaan, Kurangi dapat memberikan representasi
dari seluruh set solusi. Untuk persamaan transendental, sering berakhir memperkenalkan parameter baru, katakanlah
dengan nilai-nilai yang berkisar di semuabilangan bulat possi-ble.
Ini adalah representasi lengkap dari set solusi.
Seperti yang dibahas lebih panjang di Bagian 3.4.9, Kurangi memungkinkan Anda untuk membatasi domain
variabel. Kadang-kadang ini akan memungkinkan Anda menghasilkan solusi yang pasti untuk persamaan
transendental - atau menunjukkan bahwa mereka tidak ada.
Dengan domain x terbatas, ini menghasilkan solusi yang pasti.
Topik Lanjutan: Nomor Aljabar
Ketika Anda memasukkan objek Root, polinomial yang muncul di dalamnya secara otomatis dikurangi menjadi
bentuk minimal
In[1]:= Root[24 - 2 # + 4 #^5 &, 1] Out[1]= Root[12 − #1 + 2 #15 &, 1]
Objek akar adalah cara Mathematica mewakili bilangan aljabar. Nomor aljabar memiliki properti yang ketika Anda
melakukan operasi aljabar pada mereka, Anda selalu mendapatkan nomor aljabar tunggal sebagai hasilnya.
Berikut adalah akar kuadrat dari bilangan aljabar.

Dalam kasus sederhana ini objek Root secara otomatis dinyatakan dalam hal radikal
Jika Solve dan ToRadicals tidak berhasil mengekspresikan solusi untuk persamaan polinomial tertentu dalam hal
radikal, maka itu adalah tebakan yang baik bahwa ini pada dasarnya tidak dapat dilakukan. Namun, Anda harus
menyadari bahwa ada beberapa kasus khusus di mana pengurangan radikal pada prinsipnya mungkin, tetapi
Mathematica tidak dapat menemukannya. Contoh sim-plest adalah persamaan x5 + 20 x + 32 = 0, tetapi di sini
solusi dalam hal radikal sangat rumit. The equation x6 - 9 x4 - 4 x3 + 27 x2 - 36 x - 23 is another example, where now
x = 21/3+31/2 is a solution.
Ini memberikan objek Root yang melibatkan polinomial tingkat enam In[10]:= RootReduce[2^(1/3) + Sqrt[3]]
Out[10]= Root[−23 − 36 #1 + 27 #12 − 4 #13 − 9 #14 + #16 &, 2]
Di luar derajat empat, sebagian besar polinomial tidak memiliki akar yang dapat diekspresikan sama sekali dalam
hal radikal. Namun, untuk derajat lima ternyata akar selalu dapat dinyatakan dalam hal fungsi elips atau
hipergeometrik. Hasilnya, bagaimanapun, biasanya terlalu rumit untuk berguna dalam praktik.
Ini menghitung jumlah timbal balik dari akar 1 + 2 x + x5 In[12]:= RootSum[(1 + 2 # + #^5)&, (1/#)&]
Out[12]= −2
Persamaan Simultan
Anda dapat memberikan Memecahkan daftar persamaan simultan untuk dipecahkan. Solve dapat menemukan solusi
eksplisit untuk kelas besar persamaan polinomial simultan.
Berikut adalah persamaan linear sederhana dengan dua yang tidak diketahui.
Jika Anda membangun persamaan simultan dari matriks, Anda biasanya mendapatkan persamaan antara daftar
ekspresi.
In[9]:= {{3,1},{2,-5}}.{x,y}=={7,8} Out[9]= {3 x + y, 2 x − 5 y} = {7, 8}

Solusi Generik dan Non-Generik
Jika Anda memiliki persamaan seperti 2 x == 0,sangat jelas bahwa satu-satunya solusi yang mungkin adalah x -> 0.
Namun, jika Anda memiliki persamaan seperti x == 0,semuanya tidak begitujelas. Jika a tidak sama dengan nol,
maka x -> 0 sekali lagi adalah satu-satunya solusi. Namun, jika a sebenarnya sama dengan nol, maka nilai x adalah
solusi. Anda dapat melihat ini dengan menggunakan Reduce.
Solve secara implisit mengasumsikan bahwa parameter a tidak memiliki nilai khusus 0
In[1]:= Solve[ a x == 0 , x ] Out[1]= {{8x → 0}}

Perbedaan mendasar antara Reduce and Solve adalah bahwa Reduce memberikan semua solusi yang mungkin untuk
satu set persamaan, sementara Solve hanya memberikan yang generik. Solusi dianggap "generik" jika mereka
melibatkan kondisi hanya pada variabel yang Anda pecahkan secara eksplisit, dan bukan pada parameter lain dalam
persamaan. Kurangi dan Pecahkan juga berbeda karena Mengurangi selalu mengembalikan kombinasi persamaans,
sementara Solve memberikan hasil dalam bentuk aturan transformasi.
Ini adalah solusi untuk persamaan linear sewenang-wenang yang diberikan oleh Solve.
Menghilangkan Variabel
Ketika Anda menuliskan satu set persamaan simultan dalam Mathematica,Anda menentukan kumpulan kendala
antara variabel. Ketika Anda menggunakan Solve,Anda menemukan nilai untuk beberapa variabel dalam hal yang
lain, tunduk pada kendala yang diwakili oleh persamaan.
Berikut adalah dua persamaan yang melibatkan x, y dan "parameter" a dan b.
Dalam berurusan dengan set persamaan, adalah umum untuk mempertimbangkan beberapa objek yang muncul
sebagai "variabel" sejati, dan yang lainnya sebagai "parameter". Dalam beberapa kasus, Anda mungkin perlu tahu
untuk apa nilai parameter hubungan tertentu antara variabel selalu puas.
Ini menemukan nilai parameter yang membuat persamaan bertahan untuk semua x In[9]:= SolveAlways[a + b x + c
x^2 == (1 + x)^2, x]
Out[9]= {{a → 1, b → 2, c → 1}}
Memecahkan Kombinasi Persamaan Logis
Ketika Anda memberikan daftar persamaan untuk Dipecahkan,itu mengasumsikan bahwa Anda ingin semua
persamaan terpenuhi secara bersamaan. Hal ini juga
memungkinkan untuk memberikan Solve kombinasi logis yang lebih rumit dari persamaan.
Solve mengasumsikan bahwa persamaan x + y == 1 dan x - y == 2 secara bersamaan valid
Ketika Anda menggunakan Solve,hasil akhir yang Anda dapatkan adalah dalam bentuk aturan transformasi. Jika
Anda menggunakan Reduce atau Elimig nate,di sisilain, maka hasil Anda adalah pernyataan logis, yang dapat Anda
manipulasi lebih lanjut.
In[7]:= Reduce[x^2 == x, x] Out[7]= x = 0 | | x = 1

Pernyataan logis yang dihasilkan oleh Reduce dapat dianggap sebagai representasi dari solusi yang ditetapkan untuk
ion equatAnda. Penghubung logis &&|| dan seterusnya kemudian sesuai dengan operasi pada set ini.
Anda mungkin sering merasa nyaman untuk menggunakan notasi khusus untuk penghubung logis, seperti yang
dibahas dalam Bagian 3.10.4.
Input menggunakan notasi khusus untuk Implies dan Or. In[9]:= Reduce[x^2 == 1 ⇒ (x == 1 fi x == -1), x] Out[9]=
True
Ketidaksetaraan
Sama seperti persamaan x ^ 2 + 3x == 2 menegaskan bahwa x ^ 2 + 3x sama dengan 2, demikianjuga
ketidaksetaraan x ^ 2 + 3x > 2 menegaskan bahwa x
^ 2 + 3x lebih besar dari 2. Dalam Mathematica, kurangi karya tidak hanya pada persamaan, tetapi juga pada
ketidaksetaraan.
Pasangan ketidaksetaraan ini berkurang menjadi satu ketidaksetaraan. In[1]:= Reduce[{0 < x < 2, 1 < x < 4}, x]
Out[1]= 1 < x < 2
Jika Anda memiliki ketidaksetaraan yang melibatkan <= serta <,mungkin ada titik- titik terisolasi di mana
ketidaksetaraan dapat dikusp. Mengurangi mewakili poin- poin tersebut dengan memberikan persamaan.
Ketidaksetaraan ini dapat dipenuhi hanya pada dua titik yang terisolasi.
Untuk ketidaksetaraan yang melibatkan beberapa variabel, Kurangi hasil bersarangk oleksi spesifikasi interval, di
mana variabel kemudian memiliki batas yang tergantung pada variabel sebelumnya.
Ini mewakili disk unit sebagai ketidaksetaraan bersarang untuk x dan y.
Dalam istilah geometris, setiap ketidaksetaraan linier membagi ruang menjadi dua bagian. Daftar ketidaksetaraan
linier sehingga mendefinisikan polyhe-dra, kadang-
kadang dibatasi, kadang-kadang tidak. Reduce mewakili polihedra tersebut dalam hal ketidaksetaraan bersarang.
Sudut-sudutpolihedra selalu muncul di antara titik akhir ketidaksetaraan ini.
Kurangi upaya untuk memberi Anda deskripsi lengkap tentang wilayah yang ditentukan oleh serangkaian
ketidaksetaraan. Kadang-kadang, bagaimanapun, Anda mungkin hanya ingin menemukan contoh individu nilai-nilai
variabel yang memenuhi ketidaksetaraan. Anda dapat melakukan ini menggunakan FindInstance.
Ini menemukan contoh spesifik yang memenuhi ketidaksetaraan

Ini menunjukkan bahwa tidak ada cara untuk memuaskan ketidaksetaraan. In[23]:= FindInstance[{Sin[x y] > 1/2,
x^2 + y^2 < 1/4}, {x, y}] Out[23]= {}
FindInstance dalam beberapa hal adalah analog untuk ketidaksetaraan Solve untuk persamaan. Untuk seperti Solve,ia
mengembalikan daftar aturan yang memberikan nilai tertentu untuk variabel. Tetapi sementara untuk persamaan nilai-
nilai ini secara umum dapat memberikan representasi yang akurat dari semua solusi, untuk ketidaksetaraan mereka
hanya dapat sesuai dengan titik sampel terisolasi di wilayah yang dijelaskan oleh ketidaksetaraan.
Setiap kali Anda memanggil FindInstance dengan input tertentu, itu akan memberikan output yang sama. Dan ketika
ada contoh yang sesuai dengan poin khusus, membatasi, dari beberapa jenis, itu akan secara istimewa mengembalikan
ini. Tetapi secara umum, distribu-tion kasus yang dikembalikan oleh FindInstance biasanya akan tampak agak acak.
Setiap contoh, bagaimanapun, pada dasarnya
adalah bukti konstruktif bahwa ketidaksetaraan yang Anda berikan sebenarnya dapat dipenuhi.
Jika Anda meminta satu titik di disk unit, FindInstance memberikan asal. In[24]:= FindInstance[x^2 + y^2 <= 1, {x,
y}]
Out[24]= {{x → 0, y → 0}}
Ini menemukan 500 titik di disk unit
In[25]:= FindInstance[x^2 + y^2 <= 1, {x, y}, 500]; In[26]:= ListPlot[{x, y} /. %, AspectRatio->Automatic]
Persamaan dan Ketidaksetaraan atas Domain
Mathematica biasanya mengasumsikan bahwa variabel yang muncul dalam persamaan dapat berdiri untuk bilangan
kompleks sewenang-wenang.Tetapi ketika Anda menggunakan Reduce, Anda dapat secara eksplisit memberi tahu
Mathematica bahwa variabel tersebut berarti objek di domain yang lebih terbatas.
Kurangi secara default mengasumsikan bahwa x bisa rumit, dan memberikan kelima solusi kompleks.
Persamaan polinomial tunggal dalam satu variabel akan selalu memiliki satu set terbatas solusi diskrit. Dan dalam
kasus seperti itu orang dapat memikirkan Reduce[eqns, vars, dom] hanya sebagai penyaringan solusi dengan
memilih yang kebetulan terletak di domain dom.
Tetapi begitu ada lebih banyak variabel, hal-hal dapat menjadi lebih rumit, dengan solusi untuk persamaan sesuai
dengan kurva parametrik atau permukaan dalam which nilai beberapa variabel dapat bergantung padanilai-nilai
orang lain. Seringkali ketergantungan ini dapat dijelaskan oleh beberapa koleksi persamaan atau ketidaksetaraan,
tetapi bentuk ini dapat berubah secara signifikan ketika seseorang beralih dari satu domain ke domain lainnya.
Ini memberikan solusi atas bilangan kompleks sebagai rumus sederhana.
Jika input Anda hanya melibatkan persamaan, maka Kurangi secara default akan berasumsi bahwa semua variabel
itu rumit. Tetapi jika input Anda melibatkan ketidaksetaraan, maka Kurangi akan berasumsi bahwa setiap variabel
aljabar yang muncul di dalamnya adalah nyata, karena inequalities hanya dapat membandingkan jumlah nyata.
Karena variabel muncul dalam ketidaksetaraan, mereka dianggap nyata.
Untuk sistem polinomial atas domain nyata dan kompleks, solusi selalu terdiri dari sejumlah compo-nents yang
terbatas, di mana nilai-nilai variabel diberikan oleh angka atau fungsi aljabar.
Di sini komponen dibedakan oleh persamaan dan inequations pada x.
Dan di sini komponen dibedakan oleh ketidaksetaraan pada x.

Sementara pada prinsipnya Reduce selalu dapat menemukan solusi lengkap untuk setiap koleksi persamaan
polinomial dan ketidaksetaraan dengan variabel nyata atau kompleks, hasilnya seringkali sangat rumit, dengan
jumlah komponen biasanya tumbuh secara eksponensial karena jumlah variabel meningkat.
Dengan 3 variabel, solusinya di sini sudah melibatkan 8 komponen.
Begitu seseorang memperkenalkan fungsi seperti Sin atau Exp,bahkan persamaan dalam variabel nyata atau
kompleks tunggal dapat memiliki solusi dengan jumlah komponen yang tak terbatas. Kurangi label komponen ini
dengan memperkenalkan parame-ters tambahan. Secara default, parameter nth dalam solusi yang diberikan akan
diberi nama C[n] . Secara umum Anda dapat menentukan bahwa itu harus diberi nama f[n] dengan memberikan
pengaturan opsi GeneratedParameters -> f.
Komponen di sini diberi label oleh parameter integer c1.
In[11]:= Reduce[Exp[x] == 2, x, GeneratedParameters -> (Subscript[c, #]&)]

Out[11]= c1 Integers && x = Log[2] + 2i π c1
Mengurangi dapat memecahkan sistem persamaan linier atau ketidaksetaraan atas bilangan bulat. Dengan persamaan
linear m dalam variabel n, parameter n - m biasanya perlu diperkenalkan. Tetapi dengan ketidaksetaraan, jumlah
parameter yang jauh lebih besar mungkin dibutuhkan.
Tiga parameter diperlukan di sini, meskipun hanya ada dua variabel.
Dengan dua variabel, Reduce dapat memecahkan persamaan kuadrat atas bilangan bulat. Hasilnya bisa berupa
urutan seperti Fibonacci, diwakili dalam hal kekuatan irasional kuadrat.
Berikut adalah solusi untuk persamaan Pell.
Mengubah sisi kanan menjadi 3,persamaan sekarang tidak memiliki solusi. In[19]:= Reduce[x^3 - 4 x y^2 + y^3 ==
3, {x, y}, Integers]
Out[19]= False
Persamaan atas bilangan bulat kadang-kadang memiliki koleksi solusi yang tampaknya cukup acak. Dan bahkan
perubahan kecil dalam persamaan sering dapat menyebabkan mereka tidak memiliki solusi sama sekali.
Untuk persamaan polinomial atas bilangan real dan kompleks, ada prosedur keputusan yang pasti untuk menentukan
apakah ada solusi atau tidak. Tetapi untuk persamaan polinomial di atas bilangan bulat, tidak terpecahkan dari
Masalah kesepuluh Hilbert demonstrates bahwa tidak pernah ada prosedur umum seperti itu
untuk kelas persamaan tertentu, bagaimanapun, prosedur dapat ditemukan, dan memang banyak yang
diimplementasikan dalam Kurangi.
Tetapi menangani kelas persamaan yang berbeda seringkali tampaknya memerlukan berbagai cabang teori bilangan,
dan jenis perhitungan yang sangat berbeda. Dan pada kenyataannya diketahui bahwa ada persamaan polinomial
integer universal, untuk yang mengisi beberapa variabel dapat membuat solusi untuk variabel lain sesuai dengan
output dari program yang benar-benar mungkin. Ini kemudian berarti bahwa untuk persamaan semacam itu tidak
pernah ada solusi bentuk tertutup yang dibangun dari elemen fixed seperti fungsi aljabar.
Jika seseorang menyertakan fungsi seperti Sin,maka bahkan untuk persamaan yang melibatkan bilangan real dan
kompleks, masalah yang sama dapat muncul.
Kurangi di sini secara efektif harus menyelesaikan persamaan di atas bilangan bulat.
Karena hanya ada sejumlah solusi yang mungkin untuk persamaan integer modulo n, Kurangi dapat systemati-cally
menemukannya.
Ini menemukan semua solusi modulo 4
Ini mengasumsikan bahwa x adalah bilangan bulat, tetapi y adalah nyata.
Mengurangi biasanya memperlakukan variabel kompleks sebagai objek tunggal. Tetapi dalam berurusan dengan
fungsi yang tidak analitik atau memiliki pemotongan cabang, kadang-kadang harus memecahnya menjadi pasangan
variabel nyata Re[z] dan Im[z].
Hasilnya melibatkan bagian nyata dan imajiner yang terpisah.

Kurangi selalu mengembalikan representasi lengkap dari solusi untuk sistem persamaan atau ketidaksetaraan.
Kadang-kadang, bagaimanapun, Anda mungkin hanya ingin menemukan solusi sampel tertentu. Anda dapat
melakukan ini menggunakan FindInstance.
Jika FindInstance[expr, vars, dom] kembali {} maka ini berarti bahwa Mathematica telah secara efektif
membuktikan bahwa expr tidak dapat dipenuhi untuk nilai variabel apa pun dalam domain yang ditentukan. Ketika
expr dapat dipenuhi, FindInstance biasanya akan memilih cukup sewenang-wenang di antara nilai-nilai yang
melakukan ini, seperti yang dibahas untuk ketidaksetaraan dalam Bagian 3.4.8.
Khusus untuk persamaan integer, FindInstance sering dapat menemukan solusi khusus untuk persamaan bahkan
Ketika Reduce tidak dapat menemukan solusi
lengkap. Dalam kasus seperti itu biasanya mengembalikan salah satusolusi smallest ke persamaan.
Ini menemukan titik integer terkecil pada kurva elips.
In[29]:= FindInstance[{x^2 == y^3 + 12, x > 0, y > 0}, {x, y}, Integers] Out[29]= {{x → 47, y → 13}} Salah
satu fitur FindInstance adalah bahwa ia juga bekerja dengan ekspresi Boolean yang variabelnya dapat memiliki
nilai True or False. Anda dapat menggunakan FindInstance untuk menentukan apakah ekspresi tertentu dapat
dikenali,sehingga ada beberapa pilihan nilai kebenaran untuk variabelnyayang membuat ekspresi benar.
Ekspresi ini tidak dapat dipenuhi untuk pilihan p dan q. In[30]:= FindInstance[p && ! (p || ! q), {p, q}, Booleans]
Out[30]= {}
Tapi ini bisa.
In[31]:= FindInstance[p && ! (! p || ! q), {p, q}, Booleans] Out[31]= {{p → True, q → True}}
Topik Lanjutan: Representasi Set Solusi
Seseorang dapat memikirkan kombinasi persamaan atau ketidaksetaraan sebagai mendefinisikan suatu wilayah
secara implisit di beberapa jenis ruang. Fungsi dasar dari Reduce adalah untuk mengubah jenis deskripsi implisit ini
menjadi deskripsi eksplisit.
Descr iption implisitdalam hal persamaan atau ketidaksetaraan sudah cukup jika seseorang hanya ingin menguji
apakah titik yang ditentukan oleh nilai variabel ada
di wilayah tersebut. Tetapi untuk memahami struktur wilayah, atau untuk menghasilkan titik-titik di dalamnya,
satuly khasmembutuhkan deskripsi yang lebih eksplisit, dari jenis yang diperoleh dari Reduce.
Berikut adalah ketidaksetaraan yang secara implisit mendefinisikan wilayah setengah lingkaran.
In[1]:= semi = x > 0 && x^2 + y^2 < 1 Out[1]= x > 0 && x2 + y2 < 1
Ini menunjukkan bahwa titik (1/2, ½) terletak In[2]:= semi /. { x -> 1/2, y -> 1/2 }
Out[2]= True
Untuk persamaan polinomial atau ketidaksetaraan atas real, struktur hasil yang dikembalikan oleh Reduce biasanya
merupakan dekomposisi aljabar silinder atau CAD. Terkadang Reduce dapat menghasilkan bentuk yang lebih
sederhana. Tetapi dalam semua kasus Anda mendapatkan CAD lengkap dengan menggunakan
CylindricalDecomposition.
Topik Lanjutan: Quantifiers
Dalam sebuah pernyataan seperti x ^ 4 + x ^ 2 > 0, Mathematica memperlakukan variabel x sebagai memiliki nilai
yang pasti, meskipun tidak ditentukan. Kadang- kadang, bagaimanapun, adalah berguna untuk dapat membuat
pernyataan tentang seluruh koleksi nilai yang mungkin untuk x. Anda dapat melakukan ini dengan menggunakan
quantifiers.
Anda dapat bekerja dengan kuantifikasi dalam Mathematica sama seperti Anda bekerja dengan persamaan,
ketidaksetaraan atau ikat logis. Dalam kebanyakan kasus, kuantifikasi tidak akan segera diubah dengan evaluasi.
Tetapi mereka dapat disederhanakan atau dikurangi dengan fungsi seperti FullSimplify dan Reduce.
Ini menegaskan bahwa x ada yang membuat ketidaksetaraan itu benar. Output di sini hanyalah versi input yang
diformat
In[1]:= Exists[x, x^4 + x^2 > 0] Out[1]= x x2 + x4 > 0

FullSimplify menetapkan bahwa pernyataan itu benar.
In[2]:= FullSimplify[%] Out[2]= True

Ini memberi False,karena ketidaksetaraan gagal ketika x adalah nol. In[3]:= FullSimplify[ForAll[x, x^4 + x^2 > 0]]
Out[3]= False
Mathematica mendukung versi notasi standar untuk kuantifikasi yang digunakan dalam logika predikat dan
matematika murni. Anda dapat memasukkan "sebagai î[ForAll] atau Çfad,dan Anda dapat memasukkan $ sebagai
î[Exists] atau Çexd. Untuk membuat notasi tepat, bagaimanapun, Mathematica membuat variabel kuantitatif
subskrip. Kondisi pada variabel juga dapat diberikan dalam subskrip, dipisahkan oleh koma.
Mengingat pernyataan yang melibatkan kuantifikasi, ada kasus-kasus penting tertentu di mana dimungkinkan untuk
menyelesaikannya menjadi pernyataan yang setara di mana kuantifikasi telah dihilangkan. Agak seperti
memecahkan persamaan, elimination quantifier tersebut mengubah pernyataan implisit tentang apa yang benar
untuk semua x atau untuk beberapa x menjadi pernyataan eksplisit tentang kondisi di mana ini berlaku.
Ini menunjukkan bahwa x ada yang membuat persamaan itu benar. In[4]:= Resolve[Exists[x, x^2 == x^3]]
Out[4]= True
Ini menunjukkan bahwa persamaan hanya dapat dipenuhi jika c mematuhi kondisi tertentu
In[5]:= Resolve[Exists[x, x^2 == c && x^3 == c + 1]] Out[5]= −1 − 2 c − c2 + c3 = 0

Resolve selalu dapat menghilangkan kuantifikasi dari setiap koleksi persamaan polinomial dan inequations atas
bilangan kompleks, dan dari setiap koleksi persamaan polinomial dan ketidaksetaraan atas bilangan real. Hal ini
juga dapat menghilangkan quantifiers dari ekspresi Boolean.
Ini menemukan kondisi untuk bentuk kuadrat atas real menjadi positif.
Ini menunjukkan bahwa ada cara untuk menetapkan nilai-nilai kebenaran ke p dan q yang membuat ekspresi itu
benar.
In[7]:= Resolve[Exists[{p, q}, p || q && ! q], Booleans] Out[7]= True

Minimalisasi dan Maksimalisasi
Minimalkan dan Maksimalkan daftar hasil yang memberikan nilai yang dicapai minimal atau maksimum, bersama
dengan aturan yang menentukan di mana minimum atau maksimum terjadi.
Ini menemukan minimal fungsi kuadrat.

Menerapkan aturan untuk x memberikan nilai minimal.
Ini memaksimalkan sehubungan dengan x dan y.
Berikut adalah fungsi dengan banyak maxima lokal dan minimal
Jika Anda memberikan fungsi yang tidak terbatas, Minimalkan dan Maksimalkan akan kembali -¶ dan +¶ sebagai
minima dan maxima. Dan jika Anda memberikan kendala yang tidak pernah bisa dipenuhi, mereka akan kembali +¶
dan -¶ sebagai minima dan maxima, dan Indeterminate sebagai nilai variabel.
Salah satu masalah halus adalah bahwa Meminimalkan dan Memaksimalkan memungkinkan kedua ketidaksetaraan
non-ketat dari bentuk x < = v,dan yang ketat dari bentuk x < v. Dengan ketidaksetaraan yang tidak ketat tidak ada
masalah dengan minimum atau maksimum berbaring tepat pada batas x -> v. Tetapi dengan ketidaksetaraan yang
ketat, minimum atau maksimum pada prinsipnya harus setidaknya jauh di dalam batas.
Dengan ity inequal yang ketat, Mathematica mencetak peringatan, lalu mengembalikan titik pada batas
.Minimalkan dan Maksimalkan secara normal asumsikan bahwa semua variabel yang Anda berikan adalah nyata.
Tetapi dengan memberikan batasan seperti x "Bilangan bulat Anda dapat menentukan bahwa variabel sebenarnya
harus menjadi bilangan bulat.
Kalkulus
Diferensiasi
Ini memberikan derivatif ketiga
Anda dapat membedakan sehubungan dengan ekspresi apa pun yang tidak melibatkan operasi matematika eksplisit.
In[3]:= D[ x[1]^2 + x[2]^2, x[1] ] Out[3]= 2 x[1]

Total Derivatif
Ketika Anda menemukan turunan dari beberapa ekspresi f sehubungan dengan x, Anda secara efektif mencari tahu
seberapa cepat f berubah saat Anda bervariasi x. Seringkali f akan tergantung tidak hanya pada x, tetapi juga pada
variabel lain, katakanlah y dan z. Hasil yang Anda dapatkan kemudian tergantung pada bagaimana Anda
menganggap bahwa y dan z bervariasi saat Anda mengubah x
.Ada dua kasus umum. Baik y dan z diasumsikan tetap tetap ketika x berubah, atau mereka diizinkan untuk
bervariasi. dengan x. Dalam derivatif parsial standar δf/δx semua variabel selain x diasumsikan tetap. Di sisi lain,
secara total df/dx, semua variabel diperbolehkan untuk berubah dengan x.
Dalam Mathematica, D[f, x] memberikan turunan parsial, dengan semua variabel lain diasumsikan independen dari
x. Dt[f, x] memberikan turunan total, di mana semua variabel diasumsikan bergantung pada x. Dalam kedua kasus,
Anda dapat menambahkan argumen untuk memberikan informasi lebih lanjut tentang dependensi.
Turunan dari Fungsi tidak diketahui
Membedakan fungsi yang diketahui memberikan hasil yang eksplisit
Membedakan fungsi yang tidak diketahui f memberikan hasil dalam In[2]:= D[f[x]^2, x]
Out[2]= 2 f[x] f[x]
Mathematica menerapkan aturan rantai untuk diferensiasi, dan meninggalkan hasilnya dalam hal f '
In[3]:= D[x f[x^2], x]
Out[3]= f[x2] + 2 x2 f’[x2]
Pembedaan kembali memberikan hasil dalam hal f, f 'dan f''. In[4]:= D[%, x] Out[4]=
6 x f’[x2] + 4 x3 f’’[x2]
Topik Lanjutan: Representasi Derivatif
Derivatif dalam Matematika pada dasarnya bekerja sama seperti dalam matematika standar. Notasi matematika yang
biasa, bagaimanapun, sering menyembunyikan banyak detail. Untuk memahami bagaimana derivatif diwakili dalam
Mathematica,kita harus melihat rincian ini.
Dengan fungsi lebih dari satu argumen, notasi sederhana berdasarkan bilangan prima rusak. Anda tidak bisa
mengatakan untuk g’(0,1) stands for untuk hamper semua g, ini akan memiliki benar-benar nilai yang berbeda.
Sekali lagi, bagaimanapun, t hanyalah variabel boneka, yang satu-satunya tujuannya adalah untuk menunjukkan
sehubungan dengan g "slot" mana yang harus dibedakan.
Dalam Mathematica,seperti dalam beberapa cabang matematika, lebih mudah untuk berpikir tentang semacam
diferensiasi yang bertindak berdasarkan fungsi,bukanekspresi. Kita perlu operasi yang mengambil fungsi f, dan
memberi kita fungsi derivative f£. Operasi seperti ini yang bertindak berdasarkan fungsi,bukan variabel, dikenal
dalam matematika sebagai fungsi-als.
Objek f 'dalam Mathematica adalah hasil dari menerapkan diferensiasi fungsional untuk fungsi f. Bentuk lengkap
dari f' sebenarnya adalah Derivatif[1][f]. Derivatif[1] adalah fungsional diferensiasi Mathematica.
Argumen dalam Derivatif fungsional [n1, n2,... Menentukan berapa kali untuk membedakan sehubungan dengan
setiap "slot" dari fungsi di mana ia bertindak. Dengan menggunakan fungsional untuk mewakili diferensiasi,
Mathematica menghindari kebutuhan untuk memperkenalkan "variabel boneka" eksplisit.
Ini adalah bentuk lengkap dari turunan dari fungsi f.
Untuk mendefinisikan turunan fungsi dengan beberapa argumen, Anda harus menggunakan representasi umum
derivatif dalam Mathematica
Ini mendefinisikan turunan kedua dari g sehubungan dengan argumen keduanya.

In[8]:= Derivative[0, 2][g][x_, y_] := g2p[x, y]
Ini menggunakan definisi yang baru saja diberikan. In[9]:= D[g[a^2, x^2], x, x]
{0,1} 2 2
Out[9]= 4 x2 g2p[a2, x2] + 2 g [a , x ]
Integral yang Tidak Terbatas
Fungsi Mathematica Integrate [f, x] memberi Anda integral yang tidak terbatas
∫fdx. Anda dapat menganggap operasi integrasi yang tidak terbatas sebagai kebalikan dari diferensiasi. Jika Anda
mengambil hasil dari Integrate [f, x], dankemudian membedakannya, Anda selalu mendapatkan hasil yang
merupakansekutu matematika yang sama dengan ekspresiasli f.
Secara umum, bagaimanapun, ada seluruh keluarga hasil yang memiliki properti bahwa derivatif mereka adalah f.
Integrasikan f, xmemberi Anda ekspresi yang turunannya adalah f. Anda bisa mendapatkan ekspresi laindengan
menambahkan konstanta integrasi arbi-trary, atau memang dengan menambahkan fungsi apa pun yang konstan
kecuali pada titik diskrit.
Jika Anda mengisi batas eksplisit untuk integral Anda, setiapkonstanta integrasi harus dibatalkan. Tetapi meskipun
integral yang tidak terbatas dapat memiliki konstanta sewenang-wenang yang ditambahkan, masih sering sangat
nyaman untuk memanipulasinya tanpa mengisi batas.
Mathematica menerapkan aturan standar untuk find integral yang tidak terbatas
Anda dapat menambahkan konstanta sewenang-wenang ke integral yang tidak terbatas, dan masih mendapatkan
turunan yang sama. Integrasikan hanya memberi Anda ekspresi dengan derivatif yang diperlukan.
Fungsi Integrasi mengasumsikan bahwa setiap objek yang tidak secara eksplisit mengandung variabel integrasi
adalah penyok yang tidak disarankan, dan dapat diperlakukan sebagai konstanta. Akibatnya, Integrate seperti
kebalikan dari fungsi diferensiasi parsial D.
Variabel a diasumsikan independen dari x.
Anda harus menyadari bahwa hasil untuk setiap integral tertentu sering dapat ditulis dalam berbagai bentuk.
Mathematica mencoba memberi Anda bentuk yang paling nyaman, mengikuti prinsip-prinsip seperti menghindari
angka kompleks eksplisit kecuali input Anda sudah contains mereka.
Integral ini diberikan dalam hal ArcTan.
Integral yang Dapat dan Tidak Dapat Dilakukan
Mengevaluasi integral jauh lebih sulit daripada mengevaluasi derivatif. Untuk derivatif, ada prosedur sistematis
berdasarkan aturan rantai yang secara efektif memungkinkan setiap derivatif untuk dikerjakan. Tetapi untuk integral,
tidak adaprosedur sistematis such.
Salah satu masalah utama adalah sulit untuk mengetahui jenis fungsi apa yang diperlukan untuk mengevaluasi
integral tertentu. Ketika Anda mengerjakan turunan, Anda selalu berakhir dengan fungsi yang sama atau r
sederhanadaripada yang Anda mulai. Tetapi ketika Anda bekerja di luar integral, Anda sering berakhir perlu
menggunakan fungsi yang jauh lebih rumit daripada yang Anda mulai dengan.
Integral ini dapat dievaluasi dengan menggunakan jenis fungsi yang sama yang muncul
In[1]:= Integrate[Log[x]^2, x] Out[1]= x (2 − 2 Log[x] + Log[x]2)

Tetapi untuk integral ini fungsi khusus LogIntegral diperlukan. In[2]:= Integrate[Log[Log[x]], x]
Out[2]= x Log[Log[x]] – LogIntegral[x]
Mathematica mencakup berbagai fungsi matematika yang sangat luas, dan dengan menggunakan fungsi-fungsi ini
banyak integral dapat dilakukan. Tetapi masih mungkin untuk menemukanintegral yang cukup sederhana yang tidak
dapat dilakukan dalam hal fungsi matematika standar apapun.
Berikut adalah integral yang cukup sederhana yang tidak dapat dilakukan dalam hal fungsi matematika standar
Titik utama untuk dapat melakukan integral dalam hal fungsi matematika standar adalah memungkinkan seseorang
menggunakan sifat yang diketahui dari fungsi- fungsi ini untuk mengevaluasi atau memanipulasi hasil yang didapat
seseorang.
Dalam kasus yang paling nyaman, integral dapat dilakukan murni dalam hal fungsi dasar seperti eksponensial,
logaritma dan fungsi trigonometri. Bahkan, jika Anda memberikan integrand yang hanya melibatkan fungsi dasar
tersebut, maka salah satu kemampuan penting of Integrate adalah bahwa jika integral yang sesuai dapat dinyatakan
dalam hal fungsi dasar, maka Integrasi pada dasarnya akan selalu berhasil dalam menemukannya.
Integral dari fungsi rasional mudah untuk mengevaluasi, dan selalu keluar dalam halfungsi rasional, logaritma dan
fungsi trigonometri terbalik.
Selain bekerja dengan fungsi dasar, Integrasi mencakup sejumlah besar algoritma untuk menangani fungsi khusus.
Kadang-kadang menggunakan generalisasi langsung dari prosedur untukfungsi elementary. Tetapi lebih sering
strateginya adalah pertama mencoba menulis integrand dalam bentuk yang dapat diintegrasikan dalam hal fungsi
khusus canggih tertentu, dan kemudian melakukan ini untuk mencoba menemukan pengurangan fungsi-fungsi
canggih ini menjadi lebih familiar func-tions.
Untuk mengintegrasikan fungsi Bessel ini membutuhkan fungsi hipergeometrik umum
Sebuah buku besar tabel integral akan daftar mungkin beberapa ribu integral tak terbatas. Mathematica pada
dasarnya dapat melakukan semua bagian integral ini. Dan karena mengandung algoritma umum bukan hanya
kasuskasus tertentu, Mathematica benar-benar dapat melakukan berbagai integral yang jauh lebih luas.
Anda dapat berharap untuk menemukan integral ini dalam setiap buku besar tables integral
In[20]:= Integrate[Log[1 - x]/x, x] Out[20]= −PolyLog[2, x]

Untuk melakukan integral ini, bagaimanapun, membutuhkan algoritma yang lebih umum, bukan hanya tabel
langsung melihat ke atas
Terutama jika Anda memperkenalkan fungsi matematika baru Anda sendiri, Anda mungkin ingin mengajarkan
Mathematica jenis integral baru. Anda dapat melakukan ini dengan membuat definisi yang tepat untuk Integrasi.
Dalam kasus diferensiasi, aturan rantai memungkinkan seseorang untuk mengurangi semua derivatif ke bentuk
standar, diwakili dalam Mathematica menggunakan Derivatif. Tetapi untuk integrasi, tidak ada bentuk standar
serupa seperti itu, dan sebagai hasilnya Anda seringharus membuat definisi untuk beberapa versi yang berbeda
dari integral yang sama. Perubahan variabel dan transforma- tions lainnya jarang dapat dilakukan secara otomatis
oleh Integrate.
Integral ini tidak dapat dilakukan dalam hal salah satu fungsi matematika standar yang dibangun ke dalam
Mathematica
Sebelum Anda menambahkan aturan anda sendiri untuk integrasi, anda harus menghapus perlindungan menulis
In[23]:= Unprotect[Integrate] Out[23]= {Integrate}

Anda dapat mengatur aturan Anda sendiri untuk menentukan integral menjadi, katakanlah, fungsi "Jones". In[24]:=
Integrate[Sin[Sin[a_. + b_. x_]], x_] := Jones[a, x]/b
Sekarang Mathematica dapat melakukan integral yang memberikan fungsi Jones.

Integral Yang Pasti
Integral y dilakukan terlebih dahulu. Batasnya dapat bergantung pada nilai x. Pemesanan ini sama dengan yang
digunakan dalam fungsi seperti Sum dan Table.
Dalam kasus sederhana, integral yang pasti dapat dilakukan dengan menemukan bentuk yang tidak terbatas dan
kemudian menghitung batas yang sesuai. Tetapi ada berbagai macam integral yang bentuknya tidak terbatas tidak
dapat dinyatakan dalam hal fungsi matematika standar, tetapi bentuk yang pasti masih bisa.
Integral yang tidak terbatas ini tidak dapat dilakukan dalam hal fungsi matematika standar
Integral yang pasti ini, bagaimanapun, dapat dilakukan dalam halfungsi Bessel In[5]:= Integrate[Cos[Sin[x]], {x, 0,
2Pi}]
Out[5]= 2 π BesselJ[0,1]
Bahkan ketika Anda dapat menemukan bentuk integral yang tidak terbatas, Anda sering tidak akan mendapatkan
jawaban yang benar untuk integral yang pasti jika Anda hanya mengurangi nilai-nilai batas pada setiap titik akhir.
Masalahnya adalah bahwa dalam domain dalamtegra-tion mungkin ada singularitas yang efeknya diabaikan jika
Anda mengikuti prosedur ini.
Berikut adalah integral tak terbatas dari 1/x2

Ketika parameter muncul dalam integral yang tidak terbatas, pada dasarnya selalu mungkin untuk mendapatkan hasil
yang benar untuk hampir semua nilai parameter ini, Tetapi untuk integral yang pasti, ini tidak lagi terjadi. Masalah
yang paling umum adalah bahwa integral yang pasti dapat bertemu hanya ketika parameter yang muncul di dalamnya
memenuhi kondisi spesifik tertentu.
Integral yang tidak terbatas ini benar untuk semua n≠ -1.
Untuk integral yang pasti, bagaimanapun, n harus memenuhi suatu kondisi agar integral menjadi konvergen.
Jika n digantikan oleh 2, kondisinya puas.

Bahkan ketika integral yang pasti konvergen, kehadiran singularitas pada jalur integrasi dapat menyebabkan
perubahan penghentian ketika parameter bervariasi. Terkadang satu rumus yang berisi fungsi seperti Sign dapat
digunakan untuk menjumlahkanhasilnya. Namun, dalam kasus lain, If eksplisit lebih nyaman.
Memanipulasi Integral dalam Bentuk Simbolik
Ketika Mathematica tidak dapat memberi Anda hasil eksplisit untuk integral, ia meninggalkan integral dalam bentuk
simbolis. Hal ini sering berguna untuk memanipulasi bentuk simbolis ini.
Persamaan Diferensial
Seperti yang dibahas dalam Bagian 1.5.9, Anda dapat menggunakan fungsi Mathematica DSolve untuk menemukan
solusi simbolis untuk persamaan diferensial biasa dan parsial.
Memecahkan persamaan diferensial pada dasarnya terdiri dalam menemukan bentuk fungsi yang tidak diketahui.
Dalam Mathematica, fungsi yang tidak diketahui diwakili oleh expressions seperti y[x]. Turunan dari fungsi tersebut
diwakili oleh y'[x], y''[x] dan seterusnya.
Fungsi Mathematica DSolve kembali sebagai hasilnya daftar aturan untuk fungsi. Ada pertanyaan tentang
bagaimana fungsi-fungsi ini diwakili. Jika Anda meminta DSolve untuk menyelesaikan untuk y [x],maka DSolve
memang akan mengembalikan aturan untuk y[x]. Dalam beberapa kasus, aturan ini mungkin semua yang Anda
butuhkan. Tetapi aturan ini, dengan sendirinya, tidak memberikan nilai untuk y'[x] atau bahkan y[0]. Dalam banyak
kasus, oleh karenaitu, lebih baik meminta DSolve untuk menyelesaikan bukan untuk y [x],melainkan untuk y itu
sendiri. Dalam hal ini, apa yang akan dikembalikan DSolve adalah aturan yang memberi y sebagai fungsi murni,
dalam arti yang dibahas dalam Bagian 2.2.5.
Dalam notasi matematika standar, seseorang biasanya mewakili solusi untuk persamaan diferensial dengan secara
eksplisit memperkenalkan "variabel boneka" untuk mewakili argumen fungsi yang muncul. Jika yang Anda butuhkan
hanyalah bentuk simbolis untuk solusinya, then yang memperkenalkan variabel dummy semacam itu mungkin
nyaman. Namun, jika Anda benar-benar berniat untuk menggunakan solusi dalam berbagai perhitungan lainnya,
maka Anda biasanya akan merasa lebih baik untuk mendapatkan solusi dalam bentuk fungsi murni, tanpa variable
boneka. Perhatikan bahwa bentuk ini, meskipun mudah diwakili dalam Mathematica,tidak memiliki analog langsung
dalam notasi matematika standar.
Ini memecahkan dua persamaan diferensial simultan.
Jika Anda meminta Mathematica untuk memecahkan satu set persamaan diferensial dan Anda tidak memberikan
kendala atau bumbu batas maka Mathematica akan mencoba menemukan solusi umum untuk persamaan Anda.
Solusi umum ini akan melibatkan berbagai onstants c yang belum ditentukan. Satu konstanta baru diperkenalkan
untuk setiap urutan derivatif dalam setiap persamaan yang Anda berikan.
Defaultnya adalah bahwa konstanta ini diberi nama C,di mana indeks n dimulai pada 1 untuk setiap permohonan
DSolve. Anda dapat mengesampingkan pilihan ini,dengan secara eksplisit memberikan pengaturan untukopsi
GeneratedParameters. Fungsi apa pun yang Anda berikan diterapkan pada setiap nilai indeks berturut-turut n untuk
mendapatkan konstanta yang digunakan untuk setiap pemanggilan DSolve.
Solusi umum untuk persamaan urutan keempat ini melibatkan empat konstanta yang belum ditentukan.
Anda harus menyadari bahwa menemukan rumus yang tepat untuk solusi untuk persamaan diferensial adalah
masalah yang sulit. Bahkan hanya ada beberapa jenis persamaan yang rumus tersebut dapat ditemukan, setidaknya
dalam hal fungsi matematika-matical standar.
Persamaan diferensial yang paling banyak diselidiki adalah yang linier, di mana fungsi yang Anda pecahkan, serta
turunannya, hanya muncul secara linear.
Ini adalah persamaan diferensial linear orde pertama yang homogen, dan solusinya cukup simple
Jika Anda hanya memiliki persamaan diferensial linier tunggal, dan hanya melibatkan turunan pertama dari fungsi
yang Anda pecahkan, maka ternyata solusinya selalu dapat ditemukan hanya dengan melakukan integral.
Tetapi begitu Anda memiliki lebih dari satu persamaan diferensial, atau lebih dari turunan first-order, ini tidak lagi
benar. Namun, beberapa persamaan diferensial linier orde kedua sederhana tetap dapat diselesaikan dengan
menggunakan berbagai fungsi khusus dari Bagian 3.2.10. Memang, secara historis banyak dari fungsi- fungsi khusus
ini pertama kali diperkenalkan secara khusus untuk mewakili solusi untuk persamaan tersebut.
Ini adalah persamaan Airy, yang diselesaikan dalam hal fungsi Airy
Di luar urutan kedua, jenis fungsi yang diperlukan untuk memecahkan persamaan diferensial linier yang cukup
sederhana menjadi sangat rumit. Pada urutan ketiga, fungsi Meijer G umum MeijerG kadang-kadang dapat
digunakan, tetapi pada urutan keempat dan di luar sama sekali tidak ada fungsi matematika standar biasanya
memadai, kecuali dalam kasus yang sangat khusus.
Berikut adalah persamaan diferensial linier urutan ketiga yang dapat diselesaikan dalam halctions menyenangkan
hipergeometrik umum
Untuk persamaan diferensial nonlinier, hanya kasus yang agak khusus yang biasanya dapat diselesaikan dalam hal
fungsi mathemati-cal standar. Namun
demikian, DSolve mencakup prosedur yang cukup umum yang memungkinkannya menangani hampir semua
persamaan diferensial nonlinier yang solusinya ditemukan dalam buku referensi standar.
Persamaan diferensial nonlinier orde pertama di mana x tidak muncul dengan sendirinya cukup mudah dipecahkan
Di luar persamaan diferensial biasa, seseorang dapat mempertimbangkan persamaan diferensial-aljabar yang
melibatkan campuran persamaan diferensial dan aljabar.
DSolve diatur untuk menangani tidak hanya persamaan diferensial biasa di mana hanya satu variabel independen
muncul, tetapi juga persamaan diferensial parsial di mana dua atau lebih bles varia independent muncul.
Ini menemukan solusi umum untuk persamaan diferensial parsial sederhana dengan dua variabel independen.
Matematika dasar persamaan diferensial parsial jauh lebih cocok daripada persamaandifferen-tial biasa. Salah satu
fitur adalah bahwa sedangkan solusi umum untuk persamaan diferensial biasa hanya melibatkan konstanta
sewenang- wenang, solusi umum untuk persamaan diferensial parsial, jika dapat ditemukan sama sekali, harus
melibatkan fungsi sewenang-wenang. Memang, dengan variabel
m independen, fungsi sewenang-wenang dari m - 1 argumen muncul. DSolve secara default menamai ion-ion funct
ini C[n].
Berikut adalah PDE sederhana yang melibatkan tiga variabel independent
Untuk persamaan diferensial biasa, dijamin bahwa solusi umum harus ada, dengan properti yang menambahkan
kondisi awal atau batas hanya sesuai dengan memaksa pilihan spesifik untuk konstanta sewenang-wenang dalam
larutan. Tetapi untuk persamaan diferensial partial ini tidak lagi benar. Memang, hanya untuk diferensial parsial linier
dan beberapa jenis khusus lainnya bahwa solusi umum tersebut ada.
Persamaan diferensial parsial lainnya dapat diselesaikan hanya ketika nilai awal atau batas tertentu diberikan, dan
dalam sebagian besar kasus tidak ada solusi yang dapat ditemukan sebagai rumus yang tepat dalam hal fungsi
matematika standar.
Karena y dan turunannya hanya muncul secara linear di sini, ada solusi umum.
Transformasi Integral dan Operasi Terkait Transformasi Laplace
Transformasi Laplace dari fungsi f (t) diberikan oleh TransformasiL aplace terbalik dari F(s)
diberikan for suitable
Berikut adalah transformasi Laplace yang sederhana
Transformasi Laplace memiliki properti yang mereka ubah integrasi dan diferensiasi menjadi operasi aljabar pada
dasarnya. Oleh karena itu mereka umumnya digunakan dalam mempelajari sistem yang diatur oleh persamaan
diferensial.
Integrasi menjadi perkalian dengan 1/s ketika seseorang melakukan transformasi Laplace.
Transformasi Fourier
Dalam bidang ilmiah dan teknis yang berbeda konvensi yang berbeda sering digunakan untuk mendefinisikan
transformasi Fourier. Pilihan FourierParameters dalam Mathematica memungkinkan Anda untuk memilih salah satu
konvensi yang Anda inginkan
Berikut adalah transformasi Fourier dengan pilihan parameter
Berikut adalah transformasi Fourier yang sama dengan pilihan parameter yang biasanya digunakan dalam
pemrosesan sinyal
Dalam beberapa aplikasi transformasi Fourier, lebih mudah untuk menghindari memperkenalkan eksponensial yang
kompleks. Fourier sinus dan cosine
transforms sesuai dengan integrasi masing-masing dengan sin(wt) dan cos(wt) bukan exp(iwt), dan menggunakan
batas 0 dan ∞ bukan -∞ dan ∞ .
Berikut adalah transformasi sinus dan cosine Fourier dari e-t.
Ini mengevaluasi transformasi Fourier dua dimensi
Ini membalikkan transformasi
Z Transforms
Transformasi Z dari fungsi f(n) diberikan oleh . Transformasi Z terbalik

dari F(z) diberikan oleh kontur integral transforms secara efektif analog diskrit dari Laplace berubah. Mereka
banyak digunakan untuk memecahkan persamaan perbedaan, terutama dalam pemrosesan sinyal digital dan teori
kontrol.
Mereka dapat dianggap sebagai menghasilkan fungsi pembangkit, dari jenis yang biasa digunakan dalam
kombinatorik dan teori bilangan.
Ini menghitung transformasi Z 2-n

Berikut adalah transformasi Z terbalik In[2]:= InverseZTransform[%, z, n] Out[2]= 2−n
Fungsi pembangkit untuk 1/n! Adalah fungsi eksponensial
Fungsi Umum dan Objek Terkait
Dalam banyak situasi praktis, lebih mudah untuk mempertimbangkan batasan di mana sejumlah tetap sesuatu
terkonsentrasi ke wilayah yang sangat kecil. Fungsi matematika biasa dari jenis yang biasanya ditemui dalam
kalkulus tidak dapat dengan mudah mewakili batas-batas tersebut. Namun, adalah mungkin untuk memperkenalkan
fungsi umum atau distribusi yang dapat mewakili batas-batas ini dalam integral dan jenis perhitungan lainnya
Berikut adalah fungsi terkonsentrasi di sekitar x = 0.
Ketika n semakin besar, fungsi menjadi semakin terkonsentrasi

Untuk setiap n > 0, integral mereka masih selalu sama dengan 1
In[3]:= Integrate[Sqrt[n/Pi] Exp[-n x^2], {x, -Infinity, Infinity}, Assumptions -> n >
0]
Out[3]= 1
Batas fungsi untuk n tak terbatas secara efektif merupakan fungsi delta Dirac, yang integralnya lagi 1
In[4]:= Integrate[DiracDelta[x], {x, -Infinity, Infinity}] Out[4]= 1

DiracDelta mengevaluasi ke 0 di semua titik nyata kecuali x In[5]:= Table[DiracDelta[x], {x, -3, 3}]
Out[5]= {0, 0, 0, DiracDelta[0], 0, 0, 0}
Memasukkan fungsi delta dalam integral secara efektif menyebabkan integrand diambil sampelnya pada titik-titik
diskrit di mana argumen fungsi delta lenyap
Ini sampel fungsi f dengan argumen 2.
In[6]:= Integrate[DiracDelta[x - 2] f[x], {x, -4, 4}] Out[6]= f[2]

Berikut adalah contoh yang sedikit lebih rumit
Fungsi unit langkah UnitStep adalah secara efektif merupakan bagian integral tak terbatas dari fungsi delta.
Kadangkadang dikenal sebagai fungsi Heaviside,dan berbagaidilambangkan H (x), q (x), m (x), dan U (x). Tidak
perlu consid-ered sebagai fungsi umum, meskipun memiliki diskontinuitas pada x = 0. Fungsi langkah unit sering
digunakan dalam menyiapkan fungsi kontinu sekecil apa pun, dan dalam mewakili sinyal dan jumlah lain yang
menjadi non-nol hanya di luar titik sama
.Integral yang tidak terbatas dari fungsi delta adalah fungsi satuan In[9]:= Integrate[DiracDelta[x], x]
Out[9]= UnitStep[x]
Ini menghasilkan gelombang persegi

Berikut adalah bagian integral dari gelombang persegi. In[11]:= Integrate[UnitStep[Sin[x]], {x, 0, 30}]
Out[11]= 5 π
Nilai integral tergantung pada apakah terletak pada interval (-2,2) In[12]:= Integrate[f[x] DiracDelta[x - a], {x, -2,
2}]
Out[12]= f[a]
DiracDelta dan UnitStep sering muncul dalam melakukan transformasi integral. Transformasi Fourier dari fungsi
konstan adalah fungsi delta
Transformasi Fourier dari cos HtL melibatkan jumlah dua fungsi delta
Fungsi delta dirac dapat digunakan di DSolve untuk menemukan respons impuls atau fungsi sistem Green yang
diwakili oleh persamaan diferensial linier dan tertentu lainnya.
Ini menemukan perilaku osilator harmonik yang mengalami impuls pada t = 0.
Terkait dengan fungsi delta Dirac multidimensi adalah dua fungsi integer: delta diskrit dan delta Kronecker. Delta
diskrit delta(n1,n2, adalah 1 jika semua ni = 0, dan nol sebaliknya. Kronecker delta n1 n2 ... Adalah 1 jika semua ni
sama, dan nol sebaliknya.
HAL 892
Seri , Batas dan Residu

3.6.1 Membuat Ekspansi Seri Daya
Seri [ expr, {x, temukan ekspansi deret daya dari

x0 , n }] expr tentang
Seri [expr, { x, x 0, nx } , {y, titik x = x0 untuk memesan paling
y , n }] banyak (x-x0 )
n
4
Berikut adalah ekspansi deret daya untuk exp ( x) tentang titik x = 0 untuk memesan x
Berikut ini adalah perluasan deret exp x terhadap titik x = 1.
Jika Mathematica tidak mengetahui perluasan deret dari fungsi tertentu, ia menulis hasilnya secara simbolis dalam bentuk
turunan.
Dalam istilah matematika, Deret dapat dilihat sebagai cara membangun deret Taylor untuk fungsi.
Rumus standar untuk ekspansi deret Taylor tentang titik x = x0 dari suatu fungsi g ( x ) dengan
∞ ∑ 𝑘 ( x0) ( 𝑥−𝑥0 )𝑘
turunan k g ( k (x) is g ( x) = 𝑘=0 . Kapan pun rumus ini
) 𝑘!
diterapkan, ia memberikan hasil yang sama dengan Seri. (Untuk fungsi umum, Seri namun secara internal menggunakan
algoritma yang agak lebih efisien.)
Deret juga dapat menghasilkan beberapa deret pangkat yang melibatkan pangkat pecahan dan pangkat negatif, yang tidak secara
langsung dicakup oleh rumus deret Taylor standar.
Berikut adalah deret pangkat yang mengandung pangkat negatif dari x.
Berikut adalah deret pangkat yang melibatkan pangkat pecahan dari x.
Deret juga dapat menangani deret yang melibatkan suku logaritma.
Tentu saja ada fungsi matematika yang tidak memiliki deret pangkat standar. Mathematica mengakui banyak kasus seperti itu.
1 ) memiliki singularitas esensial pada x = 0, dan tidak

Series sees that exp (
𝑥
menghasilkan deret pangkat.
1
Seri tetap dapat memberi Anda seri daya untuk exp (
𝑥
) tentang titik x = ∞
Terutama ketika kekuatan negatif terjadi, ada beberapa kehalusan dalam berapa banyak istilah dari rangkaian kekuatan tertentu
fungsi Seri akan menghasilkan.
Salah satu cara untuk memahami apa yang terjadi adalah dengan memikirkan analogi antara deret pangkat yang diambil pada urutan
tertentu, dan nyata angka yang diambil dengan presisi tertentu. Deret pangkat adalah "rumus perkiraan" dalam arti yang sama seperti
bilangan real presisi-hingga adalah bilangan perkiraan.
Prosedur yang diikuti Seri dalam membangun rangkaian daya sebagian besar analog dengan prosedur yang diikuti N dalam
membangun pendekatan bilangan real. Kedua fungsi secara efektif dimulai dengan mengganti bagian terkecil dari Anda ekspresi
dengan orde-hingga, atau presisi-hingga, aproksimasi, dan kemudian mengevaluasi ekspresi yang dihasilkan. Jika ada adalah,
misalnya, pembatalan, prosedur ini dapat memberikan hasil akhir yang urutan atau presisinya kurang dari urutan atau presisi yang
awalnya Anda minta. Seperti N, bagaimanapun, Seri memiliki beberapa kemampuan untuk mencoba kembali perhitungannya untuk
mendapatkan hasil untuk pesanan yang Anda minta.
Dalam kasus di mana itu tidak berhasil, Anda biasanya masih bisa mendapatkan hasil untuk pesanan tertentu dengan meminta
pesanan yang lebih tinggi dari yang Anda butuhkan.
3
Seri mengkompensasi pembatalan dalam perhitungan ini, dan berhasil memberi Anda hasil untuk memesan x .
Ketika Anda membuat ekspansi deret pangkat dalam variabel x, Mathematica mengasumsikan bahwa semua objek yang tidak secara
eksplisit mengandung x sebenarnya independen dari x. Seri dengan demikian melakukan turunan parsial (secara efektif
menggunakan D) untuk membangun Taylor seri.
Baik a dan n diasumsikan bebas dari x.
a [ x ] sekarang diberikan sebagai fungsi eksplisit dari x.

Anda dapat menggunakan Seri untuk menghasilkan seri daya dalam urutan variabel yang berbeda. Seri berfungsi seperti
Integrasikan, Jumlahkan dan seterusnya, dan kembangkan terlebih dahulu sehubungan dengan variabel terakhir yang Anda tentukan.
Deret melakukan ekspansi deret berturut-turut terhadap setiap variabel. Hasil dalam kasus ini adalah deret dalam x, yang koefisien
adalah seri dalam y.
3.6. 2 Topik Lanjutan: Representasi Power Series

Deret pangkat direpresentasikan dalam Mathematica sebagai objek Series Data.
Deret pangkat dicetak sebagai jumlah suku, diakhiri dengan O[x] dipangkatkan.
Secara internal, bagaimanapun, seri disimpan sebagai objek Series Data.
Dengan menggunakan objek SeriesData, bukan ekspresi biasa, untuk mewakili deret pangkat, Mathematica dapat menyimpan
melacak urutan dan titik ekspansi, dan melakukan operasi pada rangkaian daya dengan tepat. Anda seharusnya tidak biasanya perlu
mengetahui struktur internal objek SeriesData.
Anda dapat mengenali rangkaian daya yang dicetak dalam bentuk keluaran standar dengan adanya suku O[x]. Ini suku meniru notasi
matematika standar O (x), dan mewakili suku orde x yang dihilangkan. Untuk berbagai alasan konsistensi, Mathematica
n n menggunakan notasi O[x]^n untuk menghilangkan suku
orde x , sesuai dengan matematika notasi O (x) , daripada bentuk yang sedikit lebih akrab, meskipun setara, O (xn).
Setiap kali objek seperti O[x] muncul dalam jumlah suku, Mathematica sebenarnya akan mengubah seluruh jumlah menjadi seri
kekuasaan.
Kehadiran O[x] membuat Mathematica mengubah seluruh jumlah menjadi deret pangkat.
3.6 .3 Operasi pada Power Series

Mathematica memungkinkan Anda untuk melakukan banyak operasi pada rangkaian daya. Dalam semua kasus, Mathematica
memberikan hasil hanya sebagai banyak istilah yang dapat dibenarkan dari keakuratan masukan Anda.
Berikut adalah deret pangkat yang akurat hingga orde keempat dalam x.
Saat Anda mengkuadratkan seri daya, Anda mendapatkan seri daya lain, juga akurat hingga urutan keempat.
4
Mengambil logaritma memberi Anda hasil 2x, tetapi hanya untuk memesan x .
Mathematica melacak urutan deret pangkat dengan cara yang sama seperti melacak presisi dari mendekati bilangan real. Seperti
halnya perhitungan numerik, ada operasi pada rangkaian daya yang dapat meningkat, atau penurunan, presisi (atau urutan) hasil
Anda.
Berikut adalah seri daya yang akurat untuk memesan x10 .
6
Ini memberikan rangkaian daya yang akurat hanya untuk orde x .
Mathematica juga memungkinkan Anda melakukan kalkulus dengan deret pangkat.
Berikut adalah seri daya untuk tan (x).
Berikut adalah turunannya terhadap x
Mengintegrasikan sehubungan dengan x mengembalikan seri daya asli.
Saat Anda melakukan operasi yang melibatkan ekspresi normal dan deret pangkat, Mathematica "menyerap" ekspresi normal ke
dalam deret pangkat bila memungkinkan.
1 secara otomatis diserap ke dalam seri daya.
x^2 juga diserap ke dalam deret pangkat.
Jika Anda menambahkan Sin[x], Mathematica menghasilkan deret pangkat yang sesuai untuk Sin[x], dan
menggabungkannya dengan deret pangkat yang Anda memiliki.
Mathematica juga menyerap ekspresi yang mengalikan deret pangkat. Simbol a diasumsikan bebas dari x.
Mathematica tahu bagaimana menerapkan berbagai macam fungsi ke deret pangkat. Namun, jika Anda menerapkan
sewenangwenang fungsi ke deret pangkat, Mathematica tidak mungkin memberi Anda apa pun kecuali hasil simbolis.
Mathematica tidak tahu bagaimana menerapkan fungsi f ke deret pangkat, jadi hanya meninggalkan hasil simbolis
3. 6. 4 Topik Lanjutan: Komposisi dan Pembalikan Seri Daya

Saat Anda
BuatSeri [ seri , seri menyusu memanipulasi deret
1 2 pangkat, terkadang
n seri
lebih mudah untuk
Seri Inverse membalikka menganggap deret
tersebut sebagai fungsi yang mewakili, yang Anda dapat, misalnya, menulis atau membalikkan.
, ….]
[Seri x ] n seri
5
Berikut adalah seri daya untuk exp (x) untuk memesan x .
Ini menggantikan variabel x dalam deret pangkat untuk exp (x) dengan deret pangkat untuk sin (x).
Hasilnya adalah rangkaian daya untuk exp (sin (x)).
Jika Anda memiliki deret pangkat untuk fungsi f (y), maka seringkali mungkin untuk mendapatkan aproksimasi deret pangkat untuk
solusi untuk y dalam persamaan f (y) = x. Deret pangkat ini secara efektif memberikan fungsi invers f
-1
(x) sedemikian rupa sehingga f ( f-1 (x)) = x. Operasi pencarian deret pangkat untuk fungsi invers kadang-kadang dikenal
sebagai pembalikan dari seri kekuasaan. Berikut adalah seri untuk sin (y).
Pembalikan deret tersebut menghasilkan deret untuk sin-1 (x).

Menyusun dua deret memberikan fungsi identitas.
3. 6. 5 Converting Power Series to Normal Expressions
Normal [ expr ] mengonversi deret pangkat menjadi ekspresi normal.
Seperti dibahas di atas, deret pangkat di Mathematica direpresentasikan dalam bentuk internal khusus, yang melacaknya: atribut
sebagai urutan ekspansi mereka.
Untuk beberapa tujuan, Anda mungkin ingin mengonversi deret pangkat ke ekspresi normal. Dari sudut pandang matematika, ini
sesuai dengan pemotongan deret pangkat, dan dengan asumsi bahwa semua suku orde tinggi adalah nol.
Ini menghasilkan seri daya, dengan empat istilah
Mengkuadratkan seri daya memberi Anda seri daya lain, dengan jumlah istilah yang sesuai.
Normal memotong deret pangkat, memberikan ekspresi normal.

Anda sekarang dapat menerapkan operasi aljabar standar.
Deret Koefisien,[ seri n ] memberikan koefisien suku orde ke-n dalam deret
pangkat.
Deret Koefisien,[ seri n ] memberikan koefisien suku orde ke-n dalam deret pangkat.
Ini memberikan koefisien x7 dalam deret pangkat asli.
3.6 .6 Memecahkan Persamaan yang Melibatkan Deret Pangkat
Logika Perluas [ seri1= berikan persamaan yang diperoleh dengan seri 2 ]

menyamakan koefisien yang sesuai dalam
Solve [ series =
1 deret pangkat memecahkan koefisien dalam
deret
pangkat
Berikut ini adalah rangkaian kekuatan.

Ini memberikan persamaan yang melibatkan deret pangkat.
LogicalExpand menghasilkan urutan persamaan untuk setiap kekuatan x.
Ini memecahkan persamaan untuk koefisien a [i] . Anda juga dapat mengumpankan persamaan yang melibatkan deret pangkat
langsung ke penyelesaian.
Beberapa persamaan yang melibatkan deret pangkat juga dapat diselesaikan dengan menggunakan fungsi InverseSeries yang dibahas
dalam Bagian 3.6.4.
3. 6. 7 Penjumlahan Deret
Penjumalahan [ seri , { n, nmin, nmax } ] temukan jumlah seri saat n beralih dari
nmin ke nmax
x
Mathematica mengakui ini sebagai perluasan deret pangkat dari e .
Jumlah ini keluar dalam hal fungsi Bessel.
Berikut adalah jumlah lain yang dapat dilakukan dalam hal fungsi khusus umum.
Fungsi hipergeometrik umum tidak jarang dalam jumlah.
Ada banyak analogi antara jumlah dan integral. Dan seperti halnya mungkin untuk memiliki integral tak tentu, demikian pula jumlah
tak tentu dapat dibentuk dengan menggunakan variabel simbolik sebagai batas atas.
Ini secara efektif merupakan jumlah yang tidak terbatas.
Jumlah ini keluar dalam hal fungsi gamma yang tidak lengkap.
Jumlah ini melibatkan fungsi poligami.
Mengambil perbedaan antara hasil untuk nilai n yang berurutan akan mengembalikan summand asli.
Mathematica pada dasarnya dapat melakukan semua jumlah yang ditemukan dalam buku tabel. Sama seperti integral tak tentu, tak
tentu jumlah ekspresi yang melibatkan fungsi sederhana cenderung memberikan jawaban yang melibatkan fungsi yang lebih rumit.
Pasti jumlah, seperti integral tertentu, sering kali muncul dalam bentuk fungsi yang lebih sederhana.
Jumlah tak tentu ini memberikan hasil yang cukup rumit.
Bentuk pasti jauh lebih sederhana.
3. 6. 8 Memecahkan Persamaan Pengulangan

Jika Anda mewakili suku ke-n dalam suatu barisan sebagai a[n], Anda dapat menggunakan persamaan perulangan untuk menentukan
bagaimana ia terkait dengan istilah lain dalam urutan.
R Penyelesaian mengambil persamaan perulangan dan menyelesaikannya untuk mendapatkan rumus eksplisit untuk a[n].
Ini memecahkan persamaan perulangan sederhana.
Ini mengambil solusi dan membuat tabel eksplisit dari sepuluh a[n] pertama.
Rsolve [ eqn , a [n] , n] menyelesaikan persamaan

perulangan
Ini memecahkan persamaan rekurensi untuk deret geometri.
Ini memberikan hasil yang sama.
Ini memberikan solusi aljabar untuk persamaan perulangan Fibonacci.
RSolve dapat dianggap sebagai analog diskrit dari DSolv. Banyak fungsi yang sama yang dihasilkan dalam
menyelesaikan persamaan diferensial juga muncul dalam menemukan solusi simbolis untuk persamaan perulangan. Ini
menghasilkan fungsi gamma, yang menggeneralisasi faktorial.
Persamaan perulangan orde kedua ini muncul dalam bentuk fungsi Bessel.
RSolve tidak mengharuskan Anda untuk menentukan nilai eksplisit untuk istilah seperti a[1]. Seperti DSolve, secara otomatis
memperkenalkan konstanta tak tentu C[i] untuk memberikan solusi umum.
Ini memberikan solusi umum dengan satu konstanta yang tidak ditentukan.
RSolve dapat menyelesaikan persamaan yang tidak bergantung hanya secara linear pada a[n]. Untuk persamaan nonlinier,
bagaimanapun, ada terkadang beberapa solusi berbeda yang harus diberikan. Sama seperti persamaan diferensial, ini adalah soal
yang sulit ditemukan solusi simbolis untuk persamaan perulangan, dan fungsi matematika standar hanya mencakup serangkaian
kasus yang terbatas.
Berikut adalah solusi umum untuk persamaan perulangan nonlinier.
Ini memberikan dua solusi berbeda.
RSolve tidak hanya dapat menyelesaikan persamaan perbedaan biasa di mana argumen dari a berbeda dengan bilangan bulat, tetapi
juga persamaan q- difference di mana argumen a dihubungkan oleh faktor perkalian.
Ini memecahkan analog q-difference dari persamaan faktorial

Rsolve [ { eqn1 , eqn2, menyelesaikan sistem persamaan
… }, rekurensi
{ a1 [ n] , a2 [n] ,…} berpasa
, n] ngan
Ini memecahkan sistem dua persamaan pengulangan berpasangan.
ust sebagai seseorang dapat mengatur persamaan diferensial parsial yang melibatkan fungsi dari beberapa variabel, sehingga
seseorang juga dapat mengatur persamaan rekurensi parsial yang melibatkan barisan multidimensi.
Sama seperti dalam kasus persamaan diferensial, umum solusi untuk persamaan perulangan parsial dapat melibatkan fungsi yang
tidak ditentukan.
Ini memberikan solusi umum untuk persamaan perulangan parsial sederhana.
3. 6. 9 Menemukan Batas
Dalam melakukan berbagai macam perhitungan, Anda perlu mengevaluasi ekspresi ketika variabel mengambil nilai tertentu. Di
dalam dalam banyak kasus, Anda dapat melakukan ini hanya dengan menerapkan aturan transformasi untuk variabel menggunakan /.
Operator
Anda bisa mendapatkan nilai cos(x2) pada 0 hanya dengan secara eksplisit mengganti x dengan 0, lalu mengevaluasi hasilnya.
Namun, dalam beberapa kasus, Anda harus lebih berhati-hati.
Perhatikan, misalnya, mencari nilai dari ekspresi sin(𝑥) ketika x = 0. Jika Anda
𝑥
cukup mengganti x dengan 0 dalam ekspresi, Anda mendapatkan hasil tak tentu
0
. Untuk menemukan nilai yang benar dari sin HxL x ketika x = 0, Anda perlu
0 mengambil
membatasi.
Limit [expr , x −> x0 ] tentukan limit expr ketika x mendekati x0
Ini memberikan nilai yang benar untuk batas sin(𝑥) as x → 0.

𝑥
Tidak ada batasan terbatas dalam kasus ini.
Limit dapat menemukan limit ini, meskipun Anda tidak dapat memperoleh deret pangkat biasa untuk x log (x) pada x = 0.
Hal yang sama juga berlaku di sini.

.
Nilai Tanda[x] pada x=0 adalah 0.
Batasnya, bagaimanapun, adalah 1. Batasnya secara default diambil dari atas
Tidak semua fungsi memiliki limit tertentu pada titik-titik tertentu. Misalnya, fungsi sin (1/ x) sering berosilasi tak terhingga dekat x
= 0, sehingga tidak memiliki batas yang pasti di sana. Namun demikian, setidaknya selama x tetap nyata, nilai-nilai fungsi dekat x =
0 selalu terletak antara -1 dan 1. Batas mewakili nilai dengan variasi terbatas menggunakan objek Interval.
Secara umum, Interval[{xmin, xmax}] mewakili nilai yang tidak pasti yang terletak di suatu tempat dalam interval x min ke x maks.
Limit mengembalikan objek Interval, yang mewakili kisaran nilai yang mungkin dari sin (1 /x) di dekat singularitas esensialnya pada
x = 0.
Mathematica mewakili batas ini secara simbolis dalam bentuk objek Interval.
Beberapa fungsi mungkin memiliki batas yang berbeda pada titik tertentu, tergantung pada arah dari mana Anda mendekati titik-titik
itu. Anda dapat menggunakan opsi Arah untuk Batas untuk menentukan arah yang Anda inginkan.
Fungsi 1/ x memiliki nilai pembatas yang berbeda pada x = 0, tergantung apakah Anda mendekati dari atas atau bawah.
In[11]:= Plot[1/x, {x, -1, 1}]
Mendekati dari bawah memberikan nilai pembatas -∞
Mendekati dari atas memberikan nilai pembatas ∞
Limit tidak membuat asumsi tentang fungsi seperti f[x] yang tidak memiliki pengetahuan pasti. Hasil dari, Batas tetap tidak
dievaluasi dalam banyak kasus yang melibatkan fungsi simbolis.
Limit tidak memiliki pengetahuan pasti tentang f, sehingga limit ini tidak dievaluasi.
3. 6. 10 Residu
Limit [expr, x - > x0] memberi tahu Anda berapa nilai expr ketika x cenderung ke x0 . Ketika nilai ini tak terhingga, seringkali
berguna sebagai gantinya untuk mengetahui sisa expr ketika x sama dengan x0 . Residu diberikan oleh koefisien( x - x0)-1 di ekspansi
deret daya dari expr tentang titik x0 .
Residu [ expr , { x, x0 }]residu expr ketika x sama dengan x0
Residu di sini sama dengan 1
Residu di sini adalah nol.
3. 7 Aljabar linier
3. 7. 1 Membangun Matriks
Table [ f , { i, m} , { j, n } ] bangun matriks mxn di mana f adalah fungsi

dari
i dan j yang memberikan nilai entri ke
Himpunan [ f, {m, n} ] buat matriks mxn yang entri ke-i, j nya

i, j] adalah f [
Diagonal Matrix menghasilkan matriks diagonal dengan

[list] elemen
Identitas Matriks menghasilkan matriks identitas
[n] nxn
Normal [himpunan jarang [ { { buat matriks dengan nilai bukan nol vk pada
ij} posisi { ik , jk}
v1, { i2, j2 −>v2 , …} , {m,
n} ] ]
Ini menghasilkan matriks 2x2 yang entri ke-i, ke-jnya adalah a[i, j].
Berikut adalah cara lain untuk menghasilkan matriks yang sama.
Diagonal Matrix membuat matriks dengan nol di mana-mana kecuali pada diagonal utama.
Identity Matrix[n] menghasilkan matriks identitas n x n.
Ini membuat matriks 3x4 dengan dua nilai bukan nol terisi
Matrix Form mencetak matriks dalam bentuk dua dimensi
Table [ 0, { m }, {n}] Matriks nol

Table {Random[ ] , {m} , {n} ] matriks dengan entri numerik acak
Table [ if [ I >= j, matriks segitiga bawah
Tabel mengevaluasi Random[ ] secara terpisah untuk setiap elemen, untuk memberikan nomor pseudorandom yang berbeda dalam
setiap kasus
Himpunan Jarang [ { }, {n matriks nol

,n}] matriks
SparseArra identitas n x n
y [ { i_} ,/ I; _i >} =
->j 1,
-> 1, {
n, n } ]
Ini membentuk matriks segitiga bawah umum.

3. 7. 2 Mendapatkan dan Mengatur Potongan Matriks
m[[i,j]] enter i ke-i, j

m[[i] baris ke-i
m [ [ All , i ] ] kolom ke-i
Take [ m , { i0 , i1} , { j0, submatriks dengan baris i0
j1}] melalui i1 dan kolom j0 melalui j 1
baris ik dan indeks

kolom j k
Tr
[ m, elemen pada diagonal
Array
Matriks di Mathematica direpresentasikan sebagai daftar daftar. Anda dapat menggunakan semua manipulasi daftar
Mathematica standar operasi pada matriks. Berikut adalah contoh matriks 3 x 3.
Ini memilih baris kedua dari matriks.
Berikut adalah kolom kedua dari matriks
m = { { a11, a12 ,
Ini memilih submatriks. …
} , { a21 , a22 , …} , …} m [ [ I,
j]]=vm[[I]]=v
m [ [ I ] ] = { v1, v2, … }
…}
m [ [ All , j ] ] = v tetapkan m sebagai
m [ [ All , j ] ] = { v1, v2 matriks reset elemen { i, j }
menjadi v
reset semua elemen di baris i menjadi v
reset elemen pada baris i menjadi { v1, v2,
reset semua elemen di kolom j menjadi v

Ini me-reset elemen 2, 2 menjadi x, kemudian menampilkan seluruh matriks.
Ini mengatur ulang semua elemen di kolom kedua menjadi z.
Ini secara terpisah mengatur ulang dua elemen di kolom kedua.
Ini menambah semua nilai di kolom kedua.
3. 7. 3 Skalar, Vektor dan Matriks
Mathematica mewakili matriks dan vektor menggunakan daftar. Apa pun yang bukan merupakan daftar yang dianggap Mathematica
sebagai skalar.
Sebuah vektor di Mathematica terdiri dari daftar skalar. Matriks terdiri dari daftar vektor, yang mewakili masing-masing baris.
Untuk menjadi matriks yang valid, semua baris harus memiliki panjang yang sama, sehingga elemen-elemen matriks efektif
membentuk barisan persegi panjang.
Vector Q memberikan True jika expr

memiliki bentuk vektor, dan False sebaliknya
[expr ] Matrix Q [ memberikan True jika expr
expr ] memiliki bentuk matriks, dan False sebaliknya

Daftar {a, b, c} berbentuk vektor.
Apa pun yang bukan daftar secara nyata diperlakukan sebagai skalar, jadi menerapkan VectorQ memberikan False.
Untuk vektor, Dimensi memberikan daftar dengan elemen tunggal yang sama dengan hasil dari Panjang.
Objek ini tidak dihitung sebagai matriks karena panjang barisnya berbeda.
3. 7.4 Operasi Skalar, Vektor, dan Matriks
Sebagian besar fungsi matematika di Mathematica diatur untuk menerapkan diri mereka sendiri secara terpisah ke setiap elemen
dalam daftar. Ini adalah benar khususnya dari semua fungsi yang membawa atribut Listable.
Konsekuensinya adalah bahwa sebagian besar fungsi matematika diterapkan elemen demi elemen ke matriks dan vektor.
Log berlaku sendiri secara terpisah untuk setiap elemen dalam vektor.
Hal yang sama berlaku untuk matriks, atau, dalam hal ini, untuk daftar bersarang apa pun.
Fungsi diferensiasi D juga berlaku secara terpisah untuk setiap elemen dalam daftar.
Penjumlahan dua vektor dilakukan elemen demi elemen
Jika Anda mencoba menambahkan dua vektor dengan panjang yang berbeda, Anda mendapatkan kesalahan.
Ini menambahkan skalar 1 ke setiap elemen vektor.
Objek apa pun yang bukan daftar secara nyata diperlakukan sebagai skalar. Di sini c diperlakukan sebagai skalar, dan ditambahkan
secara terpisah ke setiap elemen dalam vektor.
Ini mengalikan setiap elemen dalam vektor dengan skalar k.
Penting untuk disadari bahwa Mathematica memperlakukan sebuah objek sebagai vektor dalam operasi tertentu hanya jika objeknya
adalah secara eksplisit daftar pada saat operasi dilakukan. Jika objek tidak secara eksplisit daftar, Mathematica selalu
memperlakukannya sebagai skalar. Ini berarti Anda bisa mendapatkan hasil yang berbeda, tergantung pada apakah Anda menetapkan
objek tertentu sebagai daftar sebelum atau sesudah Anda melakukan operasi tertentu.
Objek p diperlakukan sebagai skalar, dan ditambahkan secara terpisah ke setiap elemen dalam vektor.
Inilah yang terjadi jika Anda sekarang mengganti p dengan daftar {c, d}.
Anda akan mendapatkan hasil yang berbeda jika Anda mengganti p dengan {c, d} sebelum Anda melakukan operasi pertama
3. 7. 5 Perkalian Vektor dan Matriks
c v , c m , etc. kalikan setiap elemen dengan skalar

v.v , v.m , m.v , m.m , . perkalian vektor dan matriks
etc. Cross [ v, v ] vektor lintas produk Halso input sebagai v
Outer [ Times, t, u
x v produk luar
Ini mengalikan setiap elemen vektor dengan skalar k.
Operator "titik" memberikan produk skalar dari dua vektor.
Anda juga dapat menggunakan titik untuk mengalikan matriks dengan vektor.
Titik juga merupakan notasi untuk perkalian matriks dalam Mathematica.
Penting untuk disadari bahwa Anda dapat menggunakan “titik” untuk perkalian vektor kiri dan kanan dengan matriks.
Mathematica tidak membedakan antara vektor "baris" dan "kolom". Dot melakukan operasi apa pun yang mungkin. (Di dalam
istilah formal, a.b mengontrak indeks terakhir dari tensor a dengan indeks pertama b.) Berikut adalah definisi untuk matriks m dan
vektor v.
Kiri ini mengalikan vektor v dengan m. Objek v secara efektif diperlakukan sebagai vektor kolom dalam kasus ini.
Anda juga dapat menggunakan titik untuk mengalikan kanan v dengan m. Sekarang v secara efektif diperlakukan sebagai vektor
baris.
Anda dapat mengalikan m dengan v di kedua sisi, untuk mendapatkan skalar.
Untuk beberapa tujuan, Anda mungkin perlu merepresentasikan vektor dan matriks secara simbolis, tanpa secara
eksplisit memberikan elemen. Anda dapat menggunakan titik untuk mewakili perkalian dari objek simbolis tersebut.
secara efektif bertindak di sini sebagai bentuk perkalian non-komutatif.
Ini, bagaimanapun, asosiatif.
Produk titik dari jumlah tidak secara otomatis diperluas
Anda dapat menerapkan hukum distributif dalam kasus ini menggunakan fungsi Distribusikan, seperti yang dibahas dalam Bagian
2.2.10
Operator "titik" memberikan "produk dalam" dari vektor, matriks, dan sebagainya. Dalam perhitungan yang lebih maju, Anda dapat
juga perlu membangun produk luar atau Kronecker dari vektor dan matriks. Anda dapat menggunakan fungsi umum Luar untuk
melakukan hal ini.
Hasil kali luar dua buah vektor adalah matriks.
Hasil kali luar matriks dan vektor adalah tensor pangkat tiga.
Produk luar akan dibahas lebih rinci di Bagian 3.7.11.
3. 7. 6 Inversi Matriks
Invers[ m ] cari invers matriks persegi

Berikut adalah matriks 2 x 2 sederhana.
Ini memberikan kebalikan dari m. Dalam menghasilkan rumus ini, Mathematica secara implisit mengasumsikan bahwa determinan a
d - b c bukan nol.
Mengalikan invers dengan matriks asli akan menghasilkan matriks identitas
Anda harus menggunakan Together untuk menghapus penyebut, dan mendapatkan kembali matriks identitas standar.
Berikut adalah matriks bilangan rasional.
Mathematica menemukan kebalikan yang tepat dari matriks.
Mengalikan dengan matriks asli menghasilkan matriks identitas.

Jika Anda mencoba untuk membalikkan matriks tunggal, Mathematica mencetak pesan peringatan, dan mengembalikan
kebalikannya dibatalkan.
Jika Anda memberikan matriks dengan entri simbolis atau numerik yang tepat, Mathematica memberikan kebalikan yang tepat. Jika,
di sisi lain tangan, beberapa entri dalam matriks Anda adalah perkiraan bilangan real, maka Mathematica menemukan hasil numerik
perkiraan.
Berikut adalah matriks yang berisi perkiraan bilangan real.
Ini menemukan kebalikan numerik.
Mengalikan dengan matriks asli memberi Anda matriks identitas dengan kesalahan numerik kecil.
Anda dapat menghilangkan istilah off-diagonal kecil menggunakan Chop.
Ketika Anda mencoba untuk membalikkan matriks dengan entri numerik yang tepat, Mathematica selalu dapat mengetahui apakah
matriks tersebut tunggal. Ketika Anda membalikkan matriks numerik perkiraan, Mathematica biasanya tidak dapat menentukan
dengan pasti apakah atau bukan matriksnya tunggal: yang dapat diketahui adalah misalnya bahwa determinannya kecil dibandingkan
dengan entri-entri dari matriks. Ketika Mathematica mencurigai bahwa Anda mencoba untuk membalikkan matriks numerik tunggal,
ia mencetak peringatan.
Mathematica mencetak peringatan jika Anda membalikkan matriks numerik yang diduga tunggal.
Jika Anda bekerja dengan angka perkiraan presisi tinggi, Mathematica akan melacak presisi invers matriks yang Anda
hasilkan
Ini menghasilkan matriks numerik 6 x 6 dengan entri presisi 50 digit.
Ini mengambil matriks, mengalikannya dengan kebalikannya, dan menunjukkan baris pertama dari hasilnya.
Ini menghasilkan aproksimasi numerik 50 digit ke matriks Hilbert 6 x 6. Matriks Hilbert sangat sulit untuk dibalik secara numerik.
Hasilnya masih benar, tetapi angka nol sekarang memiliki akurasi yang lebih rendah.
Invers hanya bekerja pada matriks persegi. Bagian 3.7.10 membahas fungsi PseudoInverse, yang juga dapat menjadi
digunakan dengan matriks non-persegi.
3. 7. 7 Operasi Matriks Dasar

Transposisi matriks akan menggantikan baris dan kolom dalam matriks. Jika Anda mentranspos matriks män, Anda mendapatkan
matriks n x m sebagai hasilnya.
Transposisi matriks 2 x 3 memberikan hasil 3 x 2.
Det [m] memberikan determinan matriks persegi m. Minors [m] adalah matriks yang elemennya ( i, j) th memberikan determinan i+
j submatriks yang diperoleh dengan menghapus baris ( n - i + 1 ) dan kolom ( n - j + 1) dari m. ( i, j) th kofaktor m adalah (-1)
kali elemen (n - i + 1, n - j + 1) dari matriks minor.
Minor[m, k] memberikan determinan dari submatriks k k yang diperoleh dengan memilih setiap himpunan yang mungkin dari k
baris dan k kolom dari m. Perhatikan bahwa Anda dapat menerapkan Minor ke matriks persegi panjang, serta persegi. Berikut
adalah determinan matriks 2 x 2 sederhana.
Ini menghasilkan matriks 3 x 3, yang entri ke-i, ke-j nya adalah a [i, j].
Jejak atau taji suatu matriks Tr[m] adalah jumlah suku-suku pada diagonal terdepan. Ini menemukan jejak matriks 2 x 2 sederhana.
Matrixpo n th matrix power
wer matrix exponential
Ini setara dengan mengalikan tiga salinan matriks.
Ini adalah kekuatan matriks ke-sejuta
Ini memberikan matriks eksponensial m.
Berikut adalah aproksimasi eksponensial m, berdasarkan aproksimasi deret pangkat.
3. 7. 8 Memecahkan Sistem Linier
Banyak perhitungan melibatkan pemecahan sistem persamaan linier. Dalam banyak kasus, Anda akan merasa nyaman untuk menulis
turunkan persamaan secara eksplisit, dan kemudian selesaikan menggunakan Solve.
Namun, dalam beberapa kasus, Anda mungkin lebih suka mengubah sistem persamaan linier menjadi persamaan matriks, dan
kemudian menerapkan operasi manipulasi matriks untuk menyelesaikannya. Pendekatan ini sering berguna ketika sistem persamaan
muncul sebagai: bagian dari algoritma umum, dan Anda tidak tahu sebelumnya berapa banyak variabel yang akan terlibat.
Suatu sistem persamaan linier dapat dinyatakan dalam bentuk matriks sebagai m.x = b, di mana x adalah vektor variabel.
Perhatikan bahwa jika sistem persamaan Anda lebih jarang, sehingga sebagian besar entri dalam matriks m adalah nol, maka yang
terbaik adalah mewakili matriks sebagai objek SparseArray. Seperti yang dibahas di Bagian 3.7.12, Anda dapat mengonversi dari
simbolik persamaan ke objek SparseArray menggunakan CoefficientArrays. Semua fungsi yang dijelaskan di bagian ini berfungsi
pada objek SparseArray serta matriks biasa.
LinearSolv yang linear kombinasi memenuhi persamaan
e [ m, b ] matriks m . x = MatrixRa nk [ m ]
Ruangkoson RowRedu
vektor x yang
menyelesaikan
persamaan
matriks jumlah baris bebas linier dari m
m . x = b daftar bentuk sederhana dari m
vektor basis diperoleh dengan membuat kombinasi linier
Anda dapat menggunakan Solve secara langsung untuk menyelesaikan persamaan ini.
Anda juga bisa mendapatkan vektor solusi dengan memanggil LinearSolve. Hasilnya setara dengan yang Anda dapatkan dari Solve.
Cara lain untuk menyelesaikan persamaan adalah dengan membalikkan matriks m, lalu mengalikan {a, b} dengan inversnya. Ini
tidak seefisien menggunakan LinearSolve.
RowReduce melakukan versi eliminasi Gaussian dan juga dapat digunakan untuk menyelesaikan persamaan.
Jika Anda memiliki matriks persegi m dengan determinan bukan nol, maka Anda selalu dapat menemukan solusi unik untuk matriks
tersebut persamaan m.x = b untuk sembarang b.
Namun, jika matriks m memiliki determinan nol, maka mungkin tidak ada vektor, atau an jumlah tak terbatas vektor x yang
memenuhi m.x = b untuk b tertentu. Ini terjadi ketika persamaan linier diwujudkan dalam m tidak independen.
Ketika m memiliki determinan nol, selalu mungkin untuk menemukan vektor tak nol x yang memenuhi m.x = 0. Himpunan dari
vektor x yang memenuhi persamaan ini membentuk ruang nol atau inti dari matriks m. Salah satu dari vektor ini dapat menjadi
dinyatakan sebagai kombinasi linier dari himpunan vektor basis tertentu, yang dapat diperoleh dengan menggunakan NullSpace[m].
Berikut adalah matriks sederhana, sesuai dengan dua persamaan linier identik.
Matriks memiliki determinan nol
LinearSolve tidak dapat menemukan solusi untuk persamaan m.x = b dalam kasus ini.
Ada vektor basis tunggal untuk ruang nol m.
Mengalikan vektor basis untuk ruang nol dengan m menghasilkan vektor nol.
Hanya ada 1 baris bebas linier di m.

NullSpace dan MatrixRank harus menentukan apakah kombinasi tertentu dari elemen matriks adalah nol. Untuk perkiraan matriks
numerik, opsi Toleransi dapat digunakan untuk menentukan seberapa dekat dengan nol dianggap baikcukup. Untuk matriks
simbolik yang tepat, terkadang Anda mungkin perlu menentukan sesuatu seperti ZeroTest->(Fullg Sederhanakan[#]==0&) untuk
memaksa lebih banyak yang harus dilakukan untuk menguji apakah ekspresi simbolis adalah nol. Berikut adalah matriks simbolik
sederhana dengan determinan nol
Basis untuk ruang nol dari m berisi dua vektor
Mengalikan m dengan kombinasi linear dari vektor-vektor ini menghasilkan nol.
Ini meminta solusi untuk himpunan persamaan yang tidak konsisten x = 1 dan x = 0.
Matriks ini mewakili dua persamaan, untuk tiga variabel.
LinearSolve memberikan salah satu solusi yang mungkin untuk himpunan persamaan yang tidak ditentukan ini.
Ketika sebuah matriks mewakili sistem persamaan yang tidak ditentukan, matriks tersebut memiliki ruang nol non-trivial. Dalam hal
ini, null ruang direntang oleh satu vektor.
Jika Anda mengambil solusi yang Anda dapatkan dari LinearSolve, dan menambahkan kombinasi linear dari vektor basis untuk
ruang nol, Anda masih mendapatkan solusi.
Jumlah persamaan independen adalah pangkat matriks MatrixRank[m]. Jumlah persamaan redundan adalah Panjang[NullSpace[m]].
Perhatikan bahwa jumlah kuantitas ini selalu sama dengan jumlah kolom di m.
Persamaan menghasilkan fungsi untuk menyelesaikan persamaan bentuk m .x
=b
Dalam beberapa aplikasi, Anda akan ingin menyelesaikan persamaan bentuk m.x = b berkali- kali dengan m yang sama, tetapi
berbeda B. Anda dapat melakukan ini secara efisien di Mathematica dengan menggunakan LinearSolve[m] untuk membuat satu
LinearSolveFuncg bahwa Anda dapat menerapkan sebanyak mungkin vektor yang Anda inginkan.
Ini menciptakan LinearSolveFunction.
Anda mendapatkan hasil yang sama dengan memberikan vektor sebagai argumen eksplisit ke LinearSolve.
Tetapi Anda dapat menerapkan f ke vektor apa pun yang Anda inginkan.
3. 7 .9 Nilai Eigen dan Vektor Eigen
Nilai eigen [m ] daftar nilai eigen dari m

Vektor eigen [ m ] daftar vektor eigen dari m
Sistem eigen [ m ] daftar bentuk nilai eigen, vektor eigen
nilai eigen numerik
Eigenvalues [ N[ m ] ], nilai eigen numerik, dimulai dengan presisi p –
Nilai eigen dari matriks m adalah nilai x1 yang dapat dicari vektor bukan-nol v1 sedemikian rupa sehingga m.yi = x1 v1 .
eigenvectors adalah vektor v1 .
Karakteristik polinomial Karakteristik Polinomial [m, x] untuk matriks n x n diberikan oleh Det[m – x IdentityMatrix[n]]. Nilai
eigen adalah akar dari polinomial ini.
Menemukan nilai eigen dari matriks n x n secara umum melibatkan penyelesaian persamaan polinomial derajat ke-n. Untuk n 5, oleh
karena itu, hasilnya secara umum tidak dapat dinyatakan secara murni dalam istilah radikal eksplisit. Objek root tetap bisa selalu
digunakan, meskipun kecuali untuk matriks yang cukup jarang atau sederhana, ekspresi yang diperoleh sering kompleks yang tidak
terkendali.
Bahkan untuk matriks sesederhana ini, bentuk eksplisit dari nilai eigen cukup rumit.
Jika Anda memberikan matriks perkiraan bilangan real, Mathematica akan menemukan
perkiraan nilai eigen numerik dan vektor eigen.
Eigensystem menghitung nilai eigen dan vektor eigen secara bersamaan. Penugasan menetapkan vals ke daftar nilai eigen, dan vec
ke daftar vektor eigen.
Ini memverifikasi bahwa nilai eigen dan vektor eigen pertama memenuhi kondisi yang sesuai.
Ini menemukan nilai eigen dari matriks 4 x 4 acak. Untuk matriks non-simetris, nilai eigen dapat memiliki bagian imajiner.
Fungsi Nilai Eigen selalu memberi Anda daftar n nilai eigen untuk matriks n x n. Nilai eigennya sesuai ke akar polinomial
karakteristik untuk matriks, dan mungkin tidak harus berbeda. Vektor eigen, pada sisi lain, memberikan daftar vektor eigen yang
dijamin independen. Jika jumlah vektor eigen tersebut kurang dari n, maka vektor Eigen menambahkan nol vektor ke daftar yang
dikembalikannya, sehingga panjang total daftar adalah selalu n.
Namun, hanya ada satu vektor eigen independen untuk matriks. Vektor eigen menambahkan dua vektor nol untuk memberikan total
tiga vektor dalam hal ini.
Eigenvalues [ m, nilai eigen k terbesar dari m
vektor eigen yang sesuai dari m
k ] Eigenvectors [m, k ]
nilai eigen k terkecil dari m
Eigenvalues [ m, − k ]
Nilai eigen mengurutkan nilai eigen numerik sehingga nilai absolut yang besar didahulukan. Dalam banyak situasi, Anda mungkin
hanya tertarik pada nilai eigen terbesar atau terkecil dari suatu matriks. Anda bisa mendapatkannya secara efisien menggunakan
Nilai Eigen[m, k] dan Nilai Eigen[m, -k].
Ini menghitung nilai eigen yang tepat dari matriks bilangan bulat.
Nilai eigen diurutkan dalam urutan penurunan ukuran.
Ini memberikan tiga nilai eigen dengan nilai absolut terbesar.
Nilai eigen umum untuk matriks m terhadap matriks a didefinisikan sebagai xi yang
m.vi = xi a.vi .
Nilai eigen umum sesuai dengan nol dari karakteristik umum polinomial Det[m - x a]
Perhatikan bahwa sementara nilai eigen matriks biasa selalu memiliki nilai yang pasti, beberapa nilai eigen yang digeneralisasi akan
selalu Tak tentu jika polinomial karakteristik umum menghilang, yang terjadi jika m dan a berbagi ruang nol. Perhatikan juga bahwa
nilai eigen yang digeneralisasikan dapat menjadi tak terhingga.
Kedua matriks ini berbagi ruang nol satu dimensi, jadi satu nilai eigen yang digeneralisasikana dalah Tak tentu.
3. 7 . 10 Operasi Matriks Tingkat Lanjut

SingularValueList [ daftar nilai singular bukan nol dari
m] m
SingularValueList [ k nilai tunggal terbesar dari m
m, k ] SingularValueList [ nilai tunggal umum m sehubungan
Nilai singular matriks m adalah akar kuadrat dari nilai eigen m.m* , di mana * menunjukkan transpos Hermitian. Jumlah nilai
singular tersebut adalah dimensi yang lebih kecil dari matriks. SingularValueList mengurutkan nilai tunggal dari terbesar ke terkecil.
Nilai singular yang sangat kecil biasanya tidak berarti secara numerik. Dengan pengaturan opsi Toleransi -> t, SingularValueList
menjatuhkan nilai tunggal yang kurang dari pecahan t dari nilai tunggal terbesar. Untuk matriks numerik perkiraan, toleransi secara
default sedikit lebih besar dari nol.
Jika Anda mengalikan vektor untuk setiap titik dalam bola satuan dalam ruang n-dimensi dengan matriks män m, maka Anda
mendapatkan ellipsoid m-dimensi, yang sumbu utamanya memiliki panjang yang diberikan oleh nilai tunggal m.
Norma 2 dari suatu matriks Norma[m, 2] adalah sumbu utama terbesar dari ellipsoid, sama dengan nilai singular terbesar dari
matriks. Ini juga merupakan panjang maksimum 2-norma m.v untuk setiap vektor satuan yang mungkin v.
Norma-p suatu matriks Norma[m, p] secara umum adalah panjang norma-p maksimum m.v yang dapat dicapai. Kasus-kasus paling
sering dipertimbangkan adalah p = 1, p = 2 dan p = . Juga kadang-kadang dipertimbangkan adalah norma Frobenius, yang
kuadratnya adalah jejak m.m* .
Definisi standar untuk invers matriks gagal jika matriks tidak persegi atau tunggal. Kebalikan semu m(-1) dari matriks m masih
dapat didefinisikan. Ini diatur untuk meminimalkan jumlah kuadrat dari semua entri di m.m-1 , di mana I adalah matriks identitas.
Pseudoinverse
kadang-kadang dikenal sebagai invers umum, atau Kebalikan Moore-Penrose. Hal ini terutama digunakan dalam melakukan masalah
yang berkaitan dengan pemasangan kuadrat terkecil
Dekomposisi nilai singular, atau SVD, adalah elemen dasar dalam banyak algoritma matriks numerik. Ide dasarnya adalah menulis
sembarang matriks m dalam bentuk usv* , di mana s adalah matriks dengan nilai singular m pada diagonalnya, u dan v adalah
matriks ortonormal, dan v* adalah transpos Hermitian dari v.
3. 7. 11 Topik Lanjutan: Tensor
Tensor adalah objek matematika yang memberikan generalisasi vektor dan matriks. Di Mathematica, tensor direpresentasikan
sebagai sekumpulan daftar, bersarang ke sejumlah level tertentu. Level bersarang adalah peringkat tensor.
Tensor peringkat k pada dasarnya adalah tabel nilai k-dimensi. Untuk menjadi tensor peringkat k sejati, itu harus mungkin untuk
menyusun elemen-elemen dalam tabel dalam array berbentuk kubus k-dimensi. Tidak boleh ada lubang atau tonjolan pada kubus.
Indeks yang menentukan elemen tertentu dalam tensor sesuai dengan koordinat dalam balok.
Dimensi tensor sesuai dengan panjang sisi balok.
Salah satu cara sederhana agar tensor rank k dapat muncul adalah dengan memberikan tabel nilai fungsi dari k variabel.
Dalam fisika, tensor yang terjadi biasanya memiliki indeks yang berjalan di atas kemungkinan arah dalam ruang atau
ruangwaktu.
Perhatikan, bagaimanapun, bahwa tidak ada gagasan bawaan tentang indeks tensor kovarian dan kontravarian di Mathematica: Anda
harus mengaturnya secara eksplisit menggunakan tensor metrik.
Table [ f , { i1 , n1 } , buat n1x n2 ...x nk
{i2 , n2 } , … , { ik , nk } ] tensor yang elemen-elemennya adalah nilai f Array [
a, { n1 , n2 , …, nk}] buat n1 n2 ... x nk tensor dengan elemen yang
diberikan dengan menerapkan a
ke
setiap set indeks
ArrayQ [ t , n ] uji apakah t adalah tensor pangkat n

Dimensions [ t ] berikan daftar dimensi tensor
ArrayDepth [ t ] temukan pangkat tensor
MatrixForm menampilkan elemen tensor dalam array dua dimensi. Anda dapat menganggap array sebagai matriks 2 x 3 dari vektor
kolom.
Peringkat tensor sama dengan jumlah indeks yang diperlukan untuk menentukan setiap elemen. Anda dapat memilih
subtensor dengan menggunakan jumlah indeks yang lebih kecil.
Berikut adalah matriks yang juga dapat Anda anggap sebagai tensor 2 x 3.
Menerapkan Transpose memberi Anda tensor 3 x 2. Transpose secara efektif menukar dua "slot" untuk indeks tensor.
Elemen m[[2, 3]] di tensor asli menjadi elemen m[[3, 2]] di tensor yang ditransposisikan.
Jika Anda memiliki tensor yang berisi daftar dengan panjang yang sama pada level yang berbeda, maka Anda dapat menggunakan
Transpose untuk menciutkan level yang berbeda secara efektif.
Ini meruntuhkan ketiga level, memberikan daftar elemen pada "diagonal utama"
Ini membentuk jejak biasa tensor peringkat 3.
Ini menggabungkan elemen diagonal hanya sampai ke level 2.
Ini memberikan "f luar" dari dua vektor. Hasilnya adalah matriks.
Jika Anda mengambil "f luar" dari vektor panjang 3 dengan vektor panjang 2, Anda mendapatkan matriks 3 x 2.
Hasil pengambilan “f terluar” dari matriks 2x2 dan vektor dengan panjang 3 adalah tensor 2x2x 3.
Berikut adalah dimensi tensor.
Ini memberikan generalisasi dari produk skalar standar dari dua vektor.
Ini memberikan generalisasi produk matriks.
Berikut adalah dimensi hasil.
Dalam banyak aplikasi tensor, Anda perlu menyisipkan tanda untuk menerapkan antisimetri. Fungsi Tanda Tangan[i1 , i2, … ], yang
memberikan tanda permutasi, seringkali berguna untuk tujuan ini.
Outer [ f , t1, t2, … ] membentuk produk luar umum dengan
menggabungkan elemen tingkat terendah dari t1 , t2 , …
Luar [ f , t1, t2, perlakukan hanya sublist pada level n sebagai
… , n ] terpisah elemen
Outer [f , t1, t2, … , n1 membentuk bagian dalam yang

, n2, … ] digeneralisasikan
Inner [ f , t1, produk menggunakan element level terendah dari t2 , g, n ]
terpisah
Di sini setiap simbol diperlakukan sebagai elemen terpisah.
Tapi di sini hanya sublist di level 1 yang diperlakukan sebagai elemen terpisah.
3. 7 . 12 Array Jarang
Banyak aplikasi aljabar linier skala besar melibatkan matriks yang memiliki banyak elemen, tetapi secara komparatif sedikit tidak
nol. Anda dapat merepresentasikan matriks jarang seperti itu secara efisien di Mathematica menggunakan objek SparseArray,
sebagai dibahas dalam Bagian 2.4.5. Objek SparseArray bekerja dengan memiliki daftar aturan yang menentukan di mana nilai
bukan nol muncul.
SparseArray [ daftar ] versi SparseArray dari daftar biasa
SparseArray [{ { i1, j1 } −> sebuah m x n sparse array dengan elemen { ik , jk }
v1,
{ i2, j2} −> v2, … } , { m, n array jarang
yang sama
}]
Seperti yang dibahas di Bagian 2.4.5, Anda dapat menggunakan pola untuk menentukan kumpulan elemen dalam larik jarang.
Anda juga bisa memiliki array jarang yang sesuai dengan tensor peringkat apa pun. Ini membuat matriks numerik renggang 50 x
50, dengan 148 elemen bukan nol.
Ini menunjukkan representasi visual dari elemen matriks.

Berikut adalah empat nilai eigen terbesar dari matriks.
memberikan hasil SparseArray
Anda dapat mengekstrak bagian seperti dalam array biasa
Anda dapat menerapkan sebagian besar operasi struktural standar langsung ke objek SparseArray, seperti yang Anda lakukan pada
biasa daftar. Ketika hasilnya jarang, mereka biasanya mengembalikan objek SparseArray.
Dimensio dimensi array
ns [ m ] aturan untuk elemen bukan nol
ArrayRule dalam array
s[m] elem
m[[
en i , j baris
i, j ] ]
Ini memberikan kolom pertama m. Ini hanya memiliki 2 elemen bukan nol.
Ini menambahkan 3 untuk setiap elemen di kolom pertama m.

Sekarang semua elemen di kolom pertama bukan nol.
Ini memberikan aturan untuk elemen bukan nol pada baris kedua.
SparseArray [ aturan ] menghasilkan array yang jarang dari

aturan
CoefficientArrays [ {
eqns1, Eqns2, … } , { x1 , impor array jarang
dari file
Ini menghasilkan matriks acak tridiagonal.
Bahkan kekuatan kesepuluh dari matriks masih cukup jarang
Ini mengekstrak koefisien sebagai array yang jarang.
Berikut adalah array biasa yang sesuai.
Ini mereproduksi bentuk aslinya.

CoefficientArrays dapat menangani persamaan polinomial umum.
3. 8 Operasi Numerik pada Data

3. 8. 1 Statistik Dasar
mean (daftar) mean (rata-rata) Median

(daftar ) median ( nilai tengah)
Max ( daftar ) nilai maksimum
Perbedaan ( daftar ) perbedaan
Deviasi Standar ( daftar ) Standar Deviasi
Kuantil ( daftar , q ) kuantil ke-q
Total ( daftar ) total
Diberikan daftar dengan n elemen xI ,Rata rata Mean [list] didefinisikan sebagai 𝜇 ( 𝑥 ) =
𝑥 = ∑ 𝑥𝑖/𝑛
Perbedaan Variance [daftar] didefinisikan sebagai var ( 𝑥) = 𝜎2(𝑥) = ∑ 𝑥𝑖 − 𝜇 (𝑥))^2/𝑛
Standar deviasi StandardDeviation[list] didefinisikan sebagai 𝜎 ( x) = √𝑣𝑎𝑟 (𝑥)
Jika elemen-elemen dalam daftar dianggap dipilih secara acak menurut beberapa distribusi probabilitas, maka
mean memberikan perkiraan di mana pusat distribusi berada, sedangkan standar deviasi memberikan perkiraan
seberapa luas dispersi dalam distribusi.
Median Median[list] secara efektif memberikan nilai pada titik tengah dalam daftar yang diurutkan Sort[list]. Ini sering dianggap
sebagai ukuran yang lebih kuat dari pusat distribusi daripada rata-rata, karena kurang bergantung pada outlying nilai-nilai.
Kuantil qth Quantile[list, q] secara efektif memberikan nilai yaitu q dari jalan melalui daftar yang diurutkan Urutkan[daftar].
Untuk daftar dengan panjang n, Mathematica mendefinisikan Quantile[list, q] menjadi Sort [list] [[Ceiling [n q]]].
Namun, ada sekitar sepuluh definisi kuantil lain yang digunakan, semuanya berpotensi memberikan hasil yang sedikit berbeda.
Mathematica mencakup kasus-kasus umum dengan memperkenalkan empat parameter kuantil dalam bentuk Quantile[daftar, q, { {a,
b}, {c, d}
}]. Parameter a dan b yang berlaku menentukan di mana dalam daftar harus dianggap sebagai pecahan q jalan melalui. Jika ini sesuai
dengan posisi bilangan bulat, maka elemen pada posisi itu diambil sebagai kuantil ke-q. Jika bukan posisi bilangan bulat, maka
kombinasi linier elemen di kedua sisi digunakan, seperti yang ditentukan oleh c dan d .
Posisi dalam daftar terurut s untuk kuantil ke-q diambil sebagai k = a + (n + b) q. Jika k bilangan bulat, maka kuantilnya adalah s [ [
k ] ]. Jika tidak, itu adalah s [ [ Floor [k] ] ] + (s [ [Ceiling [ k] ] ] – s [ [ Floor [ k ] ] ] ) (c + d Fractionalg Bagian [ k ] ), dengan
indeks yang diambil menjadi 1 atau n jika berada di luar jangkauan.
{ { 0, 0}, {1, 0} } CDF empiris terbalik (default)
{ { 0, 0}, { 0, 1} } interpolasi linier (metode California)
{ { ½ , 0 } , { 0, 0} } elemen bernomor paling dekat dengan q n
{ { 1/2 , 0 } , { 0, 1} } interpolasi linier (metode hidrologi)
{ { 0, 1} , { 0, 1} } estimasi berbasis rata-rata (metode Weibull)
{ { 1, -1 } , { 0, 1} } perkiraan berbasis mode
{ { 1/3 , 1/3 } , { 0, 1 } } estimasi berbasis median
{ { 3/8 , ¼} , { 0, 1 } perkiraan distribusi normal
Kapan pun d = 0, nilai kuantil ke-q selalu sama dengan beberapa elemen aktual dalam daftar, sehingga hasilnya berubah
terputusputus karena q bervariasi. Untuk d = 1, kuantil ke-q menginterpolasi secara linier antara elemen-elemen yang berurutan
dalam daftar.
Median didefinisikan untuk menggunakan interpolasi seperti itu.
Perhatikan bahwa Kuantil [daftar, q] menghasilkan kuartil ketika q = m 4 dan persentil ketika q = m 100.
Ini secara terpisah menemukan rata-rata dari setiap "kolom" data.
Perhatikan bahwa Anda dapat mengekstrak elemen di i th "kolom" dari daftar multidimensi menggunakan list[[All, i]].
Paket standar yang didistribusikan dengan Mathematica mencakup beberapa untuk melakukan statistik yang lebih canggih analisis,
sebagaimana disebutkan dalam Bagian 1.6.7.
3. 8. 2 Pemasangan Kurva
Ada banyak situasi di mana seseorang ingin menemukan formula yang paling sesuai dengan kumpulan data tertentu. Salah satu cara
untuk melakukannya di Mathematica adalah menggunakan Fit.
Fit [ { f1, f2, …} , fi { temukan kombinasi linear dari funi yang paling sesuai dengan nilainya
fun1, fun2, … } , x ]
temukan kombinasi linear dari funi yang paling sesuai dengan nilai
Ini memberikan kecocokan linier ke daftar bilangan prima. Hasilnya adalah kombinasi linear terbaik dari fungsi 1 dan x.
Berikut adalah kecocokan yang ditumpangkan pada data asli.
Ini memberikan kecocokan kuadrat dengan data.
Ini menunjukkan kecocokan yang ditumpangkan pada data asli. Kecocokan kuadrat lebih baik daripada kecocokan linier.
{ f1, titik data yang diperoleh ketika satu koordinat mengambil
2,… nilai 1 ,
{ { x1 , f1 }, {x2, f2 } , … } titik data yang diperoleh ketika satu koordinat
mengambil nilai
x1, x2, …
{ { x1, y1, … , f1 }, titik data yang diperoleh dengan nilai

{ x2, y2, …, f2 } , …} xi , yi , ... dari urutan koordinat
Jika Anda memberikan data dalam bentuk { f 1, f 2, … } maka Fit akan menganggap bahwa berturut-turut f i sesuai dengan nilai a
fungsi pada titik bilangan bulat berturut-turut 1, 2, … . Tetapi Anda juga dapat memberikan data Fit yang sesuai dengan nilai a
berfungsi pada titik sembarang, dalam satu atau lebih dimensi.
Fit [ data, cocok untuk fungsi dari beberapa

{ fun Fun2, … }, { x, y ,variabel
…}]
Ini memberikan tabel nilai x, y dan 1 + 5 x - x y. Anda perlu menggunakan Flatten untuk mendapatkannya dalam bentuk yang tepat
untuk Fit.
Ini menghasilkan kecocokan dengan fungsi dua variabel

Fit mengambil daftar fungsi, dan menggunakan prosedur yang pasti dan efisien untuk menemukan kombinasi linier dari ini fungsi
memberikan kuadrat terkecil yang paling sesuai dengan data Anda. Namun, terkadang Anda mungkin ingin menemukan kecocokan
nonlinier yang tidak hanya terdiri dari kombinasi linier dari fungsi tertentu. Anda dapat melakukan ini menggunakan FindFit, yang
membutuhkan waktu: fungsi bentuk apa pun, lalu mencari nilai parameter yang paling sesuai dengan data Anda.
Temukan Fit (data, formulir) cari nilai pari yang membuat bentuk data
paling
sesuai
{ par1, par2, … }, x ] sesuaikan data
multivariat
Findfit [ data ,
Ini cocok dengan daftar bilangan prima dengan kombinasi linear sederhana dari istilah.
Hasilnya sama seperti dari Fit.
Ini cocok dengan bentuk nonlinier, yang tidak dapat ditangani oleh Fit
Secara default, Fit dan FindFit menghasilkan kecocokan kuadrat terkecil, yang didefinisikan untuk meminimalkan kuantitas x 2 =∑ 𝑖
I1 ri I2 , di mana ri adalah residual yang memberikan perbedaan antara setiap titik data asli dan nilai pasnya. Seseorang dapat,
bagaimanapun, juga mempertimbangkan kecocokan berdasarkan norma-norma lain. Jika Anda mengatur opsi NormFunction -> u,
maka Findg Fit akan mencoba menemukan kecocokan yang meminimalkan kuantitas u[r], di mana r adalah daftar residu. Standarnya
adalah Norm Fungsi
-> Norma, sesuai dengan kecocokan kuadrat terkecil.
Ini menggunakan ∞-norma, yang meminimalkan jarak maksimum antara fit dan data. Hasilnya sedikit berbeda dari kuadrat terkecil.
FindFit bekerja dengan mencari nilai parameter yang menghasilkan paling cocok. Terkadang Anda mungkin harus memberi tahu di
mana untuk mulai melakukan pencarian ini. Anda dapat melakukannya dengan memberikan parameter dalam bentuk { {a, a 0 } { b,
b0 } , … }. Temukan juga memiliki berbagai opsi yang dapat Anda atur untuk mengontrol cara pencariannya.
3. 8. 3 Perkiraan Fungsi dan Interpolasi
Dalam banyak jenis perhitungan numerik, akan lebih mudah untuk memperkenalkan fungsi perkiraan. Perkiraan fungsi dapat
dianggap sebagai generalisasi dari perkiraan bilangan real biasa. Sementara perkiraan bilangan real memberikan nilai presisi tertentu
dari kuantitas numerik tunggal, fungsi perkiraan memberikan nilai tertentu presisi besaran yang bergantung pada satu atau lebih
parameter. Mathematica menggunakan fungsi perkiraan, untuk contoh,
untuk mewakili solusi numerik untuk persamaan diferensial yang diperoleh dengan ND Solve, seperti yang dibahas dalam Bagian
1.6.4.
Perkiraan fungsi dalam Mathematica diwakili oleh objek InterpolingFunction. Benda-benda ini berfungsi seperti fungsi murni yang
dibahas dalam Bagian 2.2.5. Ide dasarnya adalah ketika diberikan argumen tertentu, sebuah Interpog objek latingFunction
menemukan nilai fungsi perkiraan yang sesuai dengan argumen itu. objek InterpolatingFunction berisi representasi dari fungsi
perkiraan berdasarkan interpolasi. Biasanya berisi nilai dan mungkin turunan pada urutan titik. Ini secara efektif mengasumsikan
bahwa fungsi bervariasi dengan lancar di antara titik-titik ini. Akibatnya, ketika Anda menanyakan nilai fungsi dengan tertentu
argumen, objek InterpolingFunction dapat diinterpolasi untuk menemukan perkiraan ke nilai yang Anda inginkan.
Interpolasi [ { f1, f2, … } ] membangun fungsi perkiraan dengan nilai f
i pada bilangan bulat berurutan
Interpolasi [ { { x membangun fungsi perkiraan dengan nilai f i di titik xi
1, f1 }, { x2, f2}, …} ]
Berikut adalah tabel nilai fungsi sinus.
Ini membangun fungsi perkiraan yang mewakili nilai-nilai ini.
Fungsi perkiraan mereproduksi setiap nilai dalam tabel asli
Ini juga memungkinkan Anda untuk mendapatkan nilai perkiraan di titik lain.
Dalam hal ini interpolasi adalah pendekatan yang cukup baik untuk fungsi sinus yang sebenarnya.
Anda dapat bekerja dengan fungsi perkiraan seperti yang Anda lakukan dengan fungsi Mathematica lainnya. Anda
dapat merencanakan fungsi perkiraan, atau melakukan operasi numerik seperti integrasi atau pencarian akar. Jika Anda
memberikan argumen non-numerik, fungsi perkiraan dibiarkan dalam bentuk simbolis
Berikut adalah integral numerik dari fungsi perkiraan.
Berikut adalah integral numerik yang sama untuk fungsi sinus sebenarnya.
Plot dari fungsi perkiraan pada dasarnya tidak dapat dibedakan dari fungsi sinus yang sebenarnya.
Jika Anda membedakan fungsi perkiraan, Mathematica akan mengembalikan fungsip erkiraan lain yang mewakili turunan.
Ini menemukan turunan dari fungsi sinus perkiraan, dan mengevaluasinya pada 𝜋 /6
Hasilnya mendekati persis.

Dalam format output standar, satu-satunya bagian dari objek InterpolingFunction yang dicetak secara eksplisit adalah domainnya.
Jika Anda meminta nilai di luar domain, Mathematica mencetak peringatan, lalu
menggunakan ekstrapolasi untuk menemukan hasilnya.
Semakin banyak informasi yang Anda berikan tentang fungsi yang Anda coba aproksimasi, semakin baik aproksimasi konstruksi
Mathematica. Anda dapat, misalnya, menentukan tidak hanya nilai fungsi pada urutan titik, tetapi juga turunan.
Interpolasi [ { { x1, { membangun perkiraan f1, df1, ddf1, … } }, …} ]

fungsi dengan turunan tertentu di titik xi
Ini membuat tabel nilai fungsi kosinus.
Ini menciptakan fungsi perkiraan menggunakan interpolasi linier antara nilai-nilai dalam tabel.
Fungsi perkiraan terdiri dari kumpulan segmen garis lurus.

Dengan pengaturan default InterpolationOrder -> 3, kurva kubik digunakan, dan fungsinya terlihat mulus
Meningkatkan pengaturan untuk InterpolationOrder biasanya menghasilkan fungsi perkiraan yang lebih mulus.
Namun, jika Anda meningkatkan pengaturan terlalu banyak, goyangan palsu dapat berkembang.
(membangun fungsi perkiraan dari kisi-kisi nilai dua dimensi pada titik-titik bilangan bulat mengasumsikan
nilainilai tersebut berasal dari kisi spasi merata dengan domain yang ditentukan menganggap nilainya berasal dari
kisi dengan garis kisi yang ditentukan)
Ini menginterpolasi array nilai dari titik grid integer.
Berikut adalah nilai pada posisi tertentu.

Berikut ini adalah array nilai lainnya.
Untuk menginterpolasi array ini, Anda secara eksplisit harus memberi tahu Mathematica domain yang dicakupnya.
Interpolasi Daftar berfungsi untuk array dimensi apa pun, dan dalam setiap kasus ia menghasilkan objek Fungsi
Interpolasi yang mengambil jumlah argumen yang sesuai. Ini menginterpolasi array tiga dimensi.
Objek Fungsi Interpolasi yang dihasilkan membutuhkan tiga argumen.
Mathematica tidak hanya dapat menangani fungsi perkiraan numerik murni, tetapi juga fungsi yang melibatkan
simbolis parameter.
Ini menghasilkan Fungsi Interpolasi yang bergantung pada parameter a dan b.
Ini menunjukkan bagaimana nilai interpolasi pada 2.2 bergantung pada parameter
Dengan pengaturan default untuk InterpolationOrder yang digunakan, nilai pada titik ini tidak lagi bergantung pada
a.
Dalam bekerja dengan fungsi perkiraan, Anda cukup sering berakhir dengan kombinasi rumit Interpolatg ingFungsi
objek. Anda selalu dapat memberi tahu Mathematica untuk menghasilkan satu objek InterpolingFunction valid atas
domain tertentu dengan menggunakan FunctionInterpolation.
Ini menghasilkan objek InterpolatingFunction baru yang valid dalam domain 0 hingga 1.
Ini menghasilkan objek Fungsi Interpolasi bersarang.
Ini menghasilkan objek Fungsi Interpolasi dua dimensi murni.
(Membangun fungsi perkiraan dengan mengevaluasi Expr dengan x mulai dari xmin hingga xmax membangun fungsi
perkiraan dimensi yang lebih tinggi)
Transformasi Fourier
Operasi umum dalam menganalisis berbagai jenis data adalah menemukan transformasi Fourier, atau spektrum, dari
daftar nilai. Idenya biasanya untuk memilih komponen data dengan frekuensi tertentu, atau rentang frekuensi.
(Transformasi Fourier terbalik Transformasi Fourier)
Berikut adalah beberapa data, sesuai dengan pulsa persegi.
Berikut ini adalah transformasi Fourier dari data tersebut. Ini melibatkan bilangan kompleks.
Berikut ini adalah transformasi Fourier terbalik.
Fourier berfungsi apakah daftar data Anda memiliki panjang yang merupakan kekuatan dua.
Ini menghasilkan daftar panjang-200 yang berisi sinyal periodik dengan noise acak ditambahkan.
Data terlihat cukup acak jika Anda memplotnya secara langsung.

Transformasi Fourier, bagaimanapun, menunjukkan puncak yang kuat pada 30 + 1, dan puncak simetris pada 201 -
30, mencerminkan frekuensi komponen sinyal asli dekat 30/200
Dalam bidang ilmiah dan teknis yang berbeda, konvensi yang berbeda sering digunakan untuk mendefinisikan
transformasi Fourier diskrit. Opsi FourierParameters di Mathematica memungkinkan Anda memilih salah satu
konvensi yang Anda inginkan.
Mathematica can find Fourier transforms for data in any number of dimensions. In n dimensions, the data is
specified by a list nested n levels deep. Two-dimensional Fourier transforms are often used in image processing.
Konvolusi dan Korelasi

Konvolusi dan korelasi merupakan pusat berbagai jenis operasi pada daftar data. Mereka digunakan di area seperti
pemrosesan sinyal dan gambar, analisis data statistik, perkiraan persamaan diferensial parsial, serta operasi pada
urutan digit dan seri daya.
Baik dalam konvolusi maupun korelasi, ide dasarnya adalah menggabungkan daftar kernel dengan subdaftar daftar
data yang berurutan. Konvolusi kernel Kr dengan list us memiliki bentuk umum r Kr us-r , sedangkan korelasi
memiliki bentuk umum bentuk r Kr us+r
Ini membentuk konvolusi kernel {x, y} dengan daftar data.
Ini membentuk korelasi.

Dalam hal ini membalikkan kernel memberikan hasil yang persis sama dengan ListConvolv
Ini membentuk perbedaan data yang berurutan.
Dalam membentuk sublist untuk digabungkan dengan kernel, selalu ada masalah tentang apa yang harus dilakukan
di akhir daftar data. Oleh default, ListConvolve dan ListCorrelate tidak pernah membentuk sublist yang akan
"menggantung" di ujung daftar data. Ini berarti bahwa output yang Anda dapatkan biasanya lebih pendek dari
daftar data asli.
Dalam praktiknya, seseorang sering ingin mendapatkan output sepanjang daftar data asli. Untuk melakukan ini,
perlu menyertakan sublist yang menjorok satu atau kedua ujung daftar data. Elemen tambahan yang diperlukan
untuk membentuk sublist ini harus diisi dengan semacam "padding".
Secara default, Mathematica mengambil salinan dari daftar asli untuk memberikan padding, jadi efektif
memperlakukan daftar sebagai siklus.
Default tidak melibatkan overhang.

Istilah terakhir dalam elemen terakhir sekarang berasal dari awal daftar.
Sekarang suku pertama dari elemen pertama dan suku terakhir dari elemen terakhir keduanya melibatkan sampul.
Dalam kasus umum ListCorrelate[kernel, list, {kL, kR }] diatur sehingga pada elemen pertama dari hasil, Elemen
pertama dari daftar muncul dikalikan dengan elemen pada posisi kL di kernel, dan di elemen terakhir dari hasil,
elemen Elemen terakhir dari daftar muncul dikalikan dengan elemen pada posisi kR di kernel. Kasus default di
mana tidak ada overhang adalah Diperbolehkan di kedua sisi sehingga sesuai dengan ListCorrelate[kernel, list, {1,
-1}].
Dengan kernel dengan panjang 3, perataan {-1, 2} selalu membuat elemen pertama dan terakhir dari hasil sama.
Untuk banyak jenis data, lebih mudah untuk mengasumsikan bukan bahwa data itu siklis, melainkan diisi di kedua ujungnya
oleh beberapa elemen tetap, seringkali 0, atau oleh beberapa urutan elemen.
Bantalan ini dengan elemen p.
Kasus umum adalah pad dengan nol.
dalam hal ini q muncul di satu ujung, dan p di ujung lainnya.

Pilihan kernel yang berbeda memungkinkan ListConvolve dan ListCorelate digunakan untuk berbagai jenis
komputasi tion.
Berikut adalah kernel Gaussian.
Ini menghasilkan beberapa "data".
Berikut adalah plot datanya.
Ini melibatkan kernel dengan data.
Hasilnya adalah versi data yang dihaluskan.

Anda dapat menggunakan ListConvolve dan ListCorrelate untuk menangani data simbolik dan numerik.
Ini membentuk konvolusi dari dua daftar simbolis.
Hasilnya sesuai persis dengan koefisien dalam bentuk diperluas dari produk polinomial ini.
ListConvolve dan ListCorrelate bekerja pada data dalam sejumlah dimensi.
Ini mengimpor data gambar dari file.
Berikut adalah gambar.

Ini menggabungkan data dengan kernel dua dimensi.
Ini menunjukkan gambar yang sesuai dengan data.

Automata Seluler
Automata seluler menyediakan cara yang nyaman untuk mewakili berbagai jenis sistem di mana nilai-nilai sel
dalam array diperbarui dalam langkah-langkah terpisah sesuai dengan aturan lokal.
Ini dimulai dengan daftar yang diberikan, kemudian mengembangkan aturan 30 untuk empat langkah.
Ini mendefinisikan fungsi sederhana untuk menampilkan evolusi otomat seluler.
Ini menunjukkan 100 langkah evolusi aturan 30 dari kondisi awal acak.
Jika Anda memberikan daftar eksplisit nilai awal, CellularAutomaton akan mengambil elemen dalam daftar ini agar
sesuai dengan semua sel dalam sistem, diatur secara siklis. Tetangga kanan sel di akhir adalah sel di awal.
Seringkali lebih mudah untuk mengatur kondisi awal di mana ada wilayah "benih" kecil, ditumpangkan pada
konstanta "Latar Belakang". Secara default, CellularAutomaton secara otomatis mengisi latar belakang yang cukup
untuk menutupi ukuran pola yang dapat dihasilkan dalam jumlah langkah evolusi yang Anda tentukan.
Ini menunjukkan aturan 30 berkembang dari kondisi awal yang berisi satu sel hitam
Ini menunjukkan aturan 30 berkembang dari kondisi awal yang terdiri dari benih {1,1} pada latar belakang
{1,0,1,1} berulang blok.
Khususnya dalam mempelajari interaksi antar struktur, terkadang Anda mungkin ingin menentukan kondisi awal
untuk automata seluler di mana blok tertentu ditempatkan pada offset tertentu.
Ini mengatur kondisi awal dengan sel hitam pada offset 40
Dalam kasus yang paling sederhana, otomat seluler memungkinkan k nilai yang mungkin atau "warna" untuk
setiap sel, dan memiliki aturan yang melibatkan hingga r tetangga di setiap sisi. Digit dari "nomor aturan" n
kemudian menentukan warna sel baru untuk setiap kemungkinan konfigurasi lingkungan.
Ini mengembangkan satu lingkungan untuk 1 langkah.
Berikut adalah 8 kemungkinan lingkungan untuk k = 2, r = 1 otomat seluler.
Ini menunjukkan warna baru sel tengah untuk masing-masing dari 8 lingkungan.
Untuk aturan 30, urutan ini sesuai dengan basis-2 digit angka 30.
Ini menjalankan aturan umum k = 3, r = 1 dengan aturan nomor 921408.
Untuk aturan otomat seluler umum, setiap digit dari nomor aturan menentukan warna apa yang mungkin dihasilkan
oleh lingkungan yang berbeda dari 2 r + 1 sel. Untuk mengetahui digit mana yang sesuai dengan lingkungan mana,
seseorang secara efektif memperlakukansel-sel di lingkungan sebagai digit dalam nomor. Untuk r = 1 otomat
seluler, nomornya diperoleh dari daftar elemen neig di lingkungan dengan neig . [k^2, k, 1].
Kadang-kadang nyaman untuk mempertimbangkan automata seluler totalistik, di mana nilai baru sel hanya
bergantung pada total nilai di lingkungannya. Seseorang dapat menentukan automata seluler totalistik dengan
nomor aturan atau "kode" di yang setiap digit mengacu pada lingkungan dengan nilai total yang diberikan,
diperoleh misalnya dari neig . [1, 1, 1].
Secara umum, CellularAutomaton memungkinkan seseorang untuk menentukan aturan menggunakan urutan bobot
apa pun. Pilihan lain terkadang nyaman adalah [k, 1, k], yang menghasilkan aturan totalistik luar.
Ini menjalankan k = 3, r = 1 aturan totalistik dengan nomor kode 867.

Aturan dengan rentang r melibatkan semua sel dengan offset -r hingga +r. Terkadang lebih mudah untuk
memikirkan aturan yang hanya melibatkan sel dengan offset tertentu. Anda dapat melakukan ini dengan mengganti
satu r dengan daftar offset
Setiap k = 2 aturan otomat seluler dapat dianggap sesuai dengan fungsi Boolean. Dalam kasus yang paling
sederhana, dasar Fungsi Boolean seperti And atau Nor mengambil dua argumen. Ini dengan mudah ditentukan
dalam aturan otomat seluler sebagai offset {{0}, {1}}. Perhatikan bahwa untuk kompatibilitas dengan penanganan
automata seluler dimensi tinggi, offset harus selalu diberikan dalam daftar, bahkan untuk automata seluler satu
dimensi.
Ini menghasilkan tabel kebenaran untuk aturan 2-sel-neighborhood nomor 7, yang ternyata adalah fungsi Boolean
Nand.
Nomor aturan menyediakan cara yang sangat ringkas untuk menentukan aturan otomat seluler. Tapi terkadang lebih
nyaman untuk menentukan aturan dengan memberikan fungsi eksplisit yang harus diterapkan ke setiap lingkungan
yang mungkin.
Ini menjalankan otomat seluler aditif yang aturannya menambahkan semua nilai di setiap modulo lingkungan 4
Fungsi diberikan argumen kedua, sama dengan nomor langkah.
Saat Anda menentukan aturan berdasarkan fungsi, nilai sel tidak harus berupa bilangan bulat.
Mereka bahkan bisa menjadi simbolis.
Ini menjalankan aturan 30 untuk 5 langkah, hanya mempertahankan langkah terakhir.
Ini menjaga 2 langkah terakhir.
Spec spesifikasi langkah bekerja sangat mirip dengan mengambil elemen dari daftar dengan Take. Namun, satu
perbedaannya adalah bahwa kondisi awal untuk otomat seluler dianggap sebagai langkah 0. Perhatikan bahwa
spesifikasi langkah apa pun dari form (… ) harus dilampirkan dalam daftar tambahan.
Ini berevolusi untuk 100 langkah, tetapi hanya mempertahankan setiap langkah lainnya.
Sebanyak yang Anda dapat menentukan langkah mana yang harus dipertahankan dalam evolusi otomat seluler,
Anda juga dapat menentukan sel mana yang akan menyimpan. Jika Anda memberikan kondisi awal
seperti {a1, a2, … }, blist, maka ai dianggap memiliki offset 0 untuk tujuan menentukan sel mana
yang akan disimpan.
Ini menjaga semua langkah, tetapi menjatuhkan sel pada offset lebih dari 20 di sebelah kiri.
Ini membuat hanya kolom tengah sel.
Jika Anda memberikan kondisi awal seperti { {a1, a2, … }, blist}, maka CellularAutomaton akan selalu efektif
melakukannyaotomat seluler seolah-olah ada jumlah sel yang tak terbatas. Dengan menggunakan specx seperti {
x1, x2 } Anda bisa tahu CellularAutomaton untuk memasukkan hanya sel pada offset tertentu x1 hingga x2 dalam
outputnya. SelulerOtomatis secara default menyertakan sel cukup jauh sehingga nilainya tidak pernah tetap sama
seperti di blist latar belakang.
Secara default, hanya bagian yang tidak hitam konstan yang disimpan.
Menggunakan Semua untuk specx mencakup semua sel yang dapat dipengaruhi oleh otomat seluler dengan rentang
ini.
CellularAutomaton menggeneralisasi secara langsung ke sejumlah dimensi.
Ini adalah spesifikasi aturan untuk otomat seluler totalistik 9-tetangga dua dimensi dengan kode 797
Ini memberikan langkah 0 dan 1 dalam evolusinya.
Ini menunjukkan langkah 70 dalam evolusi.

This shows all steps in a slice along the x axis.
Operasi Numerik pada Fungsi

Matematika Numerik dalam Mathematica
Salah satu fitur penting Mathematica adalah kemampuannya untuk memberi Anda hasil yang tepat, simbolis, untuk
perhitungan. Di sana adalah, bagaimanapun, perhitungan di mana secara matematis tidak mungkin untuk
mendapatkan hasil "bentuk tertutup" yang tepat. Sedemikian kasus, Anda masih sering mendapatkan hasil numerik
perkiraan.
Anda sekarang dapat mengambil bentuk simbolis dari integral, dan menanyakan perkiraan nilai numeriknya.
Ketika Mathematica tidak dapat menemukan hasil eksplisit untuk sesuatu seperti integral tertentu, ia
mengembalikan bentuk simbolis. Anda dapat mengambil bentuk simbolis ini, dan mencoba untuk mendapatkan
nilai numerik perkiraan dengan menerapkan N.
Dengan memberikan argumen kedua ke N, Anda dapat menentukan presisi numerik yang akan digunakan.
Jika Anda ingin mengevaluasi integral secara numerik di Mathematica, maka gunakan Integrasikan dan terapkan N ke
hasilnya adalah bukan cara yang paling efisien untuk melakukannya. Lebih baik daripada menggunakan fungsi
NIntegrate, yang segera memberikan a jawaban numerik, tanpa terlebih dahulu mencoba untuk mendapatkan hasil
yang tepat dan simbolis. Anda harus menyadari bahwa bahkan ketika Integ parut pada akhirnya tidak berhasil
memberi Anda hasil yang tepat, mungkin menghabiskan banyak waktu untuk melakukannya.
NIntegrate mengevaluasi integral numerik secara langsung, tanpa terlebih dahulu mencoba untuk mendapatkan hasil
simbolis.
Ketidakpastian Matematika Numerik

Berikut adalah plot dari fungsi exp (-𝑋2)
Nintegrate memberikan jawaban yang benar untuk integral numerik dari fungsi ini dari -10 hingga
+10.
Namun, jika Anda meminta integral dari -1000 hingga 1000, NIntegrate akan melewatkan puncak di dekat x = 0,
dan memberikan yang salah menjawab.
Integrasi Numerik
Fitur penting dari NIntegrate adalah kemampuannya untuk menangani fungsi yang "meledak" pada titik yang
diketahui. Ninteg parut secara otomatis memeriksa masalah seperti itu di titik akhir wilayah integrase
NIntegrate mendeteksi bahwa singularitas dalam 1 x pada x = 0 tidak dapat diintegralkan.
NIntegrate tidak secara otomatis mencari singularitas kecuali pada titik akhir wilayah integrasi Anda. Kapan
singularitas lain yang hadir, NIntegrate mungkin tidak memberikan jawaban yang tepat untuk integral. Namun
demikian, dalam mengikuti prosedur adaptifnya, NIntegrate akan sering mendeteksi keberadaan perilaku yang
berpotensi tunggal, dan akan memperingatkan Anda tentang hal itu.
Anda juga dapat menggunakan daftar titik tengah xi di NIntegrate untuk menentukan kontur integrasi yang akan
diikuti di pesawat yang kompleks. Kontur diambil terdiri dari urutan segmen garis, mulai dari xmin, melalui
masing-masing xi , dan berakhir di xmax.
Ini mengintegrasikan 1 x di sekitar kontur tertutup pada bidang kompleks, bergerak dari -1, melalui titik -i, 1 dan i,
lalu kembali ke -1.
Dengan pengaturan default untuk semua opsi, NIntegrate melewatkan puncak di exp H-x2L dekat x = 0, dan
memberikan jawaban yang salah untuk integral.
Dengan opsi MinRecursion->3, NIntegrate sampel cukup banyak titik yang memperhatikan puncak sekitar x = 0.
Dengan pengaturan default MaxRecursion, bagaimanapun, NIntegrate tidak dapat menggunakan titik sampel yang
cukup untuk dapat mengharapkan hasil yang akurat menjawab.
Dengan pengaturan MaxRecursion ini, NIntegrate bisa mendapatkan jawaban yang akurat untuk integral.
Cara lain untuk menyelesaikan masalah adalah dengan membuat NIntegrate memecah wilayah integrasi menjadi
beberapa bagian, dengan bagian kecil yang secara eksplisit mencakup lingkungan puncak.
Untuk integral dalam banyak dimensi, NIntegrate membutuhkan waktu yang lama untuk mendapatkan jawaban
yang tepat. Namun, oleh mengatur opsi MaxPoints, Anda dapat memberi tahu NIntegrate untuk memberi Anda
perkiraan kasar saja, mengambil sampel integrand hanya beberapa kali saja.
Ini memberikan perkiraan volume bola satuan dalam tiga dimensi.
Evaluasi Numerik Jumlah dan Produk

Tidak ada hasil pasti untuk jumlah ini, jadi Mathematica membiarkannya dalam bentuk simbolis
Anda dapat menerapkan N secara eksplisit untuk mendapatkan hasil numerik.
Anda juga bisa mendapatkan hasilnya, meskipun kurang efisien, dengan membangun bentuk simbolis dari
penjumlahan, kemudian mengevaluasinya secara numerik.
Solusi Numerik Persamaan Polinomial

Ketika Memecahkan tidak dapat menemukan solusi eksplisit untuk persamaan polinomial, itu mengembalikan
bentuk simbolis dari hasil dalam hal Root objek.
Anda bisa mendapatkan solusi numerik dengan menerapkan N
Ini memberikan solusi numerik untuk presisi 25 digit.
Anda dapat menggunakan NSolv untuk mendapatkan solusi numerik untuk persamaan polinomial secara langsung,
tanpa terlebih dahulu mencoba mencari hasil yang tepat.
NSolv akan selalu memberi Anda set lengkap solusi numerik untuk persamaan polinomial apa pun dalam satu
variabel.
Anda juga bisa mendapatkan solusi numerik untuk himpunan persamaan polinomial simultan. Anda dapat
menggunakan Solve untuk "bersantai" persamaan simultan, dan kemudian menerapkan N untuk mendapatkan hasil
numerik.
Memecahkan menulis solusi dalam hal akar polinomial dalam satu variabel.
Anda dapat menerapkan N untuk mendapatkan hasil numerik.
Pencarian Akar Numerik

NSolv memberi Anda cara umum untuk menemukan aproksimasi numerik untuk solusi persamaan polinomial.
Temuan solusi numerik untuk persamaan yang lebih umum, bagaimanapun, bisa jauh lebih sulit, seperti yang
dibahas dalam Bagian 3.4.2. FindRoot memberi Anda cara untuk mencari solusi numerik untuk persamaan arbitrer,
atau kumpulan persamaan.
Kurva untuk cos(x) dan x berpotongan di satu titik.

Ini menemukan pendekatan numerik untuk nilai x di mana persimpangan terjadi. 0 memberi tahu FindRoot berapa
nilai x untuk coba dulu
Persamaan sin (x) = 0 memiliki jumlah solusi tak terhingga dalam bentuk x = n p. Jika Anda mulai cukup dekat
dengan tertentu solusi, FindRoot akan memberi Anda solusi itu
Jika Anda mulai dengan x = 6, Anda mendapatkan pendekatan numerik untuk solusi x = 2
Jika Anda ingin FindRoot mencari solusi kompleks, maka Anda harus memberikan nilai awal yang kompleks
Ini menemukan nol dari fungsi zeta Riemann.
Ini menemukan solusi untuk satu set persamaan simultan
Variabel yang digunakan oleh FindRoot dapat memiliki nilai yang berupa daftar. Ini memungkinkan Anda untuk
menemukan akar fungsi yang mengambil vektor sebagai argumen.
Ini adalah cara untuk menyelesaikan persamaan linear untuk variabel x.
Ini menemukan vektor eigen x dan nilai eigen a yang dinormalisasi.

Solusi Numerik Persamaan Diferensial
Ini menemukan solusi untuk y dengan x dalam rentang 0 hingga 2, menggunakan kondisi awal untuk y[0].
Ini masih menemukan solusi dengan x dalam rentang 0 hingga 2, tetapi sekarang kondisi awalnya adalah untuk y[3].
Berikut ini adalah masalah nilai batas sederhana.
With a third-order equation, you need to give initial conditions for up to second derivatives.
Ini memplot solusi yang diperoleh.

Dengan persamaan orde ketiga, Anda juga dapat memberikan kondisi batas pada tiga titik.
Mathematica memungkinkan Anda untuk menggunakan kombinasi linear yang sesuai dari nilai fungsi dan
turunannya sebagai syarat batas.
Ini menghasilkan solusi pada rentang 0 hingga 2.
Kondisi awal dalam hal ini mengarah pada beberapa solusi.
Berikut adalah plot dari semua solusi.

Anda dapat menggunakan NDSove untuk menyelesaikan sistem persamaan diferensial berpasangan.
Ini menemukan solusi numerik untuk sepasang persamaan berpasangan.
Ini memplot solusi untuk y dari persamaan ini.
Ini menghasilkan plot parametrik menggunakan x dan y.

Ini membangun satu set lima persamaan diferensial digabungkan dan kondisi awal.
Ini memecahkan persamaan.
Berikut adalah plot dari solusi.

This solves a system of four coupled differential equations.
Berikut adalah solusinya

Ini memecahkan persamaan diferensial di mana turunannya memiliki diskontinuitas.
NDSove mengurangi ukuran langkah di sekitar x = 0 untuk mereproduksi ketegaran secara akurat.
Dalam persamaan ini, y bervariasi jauh lebih cepat daripada z.
NDSove bagaimanapun melacak kedua komponen dengan sukses.

NDSove berhenti setelah mengambil 10.000 langkah.
Sebenarnya ada singularitas dalam solusi di x = 0.
Untuk mengambil solusi persamaan Lorenz sejauh ini, Anda perlu menghapus batas default pada MaxSteps.
Berikut adalah plot parametrik dari solusi dalam tiga dimensi.
Ini memecahkan sistem persamaan diferensial-aljabar.
Inilah solusinya.
Ini menemukan solusi numerik untuk persamaan gelombang. Hasilnya adalah fungsi interpolasi dua dimensi.
Ini menghasilkan plot hasil

Ini menemukan solusi numerik untuk persamaan gelombang nonlinier.
Berikut adalah plot 3D dari hasilnya.
Ini adalah plot kepadatan resolusi yang lebih tinggi dari solusi
Berikut adalah versi persamaan dalam dimensi 2+1.

Ini menghasilkan array plot dari solusi.
Optimasi Numerik
This finds the value of x which minimizes G (x), starting from x = 2

Elemen terakhir dari daftar memberikan nilai di mana minimum tercapai
Kurva ini memiliki dua minimum lokal.
Mulai dari x = 1, Anda mendapatkan minimum lokal di sebelah kanan
Ini memberikan minimum lokal di sebelah kiri, yang dalam hal ini juga minimum global.
Ini segera menemukan minimum global.

With the constraint x > 0, NMinimize will give the local minimum on the right.
Ini menemukan minimum x + 2y dalam lingkaran satuan.
Dalam hal ini Minimize dapat memberikan hasil yang tepat.
Tapi dalam hal ini tidak bisa.

Ini memberikan perkiraan numerik, secara efektif menggunakan NMinimize.
Here is the corresponding problem in matrix form

This makes the first inequality use ≤
Topik Lanjutan: Mengontrol Ketepatan Hasil

Ini melakukan perhitungan presisi mesin dari integral numerik
Ini melakukan perhitungan dengan angka presisi arbitrer 30 digit
Presisi 50 digit tidak dapat dicapai dengan presisi kerja 30 digit.
Topik Lanjutan: Memantau dan Memilih Algoritma
Ini mencetak nilai x setiap kali langkah diambil.

Reap and Sow provide a convenient way to make a list of the steps taken.
Ini menghitung langkah.
Ini menunjukkan langkah-langkah sukses yang diambil dalam mencapai jawaban
Ini menunjukkan setiap kali fungsi dievaluasi.
Pola evaluasi yang dilakukan oleh algoritma di Mathematica bisa sangat rumit.
This solves a differential equation using method m, and returns the number of steps and evaluations needed.
With the method selected automatically, this is the number of steps and evaluations that are needed.
Ini menunjukkan apa yang terjadi dengan beberapa metode lain yang mungkin. Metode Adams yang dipilih secara
otomatis adalah yang tercepat
Topik Lanjutan: Fungsi dengan Ketergantungan Sensitif pada Inputnya

Ini menunjukkan langkah-langkah berturut-turut dalam prosedur iteratif sederhana dengan input 0,1111.
Berikut adalah hasil dengan input 0.1112. Divergensi progresif dari hasil dengan input 0,1111 terlihat.
Ini menunjukkan proses pergeseran yang dicapai oleh FractionalPart[2 x] pada 8 digit biner pertama x.
Langkah-langkah yang berurutan menghasilkan jumlah presisi yang semakin rendah, dan akhirnya tidak ada presisi
sama sekali
Ini meminta ketepatan setiap nomor. Presisi nol menunjukkan bahwa tidak ada angka penting yang benar.
This shows that the exact result is a periodic sequence.
Jika Anda menggunakan angka presisi mesin, Mathematica tidak akan lagi melacak penurunan presisi apa pun.
Ini menghasilkan urutan yang tampaknya acak, bahkan mulai dari input sederhana
Setelah nilai-nilai telah dihitung, seseorang dapat dengan aman menemukan perkiraan numerik untuk mereka.
Berikut adalah 5 hasil terakhir setelah 1000 iterasi, dihitung menggunakan angka pasti.
Menggunakan nomor presisi mesin memberikan hasil yang sepenuhnya salah.
Ini menemukan solusi untuk persamaan Duffing dengan kondisi awal 1.
Here is a plot of the solution.

Berikut adalah persamaan yang sama dengan kondisi awal 1,001.
Solusinya semakin menyimpang dari yang ditunjukkan di atas.

Notasi Matematika dan Lainnya
PERSAMAAN
DIFFERENSIAL
RUMUS PERSAMAAN SOLUSI PERSAMAAN
NO CONTOH SOAL PERSAMAAN DIFERENSIAL
DIFERENSIAL DIFERENSIAL
1. Akar nyata dan
berbeda (m = m1 𝑑 2𝑦 𝑑𝑦
dan m = m2) 𝑦= 𝐴𝑒𝑚1𝑥 + 𝐵𝑒𝑚2𝑥 − 7 + 12𝑦 = 0
𝑑𝑥2 𝑑𝑥
𝑑 2𝑦 𝑑𝑦
𝑎 +𝑏 + 𝑐𝑦 = 0 𝑚2 − 7𝑚 + 12 = 0
𝑑𝑥2 𝑑𝑥
(𝑚 − 3)(𝑚 − 4) =
𝑚 = 3 𝑎𝑡𝑎𝑢 𝑚 = 4
𝑦 = 𝐴𝑒3𝑥 + 𝐵𝑒4𝑥
2. Akar-akar nyata
dan sama (m = m1 𝑑 2𝑦 𝑑𝑦
= m2) 𝑦= 𝑒𝑚1𝑥(𝐴 + 𝐵𝑥) + 10 + 25𝑦 = 0
𝑑𝑥2 𝑑𝑥
𝑑 2𝑦 𝑑𝑦 𝑚2 + 10𝑚 + 25 = 0
𝑎 +𝑏 + 𝑐𝑦 = 0
𝑑𝑥2 𝑑𝑥
(𝑚 + 5)2 = 0
𝑚 = −5
𝑦 = 𝑒−5𝑥(𝐴+ 𝐵𝑥)
3. Akar kompleks (m =
𝜶 ± 𝒋𝜷) 𝑑 2𝑦 𝑑𝑦
𝑦= 𝑒𝛼𝑥(𝐴 cos 𝛽𝑥 + 𝐵 sin 𝛽𝑥) + 4 + 9𝑦 = 0
𝑑𝑥2 𝑑𝑥
𝑑 2𝑦 𝑑𝑦
𝑎 +𝑏 + 𝑐𝑦 = 0
𝑑𝑥2 𝑑𝑥 𝑚2 + 4𝑚 + 9 = 0
−4 ± √16 − 36
𝑚=
2
−4 ± √−20
𝑚=
2
−4 ± 2𝑗√5
𝑚=
2
𝑚 = −2 ± 𝑗√5
𝛼 = −2 𝑑𝑎𝑛 𝛽 = √5
𝑦 = 𝑒−2𝑥(𝐴 cos √5𝑥 + 𝐵 sin √5𝑥)
4. Persamaan bentuk
𝑑2𝑦 𝑦 = 𝐴 cos 𝑛𝑥 + 𝐵 sin 𝑛𝑥 𝑑2𝑦
+ 𝑛2𝑦 = 0 + 16𝑦 = 0
𝑑𝑥2 𝑑𝑥2
𝑚2 = −16
𝑚 = ±𝑗4
𝑦 = 𝐴 cos 4𝑥 + 𝐵 sin 4𝑥
5. Persamaan bentuk
𝑑2𝑦 𝑦 = 𝐴 cosh 𝑛𝑥 + 𝐵 sinh 𝑛𝑥 𝑑2𝑦
− 𝑛2𝑦 = 0 − 25𝑦 = 0
𝑑𝑥2 𝑑𝑥2
𝑚2 = 25
𝑚= ±5
𝑦 = 𝐴 cosh 5𝑥 + 𝐵 sinh 5𝑥
6. Solusi umum 𝑀𝑒𝑛𝑒𝑛𝑡𝑢𝑘𝑎𝑛 𝐶𝐹:

𝑑 2𝑦 𝑑𝑦 𝑦 = 𝐶𝐹 + 𝑃𝐼
𝑎 +𝑏 + 𝑐𝑦 = 0 𝑑2𝑦 𝑑𝑦
𝑑𝑥2 𝑑𝑥 −5 +6=5 2
𝑦 𝑥
𝑑𝑥2 𝑑𝑥
𝑚2 − 5𝑚 + 6 = 0
(𝑚 − 2)(𝑚 − 3) =
𝑚 = 2 𝑎𝑡𝑎𝑢 𝑚 = 3
𝐶𝐹 → 𝑦 = 𝐴𝑒2𝑋 + 𝐵𝑒3𝑥
𝑀𝑒𝑛𝑒𝑛𝑡𝑢𝑘𝑎𝑛 𝑃𝐼:
𝑦 = 5𝐶𝑥2 + 𝐷𝑥 + 𝐸
𝑑𝑦
= 10𝐶𝑥 + 𝐷
𝑑𝑥
𝑑2𝑦
= 10𝐶
𝑑𝑥2
10𝐶 − 5(10𝐶𝑥 + 𝐷) + 6(5𝐶𝑥2 + 𝐷𝑥+ 𝐸) = 5𝑥2
10𝐶 − 50𝐶𝑥 − 5𝐷 + 30𝐶𝑥2 + 6𝐷𝑥 + 6𝐸 = 5𝑥2
30𝐶𝑥2 + (6𝐷 − 50𝐶)𝑥 + (10𝐶 − 5𝐷 + 6𝐸) = 5𝑥2

5 1 1
[𝑥2] → 30𝐶 = 5 ∴𝐶= = ∴ 𝐶=
30 6 6
50 50 50
[𝑥] → 6𝐷 − 50𝐶= 0 ∴ 6𝐷 = = ∴𝐷=
6 36 36
250 10 190 190
[𝐶𝑇] → 10𝐶 − 5𝐷 + 6𝐸 = 0 ∴ 6𝐸 = − = ∴𝐸=
36 6 36 36
𝑥2 50𝑥 190
𝑃𝐼 → 𝑦 = + +
6 36 216
𝑦 = 𝐶𝐹 + 𝑃𝐼
2
𝑦 = 𝐴𝑒2𝑋 + 𝐵𝑒3𝑥 + 𝑥 + 50𝑥+ 190
6 36 216
PERSAMAAN DIFFERENSIAL ORDE 1
No Rumus solusi contoh

1 Dengan integrasi langsung: 𝑦 = ∫ 𝑓(𝑥)𝑑𝑥 𝑑𝑦 = 3𝑥2 − 6𝑥 + 5
𝑑𝑦
𝑑𝑥
= 𝑓(𝑥)
𝑑𝑥 𝑦 = ∫(3𝑥2 − 6𝑥 + 5)𝑑𝑥
𝑦 = 𝑥3 − 3𝑥2 + 5𝑥 + 𝐶
Dengan memisahkan variabel: ∫ 𝑓(𝑦)𝑑𝑦 = 𝑦 = ∫ 𝑓(𝑥)𝑑𝑥
2 𝑑𝑌
𝐹(𝑥). = 𝑓(𝑥) 𝑑𝑦
𝑑𝑥 (𝑦 + 1) = 2𝑥
𝑑𝑥
𝑥𝑑𝑥
∫(𝑦 + 1)𝑑𝑦 = ∫ 2𝑥𝑑𝑥

𝑦2
𝐶
3 Persamaan homogen: 𝑑𝑣 2 2
𝑑𝑦 𝑥 + 𝑦
Mengganti 𝑣+𝑥 = 𝐹(𝑣) =
𝑑𝑥
𝑦 = 𝑣𝑥 𝑑𝑥
𝑑𝑦 𝑑𝑣
∴ =𝑣+𝑥
𝑑𝑥 𝑑𝑥
𝑥2 + 𝑦2 𝑥2 + 𝑣2𝑥2 1 + 𝑣2
𝑑𝑎𝑛 = =
𝑥𝑦 𝑣𝑥 2
𝑑𝑣 1 + 𝑣 2
𝑣 𝑥𝑦
𝑑𝑣 1 + 𝑣2
∴𝑥 =− 𝑣
𝑑𝑥 𝑣 𝑣
𝑣 𝑣
𝑑𝑣 1
∴𝑥 =
𝑑𝑥 𝑣
𝑣2
𝐶
Karena
1
∫ 𝑣 𝑑𝑣 = ∫ 𝑑𝑥
𝑥
𝑣2
𝐶
Semua yang tersisa sekarang adalah untuk
mengekspresikan v kembali dalam hal x dan y. Substitusi
menggunakan 𝑦 = 𝑣𝑥 ∴𝑣=𝑦
𝑥
𝐶
𝑌2 = 2𝑥2(ln 𝑥 + 𝐶)
4 Persamaan linear: Faktor integrasi, 𝐼𝐹 = 𝑒∫𝑃𝑑𝑥 𝑑𝑦 + 𝑦 = 𝑥3

𝑑𝑦 Dan ingatlah bahwa 𝑒∫𝑃𝑑𝑥=F 𝑥
+ 𝑃𝑦 = 𝑄 𝑑𝑥
𝑑𝑥 𝑦𝐼𝐹 = ∫ 𝑄. 𝐼𝐹 𝑑𝑥
𝑑𝑦 + 1 . 𝑦 = 𝑥2
𝑖. 𝑒.
𝑑𝑥 𝑥
Bandingkan dengan[dy + Py = Q]
dx
∴𝑃 𝑑𝑎𝑛 𝑄 = X2
x
IF = e∫Pdx 𝑥
∴ IF = 𝑒ln𝑥 = 𝑥
∴ IF = 𝑥
Solusinya adalah 𝑦. 𝐼𝐹 = ∫ 𝑄. 𝐼𝐹 𝑑𝑥 ,jadi
𝑦𝑥 = ∫ 𝑥2. 𝑥 𝑑𝑥 𝐶
𝑥4
𝐶
5 Persamaan Bernoulli: Bagi dengan 𝑦𝑛: lalu letakkan 𝑧 = 𝑑𝑦 + 1 𝑦 = 𝑥𝑦2
𝑦1−𝑛 𝑑𝑥 𝑥
𝑑𝑦 + 𝑃𝑦 = 𝑄𝑦𝑛 Mengurangi ke tipe (d) di atas. −2 𝑑𝑦 + 1 . 𝑦−1 = 𝑥
𝑑𝑥
𝑦
𝑑𝑥 𝑥
𝑑𝑧 𝑑𝑦
𝑧= 𝑦−1 = ∴ −𝑦−2
𝑑𝑥 𝑑𝑥
𝑑𝑦 1
−𝑦−2 − . 𝑦−1 = −𝑥
𝑑𝑥 𝑥
Sehingga 𝑑𝑧 − 1 𝑧 = −𝑥
𝑑𝑥 𝑥
𝑑𝑧 1
− 𝑧 = −𝑥
𝑑𝑥 𝑥
IF = 𝑒∫𝑃𝑑𝑥 ∫
𝑃𝑑𝑥 𝑥
z. IF
= ∫ Q. IF 𝑑𝑥 .
𝑥 𝑥 𝑑𝑥
𝑧
∴ = ∫ −1 𝑑𝑥 = −𝑥 + 𝐶
𝑥
∴ 𝑧 = 𝐶𝑥 − 𝑥2
Tetapi 𝑧 = 𝑦−1 ∴ 1 = 𝐶𝑥 − 𝑥2 ∴ 𝑦 = (𝐶𝑥 − 𝑥 2 )−1

𝑦

Buku Ringkasan Calculation

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Buku Ringkasan Calculation

Diunggah oleh

Hak Cipta:

Format Tersedia

2021

RINGKASAN TERJEMAHAN BUKU

Sultan Hulio Andrian

Interval [{- }]...................................................................................... 577

MATEMATIKA UNTUK MESIN DAN

1.1 PRINSIP GEOMETRI—ILMU UKUR BIDANG

Pada segitiga sembarang, sudut A + sudut B + sudut C = 180°, dan sudut A =

Gambar 1.1 Segitiga

Gambar 1.2 Segitiga Sembarang

Sudut luar segitiga (lihat Gambar 1.6). Sudut C = sudut A + sudut B

GAMBAR 1.5 Segitiga siku-siku. GAMBAR 1.6 Sudut luar segitiga.

GAMBAR 1.7 Garis lurus berpotongan.

GAMBAR 1.8 Garis lurus yang memotong dua garis sejajar.

Sisi a = a′; sudut A = sudut A′ (lihat Gambar

GAMBAR 1.11 Titik singgung bersama.

GAMBAR 1.12 Garis singgung dan sudut.

GAMBAR 1.13 Setengah sudut (A).

Sudut B = 1/2 sudut A (lihat Gambar

FIGURE 1.16 Line and circle relationship (a 2 = bc).

GAMBAR 1.19 Keliling dan proporsionalitas jari-jari.

1.2 ALJABAR DASAR

1.2.1 Prosedur Aljabar

Memecahkan Persamaan Aljabar Khas. Persamaan aljabar diselesaikan dengan

Logaritma bilangan N ke basis a adalah pangkat eksponen untuk dimana a harus

Hubungan lainnya mengikuti:

Jika a dan b adalah sembarang dua basa, maka

Persamaan dengan lima variabel, ditunjukkan dalam bentuk R. Pemecahan untuk G:

Selesaikan untuk N menggunakan prosedur transposisi yang sama seperti yang

CATATAN. Ketika persamaan kompleks perlu diubah, personel toko dapat

Persamaan yang Ditransposisikan (Sudut dalam Derajat

CATATAN. Nilai sudut dinyatakan dalam

Persamaan yang Ditransposisikan (Sudut dalam Radian)

CATATAN. Nilai sudut dinyatakan dalam radian, yaitu, 90 derajat = /2

sin A = a/c (sinus)

GAMBAR 1.20 Segitiga siku-siku.

1.3.1 Hukum Trigonometri

GAMBAR 1.21 Segitiga miring.

Hukum Sinus. Lihat Gambar 1.21.

Jadi a × sin B = b × sin A; b × sin C = c × sin B, dll.

Dengan hukum sebelumnya, fungsi trigonometri untuk segitiga siku-siku, Teorema

- Dalam segitiga siku-siku Untuk memecahkan

kemudian gunakan trigonometri berfungsi untuk menyelesaikan dua sudut yang

MATEMATIKA UNTUK MESIN DAN PEKERJA LOGAM 1.15

GAMBAR 1.23 Tinggi segitiga x.

Daerah Segitiga. Lihat Gambar 1.24a dan b.

GAMBAR 1.24 Segitiga: (a) segitiga siku-siku; (b) segitiga miring.

GAMBAR 1.25 segitiga.

1.6 BAB SATU

Teorema Pythagoras. Untuk segitiga siku-siku:

CATATAN. Sisi c adalah sisi miring.

Untuk memverifikasi atau memeriksa solusi segitiga, kami memiliki persamaan

Menit = 41/60 = 0,683333 dalam bagian desimal

MATEMATIKA UNTUK MESIN DAN PEKERJA LOGAM 1.17

Menit = 0,5675 × 60 = 34,05 = 34 menit

Detik = 0,05 (menit) × 60 = 3 detik

Oleh karena itu, jawabannya adalah 56°34′3″.

Ringkasan Prosedur Trigonometri untuk Segitiga. Ada empat kemungkinan kasus

Kasus 1. Diketahui satu sisi dan dua sudut: a, A, B

Kasus 2. Diketahui dua sisi dan sudut yang berhadapan dengannya: a,

Semua segitiga miring (tidak siku-siku) dapat diselesaikan dengan menggunakan

Dalam semua kasus, solusi dapat diperiksa dengan persamaan Mollweide.

● Jika sudut A < 90° dan a b, ada satu solusi—segitiga miring.

● Jika sudut A < 90° dan a b, tidak ada solusi.