24845418400

Committed 23 Apr 2026 04:01PM UTC coverage: 92.083% (-0.5%) from 92.609%

Build # 24845418400

Build Type

push

github

Committed by

web-flow

Commit Message

Bump patch version

Coverage Stats

4629 of 5027 relevant lines covered (92.08%)

6400995.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.18

/src/constructors.jl

# This file is part of the Taylor1Series.jl Julia package, MIT license
#
# Luis Benet & David P. Sanders
# UNAM
#
# MIT Expat license
#

"""
    AbstractSeries{T<:Number} <: Number

Parameterized abstract type for [`Taylor1`](@ref),
[`HomogeneousPolynomial`](@ref) and [`TaylorN`](@ref).
"""
abstract type AbstractSeries{T<:Number} <: Number end


## Constructors ##

######################### Taylor1
"""
    Taylor1{T<:Number} <: AbstractSeries{T}

DataType for polynomial expansions in one independent variable.

**Fields:**

- `coeffs :: FixedSizeVectorDefault{T}` Expansion coefficients; the ``i``-th
    component is the coefficient of degree ``i-1`` of the expansion.

Note that `Taylor1` variables are callable. For more information, see
[`evaluate`](@ref).
"""
struct Taylor1{T<:Number} <: AbstractSeries{T}
        coeffs :: FixedSizeVectorDefault{T}
    ## Inner constructors ##
    function Taylor1{T}(coeffs::FixedSizeVectorDefault{T}) where {T<:Number}
        return new{T}(coeffs)
    end
    function Taylor1{T}(coeffs::AbstractVector{T}, order::Int) where {T<:Number}
        v = FixedSizeVectorDefault{T}(undef, order+1)
        minrange = min(eachindex(v), eachindex(coeffs))
        for ord in minrange
            v[ord] = coeffs[ord]
        end
        for ord in last(minrange)+1:order+1
            v[ord] = zero(coeffs[1])
        end
        return new{T}(v)
    end
end

## Outer constructors ##
Taylor1(x::Taylor1{T}) where {T<:Number} = x
Taylor1(coeffs::AbstractArray{T,1}, order::Int) where {T<:Number} =
    Taylor1{T}(coeffs, order)
Taylor1(coeffs::AbstractArray{T,1}) where {T<:Number} =
    Taylor1{T}(FixedSizeVectorDefault(coeffs))
Taylor1(coeffs::FixedSizeVectorDefault{T}) where {T<:Number} = Taylor1{T}(coeffs)
Taylor1(coeffs::FixedSizeVectorDefault{T}, order::Int) where {T<:Number} =
    Taylor1{T}(coeffs, order)
function Taylor1(x::T, order::Int) where {T<:Number}
    v = FixedSizeVectorDefault{T}(undef, order+1)
    v .= zero.(x)
    v[1] = deepcopy(x)
    return Taylor1{T}(v)
end


# Shortcut to define Taylor1 independent variables
"""
    Taylor1([T::Type=Float64], order::Int)

Shortcut to define the independent variable of a `Taylor1{T}` polynomial of
given `order`. The default type for `T` is `Float64`.

```julia
julia> Taylor1(16)
 1.0 t + 𝒪(t¹⁷)

julia> Taylor1(Rational{Int}, 4)
 1//1 t + 𝒪(t⁵)
```
"""
function Taylor1(::Type{T}, order::Int) where {T<:Number}
    order == 0 && return Taylor1{T}(FixedSizeVectorDefault{T}([zero(T)]))
    coeffs = FixedSizeVectorDefault{T}(undef, order+1)
    coeffs .= zero(T)
    coeffs[2] = one(T)
    return Taylor1{T}(coeffs)
end
function Taylor1(order::Int)
    order == 0 && return Taylor1{Float64}(FixedSizeVectorDefault{Float64}([0.0]))
    coeffs = FixedSizeVectorDefault{Float64}(undef, order+1)
    coeffs .= 0.0
    coeffs[2] = 1.0
    return Taylor1{Float64}(coeffs)
end


