mutable/context API

Luna-Flow/luna-poly/mutable/context 提供可变的 ContextPolynomial[A]：一个持有 immut/context 多项式的单元，add_inplace、mul_inplace 和 clear 会替换其中的值。其他所有操作都委托给不可变实现，并具有相同的语义、失败情形和开销。

这些类型由 mutable 门面包重新导出，示例即使用该门面包。“与 immut 相同”指 immut/context API。设计说明见 mutable/context 设计。

类型

ContextPolynomial

基于 VariableContext 的可变多项式。

type ContextPolynomial[A] derive(@debug.Debug)
pub impl[A : Eq + @luna-generic.AddMonoid] Add for ContextPolynomial[A]
pub impl[A : Eq + @luna-generic.AddMonoid + Neg] Sub for ContextPolynomial[A]
pub impl[A : Eq + @luna-generic.AddMonoid + Mul] Mul for ContextPolynomial[A]
pub impl[A : Eq + @luna-generic.Zero + Neg] Neg for ContextPolynomial[A]
pub impl[A : Show + @luna-generic.Zero] Show for ContextPolynomial[A]
pub impl[A : Eq + @luna-generic.AddMonoid] @core.Clearable for ContextPolynomial[A]
pub impl[A] @core.Copyable for ContextPolynomial[A]
pub impl[A : Eq + @luna-generic.AddMonoid] @core.MutablePolynomial for ContextPolynomial[A]
pub impl[A] @core.ContextualPolynomial for ContextPolynomial[A]
pub impl[A] @core.HasArity for ContextPolynomial[A]
pub impl[A] @core.HasContext for ContextPolynomial[A]
pub impl[A] @core.HasShape for ContextPolynomial[A]
pub impl[A] @core.HasTermCount for ContextPolynomial[A]
pub impl[A] @core.IsZero for ContextPolynomial[A]

ContextSubstitutionValue

某一变量的替换值：标量，或同一上下文上的可变上下文多项式。它是与不可变的 ContextSubstitutionValue 不同的独立类型；在委托代换时会进行转换。

pub(all) enum ContextSubstitutionValue[A] {
  Scalar(A)
  Polynomial(ContextPolynomial[A])
}

构造与转换

ContextPolynomial::from_immut, ContextPolynomial::to_immut

包装一个不可变上下文多项式，以及返回当前持有的不可变值。两者都不复制；这是安全的，因为所持有的值是不可变的，修改操作是替换它而不是改变它。

pub fn[A] ContextPolynomial::from_immut(@Luna-Flow/luna-poly/immut/context.ContextPolynomial[A]) -> Self[A]
pub fn[A] ContextPolynomial::to_immut(Self[A]) -> @Luna-Flow/luna-poly/immut/context.ContextPolynomial[A]

ContextPolynomial::from_named_terms_as_terms, ContextPolynomial::from_named_terms_as_terms_checked, ContextPolynomial::from_named_terms_as_sparse, ContextPolynomial::from_named_terms_as_sparse_checked

由命名项构造，与 immut 相同。

pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::from_named_terms_as_terms(@Luna-Flow/luna-poly/core.VariableContext, Array[(Array[(@Luna-Flow/luna-poly/core.Variable, UInt)], A)]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::from_named_terms_as_terms_checked(@Luna-Flow/luna-poly/core.VariableContext, Array[(Array[(@Luna-Flow/luna-poly/core.Variable, UInt)], A)]) -> Self[A]?
pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::from_named_terms_as_sparse(@Luna-Flow/luna-poly/core.VariableContext, Array[(Array[(@Luna-Flow/luna-poly/core.Variable, UInt)], A)]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::from_named_terms_as_sparse_checked(@Luna-Flow/luna-poly/core.VariableContext, Array[(Array[(@Luna-Flow/luna-poly/core.Variable, UInt)], A)]) -> Self[A]?

ContextPolynomial::from_term_polynomial, ContextPolynomial::from_sparse_polynomial

把可变的项多项式或稀疏多项式绑定到上下文。多项式会被转换为其不可变形式，因此之后修改参数不会影响结果。与 immut 相同，不会检查元数是否超过上下文大小。

pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::from_term_polynomial(@Luna-Flow/luna-poly/core.VariableContext, @term.TermPolynomial[A]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::from_sparse_polynomial(@Luna-Flow/luna-poly/core.VariableContext, @sparse.SparsePolynomial[A]) -> Self[A]

ContextPolynomial::constant, ContextPolynomial::variable, ContextPolynomial::variable_checked

与 immut 相同。

pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::constant(@Luna-Flow/luna-poly/core.VariableContext, A) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + @luna-generic.One] ContextPolynomial::variable(@Luna-Flow/luna-poly/core.VariableContext, @Luna-Flow/luna-poly/core.Variable) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + @luna-generic.One] ContextPolynomial::variable_checked(@Luna-Flow/luna-poly/core.VariableContext, @Luna-Flow/luna-poly/core.Variable) -> Self[A]?

ContextPolynomial::copy

返回持有同一不可变值的新单元，开销 $O(1)$（也是 Copyable::copy）。此后修改任一单元都不会影响另一个。

pub fn[A] ContextPolynomial::copy(Self[A]) -> Self[A]

查询与转换

ContextPolynomial::context, ContextPolynomial::to_terms, ContextPolynomial::term_count, ContextPolynomial::arity, ContextPolynomial::is_zero, ContextPolynomial::shape, ContextPolynomial::to_string

与 immut 相同。

pub fn[A] ContextPolynomial::context(Self[A]) -> @Luna-Flow/luna-poly/core.VariableContext
pub fn[A] ContextPolynomial::to_terms(Self[A]) -> Array[(@Luna-Flow/luna-poly/core.ExponentVector, A)]
pub fn[A] ContextPolynomial::term_count(Self[A]) -> Int
pub fn[A] ContextPolynomial::arity(Self[A]) -> Int
pub fn[A] ContextPolynomial::is_zero(Self[A]) -> Bool
pub fn[A] ContextPolynomial::shape(Self[A]) -> @Luna-Flow/luna-poly/core.PolynomialShape
pub fn[A : Show + @luna-generic.Zero] ContextPolynomial::to_string(Self[A]) -> String

ContextPolynomial::to_term_polynomial, ContextPolynomial::to_sparse_polynomial

返回包含当前各项的新的可变项多项式或稀疏多项式。

pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::to_term_polynomial(Self[A]) -> @term.TermPolynomial[A]
pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::to_sparse_polynomial(Self[A]) -> @sparse.SparsePolynomial[A]

求值与代换

ContextPolynomial::eval, ContextPolynomial::eval_checked, ContextPolynomial::eval_named, ContextPolynomial::eval_named_checked

与 immut 相同。

pub fn[A : @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::eval(Self[A], Array[A]) -> A
pub fn[A : @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::eval_checked(Self[A], Array[A]) -> A?
pub fn[A : @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::eval_named(Self[A], Array[(@Luna-Flow/luna-poly/core.Variable, A)]) -> A
pub fn[A : @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::eval_named_checked(Self[A], Array[(@Luna-Flow/luna-poly/core.Variable, A)]) -> A?

ContextPolynomial::eval_partial, ContextPolynomial::eval_partial_checked, ContextPolynomial::eval_partial_named, ContextPolynomial::eval_partial_named_checked

部分求值，返回同一上下文上的新可变多项式，与 immut 相同。

pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::eval_partial(Self[A], Array[(@Luna-Flow/luna-poly/core.Variable, A)]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::eval_partial_checked(Self[A], Array[(@Luna-Flow/luna-poly/core.Variable, A)]) -> Self[A]?
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::eval_partial_named(Self[A], Array[(@Luna-Flow/type_theory/core.Name, A)]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::eval_partial_named_checked(Self[A], Array[(@Luna-Flow/type_theory/core.Name, A)]) -> Self[A]?

ContextPolynomial::substitute, ContextPolynomial::substitute_checked, ContextPolynomial::substitute_names, ContextPolynomial::substitute_names_checked

用标量或同一上下文上的可变多项式进行同时代换，返回新的可变多项式，与 immut 相同。

pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::substitute(Self[A], Array[(@Luna-Flow/luna-poly/core.Variable, ContextSubstitutionValue[A])]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::substitute_checked(Self[A], Array[(@Luna-Flow/luna-poly/core.Variable, ContextSubstitutionValue[A])]) -> Self[A]?
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::substitute_names(Self[A], Array[(@Luna-Flow/type_theory/core.Name, ContextSubstitutionValue[A])]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::substitute_names_checked(Self[A], Array[(@Luna-Flow/type_theory/core.Name, ContextSubstitutionValue[A])]) -> Self[A]?

算术与修改

ContextPolynomial::add_inplace, ContextPolynomial::mul_inplace

把持有的值替换为 self + other 或 self * other。上下文不同时中止（abort）；可变类型上没有带检查的变体（请使用 ops().add_checked，或通过 to_immut 使用不可变的 add_checked）。

pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::add_inplace(Self[A], Self[A]) -> Unit
pub fn[A : Eq + @luna-generic.AddMonoid + Mul] ContextPolynomial::mul_inplace(Self[A], Self[A]) -> Unit

ContextPolynomial::clear

把持有的值替换为同一上下文上的零多项式（也是 Clearable::clear）。

pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::clear(Self[A]) -> Unit

ContextPolynomial::add, ContextPolynomial::sub, ContextPolynomial::mul, ContextPolynomial::neg, ContextPolynomial::pow

返回新单元的运算符与幂，与 immut 相同；上下文不同时二元运算符会中止（abort）。

pub fn[A : Eq + @luna-generic.AddMonoid] ContextPolynomial::add(Self[A], Self[A]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + Neg] ContextPolynomial::sub(Self[A], Self[A]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + Mul] ContextPolynomial::mul(Self[A], Self[A]) -> Self[A]
pub fn[A : Eq + @luna-generic.Zero + Neg] ContextPolynomial::neg(Self[A]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::pow(Self[A], UInt) -> Self[A]

ContextPolynomial::ops

ContextOps 记录；其 add_checked 和 mul_checked 在上下文不同时返回 None。

pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] ContextPolynomial::ops() -> @Luna-Flow/luna-poly/core.ContextOps[Self[A], A]

test "mutable context" {
  let ctx = @mutable.VariableContext::from_names(["x", "y"])
  let x = ctx.require_variable("x")
  let y = ctx.require_variable("y")
  let p = @mutable.ContextPolynomial::from_named_terms_as_sparse(ctx, [([(x, 1U)], 2)])
  let before = p.copy()
  p.add_inplace(@mutable.ContextPolynomial::from_named_terms_as_terms(ctx, [([(y, 1U)], 1)]))
  inspect(p, content="2 * x + 1 * y")
  inspect(before, content="2 * x")
  let y_poly = @mutable.ContextPolynomial::variable(ctx, y)
  inspect(p.substitute([(x, Polynomial(y_poly))]), content="3 * y")
  inspect(p.eval_named([(x, 1), (y, 1)]), content="3")
  p.clear()
  assert_true(p.is_zero())
  inspect(p.context(), content="VariableContext(x, y)")
}

已弃用

为源码兼容而保留的隐藏方法形式：

已弃用	替代方案
p.output(logger)	to_string 或字符串插值
p.to_repr()	Repr(p) 或 debug_inspect