diff --git a/js/js.libraries/src/core/math.kt b/js/js.libraries/src/core/math.kt
index 38f0a7a5072..656dc41bddb 100644
--- a/js/js.libraries/src/core/math.kt
+++ b/js/js.libraries/src/core/math.kt
@@ -202,7 +202,7 @@ public inline fun exp(a: Double): Double = nativeMath.exp(a)
 public inline fun expm1(a: Double): Double = nativeMath.expm1(a)
 
 /**
- * Computes the logarithm in the given [base] of the [a] value.
+ * Computes the logarithm of the value [a] to the given [base].
  *
  * Special cases:
  *     - `log(a, b)` is `NaN` if either `a` or `b` are `NaN`
@@ -218,7 +218,7 @@ public fun log(a: Double, base: Double): Double {
 }
 
 /**
- * Computes the natural logarithm (base `E`) of the [a] value.
+ * Computes the natural logarithm (base `E`) of the value [a].
  *
  * Special cases:
  *     - `ln(NaN)` is `NaN`
@@ -231,7 +231,7 @@ public fun log(a: Double, base: Double): Double {
 public inline fun ln(a: Double): Double = nativeMath.log(a)
 
 /**
- * Computes the decimal logarithm (base 10) of the [a] value.
+ * Computes the common logarithm (base 10) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -240,7 +240,7 @@ public inline fun ln(a: Double): Double = nativeMath.log(a)
 public inline fun log10(a: Double): Double = nativeMath.log10(a)
 
 /**
- * Computes the binary logarithm (base 2) of the [a] value.
+ * Computes the binary logarithm (base 2) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -249,17 +249,17 @@ public inline fun log10(a: Double): Double = nativeMath.log10(a)
 public inline fun log2(a: Double): Double = nativeMath.log2(a)
 
 /**
- * Computes `log(a + 1)`.
+ * Computes `ln(a + 1)`.
  *
  * This function can be implemented to produce more precise result for [a] near zero.
  *
  * Special cases:
- *     - `log1p(NaN)` is `NaN`
- *     - `log1p(x)` is `NaN` where `x < -1.0`
- *     - `log1p(-1.0)` is `-Inf`
- *     - `log1p(+Inf)` is `+Inf`
+ *     - `ln1p(NaN)` is `NaN`
+ *     - `ln1p(x)` is `NaN` where `x < -1.0`
+ *     - `ln1p(-1.0)` is `-Inf`
+ *     - `ln1p(+Inf)` is `+Inf`
  *
- * @see [ln] function.
+ * @see [ln] function
  * @see [expm1] function
  */
 @SinceKotlin("1.2")
@@ -642,7 +642,7 @@ public inline fun exp(a: Float): Float = nativeMath.exp(a.toDouble()).toFloat()
 public inline fun expm1(a: Float): Float = nativeMath.expm1(a.toDouble()).toFloat()
 
 /**
- * Computes the logarithm in the given [base] of the [a] value.
+ * Computes the logarithm of the value [a] to the given [base].
  *
  * Special cases:
  *     - `log(a, b)` is `NaN` if either `a` or `b` are `NaN`
@@ -656,7 +656,7 @@ public inline fun expm1(a: Float): Float = nativeMath.expm1(a.toDouble()).toFloa
 public inline fun log(a: Float, base: Float): Float = log(a.toDouble(), base.toDouble()).toFloat()
 
 /**
- * Computes the natural logarithm (base `E`) of the [a] value.
+ * Computes the natural logarithm (base `E`) of the value [a].
  *
  * Special cases:
  *     - `ln(NaN)` is `NaN`
@@ -669,7 +669,7 @@ public inline fun log(a: Float, base: Float): Float = log(a.toDouble(), base.toD
 public inline fun ln(a: Float): Float = nativeMath.log(a.toDouble()).toFloat()
 
 /**
- * Computes the decimal logarithm (base 10) of the [a] value.
+ * Computes the common logarithm (base 10) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -678,7 +678,7 @@ public inline fun ln(a: Float): Float = nativeMath.log(a.toDouble()).toFloat()
 public inline fun log10(a: Float): Float = nativeMath.log10(a.toDouble()).toFloat()
 
 /**
- * Computes the binary logarithm (base 2) of the [a] value.
+ * Computes the binary logarithm (base 2) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -687,15 +687,15 @@ public inline fun log10(a: Float): Float = nativeMath.log10(a.toDouble()).toFloa
 public inline fun log2(a: Float): Float = nativeMath.log2(a.toDouble()).toFloat()
 
 /**
- * Computes `log(a + 1)`.
+ * Computes `ln(a + 1)`.
  *
  * This function can be implemented to produce more precise result for [a] near zero.
  *
  * Special cases:
- *     - `log1p(NaN)` is `NaN`
- *     - `log1p(x)` is `NaN` where `x < -1.0`
- *     - `log1p(-1.0)` is `-Inf`
- *     - `log1p(+Inf)` is `+Inf`
+ *     - `ln1p(NaN)` is `NaN`
+ *     - `ln1p(x)` is `NaN` where `x < -1.0`
+ *     - `ln1p(-1.0)` is `-Inf`
+ *     - `ln1p(+Inf)` is `+Inf`
  *
  * @see [ln] function
  * @see [expm1] function
diff --git a/libraries/stdlib/common/src/kotlin/MathH.kt b/libraries/stdlib/common/src/kotlin/MathH.kt
index 85c3a490c0d..c48c086478f 100644
--- a/libraries/stdlib/common/src/kotlin/MathH.kt
+++ b/libraries/stdlib/common/src/kotlin/MathH.kt
@@ -186,7 +186,7 @@ public expect fun exp(a: Double): Double
 public expect fun expm1(a: Double): Double
 
 /**
- * Computes the logarithm in the given [base] of the [a] value.
+ * Computes the logarithm of the value [a] to the given [base].
  *
  * Special cases:
  *     - `log(a, b)` is `NaN` if either `a` or `b` are `NaN`
@@ -199,7 +199,7 @@ public expect fun expm1(a: Double): Double
 public expect fun log(a: Double, base: Double): Double
 
 /**
- * Computes the natural logarithm (base `E`) of the [a] value.
+ * Computes the natural logarithm (base `E`) of the value [a].
  *
  * Special cases:
  *     - `ln(NaN)` is `NaN`
@@ -211,7 +211,7 @@ public expect fun log(a: Double, base: Double): Double
 public expect fun ln(a: Double): Double
 
 /**
- * Computes the decimal logarithm (base 10) of the [a] value.
+ * Computes the common logarithm (base 10) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -219,7 +219,7 @@ public expect fun ln(a: Double): Double
 public expect fun log10(a: Double): Double
 
 /**
- * Computes the binary logarithm (base 2) of the [a] value.
+ * Computes the binary logarithm (base 2) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -227,17 +227,17 @@ public expect fun log10(a: Double): Double
 public expect fun log2(a: Double): Double
 
 /**
- * Computes `log(a + 1)`.
+ * Computes `ln(a + 1)`.
  *
  * This function can be implemented to produce more precise result for [a] near zero.
  *
  * Special cases:
- *     - `log1p(NaN)` is `NaN`
- *     - `log1p(x)` is `NaN` where `x < -1.0`
- *     - `log1p(-1.0)` is `-Inf`
- *     - `log1p(+Inf)` is `+Inf`
+ *     - `ln1p(NaN)` is `NaN`
+ *     - `ln1p(x)` is `NaN` where `x < -1.0`
+ *     - `ln1p(-1.0)` is `-Inf`
+ *     - `ln1p(+Inf)` is `+Inf`
  *
- * @see [ln] function.
+ * @see [ln] function
  * @see [expm1] function
  */
 @SinceKotlin("1.2")
