diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt
index 735e04a48..599660b52 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/LabeledRationalFunction.kt
@@ -19,48 +19,46 @@ public class LabeledRationalFunction<C>(
 
 // Waiting for context receivers :( TODO: Replace with context receivers when they will be available
 
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//internal fun <C, A: Ring<C>> RationalFunction(numerator: Polynomial<C>, denominator: Polynomial<C>): RationalFunction<C> =
-//    if (denominator.isZero()) throw ArithmeticException("/ by zero")
-//    else RationalFunction<C>(numerator, denominator)
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numeratorCoefficients: List<C>, denominatorCoefficients: List<C>, reverse: Boolean = false): RationalFunction<C> =
-//    RationalFunction<C>(
-//        Polynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
-//        Polynomial( with(denominatorCoefficients) { if (reverse) reversed() else this } ).also { if (it.isZero()) }
-//    )
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numerator: Polynomial<C>): RationalFunction<C> =
-//    RationalFunction(numerator, onePolynomial)
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): RationalFunction<C> =
-//    RationalFunction(
-//        Polynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } )
-//    )
-
-// TODO: Rewrite former constructors as fabrics
-//constructor(numeratorCoefficients: Map<Map<Symbol, Int>, C>, denominatorCoefficients: Map<Map<Symbol, Int>, C>) : this(
-//LabeledPolynomial(numeratorCoefficients),
-//LabeledPolynomial(denominatorCoefficients)
-//)
-//
-//constructor(numeratorCoefficients: Collection<Pair<Map<Symbol, Int>, C>>, denominatorCoefficients: Collection<Pair<Map<Symbol, Int>, C>>) : this(
-//LabeledPolynomial(numeratorCoefficients),
-//LabeledPolynomial(denominatorCoefficients)
-//)
-//
-//constructor(numerator: LabeledPolynomial<C>) : this(numerator, numerator.getOne())
-//constructor(numeratorCoefficients: Map<Map<Symbol, Int>, C>) : this(
-//LabeledPolynomial(numeratorCoefficients)
-//)
-//
-//constructor(numeratorCoefficients: Collection<Pair<Map<Symbol, Int>, C>>) : this(
-//LabeledPolynomial(numeratorCoefficients)
-//)
+@Suppress("FunctionName")
+internal fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledRationalFunction(numerator: LabeledPolynomial<C>, denominator: LabeledPolynomial<C>): LabeledRationalFunction<C> =
+    if (denominator.isZero()) throw ArithmeticException("/ by zero")
+    else LabeledRationalFunction<C>(numerator, denominator)
+@Suppress("FunctionName")
+internal fun <C, A: Ring<C>> A.LabeledRationalFunction(numerator: LabeledPolynomial<C>, denominator: LabeledPolynomial<C>): LabeledRationalFunction<C> =
+    if (denominator.coefficients.values.all { it == zero }) throw ArithmeticException("/ by zero")
+    else LabeledRationalFunction<C>(numerator, denominator)
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledRationalFunction(numeratorCoefficients: Map<Map<Symbol, UInt>, C>, denominatorCoefficients: Map<Map<Symbol, UInt>, C>): LabeledRationalFunction<C> =
+    if (denominatorCoefficients.values.all { it == zero }) throw ArithmeticException("/ by zero")
+    else LabeledRationalFunction<C>(
+        LabeledPolynomial(numeratorCoefficients),
+        LabeledPolynomial(denominatorCoefficients)
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.LabeledRationalFunction(numeratorCoefficients: Map<Map<Symbol, UInt>, C>, denominatorCoefficients: Map<Map<Symbol, UInt>, C>): LabeledRationalFunction<C> =
+    if (denominatorCoefficients.values.all { it == zero }) throw ArithmeticException("/ by zero")
+    else LabeledRationalFunction<C>(
+        LabeledPolynomial(numeratorCoefficients),
+        LabeledPolynomial(denominatorCoefficients)
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledRationalFunction(numerator: LabeledPolynomial<C>): LabeledRationalFunction<C> =
+    LabeledRationalFunction<C>(numerator, polynomialOne)
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.LabeledRationalFunction(numerator: LabeledPolynomial<C>): LabeledRationalFunction<C> =
+    LabeledRationalFunction<C>(numerator, LabeledPolynomial(mapOf(emptyMap<Symbol, UInt>() to one)))
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> LabeledRationalFunctionSpace<C, A>.LabeledRationalFunction(numeratorCoefficients: Map<Map<Symbol, UInt>, C>): LabeledRationalFunction<C> =
+    LabeledRationalFunction<C>(
+        LabeledPolynomial(numeratorCoefficients),
+        polynomialOne
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.LabeledRationalFunction(numeratorCoefficients: Map<Map<Symbol, UInt>, C>): LabeledRationalFunction<C> =
+    LabeledRationalFunction<C>(
+        LabeledPolynomial(numeratorCoefficients),
+        LabeledPolynomial(mapOf(emptyMap<Symbol, UInt>() to one))
+    )
 
 public class LabeledRationalFunctionSpace<C, A: Ring<C>>(
     public val ring: A,
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt
index 8bd925c46..67c7e9fa2 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/ListRationalFunction.kt
@@ -17,28 +17,46 @@ public data class ListRationalFunction<C> internal constructor (
 
 // Waiting for context receivers :( TODO: Replace with context receivers when they will be available
 
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//internal fun <C, A: Ring<C>> RationalFunction(numerator: Polynomial<C>, denominator: Polynomial<C>): RationalFunction<C> =
-//    if (denominator.isZero()) throw ArithmeticException("/ by zero")
-//    else RationalFunction<C>(numerator, denominator)
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numeratorCoefficients: List<C>, denominatorCoefficients: List<C>, reverse: Boolean = false): RationalFunction<C> =
-//    RationalFunction<C>(
-//        Polynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
-//        Polynomial( with(denominatorCoefficients) { if (reverse) reversed() else this } ).also { if (it.isZero()) }
-//    )
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numerator: Polynomial<C>): RationalFunction<C> =
-//    RationalFunction(numerator, onePolynomial)
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): RationalFunction<C> =
-//    RationalFunction(
-//        Polynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } )
-//    )
+@Suppress("FunctionName")
+internal fun <C, A: Ring<C>> ListRationalFunctionSpace<C, A>.ListRationalFunction(numerator: ListPolynomial<C>, denominator: ListPolynomial<C>): ListRationalFunction<C> =
+    if (denominator.isZero()) throw ArithmeticException("/ by zero")
+    else ListRationalFunction<C>(numerator, denominator)
+@Suppress("FunctionName")
+internal fun <C, A: Ring<C>> A.ListRationalFunction(numerator: ListPolynomial<C>, denominator: ListPolynomial<C>): ListRationalFunction<C> =
+    if (denominator.coefficients.all { it == zero }) throw ArithmeticException("/ by zero")
+    else ListRationalFunction<C>(numerator, denominator)
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> ListRationalFunctionSpace<C, A>.ListRationalFunction(numeratorCoefficients: List<C>, denominatorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C> =
+    if (denominatorCoefficients.all { it == zero }) throw ArithmeticException("/ by zero")
+    else ListRationalFunction<C>(
+        ListPolynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
+        ListPolynomial( with(denominatorCoefficients) { if (reverse) reversed() else this } )
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.ListRationalFunction(numeratorCoefficients: List<C>, denominatorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C> =
+    if (denominatorCoefficients.all { it == zero }) throw ArithmeticException("/ by zero")
+    else ListRationalFunction<C>(
+        ListPolynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
+        ListPolynomial( with(denominatorCoefficients) { if (reverse) reversed() else this } )
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> ListRationalFunctionSpace<C, A>.ListRationalFunction(numerator: ListPolynomial<C>): ListRationalFunction<C> =
+    ListRationalFunction<C>(numerator, polynomialOne)
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.ListRationalFunction(numerator: ListPolynomial<C>): ListRationalFunction<C> =
+    ListRationalFunction<C>(numerator, ListPolynomial(listOf(one)))
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> ListRationalFunctionSpace<C, A>.ListRationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C> =
+    ListRationalFunction<C>(
+        ListPolynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
+        polynomialOne
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.ListRationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): ListRationalFunction<C> =
+    ListRationalFunction<C>(
+        ListPolynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
+        ListPolynomial(listOf(one))
+    )
 
 public class ListRationalFunctionSpace<C, A : Ring<C>> (
     public val ring: A,
diff --git a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt
index f3b90b5c5..b32f01f2a 100644
--- a/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt
+++ b/kmath-functions/src/commonMain/kotlin/space/kscience/kmath/functions/NumberedRationalFunction.kt
@@ -5,7 +5,8 @@
 
 package space.kscience.kmath.functions
 
-import space.kscience.kmath.operations.*
+import space.kscience.kmath.operations.Ring
+import space.kscience.kmath.operations.invoke
 import kotlin.math.max
 
 
@@ -18,45 +19,46 @@ public class NumberedRationalFunction<C> internal constructor(
 
 // Waiting for context receivers :( TODO: Replace with context receivers when they will be available
 
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//internal fun <C, A: Ring<C>> RationalFunction(numerator: Polynomial<C>, denominator: Polynomial<C>): RationalFunction<C> =
-//    if (denominator.isZero()) throw ArithmeticException("/ by zero")
-//    else RationalFunction<C>(numerator, denominator)
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numeratorCoefficients: List<C>, denominatorCoefficients: List<C>, reverse: Boolean = false): RationalFunction<C> =
-//    RationalFunction<C>(
-//        Polynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } ),
-//        Polynomial( with(denominatorCoefficients) { if (reverse) reversed() else this } ).also { if (it.isZero()) }
-//    )
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numerator: Polynomial<C>): RationalFunction<C> =
-//    RationalFunction(numerator, onePolynomial)
-//context(RationalFunctionSpace<C, A>)
-//@Suppress("FunctionName")
-//public fun <C, A: Ring<C>> RationalFunction(numeratorCoefficients: List<C>, reverse: Boolean = false): RationalFunction<C> =
-//    RationalFunction(
-//        Polynomial( with(numeratorCoefficients) { if (reverse) reversed() else this } )
-//    )
-
-// TODO: Rewrite former constructors as fabrics
-//constructor(numeratorCoefficients: Map<List<Int>, C>, denominatorCoefficients: Map<List<Int>, C>) : this(
-//Polynomial(numeratorCoefficients),
-//Polynomial(denominatorCoefficients)
-//)
-//constructor(numeratorCoefficients: Collection<Pair<List<Int>, C>>, denominatorCoefficients: Collection<Pair<List<Int>, C>>) : this(
-//Polynomial(numeratorCoefficients),
-//Polynomial(denominatorCoefficients)
-//)
-//constructor(numerator: Polynomial<C>) : this(numerator, numerator.getOne())
-//constructor(numeratorCoefficients: Map<List<Int>, C>) : this(
-//Polynomial(numeratorCoefficients)
-//)
-//constructor(numeratorCoefficients: Collection<Pair<List<Int>, C>>) : this(
-//Polynomial(numeratorCoefficients)
-//)
+@Suppress("FunctionName")
+internal fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedRationalFunction(numerator: NumberedPolynomial<C>, denominator: NumberedPolynomial<C>): NumberedRationalFunction<C> =
+    if (denominator.isZero()) throw ArithmeticException("/ by zero")
+    else NumberedRationalFunction<C>(numerator, denominator)
+@Suppress("FunctionName")
+internal fun <C, A: Ring<C>> A.NumberedRationalFunction(numerator: NumberedPolynomial<C>, denominator: NumberedPolynomial<C>): NumberedRationalFunction<C> =
+    if (denominator.coefficients.values.all { it == zero }) throw ArithmeticException("/ by zero")
+    else NumberedRationalFunction<C>(numerator, denominator)
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedRationalFunction(numeratorCoefficients: Map<List<UInt>, C>, denominatorCoefficients: Map<List<UInt>, C>): NumberedRationalFunction<C> =
+    if (denominatorCoefficients.values.all { it == zero }) throw ArithmeticException("/ by zero")
+    else NumberedRationalFunction<C>(
+        NumberedPolynomial(numeratorCoefficients),
+        NumberedPolynomial(denominatorCoefficients)
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.NumberedRationalFunction(numeratorCoefficients: Map<List<UInt>, C>, denominatorCoefficients: Map<List<UInt>, C>): NumberedRationalFunction<C> =
+    if (denominatorCoefficients.values.all { it == zero }) throw ArithmeticException("/ by zero")
+    else NumberedRationalFunction<C>(
+        NumberedPolynomial(numeratorCoefficients),
+        NumberedPolynomial(denominatorCoefficients)
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedRationalFunction(numerator: NumberedPolynomial<C>): NumberedRationalFunction<C> =
+    NumberedRationalFunction<C>(numerator, polynomialOne)
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.NumberedRationalFunction(numerator: NumberedPolynomial<C>): NumberedRationalFunction<C> =
+    NumberedRationalFunction<C>(numerator, NumberedPolynomial(mapOf(emptyList<UInt>() to one)))
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> NumberedRationalFunctionSpace<C, A>.NumberedRationalFunction(numeratorCoefficients: Map<List<UInt>, C>): NumberedRationalFunction<C> =
+    NumberedRationalFunction<C>(
+        NumberedPolynomial(numeratorCoefficients),
+        polynomialOne
+    )
+@Suppress("FunctionName")
+public fun <C, A: Ring<C>> A.NumberedRationalFunction(numeratorCoefficients: Map<List<UInt>, C>): NumberedRationalFunction<C> =
+    NumberedRationalFunction<C>(
+        NumberedPolynomial(numeratorCoefficients),
+        NumberedPolynomial(mapOf(emptyList<UInt>() to one))
+    )
 
 public class NumberedRationalFunctionSpace<C, A: Ring<C>> (
     public val ring: A,
@@ -156,24 +158,6 @@ public class NumberedRationalFunctionSpace<C, A: Ring<C>> (
 
     // TODO: Разобрать
 
-    public operator fun NumberedRationalFunction<C>.div(other: NumberedRationalFunction<C>): NumberedRationalFunction<C> =
-        NumberedRationalFunction(
-            numerator * other.denominator,
-            denominator * other.numerator
-        )
-
-    public operator fun NumberedRationalFunction<C>.div(other: NumberedPolynomial<C>): NumberedRationalFunction<C> =
-        NumberedRationalFunction(
-            numerator,
-            denominator * other
-        )
-
-    public operator fun NumberedRationalFunction<C>.div(other: C): NumberedRationalFunction<C> =
-        NumberedRationalFunction(
-            numerator,
-            denominator * other
-        )
-
 //    operator fun invoke(arg: Map<Int, C>): NumberedRationalFunction<C> =
 //        NumberedRationalFunction(
 //            numerator(arg),