Tried to add constructors and/or fabrics for polynomials

This commit is contained in:
Gleb Minaev 2022-03-15 20:18:39 +03:00
parent 91c9ea61da
commit 1f9d8d34f5
3 changed files with 122 additions and 375 deletions

View File

@ -73,254 +73,59 @@ internal fun Map<Variable, UInt>.cleanUp() = filterValues { it > 0U }
// region Constructors and converters
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//internal fun <C, A: Ring<C>> LabeledPolynomial(coefs: Map<Map<Variable, UInt>, C>, toCheckInput: Boolean = true): LabeledPolynomial<C> {
// if (!toCheckInput) return LabeledPolynomial<C>(coefs)
//context(LabeledPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//internal fun <C> LabeledPolynomial(coefs: Map<Map<Variable, UInt>, C>, toCheckInput: Boolean = false) : LabeledPolynomial<C> {
// if (!toCheckInput) return LabeledPolynomial(coefs)
//
// // Map for cleaned coefficients.
// val fixedCoefs = mutableMapOf<Map<Variable, UInt>, C>()
//
// // Cleaning the degrees, summing monomials of the same degrees.
// for (entry in coefs) {
// val key = entry.key.cleanUp()
// val value = entry.value
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// // Removing zero monomials.
// return LabeledPolynomial<C>(
// fixedCoefs
// .filter { it.value.isNotZero() }
// return LabeledPolynomial(
// fixedCoefs.filterValues { it.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//internal fun <C, A: Ring<C>> LabeledPolynomial(pairs: Collection<Pair<Map<Variable, UInt>, C>>, toCheckInput: Boolean): LabeledPolynomial<C> {
// if (!toCheckInput) return LabeledPolynomial<C>(pairs.toMap())
//
// // Map for cleaned coefficients.
//context(LabeledPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//internal fun <C> LabeledPolynomial(pairs: Collection<Pair<Map<Variable, UInt>, C>>, toCheckInput: Boolean = false) : LabeledPolynomial<C> {
// if (!toCheckInput) return LabeledPolynomial(pairs.toMap())
//
// val fixedCoefs = mutableMapOf<Map<Variable, UInt>, C>()
//
// // Cleaning the degrees, summing monomials of the same degrees.
// for (entry in pairs) {
// val key = entry.first.cleanUp()
// val value = entry.second
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// // Removing zero monomials.
// return LabeledPolynomial<C>(
// return LabeledPolynomial(
// fixedCoefs.filterValues { it.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represents monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//internal fun <C, A: Ring<C>> LabeledPolynomial(vararg pairs: Pair<Map<Variable, UInt>, C>, toCheckInput: Boolean): LabeledPolynomial<C> {
// if (!toCheckInput) return LabeledPolynomial<C>(pairs.toMap())
//
// // Map for cleaned coefficients.
// val fixedCoefs = mutableMapOf<Map<Variable, UInt>, C>()
//// TODO: Do not know how to make it without context receivers
//context(LabeledPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//public fun <C> LabeledPolynomial(coefs: Map<Map<Variable, UInt>, C>) : LabeledPolynomial<C> = LabeledPolynomial(coefs, toCheckInput = true)
//
// // Cleaning the degrees, summing monomials of the same degrees.
// for (entry in pairs) {
// val key = entry.first.cleanUp()
// val value = entry.second
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//context(LabeledPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//public fun <C> LabeledPolynomial(pairs: Collection<Pair<Map<Variable, UInt>, C>>) : LabeledPolynomial<C> = LabeledPolynomial(pairs, toCheckInput = true)
//
// // Removing zero monomials.
// return LabeledPolynomial<C>(
// fixedCoefs.filterValues { it.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param coefs Coefficients of the instants.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//fun <C, A: Ring<C>> LabeledPolynomial(coefs: Map<Map<Variable, UInt>, C>): LabeledPolynomial<C> = LabeledPolynomial(coefs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represents monomials.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//fun <C, A: Ring<C>> LabeledPolynomial(pairs: Collection<Pair<Map<Variable, UInt>, C>>): LabeledPolynomial<C> = LabeledPolynomial(pairs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represents monomials.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//fun <C, A: Ring<C>> LabeledPolynomial(vararg pairs: Pair<Map<Variable, UInt>, C>): LabeledPolynomial<C> = LabeledPolynomial(*pairs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(LabeledPolynomialSpace<C, A>)
//internal fun <C, A: Ring<C>> LabeledPolynomial(coefs: Map<Map<Variable, UInt>, C>, toCheckInput: Boolean = true): LabeledPolynomial<C> {
// if (!toCheckInput) return LabeledPolynomial<C>(coefs)
//context(LabeledPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//public fun <C> LabeledPolynomial(vararg pairs: Pair<Map<Variable, UInt>, C>) : LabeledPolynomial<C> = LabeledPolynomial(pairs.toList(), toCheckInput = true)
//
// // Map for cleaned coefficients.
// val fixedCoefs = mutableMapOf<Map<Variable, UInt>, C>()
//
// // Cleaning the degrees, summing monomials of the same degrees.
// for (entry in coefs) {
// val key = entry.key.cleanUp()
// val value = entry.value
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// // Removing zero monomials.
// return LabeledPolynomial<C>(
// fixedCoefs
// .filter { it.value.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(LabeledPolynomialSpace<C, A>)
//internal fun <C, A: Ring<C>> LabeledPolynomial(pairs: Collection<Pair<Map<Variable, UInt>, C>>, toCheckInput: Boolean): LabeledPolynomial<C> {
// if (!toCheckInput) return LabeledPolynomial<C>(pairs.toMap())
//
// // Map for cleaned coefficients.
// val fixedCoefs = mutableMapOf<Map<Variable, UInt>, C>()
//
// // Cleaning the degrees, summing monomials of the same degrees.
// for (entry in pairs) {
// val key = entry.first.cleanUp()
// val value = entry.second
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// // Removing zero monomials.
// return LabeledPolynomial<C>(
// fixedCoefs.filterValues { it.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represents monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(LabeledPolynomialSpace<C, A>)
//internal fun <C, A: Ring<C>> LabeledPolynomial(vararg pairs: Pair<Map<Variable, UInt>, C>, toCheckInput: Boolean): LabeledPolynomial<C> {
// if (!toCheckInput) return LabeledPolynomial<C>(pairs.toMap())
//
// // Map for cleaned coefficients.
// val fixedCoefs = mutableMapOf<Map<Variable, UInt>, C>()
//
// // Cleaning the degrees, summing monomials of the same degrees.
// for (entry in pairs) {
// val key = entry.first.cleanUp()
// val value = entry.second
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// // Removing zero monomials.
// return LabeledPolynomial<C>(
// fixedCoefs.filterValues { it.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param coefs Coefficients of the instants.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(LabeledPolynomialSpace<C, A>)
//fun <C, A: Ring<C>> LabeledPolynomial(coefs: Map<Map<Variable, UInt>, C>): LabeledPolynomial<C> = LabeledPolynomial(coefs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represents monomials.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(LabeledPolynomialSpace<C, A>)
//fun <C, A: Ring<C>> LabeledPolynomial(pairs: Collection<Pair<Map<Variable, UInt>, C>>): LabeledPolynomial<C> = LabeledPolynomial(pairs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from keys of received
// * map, sums up proportional monomials, removes aero monomials, and if result is zero map adds only element in it.
// *
// * @param pairs Collection of pairs that represents monomials.
// *
// * @throws LabeledPolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(LabeledPolynomialSpace<C, A>)
//fun <C, A: Ring<C>> LabeledPolynomial(vararg pairs: Pair<Map<Variable, UInt>, C>): LabeledPolynomial<C> = LabeledPolynomial(*pairs, toCheckInput = true)
//
//fun <C> C.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(emptyMap<Variable, UInt>() to this))
//
//context(A)
//fun <C, A: Ring<C>> Variable.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(mapOf<Variable, UInt>(this to 1U) to one))
//
//context(LabeledPolynomialSpace<C, A>)
//fun <C, A: Ring<C>> Variable.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial<C>(mapOf(mapOf<Variable, UInt>(this to 1U) to constantOne))
//
//context(A)
//fun <C, A: Ring<C>> Variable.asLabeledPolynomial(c: C) : LabeledPolynomial<C> =
// if(c.isZero()) LabeledPolynomial<C>(emptyMap())
// else LabeledPolynomial<C>(mapOf(mapOf<Variable, UInt>(this to 1U) to c))
//
//context(LabeledPolynomialSpace<C, A>)
//fun <C, A: Ring<C>> Variable.asLabeledPolynomial(c: C) : LabeledPolynomial<C> =
// if(c.isZero()) zero
// else LabeledPolynomial<C>(mapOf(mapOf<Variable, UInt>(this to 1U) to c))
//context(LabeledPolynomialSpace<C, Ring<C>>)
//public fun <C> Variable.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial(mapOf(mapOf(this to 1u) to constantOne))
public fun <C> C.asLabeledPolynomial() : LabeledPolynomial<C> = LabeledPolynomial(mapOf(emptyMap<Variable, UInt>() to this))
// endregion

