Added API for reading and writing of floating point numbers

Implemented extension functions for reading and writing  values with types Float and Double

Resolves #167

core/common/src/Sinks.kt

@@ -275,6 +275,70 @@ public fun Sink.writeULongLe(long: ULong) {
  writeLongLe(long.toLong())
 }
 
+/**
+ * Writes four bytes of a bit representation of [float], in the big-endian order, to this sink.
+ * Bit representation of the [float] corresponds to the IEEE 754 floating-point "single format" bit layout.
+ *
+ * To obtain a bit representation, the [Float.toBits] function is used.
+ *
+ * @param float the floating point number to be written.
+ *
+ * @throws IllegalStateException when the sink is closed.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoCoreCommonSamples.writeFloat
+ */
+public fun Sink.writeFloat(float: Float) {
+ writeInt(float.toBits())
+}
+
+/**
+ * Writes eight bytes of a bit representation of [double], in the big-endian order, to this sink.
+ * Bit representation of the [double] corresponds to the IEEE 754 floating-point "double format" bit layout.
+ *
+ * To obtain a bit representation, the [Double.toBits] function is used.
+ *
+ * @param double the floating point number to be written.
+ *
+ * @throws IllegalStateException when the sink is closed.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoCoreCommonSamples.writeDouble
+ */
+public fun Sink.writeDouble(double: Double) {
+ writeLong(double.toBits())
+}
+
+/**
+ * Writes four bytes of a bit representation of [float], in the little-endian order, to this sink.
+ * Bit representation of the [float] corresponds to the IEEE 754 floating-point "single format" bit layout.
+ *
+ * To obtain a bit representation, the [Float.toBits] function is used.
+ *
+ * @param float the floating point number to be written.
+ *
+ * @throws IllegalStateException when the sink is closed.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoCoreCommonSamples.writeFloatLe
+ */
+public fun Sink.writeFloatLe(float: Float) {
+ writeIntLe(float.toBits())
+}
+
+/**
+ * Writes eight bytes of a bit representation of [double], in the little-endian order, to this sink.
+ * Bit representation of the [double] corresponds to the IEEE 754 floating-point "double format" bit layout.
+ *
+ * To obtain a bit representation, the [Double.toBits] function is used.
+ *
+ * @param double the floating point number to be written.
+ *
+ * @throws IllegalStateException when the sink is closed.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoCoreCommonSamples.writeDoubleLe
+ */
+public fun Sink.writeDoubleLe(double: Double) {
+ writeLongLe(double.toBits())
+}
+
 /**
  * Provides direct access to the sink's internal buffer and hints its emit before exit.
  *

core/common/src/Sources.kt

@@ -357,6 +357,58 @@ public fun Source.readUIntLe(): UInt = readIntLe().toUInt()
  */
 public fun Source.readULongLe(): ULong = readLongLe().toULong()
 
+/**
+ * Removes four bytes from this source and returns a floating point number with type [Float] composed of it
+ * according to the big-endian order.
+ *
+ * The [Float.Companion.fromBits] function is used for decoding bytes into [Float].
+ *
+ * @throws EOFException when there are not enough data to read an unsigned int value.
+ * @throws IllegalStateException when the source is closed.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoCoreCommonSamples.readFloat
+ */
+public fun Source.readFloat(): Float = Float.fromBits(readInt())
+
+/**
+ * Removes eight bytes from this source and returns a floating point number with type [Double] composed of it
+ * according to the big-endian order.
+ *
+ * The [Double.Companion.fromBits] function is used for decoding bytes into [Double].
+ *
+ * @throws EOFException when there are not enough data to read an unsigned int value.
+ * @throws IllegalStateException when the source is closed.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoCoreCommonSamples.readDouble
+ */
+public fun Source.readDouble(): Double = Double.fromBits(readLong())
+
+/**
+ * Removes four bytes from this source and returns a floating point number with type [Float] composed of it
+ * according to the little-endian order.
+ *
+ * The [Float.Companion.fromBits] function is used for decoding bytes into [Float].
+ *
+ * @throws EOFException when there are not enough data to read an unsigned int value.
+ * @throws IllegalStateException when the source is closed.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoCoreCommonSamples.readFloatLe
+ */
+public fun Source.readFloatLe(): Float = Float.fromBits(readIntLe())
+
+/**
+ * Removes eight bytes from this source and returns a floating point number with type [Double] composed of it
+ * according to the little-endian order.
+ *
+ * The [Double.Companion.fromBits] function is used for decoding bytes into [Double].
+ *
+ * @throws EOFException when there are not enough data to read an unsigned int value.
+ * @throws IllegalStateException when the source is closed.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoCoreCommonSamples.readDoubleLe
+ */
+public fun Source.readDoubleLe(): Double = Double.fromBits(readLongLe())
+
 /**
  * Return `true` if the next byte to be consumed from this source is equal to [byte].
  * Otherwise, return `false` as well as when the source is exhausted.

core/common/test/AbstractSinkTest.kt

@@ -449,6 +449,34 @@ abstract class AbstractSinkTest internal constructor(
  assertEquals("Buffer(size=8 hex=efcdab9078563412)", data.toString())
  }
 
+ @Test
+ fun writeFloat() {
+ sink.writeFloat(12345.678F)
+ sink.flush()
+ assertEquals(12345.678F.toBits(), data.readInt())
+ }
+
+ @Test
+ fun writeFloatLe() {
+ sink.writeFloatLe(12345.678F)
+ sink.flush()
+ assertEquals(12345.678F.toBits(), data.readIntLe())
+ }
+
+ @Test
+ fun writeDouble() {
+ sink.writeDouble(123456.78901)
+ sink.flush()
+ assertEquals(123456.78901.toBits(), data.readLong())
+ }
+
+ @Test
+ fun writeDoubleLe() {
+ sink.writeDoubleLe(123456.78901)
+ sink.flush()
+ assertEquals(123456.78901.toBits(), data.readLongLe())
+ }
+
  @Test
  fun writeByteString() {
  sink.write("təˈranəˌsôr".encodeToByteString())

core/common/test/AbstractSourceTest.kt

@@ -1464,6 +1464,70 @@ abstract class AbstractBufferedSourceTest internal constructor(
  assertEquals(0x78563412u, source.readUIntLe())
  }
 
+ @Test
+ fun readFloat() {
+ sink.write(byteArrayOf(70, 64, -26, -74))
+ sink.flush()
+ assertEquals(12345.678F.toBits(), source.readFloat().toBits())
+ }
+
+ @Test
+ fun readDouble() {
+ sink.write(byteArrayOf(64, -2, 36, 12, -97, -56, -13, 35))
+ sink.flush()
+ assertEquals(123456.78901, source.readDouble())
+ }
+
+ @Test
+ fun readFloatLe() {
+ sink.write(byteArrayOf(-74, -26, 64, 70))
+ sink.flush()
+ assertEquals(12345.678F.toBits(), source.readFloatLe().toBits())
+ }
+
+ @Test
+ fun readDoubleLe() {
+ sink.write(byteArrayOf(35, -13, -56, -97, 12, 36, -2, 64))
+ sink.flush()
+ assertEquals(123456.78901, source.readDoubleLe())
+ }
+
+ @Test
+ fun readTooShortFloatThrows() {
+ assertFailsWith<EOFException> { source.readFloat() }
+ sink.writeByte(0)
+ sink.flush()
+ assertFailsWith<EOFException> { source.readFloat() }
+ assertTrue(source.request(1))
+ }
+
+ @Test
+ fun readTooShortDoubleThrows() {
+ assertFailsWith<EOFException> { source.readDouble() }
+ sink.writeByte(0)
+ sink.flush()
+ assertFailsWith<EOFException> { source.readDouble() }
+ assertTrue(source.request(1))
+ }
+
+ @Test
+ fun readTooShortFloatLeThrows() {
+ assertFailsWith<EOFException> { source.readFloatLe() }
+ sink.writeByte(0)
+ sink.flush()
+ assertFailsWith<EOFException> { source.readFloatLe() }
+ assertTrue(source.request(1))
+ }
+
+ @Test
+ fun readTooShortDoubleLeThrows() {
+ assertFailsWith<EOFException> { source.readDoubleLe() }
+ sink.writeByte(0)
+ sink.flush()
+ assertFailsWith<EOFException> { source.readDoubleLe() }
+ assertTrue(source.request(1))
+ }
+
  @Test
  fun readTooShortUnsignedIntThrows() {
  assertFailsWith<EOFException> { source.readUInt() }

core/common/test/samples/samples.kt

@@ -488,6 +488,21 @@ class KotlinxIoCoreCommonSamples {
  assertEquals(18446744073709551615UL, buffer.readULong())
  }
 
+ @Test
+ fun readFloat() {
+ val buffer = Buffer()
+ buffer.write(byteArrayOf(70, 64, -26, -74))
+ assertEquals(12345.678F.toBits(), buffer.readFloat().toBits())
+ }
+
+ @Test
+ fun readDouble() {
+ val buffer = Buffer()
+ buffer.write(byteArrayOf(64, -2, 36, 12, -97, -56, -13, 35))
+
+ assertEquals(123456.78901, buffer.readDouble())
+ }
+
  @Test
  fun writeUByte() {
  val buffer = Buffer()
@@ -520,6 +535,22 @@ class KotlinxIoCoreCommonSamples {
  assertContentEquals(byteArrayOf(-1, -1, -1, -1, -1, -1, -1, -1), buffer.readByteArray())
  }
 
+ @Test
+ fun writeFloat() {
+ val buffer = Buffer()
+ buffer.writeFloat(12345.678F)
+
+ assertContentEquals(byteArrayOf(70, 64, -26, -74), buffer.readByteArray())
+ }
+
+ @Test
+ fun writeDouble() {
+ val buffer = Buffer()
+ buffer.writeDouble(123456.78901)
+
+ assertContentEquals(byteArrayOf(64, -2, 36, 12, -97, -56, -13, 35), buffer.readByteArray())
+ }
+
  @Test
  fun flush() {
  val rawSink = object : RawSink {
@@ -650,6 +681,20 @@ class KotlinxIoCoreCommonSamples {
  assertEquals(0xF0DEBC9A78563412U, buffer.readULongLe())
  }
 
+ @Test
+ fun readFloatLe() {
+ val buffer = Buffer()
+ buffer.write(byteArrayOf(-74, -26, 64, 70))
+ assertEquals(12345.678F.toBits(), buffer.readFloatLe().toBits())
+ }
+
+ @Test
+ fun readDoubleLe() {
+ val buffer = Buffer()
+ buffer.write(byteArrayOf(35, -13, -56, -97, 12, 36, -2, 64))
+ assertEquals(123456.78901, buffer.readDoubleLe())
+ }
+
  @Test
  fun writeUShortLe() {
  val buffer = Buffer()
@@ -670,4 +715,20 @@ class KotlinxIoCoreCommonSamples {
  buffer.writeULongLe(0x123456789ABCDEF0U)
  assertEquals(0xF0DEBC9A78563412U, buffer.readULong())
  }
+
+ @Test
+ fun writeFloatLe() {
+ val buffer = Buffer()
+ buffer.writeFloatLe(12345.678F)
+
+ assertContentEquals(byteArrayOf(-74, -26, 64, 70), buffer.readByteArray())
+ }
+
+ @Test
+ fun writeDoubleLe() {
+ val buffer = Buffer()
+ buffer.writeDoubleLe(123456.78901)
+
+ assertContentEquals(byteArrayOf(35, -13, -56, -97, 12, 36, -2, 64), buffer.readByteArray())
+ }
 }