Luna Flow
简体中文

mutable/term API

Luna-Flow/luna-poly/mutable/term 提供可变的 TermPolynomial[A]：即 immut/term 的规范降序项数组，保存在一个可变字段中，由 _inplace 方法和 clear 替换。运算符和其他所有方法都返回新值。

该类型由 mutable 门面包重新导出为 @mutable.TermPolynomial，示例中使用的就是它。“同 immut”指的是 immut/term API 中的语义、约束和代价。变更模型在 mutable/term 设计中说明。

类型

TermPolynomial

可变多元多项式，其项数组始终按单项式序降序排列、已合并且不含零系数。

type TermPolynomial[A] derive(Eq, @debug.Debug)
pub impl[A] @luna-generic.Zero for TermPolynomial[A]
pub impl[A : Eq + @luna-generic.Zero + @luna-generic.One] @luna-generic.One for TermPolynomial[A]
pub impl[A : Eq + @luna-generic.AddMonoid] Add for TermPolynomial[A]
pub impl[A : Eq + @luna-generic.AddMonoid + Neg] Sub for TermPolynomial[A]
pub impl[A : Eq + @luna-generic.AddMonoid + Mul] Mul for TermPolynomial[A]
pub impl[A : Eq + @luna-generic.Zero + Neg] Neg for TermPolynomial[A]
pub impl[A : Show + @luna-generic.Zero] Show for TermPolynomial[A]
pub impl[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] @arithmetic.PowNatChecked for TermPolynomial[A]
pub impl[A] @core.Clearable for TermPolynomial[A]
pub impl[A] @core.Copyable for TermPolynomial[A]
pub impl[A] @core.HasArity for TermPolynomial[A]
pub impl[A] @core.HasShape for TermPolynomial[A]
pub impl[A] @core.HasTermCount for TermPolynomial[A]
pub impl[A] @core.HasTotalDegree for TermPolynomial[A]
pub impl[A] @core.IsZero for TermPolynomial[A]
pub impl[A] @core.MultivariatePolynomial for TermPolynomial[A]
pub impl[A] @core.MutablePolynomial for TermPolynomial[A]

构造与转换

TermPolynomial::from_terms, TermPolynomial::from_array, TermPolynomial::zero, TermPolynomial::one

构建多项式，同 immut。输入数组会被复制。

pub fn[A : Eq + @luna-generic.AddMonoid] TermPolynomial::from_terms(Array[(@core.ExponentVector, A)]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid] TermPolynomial::from_array(Array[(Array[UInt], A)]) -> Self[A]
pub fn[A] TermPolynomial::zero() -> Self[A]
pub fn[A : Eq + @luna-generic.Zero + @luna-generic.One] TermPolynomial::one() -> Self[A]

TermPolynomial::from_immut, TermPolynomial::to_immut

与不可变类型相互转换。两者都会复制，因此之后的变更绝不会影响另一个值。to_immut 会重新规范化各项，O(mlog⁡m)O(m \log m)。

pub fn[A] TermPolynomial::from_immut(@Luna-Flow/luna-poly/immut/term.TermPolynomial[A]) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid] TermPolynomial::to_immut(Self[A]) -> @Luna-Flow/luna-poly/immut/term.TermPolynomial[A]

TermPolynomial::copy

返回一个独立副本（也可用 Copyable::copy）。

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

查询

TermPolynomial::to_terms, TermPolynomial::coefficients, TermPolynomial::size, TermPolynomial::term_count, TermPolynomial::is_zero, TermPolynomial::arity, TermPolynomial::total_degree, TermPolynomial::shape

同 immut。to_terms 和 coefficients 返回新数组，首项在前。

pub fn[A] TermPolynomial::to_terms(Self[A]) -> Array[(@core.ExponentVector, A)]
pub fn[A] TermPolynomial::coefficients(Self[A]) -> Array[A]
pub fn[A] TermPolynomial::size(Self[A]) -> Int
pub fn[A] TermPolynomial::term_count(Self[A]) -> Int
pub fn[A] TermPolynomial::is_zero(Self[A]) -> Bool
pub fn[A] TermPolynomial::arity(Self[A]) -> Int
pub fn[A] TermPolynomial::total_degree(Self[A]) -> UInt?
pub fn[A] TermPolynomial::shape(Self[A]) -> @core.PolynomialShape

