مقالات

5.4: الوظائف اللوغاريتمية


أهداف التعلم

  • تحويل من اللوغاريتمي إلى الأسي.
  • تحويل من أسي إلى لوغاريتمي.
  • تقييم اللوغاريتمات.
  • استخدم اللوغاريتمات المشتركة.
  • استخدم اللوغاريتمات الطبيعية.

في عام 2010 ، ضرب زلزال كبير هايتي ، ودمر أو دمر أكثر من 285000 منزل. بعد عام واحد ، دمر زلزال آخر أقوى مدينة هونشو اليابانية ، ودمر أو دمر أكثر من 332000 مبنى ،مثل تلك الموضحة في الشكل ( PageIndex {1} ). على الرغم من أن كلاهما تسبب في أضرار كبيرة ، إلا أن زلزال عام 2011 كان أقوى 100 مرة من زلزال هايتي. كيف نعرف؟ تقاس شدة الزلازل بمقياس يعرف بمقياس ريختر. سجل زلزال هايتي 7.0 درجات على مقياس ريختربينما سجل الزلزال الياباني 9.0.

مقياس ريختر هو مقياس لوغاريتمي ذو قاعدة عشرية. بمعنى آخر ، الزلزال الذي بلغت قوته (8 ) ليس ضعف قوة الزلزال (4 ). أنه

[10 ^ {8−4} = 10 ^ 4 = 10،000 nonumber ]

مرات عظيمة! في هذا الدرس ، سوف نتحرى طبيعة مقياس ريختر ووظيفة الأساس العشر التي يعتمد عليها.

التحويل من اللوغاريتمي إلى الصيغة الأسية

من أجل تحليل حجم الزلازل أو مقارنة حجم زلزالين مختلفين ، نحتاج إلى أن نكون قادرين على التحويل بين الشكل اللوغاريتمي والأسي. على سبيل المثال ، افترض أن كمية الطاقة المنبعثة من زلزال واحد كانت 500 مرة أكبر من كمية الطاقة المنبعثة من زلزال آخر. نريد حساب الفرق في المقدار. المعادلة التي تمثل هذه المشكلة هي (10 ​​^ x = 500 ) حيث يمثل (x ) الفرق في المقادير على مقياس ريختر. كيف نحل من أجل (س )؟

لم نتعلم بعد طريقة لحل المعادلات الأسية. لا تكفي أي من الأدوات الجبرية التي تمت مناقشتها حتى الآن لحل (10 ​​^ x = 500 ). نعلم أن ({10} ^ 2 = 100 ) و ({10} ^ 3 = 1000 ) ، لذلك من الواضح أن (x ) يجب أن تكون قيمة ما بين 2 و 3 ، بما أن (y = {10} ^ x ) آخذ في الازدياد. يمكننا فحص الرسم البياني ، كما في الشكل ( PageIndex {1} ) ، لتقدير الحل بشكل أفضل.

ومع ذلك ، فإن التقدير من الرسم البياني غير دقيق. لإيجاد حل جبري ، يجب أن نقدم وظيفة جديدة. لاحظ أن الرسم البياني في الشكل ( PageIndex {2} ) يجتاز اختبار الخط الأفقي. الدالة الأسية (y = b ^ x ) هي واحد لواحد ، لذا فإن معكوسها ، (x = b ^ y ) هي أيضًا دالة. كما هو الحال مع جميع الدوال العكسية ، فإننا ببساطة نتبادل (x ) و (y ) ونحل من أجل (y ) لإيجاد الدالة العكسية. لتمثيل (y ) كدالة لـ (x ) ، نستخدم دالة لوغاريتمية من النموذج (y = { log} _b (x) ). القاعدة (ب ) اللوغاريتم من رقم هو الأس الذي يجب أن نرفع بواسطته (b ) للحصول على هذا الرقم.

نقرأ تعبيرًا لوغاريتميًا على النحو التالي ، "اللوغاريتم الذي يحتوي على أساس (ب ) من (س ) يساوي (ص )" أو ، مبسطًا ، "السجل الأساسي (ب ) من (س ) ) هو (ص ) ". يمكننا أيضًا أن نقول ، " (b ) مرفوعًا إلى أس (y ) هو (x ) ،" لأن السجلات هي الأس. على سبيل المثال ، اللوغاريتم الأساسي (2 ) لـ (32 ) هو (5 ) ، لأن (5 ) هو الأس الذي يجب أن نطبقه على (2 ) للحصول على (32 ). بما أن (2 ^ 5 = 32 ) يمكننا كتابة ({ log} _232 = 5 ). نقرأ هذا على أنه "log base (2 ) of (32 ) is (5 )."

يمكننا التعبير عن العلاقة بين الشكل اللوغاريتمي والصيغة الأسية المقابلة لها على النحو التالي:

[ start {align} log_b (x) = y Leftrightarrow b ^ y = x، b> 0، b neq 1 end {align} ]

لاحظ أن القاعدة (ب ) موجبة دائمًا.

نظرًا لأن اللوغاريتم دالة ، تتم كتابتها بشكل صحيح على أنها ( log_b (x) ) ، باستخدام الأقواس للإشارة إلى تقييم الوظيفة ، تمامًا كما نفعل مع (f (x) ). ومع ذلك ، عندما يكون الإدخال متغيرًا أو رقمًا واحدًا ، فمن الشائع ملاحظة إسقاط الأقواس والتعبير مكتوبًا بدون أقواس ، مثل ( log_bx ). لاحظ أن العديد من الآلات الحاسبة تتطلب أقواسًا حول (x ).

يمكننا توضيح تدوين اللوغاريتمات على النحو التالي:

لاحظ أنه عند مقارنة دالة اللوغاريتم والوظيفة الأسية ، يتم تبديل المدخلات والمخرجات. هذا يعني أن (y = log_b (x) ) و (y = b ^ x ) دالات معكوسة.

تعريف الوظيفة اللوغاريتمية

قاعدة لوغاريتمية (ب ) لرقم موجب (س ) تفي بالتعريف التالي.

بالنسبة إلى (x> 0 ) ، (b> 0 ) ، (b ≠ 1 ) ،

[ start {align} y = { log} _b (x) text {يعادل} b ^ y = x end {align} ]

أين،

  • نقرأ ({ log} _b (x) ) كـ "اللوغاريتم مع القاعدة (ب ) من (س )" أو "قاعدة السجل (ب ) من (س ). "
  • اللوغاريتم (y ) هو الأس الذي يجب رفع (b ) إليه للحصول على (x ).

أيضًا ، نظرًا لأن الدالات اللوغاريتمية والأسية تقوم بتبديل قيم (x ) و (y ) ، يتم تبادل المجال ونطاق الدالة الأسية للدالة اللوغاريتمية. لذلك،

  • مجال دالة اللوغاريتم مع القاعدة (ب ) هو ((0 ، infty) ).
  • نطاق دالة اللوغاريتم مع القاعدة (ب ) هو ((- infty ، infty) ).

سؤال وجواب: هل يمكننا أخذ لوغاريتم عدد سالب؟

لا ، لأن قاعدة الدالة الأسية تكون دائمًا موجبة ، فلا يمكن أن تكون أي قوة لتلك القاعدة سالبة. لا يمكننا أبدًا أخذ لوغاريتم عدد سالب. كذلك ، لا يمكننا أخذ لوغاريتم الصفر. قد تنتج الآلات الحاسبة سجلًا لرقم سالب عندما تكون في الوضع المعقد ، لكن سجل الرقم السالب ليس رقمًا حقيقيًا.

الكيفية: إعطاء معادلة بالصيغة اللوغاريتمية ({ log} _b (x) = y ) ، قم بتحويلها إلى الصيغة الأسية

  1. افحص المعادلة (y = { log} _bx ) وحدد (b ) و (y ) و (x ).
  2. أعد كتابة ({ log} _bx = y ) كـ (b ^ y = x ).

مثال ( PageIndex {1} ): التحويل من النموذج اللوغاريتمي إلى النموذج الأسي

اكتب المعادلات اللوغاريتمية التالية في الصورة الأسية.

  1. ({ log} _6 ( sqrt {6}) = dfrac {1} {2} )
  2. ({ السجل} _3 (9) = 2 )

حل

