Tried to add constructors and/or fabrics for polynomials
This commit is contained in:
Gleb Minaev
parent
91c9ea61da
commit
1f9d8d34f5
@ -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
|
||||
|
||||
|
||||
@ -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
|
||||
}
|
||||
@ -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"
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user