修改

TermPolynomial::add_term_inplace

将 c xαc\,x^\alpha 加到接收者上：与指数向量相同的已有项合并，若和为零则将其移除。整个数组会重新规范化，O(mlog⁡m)O(m \log m)。

pub fn[A : Eq + @luna-generic.AddMonoid] TermPolynomial::add_term_inplace(Self[A], @core.ExponentVector, A) -> Unit

TermPolynomial::add_inplace

用 add_term_inplace 将 other 的项逐个加入，从而把接收者替换为 self + other。若 other 有 nn 项，代价为 O(n (m+n)log⁡(m+n))O(n\,(m + n)\log(m + n))；对于大的操作数，宜使用 p = p + q，或对拼接后的项使用 from_terms。

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

TermPolynomial::mul_inplace

将接收者替换为 self * other；乘积先被计算出来，因此 p.mul_inplace(p) 会将 p 平方。

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

TermPolynomial::scale_inplace

将接收者替换为 c xγ⋅pc\,x^\gamma \cdot p，无需重新排序即保持顺序。

pub fn[A : Eq + @luna-generic.Zero + Mul] TermPolynomial::scale_inplace(Self[A], @core.ExponentVector, A) -> Unit

TermPolynomial::clear

将接收者置为零（也可用 Clearable::clear）。

pub fn[A] TermPolynomial::clear(Self[A]) -> Unit
test "mutation" {
  let p = @mutable.TermPolynomial::from_array([([1U], 2)])
  p.add_term_inplace(@mutable.ExponentVector::from_array([0U, 1]), 3)
  inspect(p, content="3 * x_1 + 2 * x")
  p.add_term_inplace(@mutable.ExponentVector::from_array([1U, 0]), -2)
  inspect(p, content="3 * x_1")
  p.mul_inplace(p)
  p.scale_inplace(@mutable.ExponentVector::from_array([1U]), 2)
  inspect(p, content="18 * xx_1^2")
  p.clear()
  assert_true(p.is_zero())
}

非修改操作

TermPolynomial::add, TermPolynomial::sub, TermPolynomial::mul, TermPolynomial::neg

运算符 +、-、* 和一元 -，同 immut。+ 复制接收者并调用 add_inplace，因此其代价与该方法相同；* 委托给不可变乘积。

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

TermPolynomial::scale, TermPolynomial::pow, TermPolynomial::eval, TermPolynomial::eval_checked

与 immut 相同。

pub fn[A : Eq + @luna-generic.Zero + Mul] TermPolynomial::scale(Self[A], @core.ExponentVector, A) -> Self[A]
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] TermPolynomial::pow(Self[A], UInt) -> Self[A]
pub fn[A : @luna-generic.AddMonoid + Mul + @luna-generic.One] TermPolynomial::eval(Self[A], Array[A]) -> A
pub fn[A : @luna-generic.AddMonoid + Mul + @luna-generic.One] TermPolynomial::eval_checked(Self[A], Array[A]) -> A?

TermPolynomial::equal, TermPolynomial::to_string, TermPolynomial::ops

结构相等、打印以及 MultivariateOps 记录，同 immut。

pub fn[A : Eq] TermPolynomial::equal(Self[A], Self[A]) -> Bool
pub fn[A : Show + @luna-generic.Zero] TermPolynomial::to_string(Self[A]) -> String
pub fn[A : Eq + @luna-generic.AddMonoid + Mul + @luna-generic.One] TermPolynomial::ops() -> @core.MultivariateOps[Self[A], A]
test "non-mutating" {
  let p = @mutable.TermPolynomial::from_array([([1U], 1), ([], 1)])
  let q = p.pow(2)
  inspect(q, content="1 * x^2 + 2 * x + 1")
  inspect(p, content="1 * x + 1")
  inspect(q.eval([3]), content="16")
  assert_true(q.to_immut() == @immut.TermPolynomial::from_array([([2U], 1), ([1U], 2), ([], 1)]))
}

已弃用

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

已弃用替代方案
p.not_equal(q)p != q
p.output(logger)to_string 或字符串插值
p.to_repr()Repr(p) 或 debug_inspect
p.pow_nat_checked(e, ctx)@arithmetic.PowNatChecked::pow_nat_checked(p, e, ctx) 或 p.pow(e)