أولاً ، حدد قيم (ب ) و (ص ) و (س ). ثم اكتب المعادلة بالصيغة (b ^ y = x ).

  1. ({ log} _6 ( sqrt {6}) = dfrac {1} {2} )

    هنا ، (b = 6 ) ، (y = dfrac {1} {2} ) ، و (x = sqrt {6} ). لذلك ، فإن المعادلة ({ log} _6 ( sqrt {6}) = dfrac {1} {2} ) تعادل

    (6 ^ { tfrac {1} {2}} = sqrt {6} )

  2. ({ السجل} _3 (9) = 2 )

    هنا ، (ب = 3 ) ، (ص = 2 ) ، و (س = 9 ). لذلك ، فإن المعادلة ({ log} _3 (9) = 2 ) تعادل

(3^2=9)

تمرين ( PageIndex {1} )

اكتب المعادلات اللوغاريتمية التالية في الصورة الأسية.

  1. ({ log} _ {10} (1000000) = 6 )
  2. ({ السجل} _5 (25) = 2 )
الإجابة أ

({ log} _ {10} (1،000،000) = 6 ) يساوي ({10} ^ 6 = 1،000،000 )

الجواب ب

({ log} _5 (25) = 2 ) يساوي (5 ^ 2 = 25 )

التحويل من الصيغة الأسية إلى الصيغة اللوغاريتمية

للتحويل من الأس إلى اللوغاريتمات ، نتبع نفس الخطوات في الاتجاه المعاكس. نحدد القاعدة (ب ) ، الأس (س ) ، والإخراج (ص ). ثم نكتب (x = { log} _b (y) ).

مثال ( PageIndex {2} ): التحويل من النموذج الأسي إلى النموذج اللوغاريتمي

اكتب المعادلات الأسية التالية بالصيغة اللوغاريتمية.

  1. (2^3=8)
  2. (5^2=25)
  3. ({10} ^ {- 4} = dfrac {1} {10،000} )

حل

أولاً ، حدد قيم (ب ) و (ص ) و (س ). ثم اكتب المعادلة بالصيغة (x = { log} _b (y) ).

  1. (2^3=8)

    هنا ، (ب = 2 ) ، (س = 3 ) ، و (ص = 8 ). لذلك ، فإن المعادلة (2 ^ 3 = 8 ) تكافئ ({ log} _2 (8) = 3 ).

  2. (5^2=25)

    هنا ، (ب = 5 ) ، (س = 2 ) ، و (ص = 25 ). لذلك ، فإن المعادلة (5 ^ 2 = 25 ) تكافئ ({ log} _5 (25) = 2 ).

  3. ({10} ^ {- 4} = dfrac {1} {10،000} )

    هنا ، (b = 10 ) ، (x = −4 ) ، و (y = dfrac {1} {10،000} ). لذلك ، فإن المعادلة ({10} ^ {- 4} = dfrac {1} {10،000} ) تعادل ({ log} _ {10} left ( dfrac {1} {10،000} يمين) = - 4 ).

تمرين ( PageIndex {2} )

اكتب المعادلات الأسية التالية بالصيغة اللوغاريتمية.

  1. (3^2=9)
  2. (5^3=125)
  3. (2 ^ {- 1} = dfrac {1} {2} )
الإجابة أ

(3 ^ 2 = 9 ) يساوي ({ log} _3 (9) = 2 )

الجواب ب

(5 ^ 3 = 125 ) يساوي ({ log} _5 (125) = 3 )

الجواب ج

(2 ^ {- 1} = dfrac {1} {2} ) يعادل ({ log} _2 left ( dfrac {1} {2} right) = - 1 )

تقييم اللوغاريتمات

تتيح لنا معرفة المربعات والمكعبات وجذور الأعداد تقييم العديد من اللوغاريتمات ذهنيًا. على سبيل المثال ، ضع في اعتبارك ({ log} _28 ). نسأل ، "إلى أي أس يجب رفع (2 ) للحصول على 8؟" نظرًا لأننا نعلم بالفعل (2 ^ 3 = 8 ) ، فإنه يتبع ذلك ({ log} _28 = 3 ).

الآن فكر في حل ({ log} _749 ) و ({ log} _327 ) عقليًا.

  • نسأل ، "إلى أي أس يجب رفع (7 ) للحصول على (49 )؟" نحن نعلم (7 ^ 2 = 49 ). لذلك ، ({ log} _749 = 2 )
  • نسأل ، "إلى أي أس يجب رفع (3 ) للحصول على (27 )؟" نعلم (3 ^ 3 = 27 ). لذلك ، ( log_ {3} 27 = 3 )

حتى بعض اللوغاريتمات التي تبدو أكثر تعقيدًا يمكن تقييمها بدون آلة حاسبة. على سبيل المثال ، دعنا نقيم ( log _ { ce {2/3}} frac {4} {9} ) عقليًا.

  • نسأل ، "إلى أي الأس يجب رفع ( ce {2/3} ) من أجل الحصول على ( ce {4/9} )؟ "نعلم (2 ^ 2 = 4 ) و (3 ^ 2 = 9 ) ، لذلك [{ left ( dfrac {2} {3} right)} ^ 2 = dfrac {4} {9}. nonumber ] لذلك ، [{ log} _ { ce {2/3}} left ( dfrac {4} {9} right) = 2. لا يوجد رقم]

الكيفية: بالنظر إلى لوغاريتم النموذج (y = { log} _b (x) ) ، قم بتقييمه عقليًا

  1. أعد كتابة المتغير (x ) كقوة لـ (b ): (b ^ y = x ).
  2. استخدم المعرفة السابقة بصلاحيات (ب ) تحديد (ص ) من خلال طرح السؤال ، "إلى أي الأس يجب رفع (ب ) من أجل الحصول على (س )؟"

مثال ( PageIndex {3} ): حل اللوغاريتمات عقليًا

حل (y = { log} _4 (64) ) بدون استخدام الآلة الحاسبة.

حل

أولاً نعيد كتابة اللوغاريتم بالشكل الأسي: (4 ^ y = 64 ). بعد ذلك ، نسأل ، "إلى أي أس يجب رفع (4 ) للحصول على (64 )؟"

نعلم

(4^3=64)

لذلك،

({ السجل} _4 (64) = 3 )

تمرين ( PageIndex {3} )

حل (y = { log} _ {121} (11) ) بدون استخدام الآلة الحاسبة.

إجابه

({ log} _ {121} (11) = dfrac {1} {2} ) (مع الإشارة إلى أن ( sqrt {121} = {(121)} ^ { tfrac {1} {2} } = 11) )

مثال ( PageIndex {4} ): إيجاد قيمة لوغاريتم لمعاملة متبادلة

قم بتقييم (y = { log} _3 left ( dfrac {1} {27} right) ) بدون استخدام الآلة الحاسبة.

حل

أولاً نعيد كتابة اللوغاريتم بالصيغة الأسية: (3 ^ y = dfrac {1} {27} ). بعد ذلك ، نسأل ، "إلى أي أس يجب رفع (3 ) للحصول على ( dfrac {1} {27} )؟"

نحن نعلم (3 ^ 3 = 27 ) ، لكن ما الذي يجب علينا فعله للحصول على المعاملة بالمثل ، ( dfrac {1} {27} )؟ تذكر من العمل مع الأس الذي (b ^ {- a} = dfrac {1} {b ^ a} ). نحن نستخدم هذه المعلومات في الكتابة

[ begin {align *} 3 ^ {- 3} & = dfrac {1} {3 ^ 3} & = dfrac {1} {27} end {align *} ]

لذلك ، ({ log} _3 left ( dfrac {1} {27} right) = - 3 ).

تمرين ( PageIndex {4} )

قم بتقييم (y = { log} _2 left ( dfrac {1} {32} right) ) بدون استخدام الآلة الحاسبة.

إجابه

({ log} _2 left ( dfrac {1} {32} right) = - 5 )

استخدام اللوغاريتمات المشتركة

قد نرى أحيانًا لوغاريتمًا مكتوبًا بدون أساس. في هذه الحالة ، نفترض أن الأساس هو (10 ​​). بمعنى آخر ، يعني التعبير ( log (x) ) ({ log} _ {10} (x) ). نسمي القاعدة (- 10 ) اللوغاريتم أ اللوغاريتم المشترك. يتم استخدام اللوغاريتمات الشائعة لقياس مقياس ريختر المذكور في بداية القسم. تستخدم مقاييس سطوع النجوم ودرجة الحموضة للأحماض والقواعد أيضًا لوغاريتمات مشتركة.

تعريف اللوغاريتم المشترك م

