Goda matematik funktsiyalar

Qo'shish, ayirish, ko'paytirish va bo'lish kabi oddiy amallar operatorlar bilan bajariladi. Kvadrat ildiz, daraja, sinus yoki yaxlitlash kabi hisob-kitoblar uchun esa Goning standart kutubxonasidagi math paketi ishlatiladi.

Bu qismda math paketini dasturga qo'shish, uning funksiyalaridan foydalanishni ko'rib chiqamiz.

`math` paketini import qilish

Paketdagi funksiyalardan foydalanish uchun uni import qilish kerak:

package main

import "math"
import "fmt"

func main() {
    fmt.Println(math.Pi)
}

Natija:

3.141592653589793

Yuqoridagi misolda Pi o'zgaruvchi nomi.

math.Pi - o'zgarmas qiymat, shuning uchun qavs yozilmaydi. math.Sqrt(), fmt.Println() lar funksiya, larga argument berish uchun qavs ishlatiladi.

fmt.Println() math.Pining to'liq qiymatini chiqaradi. Agar sizga faqat ikki xonasi kerak bo'lsa, fmt.Printf() va %.2f formatidan foydalanish kerak bo'ladi:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Printf("Pi: %.2f\n", math.Pi)
}

Natija:

Pi: 3.14

%.2f kasrli sonni verguldan keyin ikki xona bilan ko'rsatadi. %.3f uch xona, %.4f esa to'rt xona chiqaradi. Bu faqat ekrandagi ko'rinishni o'zgartiradi math.Pining qiymatini o'zgartirmaydi.

Tip

Agar bir nechta paketlarni import qilish kerak bo'lsa, odatda ular bitta import blokida yoziladi:

import (
"fmt"
"math"
)

Ko'p ishlatiladigan matematik funksiyalar

math paketidagi funksiyalarning aksariyati float64 qiymat qabul qiladi va float64 qaytaradi.

Funksiya yoki o'zgarmas	Vazifasi
`math.Abs(x)`	`x`ning modulini, ya'ni manfiy bo'lmagan qiymatini qaytaradi
`math.Sqrt(x)`	`x`ning kvadrat ildizini hisoblaydi
`math.Cbrt(x)`	`x`ning kub ildizini hisoblaydi
`math.Pow(x, y)`	`x`ni `y` darajaga oshiradi
`math.Pow10(n)`	10 ning `n`-darajasini hisoblaydi
`math.Min(x, y)`	ikki sondan kichigini qaytaradi
`math.Max(x, y)`	ikki sondan kattasini qaytaradi
`math.Mod(x, y)`	kasrli sonlar uchun bo'lish qoldig'ini hisoblaydi
`math.Floor(x)`	eng yaqin kichik butun qiymat tomonga yaxlitlaydi
`math.Ceil(x)`	eng yaqin katta butun qiymat tomonga yaxlitlaydi
`math.Round(x)`	eng yaqin butun qiymatga yaxlitlaydi
`math.Sin(x)`	radian bilan berilgan `x`ning sinusini hisoblaydi
`math.Cos(x)`	radian bilan berilgan `x`ning kosinusini hisoblaydi
`math.Tan(x)`	radian bilan berilgan `x`ning tangensini hisoblaydi
`math.Asin(x)`	`x`ning arksinusini radianlarda qaytaradi
`math.Acos(x)`	`x`ning arkkosinusini radianlarda qaytaradi
`math.Atan(x)`	`x`ning arktangensini radianlarda qaytaradi
`math.Exp(x)`	`e` sonini `x` darajaga oshiradi
`math.Log(x)`	`x`ning natural logarifmini hisoblaydi
`math.Log10(x)`	`x`ning 10 asosli logarifmini hisoblaydi
`math.Hypot(x, y)`	katetlari `x` va `y` bo'lgan uchburchak gipotenuzasini hisoblaydi
`math.Pi`	π matematik o'zgarmas
`math.E`	e matematik o'zgarmas

