June 2018 Update

Task/Formal-power-series/Julia/formal-power-series-1.julia

@@ -0,0 +1,166 @@
+module FormalPowerSeries
+
+_div(a, b) = a / b
+_div(a::Union{Integer,Rational}, b::Union{Integer,Rational}) = a // b
+
+abstract type AbstractFPS{T<:Number} end
+
+Base.iteratorsize(::AbstractFPS) = Base.IsInfinite()
+Base.done(::AbstractFPS, ::Any) = false
+Base.iteratoreltype(::AbstractFPS) = Base.HasEltype()
+Base.eltype(::AbstractFPS{T}) where T = T
+Base.one(::AbstractFPS{T}) where T = ConstantFPS(one(T))
+
+function Base.show(io::IO, fps::AbstractFPS{T}) where T
+    itr = Iterators.take(fps, 8)
+    s = start(itr)
+    a, s = next(itr, s)
+    print(io, a)
+    a, s = next(itr, s)
+    @printf(io, " %s %s⋅x",
+        ifelse(sign(a) ≥ 0, '+', '-'), abs(a))
+    local i = 2
+    while !done(itr, s)
+        a, s = next(itr, s)
+        @printf(io, " %s %s⋅x^%i",
+            ifelse(sign(a) ≥ 0, '+', '-'), abs(a), i)
+        i += 1
+    end
+    print(io, "...")
+end
+
+struct MinusFPS{T,A<:AbstractFPS{T}} <: AbstractFPS{T}
+    a::A
+end
+Base.:-(a::AbstractFPS{T}) where T = MinusFPS{T,typeof(a)}(a)
+
+Base.start(fps::MinusFPS) = start(fps.a)
+function Base.next(fps::MinusFPS, st)
+    v, s = next(fps.a, st)
+    return -v, s
+end
+
+struct SumFPS{T,A<:AbstractFPS,B<:AbstractFPS} <: AbstractFPS{T}
+    a::A
+    b::B
+end
+Base.:+(a::AbstractFPS{A}, b::AbstractFPS{B}) where {A,B} =
+    SumFPS{promote_type(A, B),typeof(a),typeof(b)}(a, b)
+Base.:-(a::AbstractFPS, b::AbstractFPS) = a + (-b)
+
+Base.start(fps::SumFPS) = (start(fps.a), start(fps.b))
+function Base.next(fps::SumFPS{T,A,B}, st) where {T,A,B}
+    stateA, stateB = st
+    valueA, stateA = next(fps.a, stateA)
+    valueB, stateB = next(fps.b, stateB)
+    return T(valueA + valueB), (stateA, stateB)
+end
+
+struct ProductFPS{T,A<:AbstractFPS,B<:AbstractFPS} <: AbstractFPS{T}
+    a::A
+    b::B
+end
+Base.:*(a::AbstractFPS{A}, b::AbstractFPS{B}) where {A,B} =
+    ProductFPS{promote_type(A, B),typeof(a),typeof(b)}(a, b)
+
+Base.start(fps::ProductFPS{T}) where T = (start(fps.a), start(fps.b), T[], T[])
+function Base.next(fps::ProductFPS{T,A,B}, st) where {T,A,B}
+    stateA, stateB, listA, listB = st
+    valueA, stateA = next(fps.a, stateA)
+    valueB, stateB = next(fps.b, stateB)
+    push!(listA, valueA)
+    unshift!(listB, valueB)
+    return T(sum(listA .* listB)), (stateA, stateB, listA, listB)
+end
+
+struct DifferentiatedFPS{T,A<:AbstractFPS} <: AbstractFPS{T}
+    a::A
+end
+differentiate(fps::AbstractFPS{T}) where T = DifferentiatedFPS{T,typeof(fps)}(fps)
+
+function Base.start(fps::DifferentiatedFPS{T,A}) where {T,A}
+    s = start(fps.a)
+    _, s = next(fps.a, s)
+    n = zero(T)
+    return n, s
+end
+function Base.next(fps::DifferentiatedFPS{T,A}, st) where {T,A}
+    n, s = st
+    n += one(n)
+    v, s = next(fps.a, s)
+    return n * v, (n, s)
+end
+
+struct IntegratedFPS{T,A<:AbstractFPS} <: AbstractFPS{T}
+    a::A
+    k::T
+end
+integrate(fps::AbstractFPS{T}, k::T=zero(T)) where T = IntegratedFPS{T,typeof(fps)}(fps, k)
+integrate(fps::AbstractFPS{T}, k::T=zero(T)) where T <: Integer =
+    IntegratedFPS{Rational{T},typeof(fps)}(fps, k)
+
+Base.start(fps::IntegratedFPS{T,A}) where {T,A} = zero(T), start(fps.a)
+function Base.next(fps::IntegratedFPS{T,A}, st) where {T,A}
+    n, s = st
+    iszero(n) && return fps.k, (one(n), s)
+    v, s = next(fps.a, s)
+    r::T = _div(v, n)
+    n += one(n)
+    return r, (n, s)
+end
+
+# Examples of FPS: constant
+
+struct FiniteFPS{T} <: AbstractFPS{T}
+    v::NTuple{N,T} where N
+end
+Base.start(fps::FiniteFPS) = 1
+Base.next(fps::FiniteFPS{T}, st) where T =
+    st > endof(fps.v) ? (zero(T), st) : (fps.v[st], st + 1)
+Base.convert(::Type{FiniteFPS}, x::Real) = FiniteFPS{typeof(x)}((x,))
+for op in (:+, :-, :*)
+    @eval Base.$op(x::Number, a::AbstractFPS) = $op(FiniteFPS(x), a)
+    @eval Base.$op(a::AbstractFPS, x::Number) = $op(a, FiniteFPS(x))
+end
+
+struct ConstantFPS{T} <: AbstractFPS{T}
+    k::T
+end
+Base.start(::ConstantFPS) = nothing
+Base.next(c::ConstantFPS, ::Any) = c.k, nothing
+
+struct SineFPS{T} <: AbstractFPS{T} end
+SineFPS() = SineFPS{Rational{Int}}()
+Base.start(::SineFPS) = 0, 1, 1
+function Base.next(::SineFPS{T}, st) where T
+    n, fac, s = st
+    local r::T
+    if iseven(n)
+        r = zero(T)
+    else
+        r = _div(one(T), (s * fac))
+        s = -s
+    end
+    n += 1
+    fac *= n
+    return r, (n, fac, s)
+end
+
+struct CosineFPS{T} <: AbstractFPS{T} end
+CosineFPS() = CosineFPS{Rational{Int}}()
+Base.start(::CosineFPS) = 0, 1, 1
+function Base.next(::CosineFPS{T}, st) where T
+    n, fac, s = st
+    local r::T
+    if iseven(n)
+        r = _div(one(T), (s * fac))
+    else
+        r = zero(T)
+        s = -s
+    end
+    n += 1
+    fac *= n
+    return r, (n, fac, s)
+end
+
+end  # module FormalPowerSeries