View File

@ -72,100 +72,10 @@ internal fun List<UInt>.cleanUp() = subList(0, indexOfLast { it != 0U } + 1)
// endregion
// region Constructors and converters
// Waiting for context receivers :( TODO: Replace with context receivers when they will be available
//context(A)
//context(NumberedPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//internal fun <C, A: Ring<C>> NumberedPolynomial(coefs: Map<List<UInt>, C>, toCheckInput: Boolean): NumberedPolynomial<C> {
// if (!toCheckInput) return NumberedPolynomial<C>(coefs)
//
// val fixedCoefs = mutableMapOf<List<UInt>, C>()
//
// for (entry in coefs) {
// val key = entry.key.cleanUp()
// val value = entry.value
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// return NumberedPolynomial<C>(
// fixedCoefs
// .filter { it.value.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//@Suppress("FunctionName")
//internal fun <C, A: Ring<C>> NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>, toCheckInput: Boolean): NumberedPolynomial<C> {
// if (!toCheckInput) return NumberedPolynomial(pairs.toMap())
//
// val fixedCoefs = mutableMapOf<List<UInt>, C>()
//
// for (entry in pairs) {
// val key = entry.first.cleanUp()
// val value = entry.second
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// return NumberedPolynomial<C>(
// fixedCoefs
// .filter { it.value.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//@Suppress("FunctionName")
//internal fun <C, A: Ring<C>> NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>, toCheckInput: Boolean): NumberedPolynomial<C> =
// NumberedPolynomial(pairs.toMap(), toCheckInput)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param coefs Coefficients of the instants.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//public fun <C, A: Ring<C>> NumberedPolynomial(coefs: Map<List<UInt>, C>) = NumberedPolynomial(coefs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//public fun <C, A: Ring<C>> NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>) = NumberedPolynomial(pairs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(A)
//public fun <C, A: Ring<C>> NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>) = NumberedPolynomial(*pairs, toCheckInput = true)
//
//context(NumberedPolynomialSpace<C, A>)
//@Suppress("FunctionName")
//internal fun <C, A: Ring<C>> NumberedPolynomial(coefs: Map<List<UInt>, C>, toCheckInput: Boolean): NumberedPolynomial<C> {
//internal fun <C> NumberedPolynomial(coefs: Map<List<UInt>, C>, toCheckInput: Boolean = false) : NumberedPolynomial<C> {
// if (!toCheckInput) return NumberedPolynomial(coefs)
//
// val fixedCoefs = mutableMapOf<List<UInt>, C>()
@ -176,23 +86,14 @@ internal fun List<UInt>.cleanUp() = subList(0, indexOfLast { it != 0U } + 1)
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// return NumberedPolynomial<C>(
// fixedCoefs
// .filter { it.value.isNotZero() }
// return NumberedPolynomial(
// fixedCoefs.filterValues { it.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(NumberedPolynomialSpace<C, A>)
//
//context(NumberedPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//internal fun <C, A: Ring<C>> NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>, toCheckInput: Boolean): NumberedPolynomial<C> {
//internal fun <C> NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>, toCheckInput: Boolean = false) : NumberedPolynomial<C> {
// if (!toCheckInput) return NumberedPolynomial(pairs.toMap())
//
// val fixedCoefs = mutableMapOf<List<UInt>, C>()
@ -203,56 +104,25 @@ internal fun List<UInt>.cleanUp() = subList(0, indexOfLast { it != 0U } + 1)
// fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
// }
//
// return NumberedPolynomial<C>(
// fixedCoefs
// .filter { it.value.isNotZero() }
// return NumberedPolynomial(
// fixedCoefs.filterValues { it.isNotZero() }
// )
//}
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// * @param toCheckInput If it's `true` cleaning of [coefficients] is executed otherwise it is not.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(NumberedPolynomialSpace<C, A>)
//
//// TODO: Do not know how to make it without context receivers
//context(NumberedPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//internal fun <C, A: Ring<C>> NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>, toCheckInput: Boolean): NumberedPolynomial<C> =
// NumberedPolynomial(pairs.toList(), toCheckInput)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param coefs Coefficients of the instants.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(NumberedPolynomialSpace<C, A>)
//public fun <C, A: Ring<C>> NumberedPolynomial(coefs: Map<List<UInt>, C>) = NumberedPolynomial(coefs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(NumberedPolynomialSpace<C, A>)
//public fun <C, A: Ring<C>> NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>) = NumberedPolynomial(pairs, toCheckInput = true)
///**
// * Gets the coefficients in format of [coefficients] field and cleans it: removes zero degrees from end of received
// * lists, sums up proportional monomials, removes zero monomials, and if result is empty map adds only element in it.
// *
// * @param pairs Collection of pairs that represent monomials.
// *
// * @throws PolynomialError If no coefficient received or if any of degrees in any monomial is negative.
// */
//context(NumberedPolynomialSpace<C, A>)
//public fun <C, A: Ring<C>> NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>) = NumberedPolynomial(*pairs, toCheckInput = true)
//public fun <C> NumberedPolynomial(coefs: Map<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(coefs, toCheckInput = true)
//
//context(NumberedPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//public fun <C> NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>) : NumberedPolynomial<C> = NumberedPolynomial(pairs, toCheckInput = true)
//
//context(NumberedPolynomialSpace<C, Ring<C>>)
//@Suppress("FunctionName")
//public fun <C> NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(pairs.toList(), toCheckInput = true)
public fun <C, A: Ring<C>> C.asNumberedPolynomial() : NumberedPolynomial<C> = NumberedPolynomial<C>(mapOf(emptyList<UInt>() to this))
public fun <C> C.asNumberedPolynomial() : NumberedPolynomial<C> = NumberedPolynomial(mapOf(emptyList<UInt>() to this))
// endregion
@ -314,7 +184,7 @@ public open class NumberedPolynomialSpace<C, A : Ring<C>>(
*/
public override operator fun NumberedPolynomial<C>.times(other: Int): NumberedPolynomial<C> =
if (other == 0) zero
else NumberedPolynomial(
else NumberedPolynomial<C>(
coefficients
.applyAndRemoveZeros {
mapValues { (_, c) -> c * other }
@ -707,4 +577,51 @@ public open class NumberedPolynomialSpace<C, A : Ring<C>>(
}
}
// endregion
// region Constructors and converters
@Suppress("FunctionName")
internal fun NumberedPolynomial(coefs: Map<List<UInt>, C>, toCheckInput: Boolean = false) : NumberedPolynomial<C> {
if (!toCheckInput) return NumberedPolynomial<C>(coefs)
val fixedCoefs = mutableMapOf<List<UInt>, C>()
for (entry in coefs) {
val key = entry.key.cleanUp()
val value = entry.value
fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
}
return NumberedPolynomial(
fixedCoefs.filterValues { it.isNotZero() }
)
}
@Suppress("FunctionName")
internal fun NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>, toCheckInput: Boolean = false) : NumberedPolynomial<C> {
if (!toCheckInput) return NumberedPolynomial<C>(pairs.toMap())
val fixedCoefs = mutableMapOf<List<UInt>, C>()
for (entry in pairs) {
val key = entry.first.cleanUp()
val value = entry.second
fixedCoefs[key] = if (key in fixedCoefs) fixedCoefs[key]!! + value else value
}
return NumberedPolynomial(
fixedCoefs.filterValues { it.isNotZero() }
)
}
@Suppress("FunctionName")
public fun NumberedPolynomial(coefs: Map<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(coefs, toCheckInput = true)
@Suppress("FunctionName")
public fun NumberedPolynomial(pairs: Collection<Pair<List<UInt>, C>>) : NumberedPolynomial<C> = NumberedPolynomial(pairs, toCheckInput = true)
@Suppress("FunctionName")
public fun NumberedPolynomial(vararg pairs: Pair<List<UInt>, C>) : NumberedPolynomial<C> = NumberedPolynomial(pairs.toList(), toCheckInput = true)
// endregion
}

View File

@ -14,7 +14,32 @@ import kotlin.math.min
*
* @param coefficients constant is the leftmost coefficient.
*/
public data class Polynomial<C>(public val coefficients: List<C>) : AbstractPolynomial<C> {
public data class Polynomial<C>(
/**
* List that collects coefficients of the polynomial. Every monomial `a x^d` is represented as a coefficients
* `a` placed into the list with index `d`. For example coefficients of polynomial `5 x^2 - 6` can be represented as
* ```
* listOf(
* -6, // -6 +
* 0, // 0 x +
* 5, // 5 x^2
* )
* ```
* and also as
* ```
* listOf(
* -6, // -6 +
* 0, // 0 x +
* 5, // 5 x^2
* 0, // 0 x^3
* 0, // 0 x^4
* )
* ```
* It is recommended not to put extra zeros at end of the list (as for `0x^3` and `0x^4` in the example), but is not
* prohibited.
*/
public val coefficients: List<C>
) : AbstractPolynomial<C> {
override fun toString(): String = "Polynomial$coefficients"
}