Modul, ildiz va daraja

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    son := -12.5

    fmt.Println("Modul:", math.Abs(son))
    fmt.Println("81 ning kvadrat ildizi:", math.Sqrt(81))
    fmt.Println("27 ning kub ildizi:", math.Cbrt(27))
    fmt.Println("2 ning 5-darajasi:", math.Pow(2, 5))
    fmt.Println("10 ning 3-darajasi:", math.Pow10(3))
}

Natija:

Modul: 12.5
81 ning kvadrat ildizi: 9
27 ning kub ildizi: 3
2 ning 5-darajasi: 32
10 ning 3-darajasi: 1000

math.Pow(2, 5) funksiyada 2 - asos, 5 - daraja. Ikkala argument ham hisoblash vaqtida float64 turida bo'ladi.

Aylana yuzini hisoblash

Aylana yuzi S = πr² formula bilan hisoblanadi. Radiusni ekrandan olib, math.Pi va math.Pow() bilan hisoblaymiz:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    var radius float64

    fmt.Print("Aylana radiusini kiriting: ")
    fmt.Scan(&radius)
    yuza := math.Pi * math.Pow(radius, 2)
    fmt.Printf("Aylana yuzi: %.2f\n", yuza)
}

radius uchun 5 kiritilsa, natija quyidagicha bo'ladi:

Aylana radiusini kiriting: 5
Aylana yuzi: 78.54

Kvadratni radius * radius deb ham hisoblash mumkin. math.Pow() ixtiyoriy darajalar bilan ishlaganda foydali bo'ladi.

Gipotenuzani hisoblash

Pifagor teoremasiga ko'ra, katetlari a va b bo'lgan to'g'ri burchakli uchburchakning gipotenuzasi √(a²+b²)ga teng.

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    a := 3.0
    b := 4.0

    oddiyUsul := math.Sqrt(a*a + b*b)
    hypotBilan := math.Hypot(a, b)

    fmt.Println("Sqrt bilan:", oddiyUsul)
    fmt.Println("Hypot bilan:", hypotBilan)
}

Natija:

Sqrt bilan: 5
Hypot bilan: 5

math.Hypot() aynan shu uchun tayyorlangan. U juda katta yoki juda kichik sonlarda oddiy formulaga qaraganda aniqroq hisoblaydi.

Sonlarni yaxlitlash

Floor, Ceil va Round funksiyalari o'xshash ko'rinsa ham, turli yo'nalishda yaxlitlaydi:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    son := 3.7

    fmt.Println("Floor:", math.Floor(son))
    fmt.Println("Ceil:", math.Ceil(son))
    fmt.Println("Round:", math.Round(son))
}

Natija:

Floor: 3
Ceil: 4
Round: 4

math.Floor(3.7) pastga qarab 3ga tushiradi;
math.Ceil(3.7) yuqoriga qarab 4ga ko'taradi;
math.Round(3.7) eng yaqin butun qiymat 4 bo'lgani uchun 4ni qaytaradi.

Bu funksiyalar float64 qaytaradi. Natija ekranda 3 ko'rinsa ham, uning turi float64:

yaxlit := math.Floor(3.7)
fmt.Printf("Qiymat: %v, tur: %T\n", yaxlit, yaxlit)

Manfiy sonlarda etibor berish kerak: math.Floor(-3.2) natijasi -4, math.Ceil(-3.2) natijasi esa -3.

Ma'lum kasr xonasigacha yaxlitlash

Sonni ikki kasr xonasigacha matematik yaxlitlash uchun avval 100ga ko'paytirib, yaxlitlab, keyin 100ga bo'lish mumkin:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    son := 12.3456
    yaxlit := math.Round(son*100) / 100

    fmt.Println(yaxlit)
}

Natija:

12.35

Bu usul qiymatning o'zini yaxlitlaydi. fmt.Printf("%.2f", son) esa faqat chiqarilayotgan ko'rinishni o'zgartiradi.

Warning