اللوغاريتم الشائع هو لوغاريتم ذو أساس (10 ​​). نكتب ({ log} _ {10} (x) ) ببساطة كـ ( log (x) ). اللوغاريتم الشائع للرقم الموجب (س ) يفي بالتعريف التالي.

بالنسبة إلى (x> 0 ) ،

[ begin {align} y = { log} (x) text {يعادل} {10} ^ y = x end {align} ]

نقرأ ( log (x) ) كـ "اللوغاريتم مع القاعدة (10 ​​) من (x )" أو "السجل الأساسي (10 ​​) من (x )."

اللوغاريتم (y ) هو الأس الذي يجب رفع (10 ​​) إليه للحصول على (س ).

الكيفية: بالنظر إلى لوغاريتم مشترك للنموذج (y = log (x) ) ، قم بتقييمه عقليًا

  1. أعد كتابة المتغير (x ) كقوة لـ (10 ​​): ({10} ^ y = x ).
  2. استخدم المعرفة السابقة بصلاحيات (10 ​​) لتحديد (ص ) من خلال طرح السؤال ، "إلى أي أس يجب رفع (10 ​​) من أجل الحصول على (س )؟"

مثال ( PageIndex {5} ): إيجاد قيمة لوغاريتم مشترك عقليًا

قم بتقييم (y = log (1000) ) بدون استخدام الآلة الحاسبة.

حل

أولاً نعيد كتابة اللوغاريتم بالصيغة الأسية: ({10} ^ y = 1000 ). بعد ذلك ، نسأل ، "إلى أي أس يجب رفع (10 ​​) للحصول على (1000 )؟" نعلم

({10}^3=1000)

لذلك ، ( سجل (1000) = 3 ).

تمرين ( PageIndex {5} )

قم بتقييم (y = log (1،000،000) ).

إجابه

( سجل (1000000) = 6 )

الكيفية: بالنظر إلى لوغاريتم مشترك بالصيغة (y = log (x) ) ، قم بتقييمه باستخدام آلة حاسبة

  1. صحافة [سجل].
  2. أدخل القيمة المعطاة لـ (x ) ، متبوعة بـ [ ) ].
  3. صحافة [أدخل].

مثال ( PageIndex {6} ): إيجاد قيمة لوغاريتم مشترك باستخدام الآلة الحاسبة

أوجد قيمة (y = log (321) ) لأربع منازل عشرية باستخدام الآلة الحاسبة.

حل

  • صحافة [سجل].
  • أدخل 321, تليها [ ) ].
  • صحافة [أدخل].

التقريب لأربع منازل عشرية ، ( log (321) ≈2.5065 ).

تحليل

لاحظ أن ({10} ^ 2 = 100 ) وأن ({10} ^ 3 = 1000 ). نظرًا لأن (321 ) يقع بين (100 ) و (1000 ) ، فإننا نعلم أن ( السجل (321) ) يجب أن يكون بين ( السجل (100) ) و ( السجل ( 1000) ). هذا يعطينا ما يلي:

(100<321<1000)

(2<2.5065<3)

تمرين ( PageIndex {6} )

أوجد قيمة (y = log (123) ) لأربع منازل عشرية باستخدام الآلة الحاسبة.

إجابه

( سجل (123) ≈2.0899 )

مثال ( PageIndex {7} ): إعادة كتابة وحل نموذج أسي حقيقي

كانت كمية الطاقة المنبعثة من زلزال واحد (500 ) أكبر من كمية الطاقة المنبعثة من زلزال آخر. المعادلة ({10} ^ x = 500 ) تمثل هذا الموقف ، حيث (x ) هو الفرق في المقادير على مقياس ريختر. ما الفرق في المقدار لأقرب جزء من ألف؟

حل

نبدأ بإعادة كتابة المعادلة الأسية بالصيغة اللوغاريتمية.

({10} ^ س = 500 )

( log (500) = x ) استخدم تعريف السجل العام.

بعد ذلك نقوم بتقييم اللوغاريتم باستخدام الآلة الحاسبة:

  • صحافة [سجل].
  • أدخل (500 ) متبوعًا بـ [ ) ].
  • صحافة [أدخل].
  • إلى أقرب ألف ، ( log (500) ≈2.699 ).

كان الفرق في المقادير حوالي (2.699 ).

تمرين ( PageIndex {7} )

كانت كمية الطاقة المنبعثة من زلزال واحد أكبر (8500 ) مرة من كمية الطاقة المنبعثة من زلزال آخر. المعادلة ({10} ^ x = 8500 ) تمثل هذا الموقف ، حيث (x ) هو الفرق في المقادير على مقياس ريختر. ما الفرق في المقدار لأقرب جزء من ألف؟

إجابه

كان الفرق في المقادير حوالي (3.929 ).

استخدام اللوغاريتمات الطبيعية

القاعدة الأكثر استخدامًا للوغاريتمات هي (هـ ). اللوغاريتمات الأساسية مهمة في حساب التفاضل والتكامل وبعض التطبيقات العلمية ؛ يطلق عليهم اللوغاريتمات الطبيعية. القاعدة (e ) اللوغاريتم ، ({ log} _e (x) ) ، لها تدوينها الخاص ، ( ln (x) ). يمكن إيجاد معظم قيم ( ln (x) ) باستخدام الآلة الحاسبة فقط. الاستثناء الرئيسي هو أن لوغاريتم (1 ) دائمًا (0 ) في أي قاعدة ، ( ln1 = 0 ). بالنسبة إلى اللوغاريتمات الطبيعية الأخرى ، يمكننا استخدام مفتاح ( ln ) الذي يمكن العثور عليه في معظم الآلات الحاسبة العلمية. يمكننا أيضًا إيجاد اللوغاريتم الطبيعي لأي قوة لـ (e ) باستخدام الخاصية العكسية للوغاريتمات.

تعريف اللوغاريتم الطبيعي م

اللوغاريتم الطبيعي هو لوغاريتم ذو أساس (هـ ). نكتب ({ log} _e (x) ) ببساطة كـ ( ln (x) ). اللوغاريتم الطبيعي لعدد موجب (س ) يفي بالتعريف التالي.

بالنسبة إلى (x> 0 ) ،

(y = ln (x) ) يساوي (e ^ y = x )

نقرأ ( ln (x) ) كـ "اللوغاريتم ذو القاعدة (e ) لـ (x )" أو "اللوغاريتم الطبيعي لـ (x )."

اللوغاريتم (y ) هو الأس الذي يجب رفع (e ) إليه للحصول على (x ).

نظرًا لأن الدالات (y = e ^ x ) و (y = ln (x) ) هي وظائف عكسية ، ( ln (e ^ x) = x ) للجميع (x ) و (e ^ { ln (x)} = x ) لـ (x> 0 ).

الكيفية: بإعطاء لوغاريتم طبيعي بالصيغة (y = ln (x) ) ، قم بتقييمه باستخدام آلة حاسبة

  1. صحافة [LN].
  2. أدخل القيمة المعطاة لـ (x ) ، متبوعة بـ [ ) ].
  3. صحافة [أدخل].

مثال ( PageIndex {8} ): تقييم اللوغاريتم الطبيعي باستخدام الآلة الحاسبة

أوجد قيمة (y = ln (500) ) لأربع منازل عشرية باستخدام الآلة الحاسبة.

حل

  • صحافة [LN].
  • أدخل (500 ) متبوعًا بـ [ ) ].
  • صحافة [أدخل].

التقريب لأقرب أربع منازل عشرية ، ( ln (500) ≈6.2146 )

تمرين ( PageIndex {8} )

أوجد قيمة ( ln (500) ).

إجابه

لا يمكن أخذ لوغاريتم عدد سالب في مجموعة الأعداد الحقيقية.

وسائط

قم بالوصول إلى هذا المورد عبر الإنترنت للحصول على تعليمات وممارسات إضافية باستخدام اللوغاريتمات.

  • مقدمة في اللوغاريتمات

المعادلات الرئيسية

تعريف الوظيفة اللوغاريتميةبالنسبة إلى (x> 0 ) ، (b> 0 ) ، (b ≠ 1 ) ، (y = { log} _b (x) ) إذا وفقط إذا (b ^ y = x ).
تعريف اللوغاريتم المشتركبالنسبة إلى (x> 0 ) ، (y = log (x) ) إذا وفقط إذا ({10} ^ y = x ).
تعريف اللوغاريتم الطبيعيبالنسبة إلى (x> 0 ) ، (y = ln (x) ) إذا وفقط إذا (e ^ y = x ).