Task/Formal-power-series/Julia/formal-power-series-2.julia

@@ -0,0 +1,15 @@
+@show cosine = FormalPowerSeries.CosineFPS()
+@show sine = FormalPowerSeries.SineFPS()
+
+intcosine = FormalPowerSeries.integrate(cosine)
+uminintsine = 1 - FormalPowerSeries.integrate(sine)
+
+# Check coefficients up to the 20th term
+coefsine = collect(Iterators.take(sine, 20))
+coefintcosine = collect(Iterators.take(intcosine, 20))
+
+coefcosine = collect(Iterators.take(cosine, 20))
+coefuminintsine = collect(Iterators.take(uminintsine, 20))
+
+@assert coefsine == coefintcosine "The integral of cos should be sin"
+@assert coefcosine == coefuminintsine "1 minus the integral of sin should be cos"

Task/Formal-power-series/Kotlin/formal-power-series.kotlin

@@ -0,0 +1,208 @@
+// version 1.2.10
+
+fun gcd(a: Long, b: Long): Long = if (b == 0L) a else gcd(b, a % b)
+
+class Frac : Comparable<Frac> {
+    val num: Long
+    val denom: Long
+
+    companion object {
+        val ZERO = Frac(0, 1)
+        val ONE  = Frac(1, 1)
+    }
+
+    constructor(n: Long, d: Long) {
+        require(d != 0L)
+        var nn = n
+        var dd = d
+        if (nn == 0L) {
+            dd = 1
+        }
+        else if (dd < 0) {
+            nn = -nn
+            dd = -dd
+        }
+        val g = Math.abs(gcd(nn, dd))
+        if (g > 1) {
+            nn /= g
+            dd /= g
+        }
+        num = nn
+        denom = dd
+    }
+
+    constructor(n: Int, d: Int) : this(n.toLong(), d.toLong())
+
+    operator fun plus(other: Frac) =
+        Frac(num * other.denom + denom * other.num, other.denom * denom)
+
+    operator fun unaryPlus() = this
+
+    operator fun unaryMinus() = Frac(-num, denom)
+
+    operator fun minus(other: Frac) = this + (-other)
+
+    operator fun times(other: Frac) =
+        Frac(this.num * other.num, this.denom * other.denom)
+
+    operator fun rem(other: Frac) = this - Frac((this / other).toLong(), 1) * other
+
+    operator fun inc() = this + ONE
+    operator fun dec() = this - ONE
+
+    fun inverse(): Frac {
+        require(num != 0L)
+        return Frac(denom, num)
+    }
+
+    operator fun div(other: Frac) = this * other.inverse()
+
+    fun abs() = if (num >= 0) this else -this
+
+    override fun compareTo(other: Frac): Int {
+        val diff = this.toDouble() - other.toDouble()
+        return when {
+            diff < 0.0  -> -1
+            diff > 0.0  -> +1
+            else        ->  0
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+       if (other == null || other !is Frac) return false
+       return this.compareTo(other) == 0
+    }
+
+    override fun hashCode() = num.hashCode() xor denom.hashCode()
+
+    override fun toString() = if (denom == 1L) "$num" else "$num/$denom"
+
+    fun toDouble() = num.toDouble() / denom
+
+    fun toLong() = num / denom
+}
+
+interface Gene {
+    fun coef(n: Int): Frac
+}
+
+class Term(private val gene: Gene) {
+    private val cache = mutableListOf<Frac>()
+
+    operator fun get(n: Int): Frac {
+        if (n < 0) return Frac.ZERO
+        if (n >= cache.size) {
+            for (i in cache.size..n) cache.add(gene.coef(i))
+        }
+        return cache[n]
+    }
+}
+
+class FormalPS {
+    private lateinit var term: Term
+
+    private companion object {
+        const val DISP_TERM = 12
+        const val X_VAR = "x"
+    }
+
+    constructor() {}
+
+    constructor(term: Term) {
+        this.term = term
+    }
+
+    constructor(polynomial: List<Frac>) :
+        this(Term(object : Gene {
+            override fun coef(n: Int) =
+                if (n < 0 || n >= polynomial.size)
+                    Frac.ZERO
+                else
+                    polynomial[n]
+        }))
+
+    fun copyFrom(other: FormalPS) {
+        term = other.term
+    }
+
+    fun inverseCoef(n: Int): Frac {
+        val res = Array(n + 1) { Frac.ZERO }
+        res[0] = term[0].inverse()
+        for (i in 1..n) {
+            for (j in 0 until i) res[i] += term[i - j] * res[j]
+            res[i] *= -res[0]
+        }
+        return res[n]
+    }
+
+    operator fun plus(other: FormalPS) =
+        FormalPS(Term(object : Gene {
+            override fun coef(n: Int) = term[n] + other.term[n]
+        }))
+
+    operator fun minus(other: FormalPS) =
+        FormalPS(Term(object : Gene {
+            override fun coef(n: Int) = term[n] - other.term[n]
+        }))
+
+    operator fun times(other: FormalPS) =
+        FormalPS(Term(object : Gene {
+            override fun coef(n: Int): Frac {
+                var res = Frac.ZERO
+                for (i in 0..n) res += term[i] * other.term[n - i]
+                return res
+            }
+        }))
+
+    operator fun div(other: FormalPS) =
+        FormalPS(Term(object : Gene {
+            override fun coef(n: Int): Frac {
+                var res = Frac.ZERO
+                for (i in 0..n) res += term[i] * other.inverseCoef(n - i)
+                return res
+            }
+        }))
+
+    fun diff() =
+        FormalPS(Term(object : Gene {
+            override fun coef(n: Int) = term[n + 1] * Frac(n + 1, 1)
+        }))
+
+    fun intg() =
+        FormalPS(Term(object : Gene {
+            override fun coef(n: Int) =
+                if (n == 0) Frac.ZERO else term[n - 1] * Frac(1, n)
+        }))
+
+    override fun toString() = toString(DISP_TERM)
+
+    private fun toString(dpTerm: Int): String {
+        val sb = StringBuilder()
+        var c = term[0]
+        if (c != Frac.ZERO) sb.append(c.toString())
+        for (i in 1 until dpTerm) {
+            c = term[i]
+            if (c != Frac.ZERO) {
+                if (c > Frac.ZERO && sb.length > 0) sb.append(" + ")
+                sb.append (when {
+                    c == Frac.ONE  -> X_VAR
+                    c == -Frac.ONE -> " - $X_VAR"
+                    c.num < 0      -> " - ${-c}$X_VAR"
+                    else           -> "$c$X_VAR"
+                })
+                if (i > 1) sb.append("^$i")
+            }
+        }
+        if (sb.length == 0) sb.append("0")
+        sb.append(" + ...")
+        return sb.toString()
+    }
+}
+
+fun main(args: Array<String>) {
+    var cos = FormalPS()
+    val sin = cos.intg()
+    cos.copyFrom(FormalPS(listOf(Frac.ONE)) - sin.intg())
+    println("SIN(x) = $sin")
+    println("COS(x) = $cos")
+}

Task/Formal-power-series/Mathematica/formal-power-series.math

@@ -0,0 +1,3 @@
+cos = Series[Cos[x], {x, 0, 10}];
+sin = Series[Sin[x], {x, 0, 8}];
+sin - Integrate[cos, x]