float64 ayrim o'nli kasrlarni mutlaqo aniq saqlamaydi. Moliyaviy hisoblarda oddiy float64 yaxlitlash har doim to'g'ri bo'lmasligi mumkin. Pulni eng kichik birlikda butun son sifatida saqlash yoki maxsus decimal turlardan foydalanish kerak.

Eng kichik va eng katta qiymat

math.Min() va math.Max() ikkita float64 qiymatdan birini tanlaydi:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    birinchi := 17.5
    ikkinchi := 12.8

    fmt.Println("Kichigi:", math.Min(birinchi, ikkinchi))
    fmt.Println("Kattasi:", math.Max(birinchi, ikkinchi))
}

Natija:

Kichigi: 12.8
Kattasi: 17.5

Info

Oddiy int qiymatlar bilan ishlaganda ularni float64ga aylantirish kerak bo'ladi. Goning standart kutubxonasida butun sonlar uchun min() va max() ichki funksiyalari ham mavjud.

Daraja va radian

math.Sin(), math.Cos() va math.Tan() burchakni darajada emas, radianda qabul qiladi. Darajani radianga aylantirish uchun quyidagi formulani ishlatish kerak:

radian = daraja × π / 180

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    daraja := 30.0
    radian := daraja * math.Pi / 180

    fmt.Printf("sin(30°) = %.2f\n", math.Sin(radian))
    fmt.Printf("cos(30°) = %.2f\n", math.Cos(radian))
}

Natija:

sin(30°) = 0.50
cos(30°) = 0.87

Warning

math.Sin(30) deb yozish 30 darajani emas, 30 radianni hisoblaydi. Bu trigonometrik funksiyalarda keng uchraydigan xato.

Teskari trigonometrik funksiyalar

math.Asin() va math.Acos() argumenti -1 dan 1 gacha bo'lishi kerak. Ularning natijasi radianda qaytadi. Natijani darajaga o'tkazish uchun 180 / math.Piga ko'paytiramiz:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    qiymat := 0.5
    radian := math.Asin(qiymat)
    daraja := radian * 180 / math.Pi

    fmt.Printf("asin(%.1f) = %.0f°\n", qiymat, daraja)
}

Natija:

asin(0.5) = 30°

Warning

math.Asin(2.5) yoki math.Acos(2.5) kabi oraliqdan tashqaridagi argument to'g'ri emas. Go bunday holatda NaN qaytaradi.

Info

NaN - son emas (Not a Number)

Logarifm va eksponenta

math.Exp(x) ening x-darajasini, math.Log(x) esa natural logarifmni hisoblaydi. Ular bir-biriga teskari amallar:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    x := 2.0
    eDaraja := math.Exp(x)

    fmt.Printf("e^%.0f = %.4f\n", x, eDaraja)
    fmt.Printf("log(%.4f) = %.4f\n", eDaraja, math.Log(eDaraja))
    fmt.Println("10 asosli logarifm:", math.Log10(1000))
}

Natija:

e^2 = 7.3891
log(7.3891) = 2.0000
10 asosli logarifm: 3

math.Log(x) uchun x musbat bo'lishi kerak. math.Log(0) manfiy cheksizlik, manfiy argument esa NaN qaytaradi.

`NaN` va cheksizlik

Ayrim matematik amallarning haqiqiy sonlarda javobi yo'q. math.Sqrt(-1) bunga misol. math paketi bunday holatda ko'pincha NaN qiymatini qaytaradi:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    natija := math.Sqrt(-1)

    fmt.Println(natija)
    fmt.Println("NaN qiymatmi?", math.IsNaN(natija))
}

Natija:

NaN
NaN qiymatmi? true

math.IsNaN() qiymat NaN ekanini tekshiradi. Cheksiz qiymatni math.IsInf() bilan tekshirish mumkin. Odatda dasturda funksiyaga beriladigan argument ruxsat etilgan oraliqda ekanini hisoblashdan oldin tekshiriladi.

Funksiyalarni bir dasturda ko'rish

Quyidagi misol yuqoridagi funksiyalarning bir joyda ko'rsatadi:

main.go
package main

import (
    "fmt"
    "math"
)

func main() {
    x := 2.5
    y := 3.0
    trigQiymat := 0.5

    fmt.Printf("math.Abs(-%v) = %v\n", x, math.Abs(-x))
    fmt.Printf("math.Sin(%v) = %.4f\n", x, math.Sin(x))
    fmt.Printf("math.Cos(%v) = %.4f\n", x, math.Cos(x))
    fmt.Printf("math.Tan(%v) = %.4f\n", x, math.Tan(x))
    fmt.Printf("math.Asin(%v) = %.4f\n", trigQiymat, math.Asin(trigQiymat))
    fmt.Printf("math.Acos(%v) = %.4f\n", trigQiymat, math.Acos(trigQiymat))
    fmt.Printf("math.Atan(%v) = %.4f\n", x, math.Atan(x))
    fmt.Printf("math.Exp(%v) = %.4f\n", x, math.Exp(x))
    fmt.Printf("math.Log(%v) = %.4f\n", x, math.Log(x))
    fmt.Printf("math.Pow(%v, %v) = %.4f\n", x, y, math.Pow(x, y))
    fmt.Printf("math.Pow10(3) = %.4f\n", math.Pow10(3))
    fmt.Printf("math.Sqrt(%v) = %.4f\n", x, math.Sqrt(x))
    fmt.Printf("math.Floor(%v) = %.4f\n", x, math.Floor(x))
    fmt.Printf("math.Ceil(%v) = %.4f\n", x, math.Ceil(x))
    fmt.Printf("math.Round(%v) = %.4f\n", x, math.Round(x))
    fmt.Printf("math.Pi = %.4f\n", math.Pi)
    fmt.Printf("math.E = %.4f\n", math.E)
    fmt.Printf("math.Min(%v, %v) = %.4f\n", x, y, math.Min(x, y))
    fmt.Printf("math.Max(%v, %v) = %.4f\n", x, y, math.Max(x, y))
    fmt.Printf("math.Mod(%v, %v) = %.4f\n", x, y, math.Mod(x, y))
}

Natija:

math.Abs(-2.5) = 2.5
math.Sin(2.5) = 0.5985
math.Cos(2.5) = -0.8011
math.Tan(2.5) = -0.7470
math.Asin(0.5) = 0.5236
math.Acos(0.5) = 1.0472
math.Atan(2.5) = 1.1903
math.Exp(2.5) = 12.1825
math.Log(2.5) = 0.9163
math.Pow(2.5, 3) = 15.6250
math.Pow10(3) = 1000.0000
math.Sqrt(2.5) = 1.5811
math.Floor(2.5) = 2.0000
math.Ceil(2.5) = 3.0000
math.Round(2.5) = 3.0000
math.Pi = 3.1416
math.E = 2.7183
math.Min(2.5, 3) = 2.5000
math.Max(2.5, 3) = 3.0000
math.Mod(2.5, 3) = 2.5000

Bu misolda argumentlar funksiya talab qiladigan oraliqqa mos tanlangan. Natijadagi raqamlar %.4f bilan formatlangan.

Keyingi qism Goda if, else if va else shartlari haqida.

Misollar

1. To‘g‘ri to‘rtburchak yuzi va perimetri

package main

import "fmt"

func main() {
    eni, boyi := 8.0, 5.0
    fmt.Println("Yuza:", eni*boyi)
    fmt.Println("Perimetr:", 2*(eni+boyi))
}

Yuzada tomonlar ko‘paytiriladi, perimetrda esa tomonlar yig‘indisi ikki baravar olinadi.

2. Aylana uzunligi va yuzi

package main

import (
    "fmt"
    "math"
)

func main() {
    radius := 3.0
    fmt.Printf("Uzunlik: %.2f\n", 2*math.Pi*radius)
    fmt.Printf("Yuza: %.2f\n", math.Pi*radius*radius)
}

math.Pi π sonining tayyor va aniqroq qiymatini beradi.

3. Uchta sonning o‘rtacha qiymati

package main

import "fmt"