المفاهيم الرئيسية

  • معكوس الدالة الأسية دالة لوغاريتمية ، وعكس الدالة اللوغاريتمية هو دالة أسية.
  • يمكن كتابة المعادلات اللوغاريتمية في شكل أسي مكافئ ، باستخدام تعريف اللوغاريتم. راجع المثال ( PageIndex {1} ).
  • يمكن كتابة المعادلات الأسية بالصيغة اللوغاريتمية المكافئة لها باستخدام تعريف اللوغاريتم انظر المثال ( PageIndex {2} ).
  • الدوال اللوغاريتمية ذات القاعدة (ب ) يمكن تقييمها عقليًا باستخدام المعرفة السابقة بصلاحيات (ب ). راجع المثال ( PageIndex {3} ) والمثال ( PageIndex {4} ).
  • يمكن تقييم اللوغاريتمات الشائعة عقليًا باستخدام المعرفة السابقة بصلاحيات (10 ​​). راجع المثال ( PageIndex {5} ).
  • عندما لا يمكن تقييم اللوغاريتمات الشائعة عقليًا ، يمكن استخدام آلة حاسبة. راجع المثال ( PageIndex {6} ).
  • يمكن إعادة كتابة المشاكل الأسية في العالم الحقيقي مع base (10 ​​) كلوغاريتم شائع ثم تقييمه باستخدام الآلة الحاسبة. راجع المثال ( PageIndex {7} ).
  • يمكن تقييم اللوغاريتمات الطبيعية باستخدام آلة حاسبة مثال ( PageIndex {8} ).

رسم وظائف لوغاريتمية بيانية [5.4] 2. إعطاء f (x) = 4 (2) *. أ. أوجد f & # x27 (x). ملاحظة: يجب أن تكون وظيفتك عبارة عن لوغاريتم واحد ، لذا استخدم تغيير الصيغة الأساسية إذا لزم الأمر.

help_outline

نسخ الصورةقريب

رسم وظائف لوغاريتمية بيانية [5.4] 2. إعطاء f (x) = 4 (2) *. أ. أوجد f & # x27 (x). ملاحظة: يجب أن تكون وظيفتك عبارة عن لوغاريتم واحد ، لذا استخدم تغيير الصيغة الأساسية إذا لزم الأمر.


Lua هي لغة مكتوبة ديناميكيًا. هذا يعني أن المتغيرات لا تحتوي على أنواع فقط من القيم. لا توجد تعريفات للأنواع في اللغة. كل القيم لها نوعها الخاص.

جميع القيم في Lua هي قيم من الدرجة الأولى. هذا يعني أنه يمكن تخزين جميع القيم في متغيرات ، وتمريرها كوسيطات إلى وظائف أخرى ، وإعادتها كنتائج.

هناك ثمانية أنواع أساسية في Lua: لا شيء, قيمة منطقية, عدد, خيط, وظيفة, بيانات المستخدم, مسلك، و الطاولة. نوع لا شيء له قيمة واحدة ، لا شيء، التي تكون ملكيتها الرئيسية مختلفة عن أي قيمة أخرى ، فإنها غالبًا ما تمثل عدم وجود قيمة مفيدة. نوع قيمة منطقية له قيمتان ، خاطئة و حقيقية. كلاهما لا شيء و خاطئة جعل الشرط خاطئًا يتم استدعاؤهم بشكل جماعي قيم خاطئة. أي قيمة أخرى تجعل الشرط صحيحًا. على الرغم من اسمها ، خاطئة كثيرا ما يستخدم كبديل ل لا شيء، مع الاختلاف الرئيسي خاطئة تتصرف مثل قيمة عادية في جدول ، بينما يتصرف ملف لا شيء في الجدول يمثل مفتاحًا غائبًا.

نوع عدد يمثل كلاً من الأعداد الصحيحة والأرقام الحقيقية (الفاصلة العائمة) ، باستخدام نوعين فرعيين: عدد صحيح و يطفو. يستخدم Lua القياسي أعدادًا صحيحة 64 بت وعوامات مزدوجة الدقة (64 بت) ، ولكن يمكنك أيضًا ترجمة Lua بحيث يستخدم أعدادًا صحيحة 32 بت و / أو عوامات أحادية الدقة (32 بت). يعد الخيار الذي يحتوي على 32 بتًا لكل من الأعداد الصحيحة والعوامات جذابًا بشكل خاص للآلات الصغيرة والأنظمة المدمجة. (راجع الماكرو LUA_32BITS في الملف luaconf.h.)

ما لم يذكر خلاف ذلك ، أي تجاوز عند معالجة قيم الأعداد الصحيحة التفاف حولها، وفقًا للقواعد المعتادة للحساب الثنائي. (بمعنى آخر ، النتيجة الفعلية هي العدد الصحيح الفريد الذي يمكن تمثيله والذي يساوي modulo 2 ن إلى النتيجة الرياضية ، أين ن هو عدد وحدات البت من نوع العدد الصحيح.)

يحتوي Lua على قواعد صريحة حول وقت استخدام كل نوع فرعي ، ولكنه أيضًا يتحول فيما بينها تلقائيًا حسب الحاجة (انظر القسم 3.4.3). لذلك ، قد يختار المبرمج تجاهل الاختلاف بين الأعداد الصحيحة والعائمة أو تولي السيطرة الكاملة على تمثيل كل رقم.

نوع خيط يمثل متواليات ثابتة من البايت. Lua نظيف 8 بت: يمكن أن تحتوي السلاسل على أي قيمة 8 بت ، بما في ذلك الأصفار المضمنة (' 0'). يعتبر Lua أيضًا حياديًا في الترميز ولا يقدم أي افتراضات حول محتويات سلسلة. يجب أن يتناسب طول أي سلسلة في Lua مع عدد صحيح من Lua.

يمكن لـ Lua استدعاء (ومعالجة) الوظائف المكتوبة في Lua والوظائف المكتوبة في C (انظر القسم3.4.10). كلاهما يتم تمثيلهما بالنوع وظيفة.

نوع بيانات المستخدم للسماح بتخزين بيانات C التعسفية في متغيرات Lua. تمثل قيمة بيانات المستخدم كتلة من الذاكرة الأولية. هناك نوعان من بيانات المستخدم: بيانات المستخدم الكاملة، وهو كائن به كتلة من الذاكرة يديرها Lua ، و بيانات مستخدم خفيفة، وهي ببساطة قيمة مؤشر C. لا تحتوي Userdata على عمليات محددة مسبقًا في Lua ، باستثناء اختبار التعيين والهوية. باستخدام metatables، يمكن للمبرمج تحديد العمليات لقيم بيانات المستخدم الكاملة (انظر القسم 2.4). لا يمكن إنشاء قيم Userdata أو تعديلها في Lua ، فقط من خلال C API. هذا يضمن سلامة البيانات التي يملكها البرنامج المضيف ومكتبات سي.

نوع مسلك يمثل خيوط التنفيذ المستقلة ويتم استخدامه لتنفيذ coroutines (انظر القسم 2.6). لا ترتبط مؤشرات الترابط الخاصة بـ Lua بمؤشرات ترابط نظام التشغيل. يدعم Lua coroutines على جميع الأنظمة ، حتى تلك التي لا تدعم الخيوط في الأصل.

نوع الطاولة ينفذ المصفوفات الترابطية ، أي المصفوفات التي يمكن أن تحتوي كمؤشرات ليس فقط على أرقام ، ولكن أي قيمة Lua باستثناء لا شيء و NaN. (ليس رقما هي قيمة خاصة للفاصلة العائمة يستخدمها معيار IEEE 754 لتمثيل نتائج رقمية غير محددة ، مثل 0/0.) يمكن أن تكون الجداول غير متجانسة أي أنها يمكن أن تحتوي على قيم من جميع الأنواع (باستثناء لا شيء). أي مفتاح مرتبط بالقيمة لا شيء لا يعتبر جزء من الجدول. وعلى العكس من ذلك ، فإن أي مفتاح ليس جزءًا من جدول له قيمة مقترنة لا شيء.

الجداول هي الآلية الوحيدة لهيكلة البيانات في Lua ويمكن استخدامها لتمثيل المصفوفات العادية ، والقوائم ، وجداول الرموز ، والمجموعات ، والسجلات ، والرسوم البيانية ، والأشجار ، وما إلى ذلك. لتمثيل السجلات ، يستخدم Lua اسم الحقل كفهرس. تدعم اللغة هذا التمثيل من خلال توفير a.name كسكر نحوي لـ ["الاسم"]. توجد عدة طرق ملائمة لإنشاء الجداول في Lua (راجع القسم 3.4.9).