######################### HomogeneousPolynomial
"""
    HomogeneousPolynomial{T<:Number} <: AbstractSeries{T}

DataType for homogeneous polynomials in many (>1) independent variables.

**Fields:**

- `coeffs  :: Array{T,1}` Expansion coefficients of the homogeneous
polynomial; the ``i``-th component is related to a monomial, where the degrees
of the independent variables are specified by `coeff_table[order+1][i]`.
- `order   :: Int` order (degree) of the homogeneous polynomial.

Note that `HomogeneousPolynomial` variables are callable. For more information,
see [`evaluate`](@ref).
"""
struct HomogeneousPolynomial{T<:Number} <: AbstractSeries{T}
        coeffs  :: FixedSizeVectorDefault{T}
        order   :: Int
    ## Inner constructors ##
    HomogeneousPolynomial{T}(x::T, order::Int) where {T<:Number} =
        new{T}(_coeffsHP(x, order), order)
    HomogeneousPolynomial{T}(coeffs::AbstractArray{T,1}, order::Int) where {T<:Number} =
        new{T}(_coeffsHP(coeffs, order), order)
end

HomogeneousPolynomial(x::HomogeneousPolynomial{T}) where {T<:Number} = x
HomogeneousPolynomial(coeffs::AbstractArray{T,1}, order::Int) where {T<:Number} =
    HomogeneousPolynomial{T}(coeffs, order)
HomogeneousPolynomial(coeffs::AbstractArray{T,1}) where {T<:Number} =
    HomogeneousPolynomial{T}(coeffs, orderH(coeffs))
HomogeneousPolynomial(x::T, order::Int) where {T<:Number} =
    HomogeneousPolynomial{T}(x, order)

# Shortcut to define HomogeneousPolynomial independent variable
"""
    HomogeneousPolynomial([T::Type=Float64], nv::Int])

Shortcut to define the `nv`-th independent `HomogeneousPolynomial{T}`.
The default type for `T` is `Float64`.

```julia
julia> HomogeneousPolynomial(1)
 1.0 x₁

julia> HomogeneousPolynomial(Rational{Int}, 2)
 1//1 x₂
```
"""
function HomogeneousPolynomial(::Type{T}, nv::Int) where {T<:Number}
    @assert 0 < nv ≤ get_numvars()
    v = FixedSizeVectorDefault{T}(undef, get_numvars())
    v .= zero(T)
    v[nv] = one(T)
    return HomogeneousPolynomial(v, 1)
end
function HomogeneousPolynomial(nv::Int)
    res = HomogeneousPolynomial(0.0, 1)
    res[nv] = 1.0
    return res
end



######################### TaylorN
"""
    TaylorN{T<:Number} <: AbstractSeries{T}

DataType for polynomial expansions in many (>1) independent variables.

**Fields:**

- `coeffs  :: Array{HomogeneousPolynomial{T},1}` Vector containing the
`HomogeneousPolynomial` entries. The ``i``-th component corresponds to the
homogeneous polynomial of degree ``i-1``.
- `order   :: Int`  maximum order of the polynomial expansion.

Note that `TaylorN` variables are callable. For more information, see
[`evaluate`](@ref).
"""
struct TaylorN{T<:Number} <: AbstractSeries{T}
        coeffs  :: FixedSizeVectorDefault{HomogeneousPolynomial{T}}
    ## Inner constructor ##
    function TaylorN{T}(v::AbstractArray{HomogeneousPolynomial{T},1},
            order::Int) where {T<:Number}
        isempty(v) &&
            return new{T}(zeros(HomogeneousPolynomial(zero(T),0), order))
        coeffs = _coeffsTN(v, order)
        return new{T}(coeffs)
    end
end

TaylorN(x::TaylorN{T}) where {T<:Number} = x
function TaylorN(x::AbstractArray{HomogeneousPolynomial{T},1},
        order::Int) where {T<:Number}
    if order == 0
        order = maxorderH(x)
    end
    return TaylorN{T}(x, order)
end
TaylorN(x::AbstractArray{HomogeneousPolynomial{T},1}) where {T<:Number} =
    TaylorN{T}(x, maxorderH(x))
TaylorN(x::HomogeneousPolynomial{T}, order::Int) where {T<:Number} =
    TaylorN{T}([x], order )
TaylorN(x::HomogeneousPolynomial{T}) where {T<:Number} =
    TaylorN{T}([x], get_order(x))
TaylorN(x::T, order::Int) where {T<:Number} =
    TaylorN(HomogeneousPolynomial(x, 0), order)

# Shortcut to define TaylorN independent variables
"""
    TaylorN([T::Type=Float64], nv::Int; [order::Int=get_order()])

Shortcut to define the `nv`-th independent `TaylorN{T}` variable as a
polynomial. The order is defined through the keyword parameter `order`,
whose default corresponds to `get_order()`. The default of type for
`T` is `Float64`.

```julia
julia> TaylorN(1)
 1.0 x₁ + 𝒪(‖x‖⁷)

julia> TaylorN(Rational{Int},2)
 1//1 x₂ + 𝒪(‖x‖⁷)
```
"""
TaylorN(::Type{T}, nv::Int; order::Int=get_order()) where {T<:Number} =
    TaylorN( HomogeneousPolynomial(T, nv), order )