func main() {
    a, b, c := 7.0, 8.0, 10.0
    ortacha := (a + b + c) / 3
    fmt.Printf("%.2f\n", ortacha)
}

Qiymatlar float64 bo‘lgani uchun natijaning kasr qismi saqlanadi.

4. Foizni hisoblash

package main

import "fmt"

func main() {
    narx := 240_000.0
    chegirmaFoizi := 15.0
    chegirma := narx * chegirmaFoizi / 100
    fmt.Println("Yangi narx:", narx-chegirma)
}

Avval narxning 15 foizi topiladi, keyin boshlang‘ich narxdan ayriladi.

5. Haroratni aylantirish

package main

import "fmt"

func main() {
    celsius := 25.0
    fahrenheit := celsius*9/5 + 32
    fmt.Printf("%.1f °F\n", fahrenheit)
}

Hisob float64 qiymatlar bilan bajarilgani sababli butun sonli bo‘lish natijani qisqartirmaydi.

6. Ikki nuqta orasidagi masofa

package main

import (
    "fmt"
    "math"
)

func main() {
    x1, y1 := 1.0, 2.0
    x2, y2 := 4.0, 6.0
    masofa := math.Hypot(x2-x1, y2-y1)
    fmt.Println(masofa)
}

math.Hypot() koordinatalar farqi asosida masofani hisoblaydi. Natija 5.

7. Yuqoriga qarab bo‘lish

package main

import "fmt"

func main() {
    mahsulot, qutiSigimi := 23, 5
    qutilar := (mahsulot + qutiSigimi - 1) / qutiSigimi
    fmt.Println(qutilar)
}

23 mahsulot uchun 5 ta quti kerak. Formula qoldiq bo‘lsa natijani keyingi butun songa oshiradi.

8. Sonni ma’lum oraliqda saqlash

package main

import (
    "fmt"
    "math"
)

func main() {
    foiz := 135.0
    foiz = math.Max(0, math.Min(foiz, 100))
    fmt.Println(foiz)
}

Ichki Min yuqori chegarani, tashqi Max pastki chegarani saqlaydi. Natija 100.

9. Suzuvchi nuqtali sonlarni taqqoslash

package main

import (
    "fmt"
    "math"
)

func main() {
    a := 0.1 + 0.2
    b := 0.3
    teng := math.Abs(a-b) < 1e-9
    fmt.Println(teng)
}

Kasrli sonlar xotirada taxminiy saqlanishi mumkin. Shu sababli ular kichik ruxsat etilgan farq bilan taqqoslanadi.

10. Murakkab foiz

package main

import (
    "fmt"
    "math"
)

func main() {
    boshlangich := 1_000_000.0
    yillikFoiz := 12.0
    yil := 3.0
    natija := boshlangich * math.Pow(1+yillikFoiz/100, yil)
    fmt.Printf("%.2f\n", natija)
}

math.Pow() har yili oldingi yig‘indiga foiz qo‘shilishini daraja orqali hisoblaydi.

Goda matematik funktsiyalar

math paketini import qilish

Ko'p ishlatiladigan matematik funksiyalar

Modul, ildiz va daraja

Aylana yuzini hisoblash

Gipotenuzani hisoblash

Sonlarni yaxlitlash

Ma'lum kasr xonasigacha yaxlitlash

Eng kichik va eng katta qiymat

Daraja va radian

Teskari trigonometrik funksiyalar

Logarifm va eksponenta

NaN va cheksizlik

Funksiyalarni bir dasturda ko'rish

Misollar

1. To‘g‘ri to‘rtburchak yuzi va perimetri

2. Aylana uzunligi va yuzi

3. Uchta sonning o‘rtacha qiymati

4. Foizni hisoblash

5. Haroratni aylantirish

6. Ikki nuqta orasidagi masofa

7. Yuqoriga qarab bo‘lish

8. Sonni ma’lum oraliqda saqlash

9. Suzuvchi nuqtali sonlarni taqqoslash

10. Murakkab foiz

`math` paketini import qilish

`NaN` va cheksizlik