مثل الفهارس ، يمكن أن تكون قيم حقول الجدول من أي نوع. على وجه الخصوص ، نظرًا لأن الوظائف هي قيم من الدرجة الأولى ، يمكن أن تحتوي حقول الجدول على وظائف. وبالتالي يمكن أن تحمل الجداول أيضًا أساليب (انظر القسم 3.4.11).

تتبع فهرسة الجداول تعريف المساواة الخام في اللغة. تشير التعبيرات a [i] و [j] إلى نفس عنصر الجدول إذا وفقط إذا كانت i و j متساوية (أي متساوية بدون طرق). على وجه الخصوص ، العوامات ذات القيم المتكاملة تساوي الأعداد الصحيحة الخاصة بها (على سبيل المثال ، 1.0 == 1). لتجنب الالتباسات ، يتم تحويل أي عدد عشري يستخدم كمفتاح يساوي عددًا صحيحًا إلى هذا العدد الصحيح. على سبيل المثال ، إذا كتبت [2.0] = صحيح ، فسيكون المفتاح الفعلي الذي تم إدخاله في الجدول هو الرقم الصحيح 2.

الجداول والوظائف والخيوط وقيم بيانات المستخدم (الكاملة) هي شاء: المتغيرات لا في الواقع يحتوي هذه القيم فقط المراجع لهم. التعيين وتمرير المعلمة وإرجاع الدالة دائمًا ما تعالج الإشارات إلى مثل هذه القيم ، ولا تعني هذه العمليات أي نوع من النسخ.

يقوم نوع وظيفة المكتبة بإرجاع سلسلة تصف نوع قيمة معينة (انظر النوع).


ما الجديد في Swift 5.4؟

متغيرات متعددة ، بناء جملة ضمني محسّن للعضو ، بناة النتائج ، والمزيد!

يجلب Swift 5.4 معه بعض التحسينات الضخمة في التجميع ، بما في ذلك إكمال أكواد أفضل في التعبيرات مع الأخطاء وزيادة السرعة الكبيرة للترجمة المتزايدة. ومع ذلك ، فإنه يضيف أيضًا بعض الميزات والتحسينات الجديدة المهمة ، لذا دعنا نتعمق فيها هنا ...

برعاية أداة تصميم مصممة لـ SwiftUI. ابدأ تحديث التصميم التالي باستخدام قوالب تصميم SwiftUI المضمنة. وفر الوقت عن طريق تخطي الحاجة إلى إعداد بيئة تطوير كاملة. صمم مجانًا مع ما يصل إلى 5 ملفات أو احصل على عام كامل من الملفات غير المحدودة والمزيد مقابل 29.99 دولارًا.

تحسين بناء جملة العضو الضمني

يعمل SE-0287 على تحسين قدرة Swift على استخدام تعبيرات العضو الضمنية ، لذا بدلاً من مجرد الحصول على دعم لعضو ثابت واحد بالضبط ، يمكنك إنشاء سلاسل منها.

لطالما كان لدى Swift القدرة على استخدام بناء جملة العضو الضمني للتعبيرات البسيطة ، على سبيل المثال إذا كنت تريد تلوين بعض النصوص في SwiftUI ، فيمكنك استخدام .red بدلاً من Color.red:

قبل Swift 5.4 ، لم يعمل هذا مع التعبيرات الأكثر تعقيدًا. على سبيل المثال ، إذا أردت أن يكون لونك الأحمر شفافًا بعض الشيء ، فستحتاج إلى كتابة هذا:

من Swift 5.4 وما بعده ، يستطيع المترجم فهم العديد من العناصر المتسلسلة ، مما يعني أنه يمكن استنتاج نوع اللون:

معلمات متغيرة متعددة في الوظائف

قدم SE-0284 القدرة على الحصول على وظائف ، ونصوص ، ومبدئات تستخدم معلمات متغيرة متعددة طالما أن جميع المعلمات التي تتبع معلمة متغيرة لها تسميات. قبل Swift 5.4 ، يمكن أن يكون لديك معلمة متغيرة واحدة فقط في هذه الحالة.

لذلك ، مع هذا التحسن في المكان ، يمكننا كتابة دالة تقبل متغيرًا متغيرًا يخزن الأوقات التي تم فيها تسجيل الأهداف خلال مباراة كرة القدم ، بالإضافة إلى معلمة متغيرة ثانية تسجل أسماء اللاعبين الذين سجلوا:

لاستدعاء هذه الوظيفة ، قم بتوفير مجموعتي القيم كمعلمات متغيرة ، مع التأكد من تسمية جميع المعلمات بعد المتغير الأول:

إنشاء متغيرات تستدعي دالة تحمل الاسم نفسه

من Swift 5.4 وما بعده ، من الممكن إنشاء متغير محلي عن طريق استدعاء دالة بنفس الاسم. قد يبدو هذا غامضًا ، لكنها في الواقع مشكلة نواجهها طوال الوقت.

على سبيل المثال ، يؤدي هذا إلى إنشاء بنية باستخدام طريقة color (forRow :) ، والتي يتم استدعاؤها وتعيينها إلى متغير محلي يسمى color:

لا يُسمح بهذا النوع من الاستخدام إلا من Swift 5.4 والإصدارات الأحدث. في الإصدارات السابقة من Swift ، كان يُنشئ مرجعًا دائريًا لأن Swift لم يتمكن من التمييز بين ثابت اللون المحلي واللون (forRow :) الطريقة التي كان يستدعيها - كنت سترى الخطأ "المتغير المستخدم ضمن قيمته الأولية" .

نتج عن هذا عادةً إما استخدام self.color (forRow: 1989) لتوضيح أننا نعني استدعاء الطريقة ، أو مجرد تسمية القيمة المحلية بشيء آخر مثل colorForRow.

لحسن الحظ ، حل Swift 5.4 هذا الأمر ويسمح لنا باستخدام تسمية أكثر طبيعية.

يسمح لنا هذا التغيير أيضًا بعمل نسخ محلية من الخصائص والمتغيرات العامة. على سبيل المثال ، يمكننا أخذ نسخة من خاصية اسم المستخدم والتي تسمى أيضًا اسم المستخدم ، مثل هذا:

نظرًا لأن هذا ينطبق أيضًا على المتغيرات العامة ، فإن نفس الرمز يعمل بشكل جيد حتى بدون وجود البنية:

بناة النتيجة

وصل بناة الوظائف بشكل غير رسمي إلى Swift 5.1 ، ولكن في الفترة التي سبقت Swift 5.4 ، مروا رسميًا بعملية اقتراح Swift Evolution مثل SE-0289 من أجل مناقشتها وصقلها. كجزء من هذه العملية ، تمت إعادة تسميتهم ليصبحوا بناة النتائج ليعكسوا بشكل أفضل غرضهم الفعلي ، بل واكتسبوا بعض الوظائف الجديدة.

أولاً ، الجزء الأكثر أهمية: يتيح لنا منشئو النتائج إنشاء قيمة جديدة خطوة بخطوة عن طريق تمرير تسلسل من اختيارنا. إنها تشغل أجزاء كبيرة من نظام إنشاء العرض الخاص بـ SwiftUI ، بحيث عندما يكون لدينا VStack مع مجموعة متنوعة من العروض بالداخل ، يقوم Swift بتجميعها بصمت معًا في نوع TupleView داخلي بحيث يمكن تخزينها كطفل واحد من VStack - يتحول سلسلة من وجهات النظر في عرض واحد.

يستحق منشئو النتائج مقالتهم التفصيلية ، لكنني على الأقل أريد أن أعطيك بعض أمثلة التعليمات البرمجية الصغيرة حتى تتمكن من رؤيتها أثناء العمل.

هذه دالة تقوم بإرجاع سلسلة واحدة:

هذا يعمل بشكل رائع ، ولكن ماذا لو كان لدينا العديد من السلاسل التي أردنا ضمها معًا؟ تمامًا مثل SwiftUI ، قد نرغب في توفيرها جميعًا بشكل فردي وجعل Swift يكتشفها:

في حد ذاته ، لن يعمل هذا الرمز لأن Swift لم يعد يفهم ما نعنيه. ومع ذلك ، يمكننا إنشاء مُنشئ نتائج يفهم كيفية تحويل عدة سلاسل إلى سلسلة واحدة باستخدام أي تحويل نريده ، مثل هذا:

على الرغم من أن هذا يمثل مقدارًا صغيرًا من التعليمات البرمجية ، إلا أنه يوجد الكثير لتفريغه:

  • تخبر السمةresultBuilder Swift أنه يجب معاملة النوع التالي على أنه منشئ النتائج. تم تحقيق هذا السلوك سابقًا باستخدام_functionBuilder ، الذي يحتوي على شرطة سفلية لإظهار أن هذا لم يتم تصميمه للاستخدام العام.
  • يجب أن توفر كل أداة إنشاء نتائج طريقة ثابتة واحدة على الأقل تسمى buildBlock () ، والتي يجب أن تأخذ نوعًا من البيانات وتحولها. يأخذ المثال أعلاه صفرًا أو أكثر من السلاسل ويربطها ويرسلها مرة أخرى كسلسلة واحدة.
  • والنتيجة النهائية هي أن هيكل SimpleStringBuilder الخاص بنا يصبح منشئ النتائج ، مما يعني أنه يمكننا استخدامSimpleStringBuilder في أي مكان نحتاج فيه إلى صلاحيات ضم السلسلة.

لا يوجد ما يمنعنا من استخدام SimpleStringBuilder.buildBlock () مباشرة ، مثل هذا:

ومع ذلك ، نظرًا لأننا استخدمنا التعليق التوضيحيresultBuilder مع بنية SimpleStringBuilder الخاصة بنا ، يمكننا أيضًا تطبيق ذلك على الوظائف ، مثل هذا:

لاحظ كيف أننا لم نعد بحاجة إلى الفواصل في نهاية كل سلسلة - يقومresultBuilder تلقائيًا بتحويل كل عبارة في makeSentence () إلى سلسلة واحدة باستخدام SimpleStringBuilder.

في الممارسة العملية ، يكون منشئو النتائج قادرون على تحقيق المزيد بشكل ملحوظ ، وذلك بإضافة المزيد من الأساليب إلى نوع المنشئ الخاص بك. على سبيل المثال ، يمكننا إضافة دعم if / else إلى SimpleStringBuilder الخاص بنا عن طريق إضافة طريقتين إضافيتين تصفان كيف نريد تحويل البيانات. في الكود الخاص بنا ، لا نريد تغيير سلاسلنا على الإطلاق ، حتى نتمكن من إرسالها مرة أخرى:

أعلم أنه يبدو أننا لم نقم بأي عمل تقريبًا ، ولكن وظائفنا الآن قادرة على استخدام الشروط:

وبالمثل ، يمكننا إضافة دعم للحلقات عن طريق إضافة طريقة buildArray () لنوع الباني الخاص بنا:

والآن يمكننا استخدام حلقات for:

يبدو الأمر أشبه بالسحر لأن نظام بناء النتائج يقوم بكل العمل تقريبًا من أجلنا ، وعلى الرغم من أن مثالنا كان بسيطًا إلى حد ما ، آمل أن تتمكن من تذوق الطاقة الرائعة التي يجلبها منشئو النتائج إلى Swift.

تجدر الإشارة إلى أن Swift 5.4 يوسع نظام بناء النتائج لدعم السمات التي يتم وضعها في الخصائص المخزنة ، والتي تقوم تلقائيًا بضبط مُهيئ العضو الضمني للبُنى لتطبيق مُنشئ النتائج.

هذا مفيد بشكل خاص لعروض SwiftUI المخصصة التي تستخدم منشئي النتائج ، مثل هذا:

إذا كنت ترغب في رؤية أمثلة أكثر تقدمًا من العالم الواقعي لمنشئي النتائج أثناء العمل ، فيجب عليك التحقق من مستودع Awesome Function Builders على GitHub.

الوظائف المحلية تدعم الآن التحميل الزائد

طلب SR-10069 القدرة على التحميل الزائد للوظائف في السياقات المحلية ، وهو ما يعني عمليًا أنه يمكن الآن تحميل الوظائف المتداخلة بشكل زائد بحيث يختار Swift أي منها يتم تشغيله بناءً على الأنواع المستخدمة.

على سبيل المثال ، إذا أردنا إنشاء بعض ملفات تعريف الارتباط البسيطة ، فقد نكتب رمزًا مثل هذا:

قبل Swift 5.4 ، كان من الممكن زيادة التحميل على طرق add () الثلاث فقط إذا لم تكن متداخلة داخل makeCookies () ، ولكن بدءًا من Swift 5.4 وما بعده يتم دعم التحميل الزائد للوظيفة في هذه الحالة أيضًا.

يتيح لنا Swift 5.4 أيضًا استدعاء الوظائف المحلية قبل الإعلان عنها ، مما يعني أنه يمكننا الآن كتابة رمز مثل هذا إذا لزم الأمر:

أغلفة الخصائص مدعومة الآن للمتغيرات المحلية

تم تقديم أغلفة الخصائص لأول مرة في Swift 5.1 كطريقة لإرفاق وظائف إضافية بالخصائص بطريقة سهلة وقابلة لإعادة الاستخدام ، ولكن في Swift 5.4 تم توسيع سلوكهم لدعم استخدامها كمتغيرات محلية في الوظائف.

على سبيل المثال ، يمكننا إنشاء غلاف خاصية يضمن ألا تقل قيمته أبدًا عن الصفر:

وبدءًا من Swift 5.4 فصاعدًا ، يمكننا استخدام غلاف الخاصية هذا داخل وظيفة عادية ، بدلاً من مجرد إرفاق خاصية. على سبيل المثال ، قد نكتب لعبة حيث يمكن للاعبنا أن يربح أو يخسر نقاطًا ، ولكن يجب ألا تقل درجاته أبدًا عن 0:

يمكن أن تعلن الحزم الآن عن أهداف قابلة للتنفيذ

يضيف SE-0294 خيار هدف جديد للتطبيقات التي تستخدم Swift Package manager ، مما يسمح لنا بالإعلان صراحة عن هدف قابل للتنفيذ.

هذا مهم بشكل خاص للأشخاص الذين يرغبون في استخدام SE-0281 (باستخدامmain لتمييز نقطة دخول البرنامج) ، لأنه لم يتم تشغيله بشكل جيد مع Swift Package Manager - سيبحث دائمًا عن ملف main.swift.

مع هذا التغيير ، يمكننا الآن إزالة main.swift واستخدامmain بدلاً من ذلك. ملحوظة: يجب عليك تحديد // swift-tools-version: 5.4 في ملف Package.swift الخاص بك للحصول على هذه الوظيفة الجديدة.

جربها بنفسك

يتوفر Swift 5.4 من خلال Xcode 12.5 ، والمتوفر في Mac App Store.

ما هي ميزات Swift 5.4 أنت معظم يتطلع إلى؟

برعاية أداة تصميم مصممة لـ SwiftUI. Kick-start your next design update with built-in SwiftUI design templates. Save time by skipping the need to set up a full development environment. Design for free with up to 5 files or get a full year of unlimited files and more for $29.99.

About the author

Paul Hudson is the creator of Hacking with Swift, the most comprehensive series of Swift books in the world. He's also the editor of Swift Developer News, the maintainer of the Swift Knowledge Base, and a speaker at Swift events around the world. If you're curious you can learn more here.


5.4: Logarithmic Functions

The composition of a function with its inverse returns the starting value, x.

This concept will be used to solve equations involving exponentials and logarithms.

Now that we have a basic idea of a logarithmic function, let's take a closer look at its graph.

Let's examine the function:

قيمة ال ب (the 2) is referred to as the يتمركز of the logarithm.

لاحظ أن x must be positive.

ملحوظة: In a linear graph, the " rate of change " remains the same across the entire graph.
In a logarithmic graph, the "rate of change" increases (or decreases) across the graph.

For help with logarithms on
your calculator,
click here.

For "other bases" use the following "change of base" conversion:


Or use logBASE( template at MATH &rarr arrow down to A:logBASE(.

The graphs of functions of the form have certain characteristics in common.

• graph crosses the x-axis at (1,0)

• when ب > 1, the graph increases

• when 0 < ب < 1, the graph decreases

• the domain is all positive real numbers (never zero)

• the range is all real numbers

• graph passes the vertical line test for functions

• graph passes the horizontal line test for functional inverse.

• graph is asymptotic to the ذ-axis - gets very, very close to the ذ-axis but, in this case, does not touch it or cross it.

نحن نعرف ذلك التحولات have the ability to move functions by sliding them, reflecting them, stretching them, and shrinking them. Let's see how these changes will affect the logarithmic function:

Parent function:

ترجمة ص = سجلب(x - h) + k
horizontal by h: vertical by ك:


اختصاص: x > h
نطاق: x &isin Real numbers

الجميع 3 transformations combined: y = a سجلب(x - h) + ك

By examining the nature of the logarithmic graph, we have seen that the parent function will stay to the right of the x-axis, unless acted upon by a transformation.
• The parent function , ص = سجلب x, will always have an x-intercept of one , occurring at the ordered pair of (1,0).
هنالك لا ذ-تقاطع with the parent function since it is asymptotic to the ذ-axis (approaches the ذ-axis but does not touch or cross it).

• The transformed parent function النموذج y = aسجلب x, will also always have a x-intercept of 1 , occurring at the ordered pair of (1, 0). Note that the value of أ may be positive or negative.
Like the parent function, this transformation will be asymptotic to the ذ-axis, and will have لا ذ-تقاطع.


• If the transformed parent function includes a vertical or horizontal shift , all bets are off. The horizontal shift will affect the possibility of a ذ-intercept and the vertical shift will affect the س-تقاطع. In this situation, you will need to examine the graph carefully to determine what is happening.

• The end behavior of a transformed parent function is not always consistent, but is dependent upon the nature of the transformation. Consider this example:

For the transformed equation

the horizontal shift of +5 will push the
asymptote line to the left five units.
Thus the end behavior will be:

ال ذ-تقاطع، أين x = 0, is
ص =سجل 2 (0 + 5) + 4 &asymp 6.321928095.
ال x-تقاطع، أين ذ = 0, is
approximately -4.94 (from the graph's table) .



Don't confuse log graphs
with square root graphs.
At fist glance, these two graphs appear to be similar. But the square root graph is actually ending, while the log graph is not.


End Behavior of a Function

The end behavior of a polynomial function is the behavior of the graph of f ( x ) as x approaches positive infinity or negative infinity.

The degree and the leading coefficient of a polynomial function determine the end behavior of the graph.

The leading coefficient is significant compared to the other coefficients in the function for the very large or very small numbers. So, the sign of the leading coefficient is sufficient to predict the end behavior of the function.

Leading Coefficient

To predict the end-behavior of a polynomial function, first check whether the function is odd-degree or even-degree function and whether the leading coefficient is positive or negative.

Find the end behavior of the function x 4 − 4 x 3 + 3 x + 25 .

The degree of the function is even and the leading coefficient is positive. So, the end behavior is:

f ( x ) → + ∞ , as x → − ∞ f ( x ) → + ∞ , as x → + ∞

The graph looks as follows:

Download our free learning tools apps and test prep books

Names of standardized tests are owned by the trademark holders and are not affiliated with Varsity Tutors LLC.

4.9/5.0 Satisfaction Rating over the last 100,000 sessions. As of 4/27/18.

Media outlet trademarks are owned by the respective media outlets and are not affiliated with Varsity Tutors.

Award-Winning claim based on CBS Local and Houston Press awards.

Varsity Tutors does not have affiliation with universities mentioned on its website.

Varsity Tutors connects learners with experts. Instructors are independent contractors who tailor their services to each client, using their own style, methods and materials.


Logarithmic Differentiation

The method of differentiating functions by first taking logarithms and then differentiating is called logarithmic differentiation . We use logarithmic differentiation in situations where it is easier to differentiate the logarithm of a function than to differentiate the function itself. This approach allows calculating derivatives of power, rational and some irrational functions in an efficient manner.

Consider this method in more detail. Let (y = fleft( x ight)). Take natural logarithms of both sides:

Next, we differentiate this expression using the chain rule and keeping in mind that (y) is a function of (x.)

It’s seen that the derivative is

The derivative of the logarithmic function is called the logarithmic derivative of the initial function (y = fleft( x ight).)

This differentiation method allows to effectively compute derivatives of power-exponential functions, that is functions of the form

where (uleft( x ight)) and (vleft( x ight)) are differentiable functions of (x.)

In the examples below, find the derivative of the function (yleft( x ight)) using logarithmic differentiation.


5.4: Logarithmic Functions

We know that the sign of the derivative tells us whether a function is increasing or decreasing for example, when $f'(x)>0$, $f(x)$ is increasing. The sign of the second derivative $f''(x)$ tells us whether $f'$ is increasing or decreasing we have seen that if $f'$ is zero and increasing at a point then there is a local minimum at the point, and if $f'$ is zero and decreasing at a point then there is a local maximum at the point. Thus, we extracted information about $f$ from information about $f''$.

We can get information from the sign of $f''$ even when $f'$ is not zero. Suppose that $f''(a)>0$. This means that near $x=a$, $f'$ is increasing. If $f'(a)>0$, this means that $f$ slopes up and is getting steeper if $f'(a) Figure 5.4.1. $f''(a)>0$: $f'(a)$ positive and increasing, $f'(a)$ negative and increasing.

Now suppose that $f''(a) 0$, this means that $f$ slopes up and is getting less steep if $f'(a) Figure 5.4.2. $f''(a) Example 5.4.1 Describe the concavity of $ds f(x)=x^3-x$. $ds f'(x)=3x^2-1$, $f''(x)=6x$. Since $f''(0)=0$, there is potentially an inflection point at zero. Since $f''(x)>0$ when $x>0$ and $f''(x) 0$.

Note that we need to compute and analyze the second derivative to understand concavity, so we may as well try to use the second derivative test for maxima and minima. If for some reason this fails we can then try one of the other tests.


Lesson 4

In this lesson, students work with graphs and tables that represent functions in addition to the equations and descriptions used previously. They learn the conventions of graphing the independent variable (input) on the horizontal axis and the dependent variable (output) on the vertical axis and that each coordinate point represents an input-output pair of the function.

By matching contexts and graphs and reading information about functions from graphs and tables, students become familiar with the different representations and draw connections between them.

Learning Goals

Let’s connect equations and graphs of functions.

Learning Targets

CCSS Standards

Glossary Entries

A dependent variable represents the output of a function.

For example, suppose we need to buy 20 pieces of fruit and decide to buy apples and bananas. If we select the number of apples first, the equation (b=20-a) shows the number of bananas we can buy. The number of bananas is the dependent variable because it depends on the number of apples.

An independent variable represents the input of a function.

For example, suppose we need to buy 20 pieces of fruit and decide to buy some apples and bananas. If we select the number of apples first, the equation (b=20-a) shows the number of bananas we can buy. The number of apples is the independent variable because we can choose any number for it.

A radius is a line segment that goes from the center to the edge of a circle. A radius can go in any direction. Every radius of the circle is the same length. We also use the word نصف القطر to mean the length of this segment.

For example, (r) is the radius of this circle with center (O) .

Expand Image

Print Formatted Materials

Teachers with a valid work email address can click here to register or sign in for free access to Cool Down, Teacher Guide, and PowerPoint materials.

مصادر إضافية

IM 6–8 Math was originally developed by Open Up Resources and authored by Illustrative Mathematics®, and is copyright 2017-2019 by Open Up Resources. It is licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0). OUR's 6–8 Math Curriculum is available at https://openupresources.org/math-curriculum/.

Adaptations and updates to IM 6–8 Math are copyright 2019 by Illustrative Mathematics, and are licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).

Adaptations to add additional English language learner supports are copyright 2019 by Open Up Resources, and are licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).

The second set of English assessments (marked as set "B") are copyright 2019 by Open Up Resources, and are licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).

Spanish translation of the "B" assessments are copyright 2020 by Illustrative Mathematics, and are licensed under the Creative Commons Attribution 4.0 International License (CC BY 4.0).

The Illustrative Mathematics name and logo are not subject to the Creative Commons license and may not be used without the prior and express written consent of Illustrative Mathematics.

This site includes public domain images or openly licensed images that are copyrighted by their respective owners. Openly licensed images remain under the terms of their respective licenses. See the image attribution section for more information.


5.4: Logarithmic Functions

The ECMAScript 2017 feature 𠇊sync Functions” was proposed by Brian Terlson.

5.1 Overview #

5.1.1 Variants #

The following variants of async functions exist. Note the keyword async everywhere.

  • Async function declarations: async function foo() <>
  • Async function expressions: const foo = async function () <>
  • Async method definitions: let obj = < async foo() <>>
  • Async arrow functions: const foo = async () => <>

5.1.2 Async functions always return Promises #

Fulfilling the Promise of an async function:

Rejecting the Promise of an async function:

5.1.3 Handling results and errors of asynchronous computations via await #

The operator await (which is only allowed inside async functions) waits for its operand, a Promise, to be settled:

  • If the Promise is fulfilled, the result of await is the fulfillment value.
  • If the Promise is rejected, await throws the rejection value.

Handling a single asynchronous result:

Handling multiple asynchronous results sequentially:

Handling multiple asynchronous results in parallel:

5.2 Understanding async functions #

Before I can explain async functions, I need to explain how Promises and generators can be combined to perform asynchronous operations via synchronous-looking code.

For functions that compute their one-off results asynchronously, Promises, which are part of ES6, have become popular. One example is the client-side fetch API, which is an alternative to XMLHttpRequest for retrieving files. Using it looks as follows:

5.2.1 Writing asynchronous code via generators #

co is a library that uses Promises and generators to enable a coding style that looks more synchronous, but works the same as the style used in the previous example:

Every time the callback (a generator function!) yields a Promise to co, the callback gets suspended. Once the Promise is settled, co resumes the callback: if the Promise was fulfilled, yield returns the fulfillment value, if it was rejected, yield throws the rejection error. Additionally, co promisifies the result returned by the callback (similarly to how then() does it).

5.2.2 Writing asynchronous code via async functions #

Async functions are basically dedicated syntax for what co does:

Internally, async functions work much like generators.

5.2.3 Async functions are started synchronously, settled asynchronously #

This is how async functions are executed:

  1. The result of an async function is always a Promise p . That Promise is created when starting the execution of the async function.
  2. The body is executed. Execution may finish permanently via return or throw . Or it may finish temporarily via await in which case execution will usually continue later on.
  3. The Promise p is returned.

While executing the body of the async function, return x resolves the Promise p with x , while throw err rejects p with err . The notification of a settlement happens asynchronously. In other words: the callbacks of then() and catch() are always executed after the current code is finished.

The following code demonstrates how that works:

You can rely on the following order:

  1. Line (A): the async function is started synchronously. The async function’s Promise is resolved via return .
  2. Line (C): execution continues.
  3. Line (B): Notification of Promise resolution happens asynchronously.

5.2.4 Returned Promises are not wrapped #

Resolving a Promise is a standard operation. return uses it to resolve the Promise p of an async function. هذا يعني:

  1. Returning a non-Promise value fulfills p with that value.
  2. Returning a Promise means that p now mirrors the state of that Promise.

Therefore, you can return a Promise and that Promise won’t be wrapped in a Promise:

Intriguingly, returning a rejected Promise leads to the result of the async function being rejected (normally, you𠆝 use throw for that):

That is in line with how Promise resolution works. It enables you to forward both fulfillments and rejections of another asynchronous computation, without an await :

The previous code is roughly similar to – but more efficient than – the following code (which unwraps the Promise of anotherAsyncFunc() only to wrap it again):

5.3 Tips for using await #

5.3.1 Don’t forget await #

One easy mistake to make in async functions is to forget await when making an asynchronous function call:

In this example, value is set to a Promise, which is usually not what you want in async functions.

await can even make sense if an async function doesn’t return anything. Then its Promise is simply used as a signal for telling the caller that it is finished. على سبيل المثال:

The await in line (A) guarantees that step1() is completely finished before the remainder of foo() is executed.

5.3.2 You don’t need await if you 𠇏ire and forget” #

Sometimes, you only want to trigger an asynchronous computation and are not interested in when it is finished. The following code is an example:

Here, we don’t care when individual writes are finished, only that they are executed in the right order (which the API would have to guarantee, but that is encouraged by the execution model of async functions – as we have seen).

The await in the last line of asyncFunc() ensures that the function is only fulfilled after the file was successfully closed.

Given that returned Promises are not wrapped, you can also return instead of await writer.close() :

Both versions have pros and cons, the await version is probably slightly easier to understand.

5.3.3 await is sequential, Promise.all() is parallel #

The following code make two asynchronous function calls, asyncFunc1() and asyncFunc2() .

However, these two function calls are executed sequentially. Executing them in parallel tends to speed things up. You can use Promise.all() to do so:

Instead of awaiting two Promises, we are now awaiting a Promise for an Array with two elements.

5.4 Async functions and callbacks #

One limitation of async functions is that await only affects the directly surrounding async function. Therefore, an async function can’t await in a callback (however, callbacks can be async functions themselves, as we’ll see later on). That makes callback-based utility functions and methods tricky to use. Examples include the Array methods map() and forEach() .

5.4.1 Array.prototype.map() #

Let’s start with the Array method map() . In the following code, we want to download the files pointed to by an Array of URLs and return them in an Array.

This does not work, because await is syntactically illegal inside normal arrow functions. How about using an async arrow function, then?

There are two issues with this code:

  • The result is now an Array of Promises, not an Array of strings.
  • The work performed by the callbacks isn’t finished once map() is finished, because await only pauses the surrounding arrow function and httpGet() is resolved asynchronously. That means you can’t use await to wait until downloadContent() is finished.

We can fix both issues via Promise.all() , which converts an Array of Promises to a Promise for an Array (with the values fulfilled by the Promises):

The callback for map() doesn’t do much with the result of httpGet() , it only forwards it. Therefore, we don’t need an async arrow function here, a normal arrow function will do:

There is one small improvement that we still can make: This async function is slightly inefficient – it first unwraps the result of Promise.all() via await , before wrapping it again via return . Given that return doesn’t wrap Promises, we can return the result of Promise.all() directly:

5.4.2 Array.prototype.forEach() #

Let’s use the Array method forEach() to log the contents of several files pointed to via URLs:

Again, this code will produce a syntax error, because you can’t use await inside normal arrow functions.

Let’s use an async arrow function:

This does work, but there is one caveat: the Promise returned by httpGet() is resolved asynchronously, which means that the callbacks are not finished when forEach() returns. As a consequence, you can’t await the end of logContent() .

If that’s not what you want, you can convert forEach() into a for-of loop:

Now everything is finished after the for-of loop. However, the processing steps happen sequentially: httpGet() is only called a second time بعد the first call is finished. If you want the processing steps to happen in parallel, you must use Promise.all() :

map() is used to create an Array of Promises. We are not interested in the results they fulfill, we only await until all of them are fulfilled. That means that we are completely done at the end of this async function. We could just as well return Promise.all() , but then the result of the function would be an Array whose elements are all undefined .

5.5 Tips for using async functions #

5.5.1 Know your Promises #

The foundation of async functions is Promises. That’s why understanding the latter is crucial for understanding the former. Especially when connecting old code that isn’t based on Promises with async functions, you often have no choice but to use Promises directly.

For example, this is a “promisified” version of XMLHttpRequest :

The API of XMLHttpRequest is based on callbacks. Promisifying it via an async function would mean that you𠆝 have to fulfill or reject the Promise returned by the function from within callbacks. That’s impossible, because you can only do so via return and throw . And you can’t return the result of a function from within a callback. throw has similar constraints.

Therefore, the common coding style for async functions will be:

  • Use Promises directly to build asynchronous primitives.
  • Use those primitives via async functions.

5.5.2 Immediately Invoked Async Function Expressions #

Sometimes, it𠆝 be nice if you could use await at the top level of a module or script. Alas, it’s only available inside async functions. You therefore have several options. You can either create an async function main() and call it immediately afterwards:

Or you can use an Immediately Invoked Async Function Expression:

Another option is an Immediately Invoked Async Arrow Function:

5.5.3 Unit testing with async functions #

The following code uses the test-framework mocha to unit-test the asynchronous functions asyncFunc1() and asyncFunc2() :

However, this test always succeeds, because mocha doesn’t wait until the assertions in line (B) and line (C) are executed.

You can fix this by returning the result of the Promise chain, because mocha recognizes if a test returns a Promise and then waits until that Promise is settled (unless there is a timeout).

Conveniently, async functions always return Promises, which makes them perfect for this kind of unit test:

There are thus two advantages to using async functions for asynchronous unit tests in mocha: the code is more concise and returning Promises is taken care of, too.

5.5.4 Don’t worry about unhandled rejections #

JavaScript engines are becoming increasingly good at warning about rejections that are not handled. For example, the following code would often fail silently in the past, but most modern JavaScript engines now report an unhandled rejection:


شاهد الفيديو: Concepts of Exponential u0026 Logarithmic Fn. CBSE 12 Maths u0026comp. Ex intro (شهر اكتوبر 2021).