TaylorN(nv::Int; order::Int=get_order()) = TaylorN(Float64, nv, order=order)



# A `Number` which is not an `AbstractSeries`
const NumberNotSeries = Union{Real,Complex}

# A `Number` which is not `TaylorN` nor a `HomogeneousPolynomial`
const NumberNotSeriesN = Union{Real,Complex,Taylor1}

## Additional Taylor1 and TaylorN outer constructor ##
Taylor1{T}(x::S) where {T<:Number,S<:NumberNotSeries} = Taylor1([convert(T,x)], 0)
TaylorN{T}(x::S) where {T<:Number,S<:NumberNotSeries} = TaylorN(convert(T, x), TaylorSeries.get_order())


# """
#     get_numvars
#
# Return the number of variables of a `Taylor1`, `HomogeneousPolynomial`
# or `TaylorN` object.
# """
get_numvars(t::Number) = 0
get_numvars(t::Taylor1) = 1
get_numvars(t::Taylor1{Taylor1{T}}) where {T<:Number} = get_numvars(t[0])+1
get_numvars(::T) where {T<:Union{HomogeneousPolynomial, TaylorN}} = _params_TaylorN_.num_vars

1	# This file is part of the Taylor1Series.jl Julia package, MIT license
2	#
3	# Luis Benet & David P. Sanders
4	# UNAM
5	#
6	# MIT Expat license
7	#
8
9	"""
10	AbstractSeries{T<:Number} <: Number
11
12	Parameterized abstract type for [`Taylor1`](@ref),
13	[`HomogeneousPolynomial`](@ref) and [`TaylorN`](@ref).
14	"""
15	abstract type AbstractSeries{T<:Number} <: Number end
16
17
18	## Constructors ##
19
20	######################### Taylor1
21	"""
22	Taylor1{T<:Number} <: AbstractSeries{T}
23
24	DataType for polynomial expansions in one independent variable.
25
26	Fields:
27
28	- `coeffs :: FixedSizeVectorDefault{T}` Expansion coefficients; the ``i``-th
29	component is the coefficient of degree ``i-1`` of the expansion.
30
31	Note that `Taylor1` variables are callable. For more information, see
32	[`evaluate`](@ref).
33	"""
34	struct Taylor1{T<:Number} <: AbstractSeries{T}
35	coeffs :: FixedSizeVectorDefault{T}
36	## Inner constructors ##
37	function Taylor1{T}(coeffs::FixedSizeVectorDefault{T}) where {T<:Number}	1,100,076✔
38	return new{T}(coeffs)	3,689,640✔
39	end
40	function Taylor1{T}(coeffs::AbstractVector{T}, order::Int) where {T<:Number}	712,234✔
41	v = FixedSizeVectorDefault{T}(undef, order+1)	1,429,230✔
42	minrange = min(eachindex(v), eachindex(coeffs))	933,046✔
43	for ord in minrange	719,980✔
44	v[ord] = coeffs[ord]	6,297,340✔
45	end	11,874,700✔
46	for ord in last(minrange)+1:order+1	1,397,670✔
47	v[ord] = zero(coeffs[1])	315,470✔
48	end	599,400✔
49	return new{T}(v)	719,980✔
50	end
51	end
52
53	## Outer constructors ##
54	Taylor1(x::Taylor1{T}) where {T<:Number} = x	20✔
55	Taylor1(coeffs::AbstractArray{T,1}, order::Int) where {T<:Number} =	5,730✔
56	Taylor1{T}(coeffs, order)
57	Taylor1(coeffs::AbstractArray{T,1}) where {T<:Number} =	16,066✔
58	Taylor1{T}(FixedSizeVectorDefault(coeffs))
59	Taylor1(coeffs::FixedSizeVectorDefault{T}) where {T<:Number} = Taylor1{T}(coeffs)	3,264,630✔
60	Taylor1(coeffs::FixedSizeVectorDefault{T}, order::Int) where {T<:Number} =	714,260✔
61	Taylor1{T}(coeffs, order)
62	function Taylor1(x::T, order::Int) where {T<:Number}	403,555✔
63	v = FixedSizeVectorDefault{T}(undef, order+1)	811,208✔
64	v .= zero.(x)	409,540✔
65	v[1] = deepcopy(x)	409,540✔
66	return Taylor1{T}(v)	409,540✔
67	end
68
69
70	# Shortcut to define Taylor1 independent variables
71	"""
72	Taylor1([T::Type=Float64], order::Int)
73
74	Shortcut to define the independent variable of a `Taylor1{T}` polynomial of
75	given `order`. The default type for `T` is `Float64`.
76
77	```julia
78	julia> Taylor1(16)
79	1.0 t + 𝒪(t¹⁷)
80
81	julia> Taylor1(Rational{Int}, 4)
82	1//1 t + 𝒪(t⁵)
83	```
84	"""
85	function Taylor1(::Type{T}, order::Int) where {T<:Number}	360✔
86	order == 0 && return Taylor1{T}(FixedSizeVectorDefault{T}([zero(T)]))	360✔
87	coeffs = FixedSizeVectorDefault{T}(undef, order+1)	700✔
88	coeffs .= zero(T)	3,240✔
89	coeffs[2] = one(T)	350✔
90	return Taylor1{T}(coeffs)	350✔
91	end
92	function Taylor1(order::Int)	703✔
93	order == 0 && return Taylor1{Float64}(FixedSizeVectorDefault{Float64}([0.0]))	710✔
94	coeffs = FixedSizeVectorDefault{Float64}(undef, order+1)	1,333✔
95	coeffs .= 0.0	7,210✔
96	coeffs[2] = 1.0	700✔
97	return Taylor1{Float64}(coeffs)	700✔
98	end
99
100
101	######################### HomogeneousPolynomial
102	"""
103	HomogeneousPolynomial{T<:Number} <: AbstractSeries{T}
104
105	DataType for homogeneous polynomials in many (>1) independent variables.
106
107	Fields:
108
109	- `coeffs :: Array{T,1}` Expansion coefficients of the homogeneous
110	polynomial; the ``i``-th component is related to a monomial, where the degrees
111	of the independent variables are specified by `coeff_table[order+1][i]`.
112	- `order :: Int` order (degree) of the homogeneous polynomial.
113
114	Note that `HomogeneousPolynomial` variables are callable. For more information,
115	see [`evaluate`](@ref).
116	"""
117	struct HomogeneousPolynomial{T<:Number} <: AbstractSeries{T}
118	coeffs :: FixedSizeVectorDefault{T}
119	order :: Int
120	## Inner constructors ##
121	HomogeneousPolynomial{T}(x::T, order::Int) where {T<:Number} =	12,804,656✔
122	new{T}(_coeffsHP(x, order), order)
123	HomogeneousPolynomial{T}(coeffs::AbstractArray{T,1}, order::Int) where {T<:Number} =	1,272,824✔
124	new{T}(_coeffsHP(coeffs, order), order)
125	end
126
127	HomogeneousPolynomial(x::HomogeneousPolynomial{T}) where {T<:Number} = x	10✔
128	HomogeneousPolynomial(coeffs::AbstractArray{T,1}, order::Int) where {T<:Number} =	1,245,274✔
129	HomogeneousPolynomial{T}(coeffs, order)
130	HomogeneousPolynomial(coeffs::AbstractArray{T,1}) where {T<:Number} =	4,860✔
131	HomogeneousPolynomial{T}(coeffs, orderH(coeffs))
132	HomogeneousPolynomial(x::T, order::Int) where {T<:Number} =	12,804,656✔
133	HomogeneousPolynomial{T}(x, order)
134
135	# Shortcut to define HomogeneousPolynomial independent variable
136	"""
137	HomogeneousPolynomial([T::Type=Float64], nv::Int])
138
139	Shortcut to define the `nv`-th independent `HomogeneousPolynomial{T}`.
140	The default type for `T` is `Float64`.
141
142	```julia
143	julia> HomogeneousPolynomial(1)
144	1.0 x₁
145
146	julia> HomogeneousPolynomial(Rational{Int}, 2)
147	1//1 x₂
148	```
149	"""
150	function HomogeneousPolynomial(::Type{T}, nv::Int) where {T<:Number}	3,400✔
151	@assert 0 < nv ≤ get_numvars()	3,400✔
152	v = FixedSizeVectorDefault{T}(undef, get_numvars())	6,800✔
153	v .= zero(T)	93,050✔
154	v[nv] = one(T)	3,400✔
155	return HomogeneousPolynomial(v, 1)	3,400✔
156	end
157	function HomogeneousPolynomial(nv::Int)	40✔
158	res = HomogeneousPolynomial(0.0, 1)	40✔
159	res[nv] = 1.0	40✔
160	return res	40✔
161	end
162
163
164
165	######################### TaylorN
166	"""
167	TaylorN{T<:Number} <: AbstractSeries{T}
168
169	DataType for polynomial expansions in many (>1) independent variables.
170
171	Fields:
172
173	- `coeffs :: Array{HomogeneousPolynomial{T},1}` Vector containing the
174	`HomogeneousPolynomial` entries. The ``i``-th component corresponds to the
175	homogeneous polynomial of degree ``i-1``.
176	- `order :: Int` maximum order of the polynomial expansion.
177
178	Note that `TaylorN` variables are callable. For more information, see
179	[`evaluate`](@ref).
180	"""
181	struct TaylorN{T<:Number} <: AbstractSeries{T}
182	coeffs :: FixedSizeVectorDefault{HomogeneousPolynomial{T}}
183	## Inner constructor ##
184	function TaylorN{T}(v::AbstractArray{HomogeneousPolynomial{T},1},	460,652✔
185	order::Int) where {T<:Number}
186	isempty(v) &&	1,526,298✔
187	return new{T}(zeros(HomogeneousPolynomial(zero(T),0), order))
188	coeffs = _coeffsTN(v, order)	1,526,278✔
189	return new{T}(coeffs)	1,526,278✔
190	end
191	end
192
193	TaylorN(x::TaylorN{T}) where {T<:Number} = x	10✔
194	function TaylorN(x::AbstractArray{HomogeneousPolynomial{T},1},	10,299✔
195	order::Int) where {T<:Number}
196	if order == 0	33,520✔
197	order = maxorderH(x)	8,010✔
198	end
199	return TaylorN{T}(x, order)	48,948✔
200	end
201	TaylorN(x::AbstractArray{HomogeneousPolynomial{T},1}) where {T<:Number} =	653,554✔
202	TaylorN{T}(x, maxorderH(x))
203	TaylorN(x::HomogeneousPolynomial{T}, order::Int) where {T<:Number} =	1,440,013✔
204	TaylorN{T}([x], order )
205	TaylorN(x::HomogeneousPolynomial{T}) where {T<:Number} =	50✔
206	TaylorN{T}([x], get_order(x))
207	TaylorN(x::T, order::Int) where {T<:Number} =	191,730✔
208	TaylorN(HomogeneousPolynomial(x, 0), order)
209
210	# Shortcut to define TaylorN independent variables
211	"""
212	TaylorN([T::Type=Float64], nv::Int; [order::Int=get_order()])
213
214	Shortcut to define the `nv`-th independent `TaylorN{T}` variable as a
215	polynomial. The order is defined through the keyword parameter `order`,
216	whose default corresponds to `get_order()`. The default of type for
217	`T` is `Float64`.
218
219	```julia
220	julia> TaylorN(1)
221	1.0 x₁ + 𝒪(‖x‖⁷)
222
223	julia> TaylorN(Rational{Int},2)
224	1//1 x₂ + 𝒪(‖x‖⁷)
225	```
226	"""
227	TaylorN(::Type{T}, nv::Int; order::Int=get_order()) where {T<:Number} =	11,096✔
228	TaylorN( HomogeneousPolynomial(T, nv), order )
229	TaylorN(nv::Int; order::Int=get_order()) = TaylorN(Float64, nv, order=order)	1,084✔
230
231
232
233	# A `Number` which is not an `AbstractSeries`
234	const NumberNotSeries = Union{Real,Complex}
235
236	# A `Number` which is not `TaylorN` nor a `HomogeneousPolynomial`
237	const NumberNotSeriesN = Union{Real,Complex,Taylor1}
238
239	## Additional Taylor1 and TaylorN outer constructor ##
240	Taylor1{T}(x::S) where {T<:Number,S<:NumberNotSeries} = Taylor1([convert(T,x)], 0)	1,060✔
241	TaylorN{T}(x::S) where {T<:Number,S<:NumberNotSeries} = TaylorN(convert(T, x), TaylorSeries.get_order())	20✔
242
243
244	# """
245	# get_numvars
246	#
247	# Return the number of variables of a `Taylor1`, `HomogeneousPolynomial`
248	# or `TaylorN` object.
249	# """
250	get_numvars(t::Number) = 0	×
251	get_numvars(t::Taylor1) = 1	99✔
252	get_numvars(t::Taylor1{Taylor1{T}}) where {T<:Number} = get_numvars(t[0])+1	140✔
253	get_numvars(::T) where {T<:Union{HomogeneousPolynomial, TaylorN}} = _params_TaylorN_.num_vars	×

JuliaDiff / TaylorSeries.jl / 24845418400

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous