BigInt as Array

[laftrabajo]

Hi .. may be a stupid question but I need to make some operations on bigint for cript operations and then have a byte array.. is there any way to extract the bigint byte or int array info ??

[SPC-code]

@laftrabajo I am not sure I understand your question. You can operate on Buffer/Points of big integers with corresponding algebras. If you want to extract inner byte array, for Java BigInteger, you can use appropriate method. KMath own BigInt does not use byte array representation, it uses array of UInt. It is not exposed to user. If you want it exposed for some reason, we can add this feature, but please explain your case in more detail in this case. Because inner representation is not guaranteed to be consistent.

[laftrabajo]

Thanks a lot for such a quick response. I'm migrating EC448 and EC25529 curves of Bouncy castle from java to multplatform kotlin. They use BigInteger to make some operations and then extract the XXXArray to continue with the rest. One of the issues I found was the big int so I decided to use your lib core. But now one issue is that I'm no able to extract the XXXArray.. is there a change to have the reverse for this method: public fun UIntArray.toBigInt(sign: Byte): BigInt ??
Thank you again

[SPC-code]

Yes, it is possible to expose inner Magnitude components. Though it is bit of implementation detail that could change. Do you need specific bytes that are used for its creation or a byte array for identity? The problem is that if we expose it, we need to specify which encoding do we use.

[laftrabajo]

If you are ok I give you 2 examples of code working with bit int (take into consideration that this is still Intellij translation of java code's into kotlin)
:

 /**
     * Write the passed in value as unsigned bytes to the specified buffer range, padded with
     * leading zeros as necessary.
     *
     * @param value the value to be converted.
     * @param buf   the buffer to which the value is written.
     * @param off   the start offset in array `buf` at which the data is written.
     * @param len   the fixed length of data written (possibly padded with leading zeros).
     */
    fun asUnsignedByteArray(value: BigInt, buf: ByteArray, off: Int, len: Int) {
        val bytes = value.toByteArray()
        if (bytes.size == len) {
            System.arraycopy(bytes, 0, buf, off, len)
            return
        }

        val start = if (bytes[0].toInt() == 0 && bytes.size != 1) 1 else 0
        val count = bytes.size - start

        require(count <= len) { "standard length exceeded for value" }

        val padLen = len - count
        Arrays.fill(buf, off, off + padLen, 0x00.toByte())
        System.arraycopy(bytes, start, buf, off + padLen, count)
    }


    /**
     * Return a random BigInt not less than 'min' and not greater than 'max'
     *
     * @param min    the least value that may be generated
     * @param max    the greatest value that may be generated
     * @param random the source of randomness
     * @return a random BigInt value in the range [min,max]
     */
    fun createRandomInRange(
        min: BigInt,
        max: BigInt,
        random: SecureRandom
    ): BigInt {
        val cmp = min.compareTo(max)
        if (cmp >= 0) {
            require(cmp <= 0) { "'min' may not be greater than 'max'" }

            return min
        }

        if (min.bitLength() > max.bitLength() / 2) {
            return createRandomInRange(ZERO, max.subtract(min), random).add(min)
        }

        for (i in 0..<MAX_ITERATIONS) {
            val x = createRandomBigInteger(max.bitLength(), random)
            if (x.compareTo(min) >= 0 && x.compareTo(max) <= 0) {
                return x
            }
        }

        // fall back to a faster (restricted) method
        return createRandomBigInteger(max.subtract(min).bitLength() - 1, random).add(min)
    }

[SPC-code]

OK I see the problem; it is a bit exotic. I guess we can expose both sign and Magnitude with a unstable flag.