log#

מחזיר את הלוגריתם הטבעי (בסיס e) של מספר.

log הוא ההופכי של exp. הוא לוקח EXPR מספרי, ממיר אותו ל־float בדיוק כפול אם נדרש, ומחזיר את הלוגריתם שלו לבסיס e (מספר אוילר, בקירוב 2.718281828459045). אם EXPR מושמט, log פועל על $_.

אין built-in עבור לוגריתמים לבסיס שרירותי - השתמשו באלגברה בסיסית (ראו את הדוגמאות למטה) או ב־POSIX::log10 / POSIX::log2 עבור שני הבסיסים הקבועים השכיחים.

תקציר#

log EXPR
log

מה מקבלים בחזרה#

float בדיוק כפול: הלוגריתם הטבעי של EXPR. באופן קונקרטי:

log(1) הוא 0.
log(exp(1)) הוא 1 (הזהות המגדירה).
log(x) עולה ממש עבור x > 0.

קלטים מיוחדים עוקבים אחר כללי IEEE-754 כפי שספריית ה־C של הפלטפורמה מספקת ב־log(3):

log(0) מחזיר אינסוף שלילי (-Inf).
log(x) עבור x < 0 מחזיר NaN.
log(Inf) מחזיר Inf; log(NaN) מחזיר NaN.

התוצאה היא תמיד float, גם כאשר הקלט הוא מספר שלם או מחרוזת.

דוגמאות#

הזהות המגדירה - הלוג הטבעי של e הוא 1:

use POSIX ();
print log(exp(1)), "\n";            # 1

לוגריתם בסיס־10, נבנה מ־log על־ידי החלפת בסיס. הלוג של בסיס־N של מספר שווה ללוג הטבעי שלו מחולק בלוג הטבעי של N:

sub log10 {
    my ($n) = @_;
    return log($n) / log(10);
}

print log10(1000), "\n";            # 3
print log10(0.01), "\n";            # -2

אותו ניב מוכלל לכל בסיס - שימושי עבור ביטים (בסיס 2), דציבלים (בסיס 10), או כל דבר אחר:

sub log_base {
    my ($base, $n) = @_;
    return log($n) / log($base);
}

print log_base(2, 1024), "\n";      # 10
print log_base(16, 65536), "\n";    # 4

פעולה על $_ - שימושית בתוך map או לולאת שורות while:

my @natural_logs = map { log } 1, 2, 3, 4;

המרה מספרית של ארגומנט מחרוזת - log מעריך את האופרנד שלו בהקשר מספרי בדיוק כמו האופרטורים האריתמטיים:

print log("7.389056"), "\n";        # ~2 (log of e^2, give or take)

מקרי קצה#

log(0) הוא -Inf, לא שגיאה ולא חריגת חלוקה־באפס. Perl אינו מת; אתם מקבלים אינסוף float בחזרה וכל אריתמטיקה נוספת מפיצה אותו:
```
my $x = log(0);                   # -Inf
print $x + 1, "\n";               # -Inf
```
log של מספר שלילי הוא NaN. שוב, אין חריגה - הקורא אחראי לבדיקת הטווח אם זה משנה:
```
my $x = log(-1);                  # NaN
print $x == $x ? "num" : "nan", "\n";   # nan (NaN != NaN)
```
הגנו על הקלט אם אתם זקוקים לתוצאה מוגדרת:
```
die "log domain error" unless $n > 0;
my $l = log($n);
```
מחרוזות לא־מספריות מומרות ל־0 ולכן מפיקות -Inf, ותחת use warnings מפעילות Argument "..." isn't numeric:
```
use warnings;
print log("hello"), "\n";         # -Inf, with warning
```
צורה ללא־ארגומנטים משתמשת ב־$_. log עם רשימת ארגומנטים ריקה קורא את הנושא הנוכחי; בתוך map { log } או while (<>) { print log; } זהו הקיצור הרגיל.
קלט מספר שלם לעומת float אינו עושה הבדל לסוג התוצאה: ערך ההחזרה הוא תמיד float. log(2) ו־log(2.0) הם אותו ערך.
Precision is whatever the platform C library’s log(3) delivers
- typically ~15–17 significant decimal digits on x86-64 Linux. Results are not bit-for-bit portable across architectures.

הבדלים מ־upstream#

תואם מלא ל־upstream Perl 5.42.

ראו גם#

exp - ההופכי: exp(log($x)) הוא $x עבור $x > 0, ו־log(exp($x)) הוא $x עבור כל $x סופי
** - אופרטור החזקה; $x ** $y שקול ל־exp($y * log($x)) עבור $x חיובי
POSIX::log10 - לוגריתם בסיס־10, ישירות מספריית ה־C; מהיר יותר ומעט יותר מדויק מ־log($x)/log(10)
POSIX::log2 - לוגריתם בסיס־2, אותו סיפור
POSIX::log1p - log(1 + $x) המחושב במדויק עבור $x קטן, היכן שהצורה הנאיבית מאבדת דיוק