@@ -573,7 +573,7 @@ public expect fun exp(a: Float): Float
 public expect fun expm1(a: Float): Float
 
 /**
- * Computes the logarithm in the given [base] of the [a] value.
+ * Computes the logarithm of the value [a] to the given [base].
  *
  * Special cases:
  *     - `log(a, b)` is `NaN` if either `a` or `b` are `NaN`
@@ -586,7 +586,7 @@ public expect fun expm1(a: Float): Float
 public expect fun log(a: Float, base: Float): Float
 
 /**
- * Computes the natural logarithm (base `E`) of the [a] value.
+ * Computes the natural logarithm (base `E`) of the value [a].
  *
  * Special cases:
  *     - `ln(NaN)` is `NaN`
@@ -598,7 +598,7 @@ public expect fun log(a: Float, base: Float): Float
 public expect fun ln(a: Float): Float
 
 /**
- * Computes the decimal logarithm (base 10) of the [a] value.
+ * Computes the common logarithm (base 10) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -606,7 +606,7 @@ public expect fun ln(a: Float): Float
 public expect fun log10(a: Float): Float
 
 /**
- * Computes the binary logarithm (base 2) of the [a] value.
+ * Computes the binary logarithm (base 2) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -614,15 +614,15 @@ public expect fun log10(a: Float): Float
 public expect fun log2(a: Float): Float
 
 /**
- * Computes `log(a + 1)`.
+ * Computes `ln(a + 1)`.
  *
  * This function can be implemented to produce more precise result for [a] near zero.
  *
  * Special cases:
- *     - `log1p(NaN)` is `NaN`
- *     - `log1p(x)` is `NaN` where `x < -1.0`
- *     - `log1p(-1.0)` is `-Inf`
- *     - `log1p(+Inf)` is `+Inf`
+ *     - `ln1p(NaN)` is `NaN`
+ *     - `ln1p(x)` is `NaN` where `x < -1.0`
+ *     - `ln1p(-1.0)` is `-Inf`
+ *     - `ln1p(+Inf)` is `+Inf`
  *
  * @see [ln] function
  * @see [expm1] function
diff --git a/libraries/stdlib/src/kotlin/util/MathJVM.kt b/libraries/stdlib/src/kotlin/util/MathJVM.kt
index c14ad30e472..19c047c4109 100644
--- a/libraries/stdlib/src/kotlin/util/MathJVM.kt
+++ b/libraries/stdlib/src/kotlin/util/MathJVM.kt
@@ -205,7 +205,7 @@ public inline fun exp(a: Double): Double = nativeMath.exp(a)
 public inline fun expm1(a: Double): Double = nativeMath.expm1(a)
 
 /**
- * Computes the logarithm in the given [base] of the [a] value.
+ * Computes the logarithm of the value [a] to the given [base].
  *
  * Special cases:
  *     - `log(a, b)` is `NaN` if either `a` or `b` are `NaN`
@@ -221,7 +221,7 @@ public fun log(a: Double, base: Double): Double {
 }
 
 /**
- * Computes the natural logarithm (base `E`) of the [a] value.
+ * Computes the natural logarithm (base `E`) of the value [a].
  *
  * Special cases:
  *     - `ln(NaN)` is `NaN`
@@ -234,7 +234,7 @@ public fun log(a: Double, base: Double): Double {
 public inline fun ln(a: Double): Double = nativeMath.log(a)
 
 /**
- * Computes the decimal logarithm (base 10) of the [a] value.
+ * Computes the common logarithm (base 10) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -243,7 +243,7 @@ public inline fun ln(a: Double): Double = nativeMath.log(a)
 public inline fun log10(a: Double): Double = nativeMath.log10(a)
 
 /**
- * Computes the binary logarithm (base 2) of the [a] value.
+ * Computes the binary logarithm (base 2) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -251,15 +251,15 @@ public inline fun log10(a: Double): Double = nativeMath.log10(a)
 public fun log2(a: Double): Double = nativeMath.log(a) / LN2
 
 /**
- * Computes `log(a + 1)`.
+ * Computes `ln(a + 1)`.
  *
  * This function can be implemented to produce more precise result for [a] near zero.
  *
  * Special cases:
- *     - `log1p(NaN)` is `NaN`
- *     - `log1p(x)` is `NaN` where `x < -1.0`
- *     - `log1p(-1.0)` is `-Inf`
- *     - `log1p(+Inf)` is `+Inf`
+ *     - `ln1p(NaN)` is `NaN`
+ *     - `ln1p(x)` is `NaN` where `x < -1.0`
+ *     - `ln1p(-1.0)` is `-Inf`
+ *     - `ln1p(+Inf)` is `+Inf`
  *
  * @see [ln] function
  * @see [expm1] function
@@ -690,7 +690,7 @@ public inline fun exp(a: Float): Float = nativeMath.exp(a.toDouble()).toFloat()
 public inline fun expm1(a: Float): Float = nativeMath.expm1(a.toDouble()).toFloat()
 
 /**
- * Computes the logarithm in the given [base] of the [a] value.
+ * Computes the logarithm of the value [a] to the given [base].
  *
  * Special cases:
  *     - `log(a, b)` is `NaN` if either `a` or `b` are `NaN`
@@ -706,7 +706,7 @@ public fun log(a: Float, base: Float): Float {
 }
 
 /**
- * Computes the natural logarithm (base `E`) of the [a] value.
+ * Computes the natural logarithm (base `E`) of the value [a].
  *
  * Special cases:
  *     - `ln(NaN)` is `NaN`
@@ -719,7 +719,7 @@ public fun log(a: Float, base: Float): Float {
 public inline fun ln(a: Float): Float = nativeMath.log(a.toDouble()).toFloat()
 
 /**
- * Computes the decimal logarithm (base 10) of the [a] value.
+ * Computes the common logarithm (base 10) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -728,7 +728,7 @@ public inline fun ln(a: Float): Float = nativeMath.log(a.toDouble()).toFloat()
 public inline fun log10(a: Float): Float = nativeMath.log10(a.toDouble()).toFloat()
 
 /**
- * Computes the binary logarithm (base 2) of the [a] value.
+ * Computes the binary logarithm (base 2) of the value [a].
  *
  * @see [ln] function for special cases.
  */
@@ -736,15 +736,15 @@ public inline fun log10(a: Float): Float = nativeMath.log10(a.toDouble()).toFloa
 public fun log2(a: Float): Float = (nativeMath.log(a.toDouble()) / LN2).toFloat()
 
 /**
- * Computes `log(a + 1)`.
+ * Computes `ln(a + 1)`.
  *
  * This function can be implemented to produce more precise result for [a] near zero.
  *
  * Special cases:
- *     - `log1p(NaN)` is `NaN`
- *     - `log1p(x)` is `NaN` where `x < -1.0`
- *     - `log1p(-1.0)` is `-Inf`
- *     - `log1p(+Inf)` is `+Inf`
+ *     - `ln1p(NaN)` is `NaN`
+ *     - `ln1p(x)` is `NaN` where `x < -1.0`
+ *     - `ln1p(-1.0)` is `-Inf`
+ *     - `ln1p(+Inf)` is `+Inf`
  *
  * @see [ln] function
  * @see [expm1] function