Merge pull request #195 from Kotlin/V0.3.0

Refactor complex number implementation and handling

Author: devcrocod

multik-core/build.gradle.kts

@@ -1,5 +1,6 @@
-@file:OptIn(ExperimentalWasmDsl::class)
+@file:OptIn(ExperimentalWasmDsl::class, ExperimentalKotlinGradlePluginApi::class)
 
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension
 
@@ -22,6 +23,11 @@ val nodeDownloadUrl: String by project
 
 kotlin {
  explicitApi()
+
+ compilerOptions {
+ freeCompilerArgs.add("-Xexpect-actual-classes")
+ }
+
  jvm {
  compilations.all {
  kotlinOptions.jvmTarget = "1.8"

multik-core/src/commonMain/kotlin/org/jetbrains/kotlinx/multik/ndarray/complex/ComplexDouble.kt

@@ -4,10 +4,31 @@
 
 package org.jetbrains.kotlinx.multik.ndarray.complex
 
-import kotlin.jvm.JvmInline
 import kotlin.math.atan2
 import kotlin.math.sqrt
 
+/**
+ * Creates a [ComplexDouble] with the given real and imaginary values in floating-point format.
+ *
+ * @param re the real value of the complex number in double format.
+ * @param im the imaginary value of the complex number in double format.
+ */
+public expect fun ComplexDouble(re: Double, im: Double): ComplexDouble
+
+/**
+ * Creates a [ComplexDouble] with the given real and imaginary values in number format.
+ *
+ * @param re the real value of the complex number in number format.
+ * @param im the imaginary value of the complex number in number format.
+ */
+public expect fun ComplexDouble(re: Number, im: Number): ComplexDouble
+
+/**
+ * Creates a [ComplexDouble] with a zero imaginary value.
+ * @param re the real value of the complex number in number format.
+ */
+public fun ComplexDouble(re: Number): ComplexDouble = ComplexDouble(re.toDouble(), 0.0)
+
 /**
  * Represents a complex number with double precision.
  * The class is implemented as a double-precision 128-bit complex number.
@@ -40,7 +61,7 @@ import kotlin.math.sqrt
  * @property im the imaginary part of the complex number.
  * @throws ArithmeticException if division by zero or infinity occurs during division.
  */
-public sealed interface ComplexDouble : Complex {
+public interface ComplexDouble : Complex {
 
  /**
  * The real part of the complex number.
@@ -53,64 +74,23 @@ public sealed interface ComplexDouble : Complex {
  public val im: Double
 
  public companion object {
- /**
- * Determines whether the given double value can be accurately represented as a float value or not.
- *
- * @param d is the double value to be checked.
- * @return this method returns a Boolean value,
- * true if the double value can be accurately represented as a float value, false otherwise.
- */
- private fun fitsInFloat(d: Double): Boolean = d.toFloat().toDouble() == d
-
- /**
- * Creates a [ComplexDouble] with the given real and imaginary values in floating-point format.
- *
- * @param re the real value of the complex number in double format.
- * @param im the imaginary value of the complex number in double format.
- */
- public operator fun invoke(re: Double, im: Double): ComplexDouble {
- return if (fitsInFloat(re) && fitsInFloat(im))
- ComplexDouble32(re, im)
- else
- ComplexDouble64(re, im)
- }
-
- /**
- * Creates a [ComplexDouble] with the given real and imaginary values in number format.
- *
- * @param re the real value of the complex number in number format.
- * @param im the imaginary value of the complex number in number format.
- */
- public operator fun invoke(re: Number, im: Number): ComplexDouble = invoke(re.toDouble(), im.toDouble())
-
- /**
- * Creates a [ComplexDouble] with a zero imaginary value.
- * @param re the real value of the complex number in number format.
- */
- public operator fun invoke(re: Number): ComplexDouble {
- return if (fitsInFloat(re.toDouble()))
- ComplexDouble32(re.toDouble(), 0.0)
- else
- ComplexDouble64(re.toDouble(), 0.0)
- }
-
  /**
  * Represents a [ComplexDouble] number with 1.0 real part and 0f imaginary part.
  */
  public val one: ComplexDouble
- get() = ComplexDouble32(1.0, 0.0)
+ get() = ComplexDouble(1.0, 0.0)
 
  /**
  * Represents a [ComplexDouble] number with real and imaginary parts set to 0.0.
  */
  public val zero: ComplexDouble
- get() = ComplexDouble32(0.0, 0.0)
+ get() = ComplexDouble(0.0, 0.0)
 
  /**
  * Represents a not-a-number (NaN) value in complex floating point arithmetic.
  */
  public val NaN: ComplexDouble
- get() = ComplexDouble64(Double.NaN, Double.NaN)
+ get() = ComplexDouble(Double.NaN, Double.NaN)
  }
 
  /**
@@ -452,64 +432,9 @@ public sealed interface ComplexDouble : Complex {
  * @return the imaginary part of the complex number as a Double value.
  */
  public operator fun component2(): Double = im
-}
-
-/**
- * ComplexDouble64 represents a double-precision 128-bit complex number,
- * which implements the interface `ComplexDouble`.
- *
- * @property re the real part of the complex number.
- * @property im the imaginary part of the complex number.
- * @constructor creates an instance of ComplexDouble64.
- */
-public class ComplexDouble64 internal constructor(
- public override val re: Double, public override val im: Double
-) : ComplexDouble {
-
- override fun equals(other: Any?): Boolean = when {
- this === other -> true
- other is ComplexDouble -> re == other.re && im == other.im
- else -> false
- }
-
- override fun hashCode(): Int = 31 * re.toBits().hashCode() + im.toBits().hashCode()
-
- override fun toString(): String = "$re+($im)i"
-}
-
-/**
- * Represents a complex number of single-precision real and imaginary parts.
- *
- * @param number The number representing the complex number as a Long value
- * @property re the real part of the complex number.
- * @property im the imaginary part of the complex number.
- */
-@JvmInline
-public value class ComplexDouble32 internal constructor(private val number: Long) : ComplexDouble {
- override val re: Double
- get() = Float.fromBits((number shr 32).toInt()).toDouble()
-
- override val im: Double
- get() = Float.fromBits(number.toInt()).toDouble()
-
- internal constructor(re: Double, im: Double) : this(Complex.convertComplexFloatToLong(re.toFloat(), im.toFloat()))
-
- // TODO
- // "https://youtrack.jetbrains.com/issue/KT-24874/Support-custom-equals-and-hashCode-for-value-classes"
- internal fun eq(other: ComplexDouble32): Boolean = when {
- number == other.number -> true
- else -> re == other.re && im == other.im
- }
-
- internal fun hash(): Int = 31 * number.hashCode()
 
-// override fun equals(other: Any?): Boolean = when {
-// this === other -> true
-// other is ComplexDouble -> re == other.re && im == other.im
-// else -> false
-// }
-//
-// override fun hashCode(): Int = 31 * re.toBits().hashCode() + im.toBits().hashCode()
+ // TODO("https://youtrack.jetbrains.com/issue/KT-24874/Support-custom-equals-and-hashCode-for-value-classes")
+ public fun eq(other: Any): Boolean
 
- override fun toString(): String = "$re+($im)i"
+ public fun hash(): Int
 }

multik-core/src/commonMain/kotlin/org/jetbrains/kotlinx/multik/ndarray/data/DataType.kt

@@ -5,12 +5,13 @@
 package org.jetbrains.kotlinx.multik.ndarray.data
 
 import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexDouble
-import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexDouble32
-import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexDouble64
 import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexFloat
 import org.jetbrains.kotlinx.multik.ndarray.data.DataType.*
 import kotlin.reflect.KClass
 
+@PublishedApi
+internal expect inline fun <T : Any> dataTypeOf(type: KClass<out T>): DataType
+
 /**
  * Describes the type of elements stored in a [NDArray].
  *
@@ -66,39 +67,16 @@ public enum class DataType(public val nativeCode: Int, public val itemSize: Int,
  /**
  * Returns [DataType] by class of [element].
  */
- @Suppress( "nothing_to_inline")
  public inline fun <T> of(element: T): DataType {
  element ?: throw IllegalStateException("Element is null cannot find type")
- return when (element!!::class) {
- Byte::class -> ByteDataType
- Short::class -> ShortDataType
- Int::class -> IntDataType
- Long::class -> LongDataType
- Float::class -> FloatDataType
- Double::class -> DoubleDataType
- ComplexFloat::class -> ComplexFloatDataType
- ComplexDouble64::class -> ComplexDoubleDataType
- ComplexDouble32::class -> ComplexDoubleDataType
- else -> throw IllegalStateException("One of the primitive types was expected, " +
- "got ${element!!::class.simpleName}")
- }
+ return dataTypeOf(element!!::class)
  }
 
 
  /**
  * Returns [DataType] by [KClass] of [type]. [T] is `reified` type.
  */
- public inline fun <reified T : Any> ofKClass(type: KClass<out T>): DataType = when (type) {
- Byte::class -> ByteDataType
- Short::class -> ShortDataType
- Int::class -> IntDataType
- Long::class -> LongDataType
- Float::class -> FloatDataType
- Double::class -> DoubleDataType
- ComplexFloat::class -> ComplexFloatDataType
- ComplexDouble::class -> ComplexDoubleDataType
- else -> throw IllegalStateException("One of the primitive types was expected, got ${type.simpleName}")
- }
+ public inline fun <T : Any> ofKClass(type: KClass<out T>): DataType = dataTypeOf(type)
  }
 
  override fun toString(): String {

multik-core/src/commonMain/kotlin/org/jetbrains/kotlinx/multik/ndarray/data/NDArray.kt

@@ -4,7 +4,7 @@
 
 package org.jetbrains.kotlinx.multik.ndarray.data
 
-import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexDouble32
+import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexDouble
 import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexFloat
 import org.jetbrains.kotlinx.multik.ndarray.operations.concatenate
 
@@ -300,8 +300,7 @@ public class NDArray<T, D : Dimension> constructor(
 
  val thIt = this.iterator()
  val othIt = other.iterator()
- // TODO
- // workaround for value classes: ComplexFloat and ComplexDouble32
+ // TODO(workaround for value classes: ComplexFloat and ComplexDouble)
  // "https://youtrack.jetbrains.com/issue/KT-24874/Support-custom-equals-and-hashCode-for-value-classes"
  while (thIt.hasNext() && othIt.hasNext()) {
  val left = thIt.next()
@@ -312,7 +311,7 @@ public class NDArray<T, D : Dimension> constructor(
  return false
  }
 
- left is ComplexDouble32 && right is ComplexDouble32 -> {
+ left is ComplexDouble && right is ComplexDouble -> {
  if (!(left.eq(right)))
  return false
  }

multik-core/src/jsMain/kotlin/org/jetbrains/kotlinx/multik/ndarray/complex/ComplexDouble.js.kt

@@ -0,0 +1,42 @@
+package org.jetbrains.kotlinx.multik.ndarray.complex
+
+/**
+ * Creates a [ComplexDouble] with the given real and imaginary values in floating-point format.
+ *
+ * @param re the real value of the complex number in double format.
+ * @param im the imaginary value of the complex number in double format.
+ */
+public actual fun ComplexDouble(re: Double, im: Double): ComplexDouble = JsComplexDouble(re, im)
+
+/**
+ * Creates a [ComplexDouble] with the given real and imaginary values in number format.
+ *
+ * @param re the real value of the complex number in number format.
+ * @param im the imaginary value of the complex number in number format.
+ */
+public actual fun ComplexDouble(re: Number, im: Number): ComplexDouble = ComplexDouble(re.toDouble(), im.toDouble())
+
+/**
+ * Represents a complex number with double precision.
+ *
+ * @property re The real part of the complex number.
+ * @property im The imaginary part of the complex number.
+ */
+public class JsComplexDouble internal constructor(
+ public override val re: Double, public override val im: Double
+) : ComplexDouble {
+
+ override fun eq(other: Any): Boolean = equals(other)
+
+ override fun hash(): Int = hashCode()
+
+ override fun equals(other: Any?): Boolean = when {
+ this === other -> true
+ other is ComplexDouble -> re == other.re && im == other.im
+ else -> false
+ }
+
+ override fun hashCode(): Int = 31 * re.toBits().hashCode() + im.toBits().hashCode()
+
+ override fun toString(): String = "$re+($im)i"
+}

multik-core/src/jsMain/kotlin/org/jetbrains/kotlinx/multik/ndarray/data/DataType.js.kt

@@ -0,0 +1,22 @@
+package org.jetbrains.kotlinx.multik.ndarray.data
+
+import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexDouble
+import org.jetbrains.kotlinx.multik.ndarray.complex.ComplexFloat
+import org.jetbrains.kotlinx.multik.ndarray.complex.JsComplexDouble
+import org.jetbrains.kotlinx.multik.ndarray.data.DataType.*
+import kotlin.reflect.KClass
+
+@PublishedApi
+@Suppress("NOTHING_TO_INLINE")
+internal actual inline fun <T : Any> dataTypeOf(type: KClass<out T>): DataType =
+ when (type) {
+ Byte::class -> ByteDataType
+ Short::class -> ShortDataType
+ Int::class -> IntDataType
+ Long::class -> LongDataType
+ Float::class -> FloatDataType
+ Double::class -> DoubleDataType
+ ComplexFloat::class -> ComplexFloatDataType
+ ComplexDouble::class, JsComplexDouble::class -> ComplexDoubleDataType
+ else -> throw IllegalStateException("One of the primitive types was expected, got ${type.simpleName}")
+ }