licenses
sequencelengths 1
3
| version
stringclasses 677
values | tree_hash
stringlengths 40
40
| path
stringclasses 1
value | type
stringclasses 2
values | size
stringlengths 2
8
| text
stringlengths 25
67.1M
| package_name
stringlengths 2
41
| repo
stringlengths 33
86
|
|---|---|---|---|---|---|---|---|---|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 3996 | # DDESystem
# Construction of DDESystem
A `DDESystem` is represented by the following state equation
```math
\dot{x} = f(x, h, u, t) \quad t \geq t_0
```
where ``t`` is the time, ``x`` is the value of the `state`, ``u`` is the value of the `input`. ``h`` is the history function for which
```math
x(t) = h(t) \quad t \leq t_0
```
and by the output equation
```math
y = g(x, u, t)
```
where ``y`` is the value of the `output`.
As an example, consider a system with the state equation
```math
\begin{array}{l}
\dot{x} = -x(t - \tau) \quad t \geq 0 \\
x(t) = 1. -\tau \leq t \leq 0 \\
\end{array}
```
First, we define the history function `histfunc`,
```@repl dde_system_ex
using Jusdl # hide
const out = zeros(1)
histfunc(out, u, t) = (out .= 1.);
```
Note that `histfunc` mutates a vector `out`. This mutation is for [`performance reasons`](https://docs.juliadiffeq.org/latest/tutorials/dde_example/#Speeding-Up-Interpolations-with-Idxs-1). Next the state function can be defined
```@repl dde_system_ex
function statefunc(dx, x, h, u, t)
h(out, u, t - tau) # Update out vector
dx[1] = out[1] + x[1]
end
```
and let us take all the state variables as outputs. Thus, the output function is
```@repl dde_system_ex
outputfunc(x, u, t) = x
```
Next, we need to define the `history` for the system. History is defined by specifying a history function, and the type of the lags. There may be two different lag: constant lags which are independent of the state variable ``x`` and the dependent lags which are mainly the functions of the state variable ``x``. Note that for this example, the have constant lags. Thus,
```@repl dde_system_ex
tau = 1
conslags = [tau]
```
At this point, we are ready to construct the system.
```@repl dde_system_ex
ds = DDESystem(righthandside=statefunc, history=histfunc, readout=outputfunc, state=[1.], input=nothing, output=Outport(), constlags=conslags, depslags=nothing)
```
## Basic Operation of DDESystem
The basis operaiton of `DDESystem` is the same as those of other dynamical systems. When triggered from its `trigger` link, the `DDESystem` reads its time from its `trigger` link, reads input, solves its differential equation, computes its output and writes the computed output to its `output` bus. To drive `DDESystem`, we must first launch it,
```@repl dde_system_ex
iport, trg, hnd = Inport(), Outpin(), Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
task = launch(ds)
task2 = @async while true
all(take!(iport) .=== NaN) && break
end
```
When launched, `ds` is drivable. To drive `ds`, we can use the syntax `drive(ds, t)` or `put!(ds.trigger, t)` where `t` is the time until which `ds` is to be driven.
```@repl dde_system_ex
put!(trg, 1.)
```
When driven, `ds` reads the time `t` from its `trigger` link, (since its input is `nothing`, `ds` does nothing during its input reading stage), solves its differential equation, computes output and writes the value of its output to its `output` bus. To signify, the step was taken with success, `ds` writes `true` to its `handshake` which must be read to further drive `ds`. For this, we can use the syntax `approve!(ds)` or `take!(ds.handshake)`.
```@repl dde_system_ex
take!(hnd)
```
We can continue to drive `ds`.
```@repl dde_system_ex
for t in 2. : 10.
put!(trg, t)
take!(hnd)
end
```
When launched, we constructed a `task` whose state is `running` which implies that `ds` can be driven.
```@repl dde_system_ex
task
task2
```
As long as the state of the `task` is `running`, `ds` can be driven. To terminate `task` safely, we need to terminate the `ds`.
```@repl dde_system_ex
put!(trg, NaN)
```
Note that the state of `task` is `done` which implies that `ds` is not drivable any more.
Note that the output values of `ds` is written to its `output` bus.
```@repl dde_system_ex
iport[1].link.buffer
```
## Full API
```@docs
@def_dde_system
DDESystem
DelayFeedbackSystem
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 3480 | # DiscreteSystem
## Construction of DiscreteSystem
`DiscreteSystem`s evolve by the following discrete time difference equation.
```math
x_{k + 1} = f(x_k, u_k, k) \\
y_k = g(x_k, u_k, k)
```
where ``x_k`` is the state, ``y_k`` is the value of `output` and ``u_k`` is the value of `input` at discrete time `t`. ``f`` is the state function and ``g`` is the output function of the system. See the main constructor.
## Basic Construction of DiscreteSystem
When a `DiscreteSystem` is triggered from its `trigger` link, it reads current time from its `trigger` link, reads its `input`, solves its difference equation, computes its output and writes its output value to its `output` bus. Let us continue with an example.
We first define state function `sfunc` and output function `ofunc` of the system,
```@repl discrete_system_ex
using Jusdl # hide
sfunc(dx, x, u, t) = (dx .= -0.5x)
ofunc(x, u, t) = x
```
From `sfunc`, it is seen that the system does not have any input, and from `ofunc` the system has one output. Thus, the `input` and `output` of the system is
```@repl discrete_system_ex
input = nothing
output = Outport(1)
```
We also need to specify the initial condition and time of the system
```@repl discrete_system_ex
x0 = [1.]
t = 0.
```
We are now ready to construct the system `ds`.
```@repl discrete_system_ex
ds = DiscreteSystem(righthandside=sfunc, readout=ofunc, state=x0, input=input, output=output)
```
To drive `ds`, we need to `launch` it.
```@repl discrete_system_ex
iport, trg, hnd = Inport(1), Outpin(), Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
task = launch(ds)
task2 = @async while true
all(take!(iport) .=== NaN) && break
end
```
At this point, `ds` is ready to be driven. To drive `ds`, we can either use `drive(ds, t)` or `put!(ds.trigger, t)`.
```@repl discrete_system_ex
put!(trg, 1.)
```
When the above code is executed, `ds` evolves until its time is `ds.t` is 1., During this evolution, `ds` reads time `t` from its `trigger` link, reads its `input` (in this example, `ds` has no input, so it does nothing when reading its input), solves its difference equation, computes its output and writes its output value to its `output`. To signal that the evolution is succeeded, `ds` writes `true` its `handshake` link which needs to be taken to further drive `ds`.
```@repl discrete_system_ex
hnd.link # `handshake` link is readable
take!(hnd)
```
We continue to drive `ds`,
```@repl discrete_system_ex
for i in 2. : 10.
put!(trg, i)
take!(hnd)
end
```
Note that all the output values of `ds` is written to its `output` bus.
```@repl discrete_system_ex
iport[1].link.buffer
```
When we launched `ds`, we constructed a `task` which is still running.
```@repl discrete_system_ex
task
task2
```
As long nothing goes wrong, i.e. no exception is thrown, during the evolution of `ds`, it is possible to drive `ds`. To safely terminate the `task`, we need to terminate the `ds`.
```@repl discrete_system_ex
put!(trg, NaN)
put!(ds.output, [NaN])
```
We can confirm that the `task` is not running and its state is `done`.
```@repl discrete_system_ex
task
task2
```
Since the `task` is not running any more, `ds` cannot be drivable any more. However to drive `ds` again, we need launch `ds` again.
## Full API
```@docs
@def_discrete_system
DiscreteSystem
DiscreteLinearSystem
HenonSystem
LoziSystem
BogdanovSystem
GingerbreadmanSystem
LogisticSystem
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 3851 | # ODESystem
## Basic Operation of ODESystem
When an `ODESystem` is triggered, it reads its current time from its `trigger` link, reads its `input`, solves its differential equation and computes its output. Let us observe the basic operation of `ODESystem`s with a simple example.
We first construct an `ODESystem`. Since an `ODESystem` is represented by its state equation and output equation, we need to define those equations.
```@repl ode_ex
using Jusdl # hide
sfunc(dx,x,u,t) = (dx .= -0.5x)
ofunc(x, u, t) = x
```
Let us construct the system
```@repl ode_ex
ds = ODESystem(righthandside=sfunc, readout=ofunc, state=[1.], input=Inport(1), output=Outport(1))
```
Note that `ds` is a single input single output `ODESystem` with an initial state of `[1.]` and initial time `0.`. To drive, i.e. trigger `ds`, we need to launch it.
```@repl ode_ex
oport, iport, trg, hnd = Outport(1), Inport(1), Outpin(), Inpin{Bool}()
connect!(oport, ds.input)
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
task = launch(ds)
task2 = @async while true
all(take!(iport) .=== NaN) && break
end
```
When launched, `ds` is ready to driven. `ds` is driven from its `trigger` link. Note that the `trigger` link of `ds` is writable.
```@repl ode_ex
ds.trigger.link
```
Let us drive `ds` to the time of `t` of `1` second.
```@repl ode_ex
put!(trg, 1.)
```
When driven, `ds` reads current time of `t` from its `trigger` link, reads its input value from its `input`, solves its differential equation and computes its output values and writes its `output`. So, for the step to be continued, an input values must be written. Note that the `input` of `ds` is writable,
```@repl ode_ex
ds.input[1].link
```
Let us write some value.
```@repl ode_ex
put!(oport, [5.])
```
At this point, `ds` completed its step and put `true` to its `handshake` link to signal that its step is succeeded.
```@repl ode_ex
hnd.link
```
To complete the step and be ready for another step, we need to approve the step by reading its `handshake`.
```@repl ode_ex
take!(hnd)
```
At this point, `ds` can be driven further.
```@repl ode_ex
for t in 2. : 10.
put!(trg, t)
put!(oport, [t * 10])
take!(hnd)
end
```
Note that all the output value of `ds` is written to its `output`bus,
```@repl ode_ex
iport[1].link.buffer
```
When we launched `ds`, we constructed a `task` and the `task` is still running.
```@repl ode_ex
task
task2
```
To terminate the `task` safely, we need to `terminate` `ds` safely.
```@repl ode_ex
put!(trg, NaN)
put!(ds.output, [NaN])
```
Now, the state of the `task` is done.
```@repl ode_ex
task
task2
```
So, it is not possible to drive `ds`.
## Mutation in State Function in ODESystem
Consider a system with the following ODE
```math
\begin{array}{l}
\dot{x} = f(x, u, t) \\
y = g(x, u, t) \\
\end{array}
```
where ``x \in R^d, y \in R^m, u \in R^p``. To construct and `ODESystem`, The signature of the state function `statefunc` must be of the form
```julia
function statefunc(dx, x, u, t)
dx .= ... # Update dx
end
```
Note that `statefunc` *does not construct* `dx` but *updates* `dx` and does not return anything. This is for [performance reasons](https://docs.juliadiffeq.org/latest/basics/faq/#faq_performance-1). On the contrary, the signature of the output function `outputfunc` must be of the form,
```julia
function outputfunc(x, u, t)
y = ... # Compute y
return y
end
```
Note the output value `y` is *computed* and *returned* from `outputfunc`. `y` is *not updated* but *generated* in the `outputfunc`.
## Full API
```@docs
@def_ode_system
ODESystem
ContinuousLinearSystem
LorenzSystem
ForcedLorenzSystem
ChenSystem
ForcedChenSystem
ChuaSystem
ForcedChuaSystem
RosslerSystem
ForcedRosslerSystem
VanderpolSystem
ForcedVanderpolSystem
Integrator
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 4158 | # RODESystem
## Construction of RODESystem
A `RODESystem` is represented by the state function
```math
\begin{array}{l}
dx = f(x, u, t, W)
\end{array}
```
and the output function
```math
y = g(x, u, t)
```
where ``t`` is the time, ``x \in R^n`` is the state, ``u \in R^p`` and ``y \in R^m`` is output of the system. Therefore to construct a `RODESystem`, we need to define `statefunc` and `outputfunc` with the corresponding syntax,
```julia
function statefunc(dx, x, u, t)
dx .= ... # Update dx
end
```
and
```julia
function outputfunc(x, u, t)
y = ... # Compute y
return y
end
```
As an example, consider the system with the state function
```math
\begin{array}{l}
dx_1 = 2 x_1 sin(W_1 - W_2) \\
dx_2 = -2 x_2 cos(W_1 + W_2)
\end{array}
```
and with the output function
```math
y = x
```
That is, all the state variable are taken as output. The `statefunc` and the `outputfunc` is defined as,
```@repl rode_system_ex
using Jusdl # hide
function statefunc(dx, x, u, t, W)
dx[1] = 2x[1]*sin(W[1] - W[2])
dx[2] = -2x[2]*cos(W[1] + W[2])
end
outputfunc(x, u, t) = x
```
To construct the `RODESystem`, we need to specify the initial condition and time.
```@repl rode_system_ex
x0 = [1., 1.]
t = 0.
```
Note from `statefunc`, the system has not any input, i.e. input is nothing, and has an output with a dimension of 1.
```@repl rode_system_ex
input = nothing
output = Outport(2)
```
We are ready to construct the system
```@repl rode_system_ex
ds = RODESystem(righthandside=statefunc, readout=outputfunc, state=x0, input=input, output=output, solverkwargs=(dt=0.01,))
```
Note that `ds` has a solver to solve its state function `statefunc` which is random differential equation. To solve its `statefunc`, the step size of the solver must be specified. See [`Random Differential Equtions`](https://docs.juliadiffeq.org/latest/tutorials/rode_example/) of [`DifferentialEquations `](https://docs.juliadiffeq.org/latest/) package.
## Basic Operation of RODESystem
When a `RODESystem` is triggered from its `trigger` link, it read the current time from its `trigger` link, reads its input (if available, i.e. its input is not nothing), solves its state function, computes its output value and writes its output value its `output` bus (again, if available, i.e., its output bus is not nothing). To drive a `RODESystem`, it must be `launched`. Let us continue with `ds` constructed in the previous section.
```@repl rode_system_ex
iport, trg, hnd = Inport(2), Outpin(), Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
task = launch(ds)
task2 = @async while true
all(take!(iport) .=== NaN) && break
end
```
When launched, `ds` is ready to be driven. We can drive `ds` by `drive(ds, t)` or `put!(ds.trigger, t)` where `t` is the time until which we will drive `ds`.
```@repl rode_system_ex
put!(trg, 1.)
```
When triggered, `ds` read the time `t` from its `trigger` link, solved its differential equation, computed its value and writes its output value to its `output` bus. To signal that, the evolution is succeeded, `ds` writes `true` to its `handshake` link which must be taken to further drive `ds`. (`approve!(ds)`) can also be used.
```@repl rode_system_ex
take!(hnd)
```
We can continue to drive `ds`.
```@repl rode_system_ex
for t in 2. : 10.
put!(trg, t)
take!(hnd)
end
```
After each evolution, `ds` writes its current output value to its `output` bus.
```@repl rode_system_ex
[outbuf(pin.link.buffer) for pin in iport]
```
When launched, a `task` was constructed which still running. As long as no exception is thrown during the evolution of `ds`, the state of `task` is running which implies `ds` can be driven.
```@repl rode_system_ex
task
task2
```
To terminate the `task` safely, `ds` should be terminated safely.
```@repl rode_system_ex
put!(trg, NaN)
put!(ds.output, [NaN, NaN])
```
Note that the state of `task` is `done` which implies the `task` has been terminated safely.
```@repl rode_system_ex
task
task2
```
## Full API
```@docs
@def_rode_system
RODESystem
MultiplicativeNoiseLinearSystem
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 4210 | # SDESystem
## Construction of SDESystems
A `SDESystem` is represented by the state function
```math
dx = f(x, u, t) dt + h(x, u, t)dW
```
where ``t`` is the time, ``x \in R^n`` is the value of state, ``u \in R^p`` is the value of the input. ``W`` is the Wiener process of the system. The output function is defined by
```math
y = g(x, u, t)
```
where ``y`` is the value of output at time ``t``.
As an example consider a system with the following stochastic differential equation
```math
\begin{array}{l}
dx = -x dt - x dW
\end{array}
```
and the following output equation
```math
y = x
```
The state function `statefunc` and the output function `outputfunc` is defined as follows.
```@repl sde_system_ex
using Jusdl # hide
f(dx, x, u, t) = (dx[1] = -x[1])
h(dx, x, u, t) = (dx[1] = -x[1])
```
The state function `statefunc` is the tuple of drift and diffusion functions
```@repl sde_system_ex
statefunc = (f, h)
```
The output function `outputfunc` is defined as,
```@repl sde_system_ex
g(x, u, t) = x
```
Note that the in drift function `f` and diffusion function `g`, the vector `dx` is *mutated* while in the output function `g` no mutation is done, but the output value is generated instead.
From the definition of drift function `f` and the diffusion function `g`, it is seen that the system does not have any input, that is, the input of the system is `nothing`. Since all the state variables are taken as outputs, the system needs an output bus of length 1. Thus,
```@repl sde_system_ex
input = nothing
output = Outport(1)
```
At this point, we are ready to construct the system `ds`.
```@repl sde_system_ex
ds = SDESystem(righthandside=statefunc, readout=g, state=[1.], input=input, output=output)
```
## Basic Operation of SDESystems
The basic operation of a `SDESystem` is the same as those of other dynamical systems. When triggered from its `trigger` link, a `SDESystem` reads its time `t` from its `trigger` link, reads its input value from its `input`, solves its state equation, which is a stochastic differential equation, computes its output and writes its computed output to its `output` bus.
In this section, we continue with the system `ds` constructed in the previous section. To make `ds` drivable, we need to `launch` it.
```@repl sde_system_ex
iport, trg, hnd = Inport(1), Outpin(), Inpin{Bool}()
connect!(ds.output, iport)
connect!(trg, ds.trigger)
connect!(ds.handshake, hnd)
task = launch(ds)
task2 = @async while true
all(take!(iport) .=== NaN) && break
end
```
When launched, `ds` can be driven. For this, either of the syntax `put!(ds.trigger, t)` or `drive(ds, t)` can be used.
```@repl sde_system_ex
put!(trg, 1.)
```
After this command, `ds` reads its time `t` from its `trigger` link, solves its state function and computes its output. The calculated output value is written to the buffer of `output`. To signal that, the step is takes with success, `ds` writes `true` to its `handshake` link. To further drive `ds`, this `handshake` link must be read. For this either of the syntax, `take!(ds.handshake)` or `approve!(ds)` can be used
```@repl sde_system_ex
hnd.link
take!(hnd)
```
At this point, we can further drive `ds`.
```@repl sde_system_ex
for t in 2. : 10.
put!(trg, t)
take!(hnd)
end
```
Note that during the evolution, the output of `ds` is written into the buffers of `output` bus.
```@repl sde_system_ex
iport[1].link.buffer
```
!!! warning
The values of the output is written into buffers if the `output` of the systems is not `nothing`.
When we launched `ds`, we constructed a `task` whose state is `running` which implies that the `ds` can be drivable. As long as this `task` is running, `ds` can be drivable.
!!! warning
The state of the `task` is different from `running` in case an exception is thrown.
To terminate the `task` securely, we need to terminate `ds` securely. To do that, can use `terminate!(ds)`.
```@repl sde_system_ex
put!(trg, NaN)
put!(ds.output, [NaN])
```
Note that the `task` is terminated without a hassle.
```@repl sde_system_ex
task
task2
```
## Full API
```@docs
@def_sde_system
SDESystem
NoisyLorenzSystem
ForcedNoisyLorenzSystem
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 4435 | # StaticSystems
## Basic Operation of StaticSystems
A static system is a system whose output `y` at time `t` depends on the current time `t` and the value of its input `u`. The input-output relation of a static systems is represented by its output function `outputfunc` which is of the form
```math
y = g(u, t)
```
where `g` is the output function `outputfunc`. Note that `outputfunc` is expected to have two inputs, the value `u` of the `input` and the current time `t`. The simulation in `Jusdl` is a clocked-simulation, that is the data flowing through the input and output connections of components is actually sampled at time `t`. Therefore, for example, the system modeled by
```math
y(t) = g(u(t),t)
```
is actually sampled at clock ticks `t` which is generated by a [`Clock`](@ref). Therefore the sampled system corresponds to
```math
y[k] = g(u_k, t_k)
```
where ``k`` is ``k_i T_s`` where ``k_i`` is an integer number, ``T_s`` is the sampling interval. ``T_s`` corresponds to sampling time `dt` of [`Clock`](@ref). Thus, the system given above is coded like
```julia
function g(u, t)
# Define the relation `y = g(u, t)`
end
```
For further clarity, let us continue with a case study. Consider the following static system,
```math
y(t) = g(u(t), t) = \left[
\begin{array}{l}
t u_1(t) \\
sin(u_1(t)) \\
cos(u_2(t))
\end{array}
\right]
```
Note that the number of inputs is 2 and the number of outputs of is 3. To define such a system, the output function is written as
```@repl static_system_ex
using Jusdl # hide
g(u, t) = [t * u[1], sin(u[1]), cos(u[2])]
```
Note that the function `g` is defined in such a way that the input value `u` is sampled, which implies `u` is not a vector of function but is a vector of real. Having defined output function `outputfunc`, the system can be constructed.
```@repl static_system_ex
ss = StaticSystem(readout=g, input=Inport(2), output=Outport(3))
```
Note the construction of input bus `Inport(2)` and output bus `Outport(3)` by recalling that the number of input is 2 and the number of output is 3.
A [`StaticSystem`](@ref) evolves by being triggered through its `trigger` pin. When triggered from its `trigger` pin, a `StaticSystem` reads the current time `t` from its `trigger` pin and computes its output `y` according to its output function `outputfunc` and writes its output `y(t)` to its `output` port (if `output` port exists since `output` port may be nothing depending on the relation defined by `outputfunc`). When constructed, a `StaticSystem` is not ready to be triggered since its `trigger` pin is not writeable. To make `ss` drivable, we need to construct the ports and pins for input-output and signaling.
```@repl static_system_ex
oport, iport, trg, hnd = Outport(length(ss.input)), Inport(length(ss.output)), Outpin(), Inpin{Bool}()
connect!(oport, ss.input)
connect!(ss.output, iport)
connect!(trg, ss.trigger)
connect!(ss.handshake, hnd)
task = launch(ss)
taskout = @async while true
all(take!(iport) .=== NaN) && break
end
```
Now, `ss` is drivable from its `trg` pin.
```@repl static_system_ex
ss.trigger.link
```
Now let us drive `ss`.
```@repl static_system_ex
put!(trg, 1.)
```
As this point `ss` wait for its to be written. Let us write some data to `oport`.
```@repl static_system_ex
put!(oport, [10., 10.])
```
`ss` read the value `u` of its `input`(since `ss.input` is connected to `oport`), read the current time `t`, and computed its output value `y` and wrote it its `output` port. To signal that it succeeded to be take the step, it put a `true` to its handshake which needs to be taken.
```@repl static_system_ex
hnd.link
take!(hnd)
```
We can see the current data in the `output` of `ss` through `iport` (since `iport` is connected to `ss.output`)
```@repl static_system_ex
iport[1].link.buffer
```
Let us further drive `ss`.
```@repl static_system_ex
for t in 2. : 10.
put!(trg, t)
put!(oport, [10 * t, 20 * t])
take!(hnd)
end
```
The data written to the `output` of `ss` is also written to the internal buffers of `output`.
```@repl static_system_ex
iport[1].link.buffer
```
In addition to the generic [`StaticSystem`](@ref), `Jusdl` provides some well-known static systems given in the next section.
## Full API
```@docs
@def_static_system
StaticSystem
Adder
Multiplier
Gain
Terminator
Memory
Coupler
Differentiator
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2057 | # Subsystem
## Construction of SubSystems
A SubSystem consists of connected components. Thus, to construct a `SubSystem`, we first construct components, connect them and specify the input and output of `SubSystem`.
## Basic Operation of SubSystems
The operation of a `SubSystem` is very similar to that of a [`StaticSystem`](@ref). The only difference is that when a `SubSystem` is triggered through its `trigger` pin, it distributes the trigger to the trigger pins of its components. Then, each of the components of the `SubSystem` takes steps individually.
Let us construct a subsystem consisting of a generator and an adder.
```@repl subsystem_ex
using Jusdl # hide
gen = ConstantGenerator()
adder = Adder((+,+))
```
Connect the generator and adder.
```@repl subsystem_ex
connect!(gen.output, adder.input[1])
```
We are ready to construct a `SubSystem`.
```@repl subsystem_ex
sub = SubSystem([gen, adder], [adder.input[2]], adder.output)
```
To trigger the `sub`, we need to launch it. For that purpose, we construct ports and pins for input-output and signaling.
```@repl subsystem_ex
oport, iport, trg, hnd = Outport(length(sub.input)), Inport(length(sub.output)), Outpin(), Inpin{Bool}()
connect!(oport, sub.input)
connect!(sub.output, iport)
connect!(trg, sub.trigger)
connect!(sub.handshake, hnd)
t = launch(sub)
t2 = @async while true
all(take!(iport) .=== NaN) && break
end
```
`sub` is ready to be triggered,
```@repl subsystem_ex
put!(trg, 1.)
```
Put some data to the input of `sub` via `oport` (since `oport` is connected to `sub.input`)
```@repl subsystem_ex
put!(oport, [1.])
```
The step needs to be approved.
```@repl subsystem_ex
take!(hnd)
```
Now print the data written to the outputs of the components of `sub`.
```@repl subsystem_ex
sub.components[1].output[1].links[1].buffer[1]
sub.components[2].output[1].links[1].buffer[1]
```
Note that when `sub` is triggered, `sub` transfer the trigger to all its internal components.
```@autodocs
Modules = [Jusdl]
Pages = ["subsystem.jl"]
Order = [:type, :function]
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 3517 | # Links
[`Link`](@ref)s are built on top of [`Channel`s](https://docs.julialang.org/en/v1/manual/parallel-computing/#Channels-1) of Julia. They are used as communication primitives for [`Task`s](https://docs.julialang.org/en/v1/manual/control-flow/#man-tasks-1) of Julia. A [`Link`](@ref) basically includes a `Channel` and a `Buffer`. The mode of the buffer is `Cyclic`.(see [Buffer Modes](@ref) for information on buffer modes). Every item sent through a [`Link`](@ref) is sent through the channel of the [`Link`](@ref) and written to the [`Buffer`](@ref) so that all the data flowing through a [`Link`](@ref) is recorded.
## Construction of Links
The construction of a `Link` is very simple: just specify its buffer length and element type.
```@repl
using Jusdl # hide
Link{Bool}(5)
Link{Int}(10)
Link(5)
Link()
```
## Data Flow through Links
The data can be read from and written into [`Link`](@ref)s if active tasks are bound to them. [`Link`](@ref)s can be thought of like a pipe. In order to write data to a [`Link`](@ref) from one of its ends, a task that reads written data from the other end must be bounded to the [`Link`](@ref). Similarly, in order to read data from one of the [`Link`](@ref) from one of its end, a task that writes the read data must be bound to the [`Link`](@ref). Reading from and writing to [`Link`](@ref) is carried out with [`take!`](@ref) and [`put!`](@ref) functions. For more clarity, let us see some examples.
Let us first construct a `Link`,
```@repl link_writing_ex_1
using Jusdl # hide
l = Link(5)
```
`l` is a `Link` with a buffer length of `5` and element type of `Float64`. Not that the `l` is open, but it is not ready for data reading or writing. To write data, we must bound a task that reads the written data.
```@repl link_writing_ex_1
function reader(link::Link) # Define job.
while true
val = take!(link)
val === NaN && break # Poison-pill the tasks to terminate safely.
end
end
t = @async reader(l)
```
The `reader` is defined such that the data written from one end of `l` is read until the data is `NaN`. Now, we have runnable a task `t`. This means the `l` is ready for data writing.
```@repl link_writing_ex_1
put!(l, 1.)
put!(l, 2.)
```
Note that the data flown through the `l` is written to its `buffer`.
```@repl link_writing_ex_1
l.buffer
```
To terminate the task, we must write `NaN` to `l`.
```@repl link_writing_ex_1
put!(l, NaN) # Terminate the task
t # Show that the `t` is terminated.
```
Whenever the bound task to the `l` is runnable, the data can be written to `l`. That is, the data length that can be written to `l` is not limited by the buffer length of `l`. But, beware that the `buffer` of `Link`s is `Cyclic`. That means, when the `buffer` is full, its data is overwritten.
```@repl link_writing_ex_1
l = Link(5)
t = @async reader(l)
for item in 1. : 10.
put!(l, item)
@show outbuf(l.buffer)
end
```
The case is very similar to read data from `l`. Again, a runnable task is bound the `l`
```@repl link_reading_ex_1
using Jusdl # hide
l = Link(5)
function writer(link::Link, vals)
for val in vals
put!(link, val)
end
end
t = @async writer(l, 1.:5.)
bind(l, t)
take!(l)
take!(l)
```
It is possible to read data from `l` until `t` is active. To read all the data at once, `collect` can be used.
```@repl link_reading_ex_1
t
collect(l)
t # Show that `t` is terminated.
```
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["link.jl"]
Order = [:type, :function]
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2937 | # Pins
`Pin`s are building blocks of [Ports](@ref). Pins can be thought of *gates* of components as they are the most primitive type for data transfer inside and outside the components. There are two types of pins: [`Outpin`](@ref) and [`Inpin`](@ref). The data flows from inside of the components to its outside through `Outpin` while data flow from outside of the components to its inside through `Inpin`.
## Connection and Disconnection of Pins
In Jusdl, signal flow modelling approach is adopted(see [Modeling](@ref) and [Simulation](@ref section) for more information on modelling approach in Jusdl). In this approach, the components drive each other and data flow is unidirectional. The unidirectional data movement is carried out though the [`Link`](@ref)s. A `Link` connects `Outpin`s to `Inpin`s, and the data flow is from `Outpin` to `Inpin`.
!!! note
As the data movement is from `Outpin` to `Inpin`, connection of an `Inpin` to an `Outpin` gives a `MethodError`.
For example, let us construct and `Outpin` and `Inpin`s and connect the together.
```@repl pin_example_1
using Jusdl # hide
op = Outpin()
ip = Inpin()
link = connect!(op, ip)
```
Note `connect!(op, ip)` connects `op` and `ip` through a `Link` can return the constructed link. The connection of pins can be monitored.
```@repl pin_example_1
isconnected(op, ip)
```
The constructed `link` can be accessed though the pins.
```@repl pin_example_1
op.links[1] === link
ip.link === link
```
!!! note
It is possible for an [`Outpin`](@ref) to have multiple [`Link`](@ref)s bound to itself. On contract, an [`Inpin`](@ref) can have just one [`Link`](@ref).
The connected links `Outpin` and `Inpin` can be disconnected using [`disconnect!`](@ref) function. When disconnected, the data transfer from the `Outpin` to `Inpin` is not possible.
## Data Flow Through Pins
The data flow from an `Outpin` to an `Inpin`. However for data flow through a pin, a running task must be bound the channel of the link of the pin. See the example below.
```@repl pin_example_1
t = @async while true
take!(ip) === NaN && break
end
```
As the task `t` is bound the channel of the `link` data can flow through `op` and `ip`.
```@repl pin_example_1
put!(op, 1.)
put!(op, 2.)
put!(op, 3.)
```
Note that `t` is a taker job. As the taker job `t` takes data from `op`, we were able to put values into `op`. The converse is also possible.
```@repl pin_example_1
op2, ip2 = Outpin(), Inpin()
link2 = connect!(op2, ip2)
t2 = @async for item in 1 : 5
put!(op2, item)
end
take!(ip2)
take!(ip2)
```
Note that in both of the cases given above the data flow is always from an `Outpin` to an `Inpin`.
!!! warning
It is not possible to take data from an `Outpin` and put into `Inpin`. Thus, `take!(pin::Outpoin)` and `put!(pin::Inpin)` throws a method error.
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["pin.jl"]
Order = [:type, :function]
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 3166 | # Ports
A `Port` is actually is a bunch of pins (See [Pins](@ref) for mor information on pins.). As such, the connection, disconnection and data transfer are very similar to those of pins. Basically, there are two type of port: [`Outport`](@ref) and [`Inport`](@ref). The data flows from outside of a component to its inside through an `Inport` while data flows from inside of the component to its outside through an `Outport`.
## Construction of Ports
A port (both `Inport` and `Outport`) is constructed by specifying its element type `T`, the number of pins `npins` and the buffer length of its pins.
```@repl port_example_1
using Jusdl # hide
Outport{Bool}(5)
Outport{Int}(2)
Outport(3)
Outport()
Inport{Bool}(5)
Inport{Int}(2)
Inport(3)
Inport()
```
## Connection and Disconnection of Ports
The ports can be connected to and disconnected from each other. See the following example.
Let us construct and `Outport` and an `Inport` and connect them together.
```@repl port_example_1
op1 = Outport(2)
ip1 = Inport(2)
ls = connect!(op1, ip1)
```
Note that we connected all pins of `op` to `ip`. We cannot connect the ports partially.
```@repl port_example_1
op2, ip21, ip22 = Outport(5), Inport(2), Inport(3)
ls1 = connect!(op2[1:2], ip21)
ls2 = connect!(op2[3:5], ip22)
```
The connectedness of ports can be checked.
```@repl port_example_1
isconnected(op2[1], ip21[1])
isconnected(op2[1], ip21[2])
isconnected(op2[1:2], ip21)
isconnected(op2[3:5], ip22)
isconnected(op2[5], ip22[3])
```
Connected ports can be disconnected.
```@repl port_example_1
disconnect!(op2[1], ip21[1])
disconnect!(op2[2], ip21[2])
disconnect!(op2[3:5], ip22)
```
Now check again the connectedness,
```@repl port_example_1
isconnected(op2[1], ip21[1])
isconnected(op2[1], ip21[2])
isconnected(op2[1:2], ip21)
isconnected(op2[3:5], ip22)
isconnected(op2[5], ip22[3])
```
## Data Flow Through Ports
Data flow through the ports is very similar to the case in pins(see [Data Flow Through Pins](@ref) for information about data flow through pins). Running tasks must be bound to the links of pins of the ports for data flow through the ports.
Let us construct an `Outport` and an `Inport`, connect them together with links and perform data transfer from the `Outport` to the `Inport` through the links.
```@repl port_example_1
op3, ip3 = Outport(2), Inport(2)
ls = connect!(op3, ip3)
t = @async while true
val = take!(ip3)
all(val .=== NaN) && break
println("Took " * string(val))
end
put!(op3, 1.);
ip3[1].link.buffer
```
Note that the data flowing through the links are also written into the buffers of links.
## Indexing and Iteration of Ports
Ports can be indexed similarly to the arrays in Julia. When indexed, the corresponding pin of the port is returned.
```@repl port_example_1
op4 = Outport(3)
op4[1]
op4[end]
op4[:]
op4[1] = Outpin()
op4[1:2] = [Outpin(), Outpin()]
```
The iteration of `Port`s in a loop is also possible. When iterated, the pins of the `Port` is returned.
```@repl port_example_1
ip5 = Inport(3)
for pin in ip5
@show pin
end
```
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["port.jl"]
Order = [:type, :function]
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 5107 | # Model
## Signal-Flow Approach in Modelling
Jusdl adopts *signal-flow* approach in systems modelling. In signal-flow approach, a [`Model`](@ref) consists of connected components. The components are data processing units and the behavior, i.e, the mathematical model, of the component determines how the data is processed. Connections connects the components each other and the data is transferred between components by means of connections. The data flow through the connections is unidirectional, i.e., a component is driven by other components that write data to its input bus.
## Construction of Models
A `Model` consists of connected components. The components of are defined first and the `Model` consisting of these components can be constructed. Or, an empty model can be constructed.
Let us continue with some examples. We will construct very simple `Model` consisting of a [`SinewaveGenerator`](@ref) and a [`Writer`](@ref). We construct an empty `Model` first, then we add nodes and branches as desired.
```@repl model_construction_ex
using Jusdl # hide
model = Model()
addnode!(model, SinewaveGenerator(), label=:gen)
addnode!(model, Writer(Inport()), label=:writer)
addbranch!(model, :gen => :writer, 1 => 1)
```
## Simulation of Models
A `Model` to to be simulated consists of components connected to each other an a time reference.
```@repl model_construction_ex
model.nodes # Model components
model.branches # Model components
model.clock # Model time reference
```
The time reference is used to sample the continuous time signals flowing through the busses of the model and to rigger the components. The simulation is performed by triggering the components with the pulses generated by the time reference at simulation sampling time intervals. Having been triggered, the components evolve themselves, compute their outputs and writes them to their outputs.
## Simulation Stages
### Inspection
The inspection stage is the first stage of the simulation process. In this stag,e the model is first inspected in terms of whether it is ready for simulation. This inspection is carried out to see whether the model has some inconsistencies such as unterminated busses or presence of algebraic loops. If the model has unterminated busses, the data that is supposed to flow those unterminated busses cannot flow through those busses and the simulation gets stuck. An algebraic is the subset of model components whose output depends directly on their inputs. In such a case, none of the components can produce outputs to break the loop which leads again the obstruction of simulation. Thus, to continue the simulation, the model must not contain any of those inconsistencies. The model inspection is done with [`inspect!`](@ref) function.
### Initialization
If the inspection stage results positive, the initialization stage comes next. In this stage, the tasks required for the busses of the model to be both readable and writable are activated and bound the busses. To this end, a reader and writer task are activated and bound to both sides of each bus. To initialize the model, [`initialize!`](@ref) function is used.
When the model is initialized, the pairs of components and component tasks are recorded into the task manager of the model. During the rest of the simulation, task manager keeps track of the tasks. Any exception or error that is thrown during the run stage of the simulation can be observed by means of the task manager of the model.
### Run
The run stage follows the initialization stage. The tasks activated in the initialization stage wait for the components to be triggered by the model time reference. During the run stage, time reference, that is the model clock, triggers the components by writing pulses that are generated in the intervals of the sampling period of the simulation to their trigger links. The job defined in a task is to read input dat a from the its input bus, to calculate its next state, if any, and output, and write its calculated output to its output bus. The run stage, starts at the initial time of the time reference and continues until the end time of the time reference. [`run!`](@ref) function is used to run the models,
### Termination
After the run stage, the tasks opened in the initialization stage are closed and the simulation is terminated. [`terminate!`](@ref) function is used to terminate the model
`Model`s are constructed to [`simulate!`](@ref) them. During the simulation, components of the `Model` process data and the data is transferred between the components via connection. Thus, to simulate the `Model`s, the components **must be connected**. In our model, the `writer` is used to record the output of `gen`. Thus, the flows from `gen` to `writer`. Thus, we connect `gen` output to `writer` input.
!!! note
During the `Model` construction, **the order of addition of nodes to the model is not important**. The nodes can be given in any order.
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["model.jl"]
Order = [:type, :function]
```
```@docs
@defmodel
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 945 | # Simulation
During the simulation of a `model`, a [`Simulation`](@ref) object is constructed. The field names of the `Simulation` object is
* `model::Model`: The model for which the `Simulation` is constructed.
* `path::String`: The path of the directory into which all simulation-related files (log, data files etc.) are saved.
* `logger::AbstractLogger`: The logger of the simulation constructed to log each stage of the `Simulation` .
* `state::Symbol`: The state of the `Simulation`. The `state` may be `:running` if the simulation is running, `:halted` is the simulation is terminated without being completed, `:done` if it is terminated.
* `retcode::Symbol`: The return code of the simulation. The `retcode` may be `:success` if the simulation is completed without errors, `:failed` if the an error occurs during the simulation.
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["simulation.jl"]
Order = [:type, :function]
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 1431 | # Task Manager
A [`TaskManager`](@ref) is actually the pairs of components and the tasks constructed corresponding to those components. In `Jusdl`, models are simulated by individually evolving the components. This individual evolution of components is performed by defining components individually and constructing tasks for each components. The jobs that are defined in these tasks are defined to make the components evolve by reading its time, input, compute its output. During this evolution, the tasks may fail because any inconsistency. Right after the failure of a task, its not possible for the component corresponding to the task to evolve any more. As the data flows through the components that connects the components, model simulation gets stuck. To keep track of the task launched for each component, a `TaskManager` is used. Before starting to simulate a model, a `TaskManager` is constructed for the model components. During the initialization of simulation, tasks corresponding to the components of the model is launched and the pair of component and component task is recorded in the `TaskManager` of the model. During the run stage of the simulation, `TaskManager` keeps track of the component tasks. In case any failure in components tasks, the cause of the failure can be investigated with `TaskManager`.
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["taskmanager.jl"]
Order = [:type, :function]
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2233 | # Plugins
Plugins are extensions that are used to process online the data flowing through the connections of the model during the simulation. These tools are specialized tools that are used for specialized data processing. In addition to the plugins that are provided by `Jusdl`, it is also possible to write new plugins that focus on different specialized data processing. The fundamental importance of `Plugin`s is that they make the online simulation data processing possible.
The `Plugin`s are mostly used with [Sinks](@ref). In `Jusdl`, the `Sink`s are used to *sink* simulation data flowing through the connections of the model. When a `Sink` is equipped with a proper `Plugin` according to the data processing desired, then the data flowing into the `Sink` is processed. For example, consider that a `Writer` is equipped with a `Lyapunov` plugin. During the simulation, data flowing into the `Writer` is processed to compute the maximum Lyapunov exponent, and these computed maximum Lyapunov exponents are recorded in the file of the `Writer`. Similarly, if a `Printer` is equipped with an `Fft` plugin, then Fast Fourier transform of the data flowing into the `Printer` is printed on the console.
## Data processing via Plugins
Each `Plugin` must have a `process` function which does the data processing. The first argument of the `process` function is the `Plugin` and the second argument is the data to be processed. Here are some of the methods of `process` function
## Defining New Plugins
New plugins can be defined in `Jusdl` and having they are defined properly they can work just expected. To define a new plugin, we must first define the plugin type
```@repl plugin_ex
using Jusdl # hide
struct NewPlugin <: AbstractPlugin
# Parameters of NewPlugin
end
```
!!! warning
Note that to the `NewPlugin` is defined to be a subtype of `AbstractPlugin`. This is important for the `NewPlugin` to work as expected.
Since each plugin must have implement a `process` method, and for that `Jusdl.process` function must be imported.
```@repl plugin_ex
import Jusdl.process
function process(plg::NewPlugin, x)
# Define the process according to plg
end
```
At this point, `NewPlugin` is ready to be used.
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2529 | # Buffer
A [`Buffer`](@ref) is a used to *buffer* the data flowing the connections of a model. Data can be read from and written into a buffer. The mode of the buffer determines the way to read from and write into the buffers.
## Buffer Modes
[`BufferMode`](@ref) determines the way the data is read from and written into a [`Buffer`](@ref). Basically, there are four buffer modes: [`Normal`](@ref), [`Cyclic`](@ref), [`Fifo`](@ref) and [`Lifo`](@ref). `Normal`, `Fifo` and `Lifo` are subtypes of [`LinearMode`](@ref) and `Cyclic` is a subtype of [`CyclicMode`](@ref).
## Buffer Constructors
The [`Buffer`](@ref) construction is very similar to the construction of arrays in Julia. Just specify the mode, element type and length of the buffer. Here are some examples:
```@repl
using Jusdl # hide
Buffer{Fifo}(2, 5)
Buffer{Cyclic}(2, 10)
Buffer{Lifo}(Bool, 2, 5)
Buffer(5)
```
## Writing Data into Buffers
Writing data into a [`Buffer`](@ref) is done with [`write!`](@ref) function. Recall that when the buffer is full, no more data can be written into the buffer if the buffer mode is of type `LinearMode`.
```@repl
using Jusdl # hide
normalbuf = Buffer{Normal}(3)
foreach(item -> write!(normalbuf, item), 1:3)
normalbuf
write!(normalbuf, 4.)
```
This situation is the same for `Lifo` and `Fifo` buffers, but not the case for `Cyclic` buffer.
```@repl
using Jusdl # hide
cyclicbuf = Buffer{Cyclic}(3)
foreach(item -> write!(cyclicbuf, item), 1:3)
cyclicbuf
write!(cyclicbuf, 3.)
write!(cyclicbuf, 4.)
```
## Reading Data from Buffers
Reading data from a `Buffer` is done with [`read`](@ref) function.
```@repl
using Jusdl # hide
nbuf, cbuf, fbuf, lbuf = Buffer{Normal}(5), Buffer{Cyclic}(5), Buffer{Lifo}(5), Buffer{Fifo}(5)
foreach(buf -> foreach(item -> write!(buf, item), 1 : 5), [nbuf, cbuf, fbuf, lbuf])
for buf in [nbuf, cbuf, fbuf, lbuf]
@show buf
for i in 1 : 5
@show read(buf)
end
end
```
## AbstractArray Interface of Buffers
A `Buffer` can be indexed using the similar syntax of arrays in Julia. That is, `getindex` and `setindex!` methods can be used with known Julia syntax. i.e. `getindex(buf, idx)` is equal to `buf[idx]` and `setindex(buf, val, idx)` is equal to `buf[idx] = val`.
```@repl
using Jusdl # hide
buf = Buffer(5)
size(buf)
length(buf)
for val in 1 : 5
write!(buf, 2val)
end
buf[1]
buf[3:4]
buf[[3, 5]]
buf[end]
buf[1] = 5
buf[3:5] = [7, 8, 9]
```
## Full API
```@autodocs
Modules = [Jusdl]
Pages = ["buffer.jl"]
Order = [:type, :function]
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 2160 | # Callback
`Callback`s are used to monitor the existence of a specific event and if that specific event occurs, some other special jobs are invoked. `Callback`s are intended to provide additional monitoring capability to any user-defined composite types. As such, `Callback`s are *generally* fields of user defined composite types. When a `Callback` is called, if the `Callback` is enabled and its `condition` function returns true, then its `action` function is invoked.
## A Simple Example
Let's define a test object first that has a field named `x` of type `Int` and named `callback` of type `Callback`.
```julia
julia> mutable struct TestObject
x::Int
callback::Callback
end
```
To construct an instance of `TestObject`, we need to construct a `Callback`. For that purpose, the `condition` and `action` function must be defined. For this example, `condition` checks whether the `x` field is positive, and `action` prints a simple message saying that the `x` field is positive.
```julia
julia> condition(testobject) = testobject.x > 0
condition (generic function with 1 method)
julia> action(testobject) = println("testobject.x is greater than zero")
action (generic function with 1 method)
```
Now a test object can be constructed
```julia
julia> testobject = TestObject(-1, Callback(condition, action))
TestObject(-1, Callback{typeof(condition),typeof(action)}(condition, action, true, "dac6f9eb-6daa-4622-a8fa-623f0f88780c"))
```
If the callback is called, no action is performed since the `condition` function returns false. Note the argument sent to the callback. The instance of the `TestObject` to which the callback is bound.
```julia
julia> testobject.callback(testobject)
```
Now mutate the test object so that `condition` returns true.
```julia
julia> testobject.x = 3
3
```
Now, if the callback is called, since the `condition` returns true and the callback is `enabled`, the `action` is invoked.
```julia
julia> testobject.callback(testobject)
testobject.x is greater than zero
```
## Full API
```@docs
Callback
```
```@autodocs
Modules = [Jusdl]
Pages = ["callback.jl"]
Order = [:type, :function]
``` | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 8677 | # Modeling
Jusdl adopts signal-flow approach in modeling systems. Briefly, in the signal-flow approach a model consists of components and connections. The simulation of the model is performed in a clocked simulation environment. That is, the model is not simulated in one shot by solving a huge mathematical equation, but instead is simulated by evolving the components individually and in parallel in different sampling intervals.
The components interact with each other through the connections that are bound to their port. The components are data processing units, and it is the behavior of the component that determines how the data is processed. The component behavior is defined by the mathematical equations obtained as a result of the physical laws that the physical quantities used in the modeling of the component must comply. Depending upon the nature of the system and the modeling, these equations may change, i.e. they may or may not contain derivative terms, or they may contain the continuous time or discrete time variable, etc. The data-flow through the connections is unidirectional, i.e., a component is driven by other components that write data to its input port.
Model simulation is performed by evolving the components individually. To make the components have a common time base, a common clock is used. The clock generates pulses at simulation sampling intervals. These pulses are used to trigger the components during the run stage of the simulation. Each component that is triggered reads its input data from its input port, calculates its output, and writes its output to its output port.
```@raw html
<center>
<img src="../../assets/Model/model.svg" alt="model" width="50%"/>
</center>
```
## Components
The component types in Jusdl are shown in the figure below together with output and state equations. The components can be grouped as sources, sinks, and systems.
The sources are components that generate signals as functions of time. Having been triggered, a source computes its output according to its output function and writes it to its output port. The sources do not have input ports as their outputs depend only on time.
The sinks are data processing units. Their primary objective is to process the data flowing through the connections of the model online. Having been triggered, a sink reads its input data and processes them, i.e. data can be visualized by being plotted on a graphical user interface, can be observed by being printed on the console, can be stored on data files. The data processing capability of the sinks can be enriched by integrating new plugins that can be developed using the standard Julia library or various available Julia packages. For example, invariants, spectral properties, or statistical information can be derived from the data, parameter estimation can be performed or various signal processing techniques can be applied to the data. Jusdl has been designed to be flexible enough to allow one to enlarge the scope of its available plugins by integrating newly-defined ones.
```@raw html
<center>
<img src="../../assets/Components/components.svg" alt="model" width="85%"/>
</center>
```
As the output of a static system depends on input and time, a static system is defined by an output equation. Having been triggered, a static system reads its input data, calculates its output, and writes it to its output port. In dynamical systems, however, system behavior is characterized by states and output of a dynamical system depends on input, previous state and time. Therefore, a dynamical system is defined by a state equation and an output equation. When triggered, a dynamical system reads its input, updates its state according to its state equation, calculates its output according to its output equation, and writes its output to its output port. Jusdl is capable of simulating the dynamical systems with state equations in the form of the ordinary differential equation(ODE), differential-algebraic equation(DAE), random ordinary differential equation(RODE), stochastic differential equation(SDE), delay differential equation(DDE) or discrete difference equation. Most of the available simulation environments allow the simulation of systems represented by ordinary differential equations or differential-algebraic equations. Therefore, analyzes such as noise analysis, delay analysis or random change of system parameters cannot be performed in these simulation environments. On the contrary, Jusdl makes it possible for all these analyses to be performed owing to its ability to solve such a wide range of state equations.
## Ports and Connections
A port is actually a bunch of pins to which the connections are bound. There are two types of pins: an output pin that transfers data from the inside of the component to its outside, and an input pin that transfers data from the outside of component to its inside. Hence, there are two types of ports: an output port that consists of output pins and input port that consists of input pins.
The data transferred to a port is transferred to its connection(or connections as an output port may drive multiple connections). The data transfer through the connections is performed over the links of the connections. The links are built on top Julia channels.The data written to(read from) a link is written to(read from) the its channel. Active Julia tasks that are bound to channels must exist for data to flow over these channels. Julia tasks are control flow features that allow calculations to be flexibly suspended and maintained without directly communicating the task scheduler of the operating system. Communication and data exchange between the tasks are carried out through Julia channels to which they are bound.
```@raw html
<head>
<style>
* {
box-sizing: border-box;
}
.column {
float: left;
width: 33.33%;
padding: 5px;
}
/* Clearfix (clear floats) */
.row::after {
content: "";
clear: both;
display: table;
}
/* Responsive layout - makes the three columns stack on top of each other instead of next to each other */
@media screen and (max-width: 500px) {
.column {
width: 100%;
}
}
</style>
</head>
<body>
<div class="row">
<div class="column">
<img src="../../assets/Tasks/reader_task.svg" alt="reader_task" style="width:45%">
</div>
<div class="column">
<img src="../../assets/Tasks/writer_task.svg" alt="writer_task" style="width:45%">
</div>
<div class="column">
<img src="../../assets/Tasks/reader_writer_task.svg" alt="reader_writer_task" style="width:75%">
</div>
</div>
</body>
```
In the figure above is shown symbolically the tasks that must be bound to the channel to make a channel readable, writable and both readable and writable. The putter and the taker task is the task that writes data to and reads data from the channel, respectively. To be able to read data from one side of the channel, an active putter task must be bound to the channel at the other side of the channel, and the channel is called a readable channel. Similarly, to be able to write data to one side of the channel, an active taker task must be bound to the channel on the other side, and the channel is called a writable channel. If both active putter and taker tasks are bound to either side of the channel, then the data can both be read from and written to the channel, and the channel is called both readable and writable channel. The data-flow through the channel is only achieved if the channel is both readable and writable channels. The data read from a readable channel is the data written to the channel by the putter task of the channel. If data has not been written yet to the channel by the putter task of the channel during a reading process, then reading does not occur and the putter task is waited to put data to the channel. Similarly, if the data on the channel has not been read yet from the channel by the taker task during a writing process, then the taker task is waited to take data from the channel.
In the modeling approach adopted, the components reading data from a connection are driven by other components writing data to the connection. Therefore, all of the connections of the model must be both readable and writable connections so that data can flow the connections. This means that all the connections of the model must be connected to a component from both ends. Otherwise, the simulation gets stuck and does not end during a reading process from a channel that is not connected to a component. | Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 5663 | # [Simulation](@id section)
A model to be simulated consists of components connected to each other and a time reference. The time reference is used to sample the continuous-time signals flowing through the connections of the model and to trigger the components. The simulation is performed by triggering the components with pulses generated by the time reference at simulation sampling time intervals. Having been triggered, the components evolve themselves, compute their outputs, and writes them to their output ports.
```@raw html
<center>
<img src="../../assets/FlowChart/flowchart.svg" alt="model" width="60%"/>
</center>
```
The simulation stages are shown in the flow chart in the figure above. Performing, inspecting, and reporting of all the stages of the simulation is carried out automatically without requiring any user intervention.
In the first stage, the model is inspected to see if there are connections having any unconnected terminals. If a connection having an unconnected terminal is detected, the simulation is terminated at this stage. Another case where the model is not suitable for simulation is when algebraic loops exist. For example, almost every feedback system model includes algebraic loops. An algebraic loop is a closed-loop consisting of one or more components whose outputs are directly dependent on their inputs. The simulation does not continue because none of the components in the loop can generate output to break the loop. Such a problem can be broken by rearranging the model without algebraic loops, solving the feed-forward algebraic equation of the loop, or inserting a memory component with a certain initial condition anywhere in the loop. Jusdl provides all these loop-breaking solutions. During the inspection stage, in case they are detected, all the loops are broken. Otherwise, a report is printed to notify the user to insert memory components to break the loops.
In case the inspection phase results positive, the putter and taker tasks are launched in order to ensure the data flow through the model connections. At this point, a putter and a taker task are bound to each connection. For example, in the figure below(on the left) is given an example model section consisting of components B1, B and the connections L1, L2, L3. When triggered, the B1 reads data from L1 calculates its output and writes to L2. Similarly, when triggered B2
reads data from the L2, calculates its output, and writes to the L3. The tasks that are bounded to L1, L2, and L3 corresponding to B1 and B2 are shown in the figure below(on the right). Since B1 reads the data from L1 and writes data to L2, a taker task is bounded to L1 and a putter task is bounded L2. Similarly, since B2 reads the data from L2 and writes data to L3, a taker task is bounded to L2 and a putter task is bounded L3. Since both a putter and a taker task are bound to the L2, data can flow from B1 to B2 through L2. A task manager is constructed to check whether the tasks launched during the initialization stage are active or not throughout the simulation and to report the error in case an error occurs.
```@raw html
<head>
<style>
* {
box-sizing: border-box;
}
.column {
float: left;
width: 50%;
padding: 5px;
}
/* Clearfix (clear floats) */
.row::after {
content: "";
clear: both;
display: table;
}
/* Responsive layout - makes the three columns stack on top of each other instead of next to each other */
@media screen and (max-width: 500px) {
.column {
width: 100%;
}
}
</style>
</head>
<body>
<div class="row">
<div class="column">
<img src="../../assets/TaskForComponents/components.svg" alt="components" style="width:70%">
</div>
<div class="column">
<img src="../../assets/TaskForComponents/tasks.svg" alt="tasks" style="width:100%">
</div>
</div>
</body>
```
The initialization stage is followed by the run the stage. The tasks that are launched corresponding to the components during the initialization stage expect the components to be triggered through their trigger pins. These triggers are generated in the sampling intervals of the simulation by the model clock during the run stage. It is possible to sample the signals of flowing through the connections at equal or independent time intervals. The generated triggers are put into the trigger pins of the components. The task corresponding to a triggered component is defined as reading data from the input of the component, calculating the output of the component, and writing to the output port.
When the run stage is completed, the tasks launched at the initialization stage are closed and the simulation is ended.
!!! note
In some simulation environments, a unified mathematical equation representing the model as a whole is obtained and solved in just a single shot for the entire simulation duration, even if the model is thought to consist of components]. In Jusdl, a model is, again, thought to consist of components, but is not represented by a unified mathematical equation. Instead, the model is evolved by evolving the components individually by solving their own mathematical equations. The components do not evolve in one shot, but instead, they evolve in parallel during the time intervals between subsequent sampling instants. Here, it worths noting that the type of the mathematical equations of the components of a model does not have to be the same. Thus, Jusdl allows the simulation of the models consisting of components represented by different types of mathematical equations.
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 6302 | # Breaking Algebraic Loops
It this tutorial, we will simulate model consisting a closed loop feedback system. The model has an algebraic loop.
## Algebraic Loops
An algebraic loop is a closed-loop consisting of one or more components whose outputs are directly dependent on their inputs. If algebraic loops exist in a model, the simulation gets stuck because none of the components in the loop can generate output to break the loop. Such a problem can be broken by rearranging the model without algebraic loops, solving the feed-forward algebraic equation of the loop, or inserting a memory component with a certain initial condition anywhere in the loop. Jusdl provides all these loop-breaking solutions. During the inspection stage, in case they are detected, all the loops are broken. Otherwise, a report is printed to notify the user to insert memory components to break the loops.
## Breaking Algebraic Loops Automatically
Before initializing and running the simulation, Jusdl inspects the model first. See [Simulation Stages](@ref) for more information of simulation stages. In case the they exist in the model, all the algebraic loops are tried to be broken automatically without requiring a user intervention. Consider the following model
```@raw html
<center>
<img src="../../assets/AlgebraicLoop/algebraicloop.svg" alt="model" width="65%"/>
</center>
```
where
```math
\begin{array}{l}
r(t) = t \\[0.25cm]
u(t) = r(t) - y(t) \\[0.25cm]
y(t) = u(t)
\end{array}
```
Note that there exist an algebraic loop consisting of `adder` and `gain`. Solving this algebraic loop, we have
```math
y(t) = u(t) = r(t) - y(t) \quad \Rightarrow \quad y(t) = \dfrac{r(t)}{2} = \dfrac{t}{2}
```
The following script constructs and simulates the model.
```@example breaking_algebraic_loops_ex
using Jusdl
# Describe the model
@defmodel model begin
@nodes begin
gen = RampGenerator()
adder = Adder(signs=(+,-))
gain = Gain()
writerout = Writer()
writerin = Writer()
end
@branches begin
gen[1] => adder[1]
adder[1] => gain[1]
gain[1] => adder[2]
gen[1] => writerin[1]
gain[1] => writerout[1]
end
end
# Simulate the model
ti, dt, tf = 0., 1. / 64., 1.
sim = simulate!(model, ti, dt, tf, withbar=false)
# Read the simulation data and plot
using Plots
t, y = read(getnode(model, :writerout).component)
t, r = read(getnode(model, :writerin).component)
plot(t, r, label="r(t)", marker=(:circle, 3))
plot!(t, y, label="y(t)", marker=(:circle, 3))
savefig("breaking_algebraic_loops_plot1.svg"); nothing # hide
```
## Breaking Algebraic Loops With a Memory
It is also possible to break algebraic loops by inserting a [`Memory`](@ref) component at some point the loop. For example, consider the model consider following the model which is the model in which a memory component is inserted in the feedback path.
```@raw html
<center>
<img src="../../assets/AlgebraicLoopWithMemory/algebraicloopwithmemory.svg" alt="model" width="80%"/>
</center>
```
Note that the input to `adder` is not ``y(t)``, but instead is ``\hat{y}(t)`` which is one sample delayed form of ``y(t)``. That is, we have, ``\hat{y}(t) = y(t - dt)`` where ``dt`` is the step size of the simulation. If ``dt`` is small enough, ``\hat{y}(t) \approx y(t)``.
The script given below simulates this case.
```@example breaking_algebraic_loops_with_memory
using Jusdl
# Simulation time settings.
ti, dt, tf = 0., 1. / 64., 1.
# Describe the model
@defmodel model begin
@nodes begin
gen = RampGenerator()
adder = Adder(signs=(+,-))
gain = Gain()
writerout = Writer()
writerin = Writer()
mem = Memory(delay=dt, initial=zeros(1))
end
@branches begin
gen[1] => adder[1]
adder[1] => gain[1]
gain[1] => mem[1]
mem[1] => adder[2]
gen[1] => writerin[1]
gain[1] => writerout[1]
end
end
# Simulate the model
sim = simulate!(model, ti, dt, tf, withbar=false)
# Plot the simulation data
using Plots
t, r = read(getnode(model, :writerin).component)
t, y = read(getnode(model, :writerout).component)
plot(t, r, label="r(t)", marker=(:circle, 3))
plot!(t, y, label="y(t)", marker=(:circle, 3))
savefig("breaking_algebraic_loops_with_memory_plot1.svg"); nothing # hide
```
The fluctuation in ``y(t)`` because of one-sample-time delay introduced by the `mem` component is apparent. The smaller the step size is, the smaller the amplitude of the fluctuation introduced by the `mem` component.
One other important issue with using the memory component is that the initial value of `mem` directly affects the accuracy of the simulation. By solving the loop equation, we know that
```math
y(t) = \dfrac{r(t)}{2} = \dfrac{t}{2} \quad \Rightarrow \quad y(0) = 0
```
That is the memory should be initialized with an initial value of zero, which is the case in the script above. To observe that how incorrect initialization of a memory to break an algebraic loop, consider the following example in which memory is initialized randomly.
```@example breaking_algebraic_loops_with_memory_incorrect_initialization
using Jusdl
using Plots
# Simulation time settings.
ti, dt, tf = 0., 1. / 64., 1.
# Describe the model
@defmodel model begin
@nodes begin
gen = RampGenerator()
adder = Adder(signs=(+,-))
gain = Gain()
writerout = Writer()
writerin = Writer()
mem = Memory(delay=dt, initial=rand(1))
end
@branches begin
gen[1] => adder[1]
adder[1] => gain[1]
gain[1] => mem[1]
mem[1] => adder[2]
gen[1] => writerin[1]
gain[1] => writerout[1]
end
end
# Simulate the model
sim = simulate!(model, ti, dt, tf, withbar=false)
# Plot the results
using Plots
t, r = read(getnode(model, :writerin).component)
t, y = read(getnode(model, :writerout).component)
plot(t, r, label="r(t)", marker=(:circle, 3))
plot!(t, y, label="y(t)", marker=(:circle, 3))
savefig("breaking_algebraic_loops_with_memory_incorrect_plot1.svg"); nothing # hide
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 3765 | # Coupled Systems
Consider two coupled [`LorenzSystem`](@ref)s. The first system evolves by
```math
\begin{array}{l}
\dot{x}_{1,1} = \sigma (x_{1,2} - x_{1,1}) + \epsilon (x_{2,1} - x_{1,1}) \\[0.25cm]
\dot{x}_{1,2} = x_{1,1} (\rho - x_{1,3}) - x_{1,2} \\[0.25cm]
\dot{x}_{1,3} = x_{1,1} x_{1,2} - \beta x_{1,3}
\end{array}
```
and the second one evolves by
```math
\begin{array}{l}
\dot{x}_{2,1} = \sigma (x_{2,2} - x_{2,1}) + \epsilon (x_{1,1} - x_{2,1}) \\[0.25cm]
\dot{x}_{2,2} = x_{2,1} (\rho - x_{2,3}) - x_{2,2} \\[0.25cm]
\dot{x}_{2,3} = x_{2,1} x_{2,2} - \beta x_{2,3}
\end{array}
```
where ``x_1 = [x_{1,1}, x_{1,2}, x_{1,3}]``, ``x_2 = [x_{2,1}, x_{2,2}, x_{2,3}]`` are the state vectors of the first and second system, respectively. The coupled system can be written more compactly as,
```math
\begin{array}{l}
\dot{X} = F(X) + \epsilon (A ⊗ P) X
\end{array}
```
where ``X = [x_{1}, x_{2}]``, ``F(X) = [f(x_{1}), f(x_{2})]``,
```math
A = \begin{bmatrix}
-1 & 1 \\
1 & -1 \\
\end{bmatrix}
```
```math
P = \begin{bmatrix}
1 & 0 & 0 \\
0 & 0 & 0 \\
0 & 0 & 0 \\
\end{bmatrix}
```
and ``f`` is the Lorenz dynamics given by
```math
\begin{array}{l}
\dot{x}_1 = \sigma (x_2 - x_1) \\[0.25cm]
\dot{x}_2 = x_1 (\rho - x_3) - x_2 \\[0.25cm]
\dot{x}_3 = x_1 x_2 - \beta x_3
\end{array}
```
The script below constructs and simulates the model
```@example coupled_system
using Jusdl
# Describe the model
ε = 10.
@defmodel model begin
@nodes begin
ds1 = ForcedLorenzSystem()
ds2 = ForcedLorenzSystem()
coupler = Coupler(conmat=ε*[-1 1; 1 -1], cplmat=[1 0 0; 0 0 0; 0 0 0])
writer = Writer(input=Inport(6))
end
@branches begin
ds1[1:3] => coupler[1:3]
ds2[1:3] => coupler[4:6]
coupler[1:3] => ds1[1:3]
coupler[4:6] => ds2[1:3]
ds1[1:3] => writer[1:3]
ds2[1:3] => writer[4:6]
end
end
nothing # hide
```
To construct the model, we added `ds1` and `ds2` each of which has input ports of length 3 and output port of length 3. To couple them together, we constructed a `coupler` which has input port of length 6 and output port of length 6. The output port of `ds1` is connected to the first 3 pins of `coupler` input port, and the output of `ds2` is connected to last 3 pins of `coupler` input port. Then, the first 3 pins of `coupler` output is connected to the input port of `ds1` and last 3 pins of `coupler` output is connected to the input port of `ds2`. The block diagram of the model is given below.
```@raw html
<center>
<img src="../../assets/CoupledSystem/coupledsystem.svg" alt="model" width="60%"/>
</center>
```
The the signal-flow graph of the model has 4 directed branches and each of these branches has 3 links.
It also worths pointing out that the model has two algebraic loops. The first loop consists of `ds1` and `coupler`, and the second loop consists of `ds2` and `coupler`. During the simulation these loops are broken automatically without requiring any user intervention.
The model is ready for simulation. The code block below simulates the model and plots the simulation data.
```@example coupled_system
using Plots
# Simulation settings.
ti, dt, tf = 0, 0.01, 100.
# Simulate the model
simulate!(model, ti, dt, tf, withbar=false)
# Read simulation data
t, x = read(getnode(model, :writer).component)
# Compute errors
err = x[:, 1] - x[:, 4]
# Plot the results.
p1 = plot(x[:, 1], x[:, 2], label="ds1")
p2 = plot(x[:, 4], x[:, 5], label="ds2")
p3 = plot(t, err, label="err")
plot(p1, p2, p3, layout=(3, 1))
savefig("coupled_systems_plot.svg"); nothing # hide
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 12341 | # Defining New Component Types
Jusdl provides a library that includes some well-known components that are ready to be used. For example,
* [`FunctionGenerator`](@ref), [`SinewaveGenerator`](@ref), [`SquarewaveGenerator`](@ref), [`RampGenerator`](@ref), etc. as sources
* [`StaticSystem`](@ref), [`Adder`](@ref), [`Multiplier`](@ref), [`Gain`](@ref), etc. as static systems
* [`DiscreteSystem`](@ref), [`DiscreteLinearSystem`](@ref), [`HenonSystem`](@ref), [`LogisticSystem`](@ref), etc. as dynamical systems represented by discrete difference equations.
* [`ODESystem`](@ref), [`LorenzSystem`](@ref), [`ChenSystem`](@ref), [`ChuaSystem`](@ref), etc. as dynamical systems represented by ODEs.
* [`DAESystem`](@ref), [`RobertsonSystem`](@ref), etc. as dynamical systems represented by dynamical systems represented by DAEs.
* [`RODESystem`](@ref), [`MultiplicativeNoiseLinearSystem`](@ref), etc. as dynamical systems represented by dynamical systems represented by RODEs.
* [`SDESystem`](@ref), [`NoisyLorenzSystem`](@ref), [`ForcedNoisyLorenzSystem`](@ref), etc. as dynamical systems represented by dynamical systems represented by SDEs.
* [`DDESystem`](@ref), [`DelayFeedbackSystem`](@ref), etc. as dynamical systems represented by dynamical systems represented by DDEs.
* [`Writer`](@ref), [`Printer`](@ref), [`Scope`](@ref), etc. as sinks.
It is very natural that this library may lack some of the components that are wanted to be used by the user. In such a case, Jusdl provides the users with the flexibility to enrich this library. The users can define their new component types, including source, static system, dynamical system, sink and use them with ease.
### Defining A New Source
New source types are defines using [`@def_source`](@ref) macro. Before embarking on defining new source, let us get the necessary information on how to use `@def_source`. This can be can be obtained through its docstrings.
```@repl defining_new_components_ex
using Jusdl # hide
@doc @def_source
```
From the docstring, its clear that new types of source can be defined as if we define a new Julia type. The difference is that the `struct` keyword is preceded by `@def_source` macro and the new component must be a subtype of [`AbstractSource`](@ref). Also from the docstring is that the new type has some optional and mandatory fields.
!!! warning
To define a new source, mandatory fields must be defined. The optional fields are the parameters of the source.
For example let us define a new source that generates waveforms of the form.
```math
y(t) =
\begin{bmatrix}
\alpha sin(t) \\
\beta cos(t)
\end{bmatrix}
```
Here ``\alpha`` and ``beta`` is the system parameters. That is, while defining the new source component, ``\alpha`` and ``\beta`` are optional fields. `readout` and ``output`` are the mandatory field while defining a source. Note from above equation that the output of the new source has two pins. Thus, this new source component type, say `MySource` is defined as follows.
```@repl defining_new_components_ex
@def_source struct MySource{RO, OP} <: AbstractSource
α::Float64 = 1.
β::Float64 = 2.
readout::RO = (t, α=α, β=β) -> [α*sin(t), β*cos(t)]
output::OP = Outport(2)
end
```
Note that the syntax is very similar to the case in which we define a normal Julia type. We start with `struct` keyword preceded with `@def_source` macro. In order for the `MySource` to work flawlessly, i.e. to be used a model component, it must a subtype of `AbstractSource`. The `readout` function of `MySource` is a function of `t` and the remaining parameters, i.e., ``\alpha`` and ``\beta``, are passed into as optional arguments to avoid global variables.
One other important point to note is that the `MySource` has additional fields that are required for it to work as a regular model component. Let us print all the field names of `MySource`,
```@repl defining_new_components_ex
fieldnames(MySource)
```
We know that we defined the fields `α, β, readout, output`, but, the fields `trigger, callback, handshake, callbacks, name, id` are defined automatically by `@def_source` macro.
Since the type `MySource` has been defined, any instance of it can be constructed. Let us see the constructors first.
```@repl defining_new_components_ex
methods(MySource)
```
The constructor with the keyword arguments is very much easy to uses.
```@repl defining_new_components_ex
gen1 = MySource()
gen2 = MySource(α=4.)
gen3 = MySource(α=4., β=5.)
gen3 = MySource(α=4., β=5., name=:mygen)
gen3.trigger
gen3.id
gen3.α
gen3.β
gen3.output
```
An instance works flawlessly as a model component, that is, it can be driven from its `trigger` pin and signalling cane be carried out from its `handshake` pin. To see this, let us construct required pins and ports to drive a `MySource` instance.
```@repl defining_new_components_ex
gen = MySource() # `MySource` instance
trg = Outpin() # To trigger `gen`
hnd = Inpin{Bool}() # To signalling with `gen`
iport = Inport(2) # To take values out of `gen`
connect!(trg, gen.trigger);
connect!(gen.handshake, hnd);
connect!(gen.output, iport);
launch(gen) # Launch `gen,
```
Now `gen` can be driven through `trg` pin.
```@repl defining_new_components_ex
put!(trg, 1.) # Drive `gen` for `t=1`.
take!(iport) # Read output of `gen` from `iport`
take!(hnd) # Approve `gen` has taken a step.
```
Thus, by using `@def_source` macro, it is possible for the users to define any type of sources under `AbstractSource` type and user them without a hassle.
The procedure is again the same for any other component types. The table below lists the macros that are used to define new component types.
| Macro | Component Type | Supertype | Mandatory Field Names |
| ----------- | ----------- | ----------------------------- | -------------------- |
| [`@def_source`](@ref) | Source |[`AbstractSource`](@ref) | `readout`, `output` |
| [`@def_static_system`](@ref) | StaticSystem |[`AbstractStaticSystem`](@ref) |`readout`, `output`, `input` |
| [`@def_discrete_system`](@ref) | Discrete Dynamic System |[`AbstractDiscreteSystem`](@ref) |`righthandside`, `readout`, `state`, `input`, `output` |
| [`@def_ode_system`](@ref) | ODE Dynamic System |[`AbstractODESystem`](@ref) | `righthandside`, `readout`, `state`, `input`, `output` |
| [`@def_dae_system`](@ref) | DAE Dynamic System |[`AbstractDAESystem`](@ref) | `righthandside`, `readout`, `state`, `stateder`, `diffvars`, `input`, `output` |
| [`@def_rode_system`](@ref) | RODE Dynamic System |[`AbstractRODESystem`](@ref) | `righthandside`, `readout`, `state`, `input`, `output` |
| [`@def_sde_system`](@ref) | SDE Dynamic System |[`AbstractSDESystem`](@ref) | `drift`, `diffusion`, `readout`, `state`, `input`, `output` |
| [`@def_dde_system`](@ref) | DDE Dynamic System |[`AbstractDDESystem`](@ref) | `constlags`, `depslags`, `righthandside`, `history`, `readout`, `state`, `input`, `output` |
| [`@def_sink`](@ref) | Sink |[`AbstractSink`](@ref) | `action` |
The steps followed in the previous section are the same to define other component types: start with suitable macro given above, make the newly-defined type a subtype of the corresponding supertype, define the optional fields (if exist) ands define the mandatory fields of the new type (with the default values if necessary).
### Defining New StaticSystem
Consider the following readout function of the static system to be defined
```math
y = u_1 t + a cos(u_2)
```
where ``u = [u_1, u_2]`` is the input, ``y`` is the output of the system and ``t`` is time. The system has two inputs and one output. This system can be defined as follows.
```@repl defining_new_components_ex
@def_static_system struct MyStaticSystem{RO, IP, OP} <: AbstractStaticSystem
a::Float64 = 1.
readout::RO = (t, a = a) -> u[1] * t + a * cos(u[2])
input::IP = Inport(2)
output::OP = Outport(1)
end
```
### Defining New Discrete Dynamical System
The discrete dynamical system given by
```math
\begin{array}{l}
x_{k + 1} = α x_k + u_k \\[0.25cm]
y_k = x_k
\end{array}
```
can be defined as,
```@repl defining_new_components_ex
@def_discrete_system struct MyDiscreteSystem{RH, RO, IP, OP} <: AbstractDiscreteSystem
α::Float64 = 1.
β::Float64 = 2.
righthandside::RH = (dx, x, u, t, α=α) -> (dx[1] = α * x[1] + u[1](t))
readout::RO = (x, u, t) -> x
input::IP = Inport(1)
output::OP = Outport(1)
end
```
### Defining New ODE Dynamical System
The ODE dynamical system given by
```math
\begin{array}{l}
\dot{x} = α x + u \\[0.25cm]
y = x
\end{array}
```
can be defined as,
```@repl defining_new_components_ex
@def_ode_system struct MyODESystem{RH, RO, IP, OP} <: AbstractDiscreteSystem
α::Float64 = 1.
β::Float64 = 2.
righthandside::RH = (dx, x, u, t, α=α) -> (dx[1] = α * x[1] + u[1](t))
readout::RO = (x, u, t) -> x
input::IP = Inport(1)
output::OP = Outport(1)
end
```
### Defining New DAE Dynamical System
The DAE dynamical system given by
```math
\begin{array}
dx = x + 1 \\[0.25cm]
0 = 2(x + 1) + 2
\end{array}
```
can be defined as,
```@repl defining_new_components_ex
@def_dae_system mutable struct MyDAESystem{RH, RO, ST, IP, OP} <: AbstractDAESystem
righthandside::RH = function sfuncdae(out, dx, x, u, t)
out[1] = x[1] + 1 - dx[1]
out[2] = (x[1] + 1) * x[2] + 2
end
readout::RO = (x,u,t) -> x
state::ST = [1., -1]
stateder::ST = [2., 0]
diffvars::Vector{Bool} = [true, false]
input::IP = nothing
output::OP = Outport(1)
end
```
### Defining RODE Dynamical System
The RODE dynamical system given by
```math
\begin{array}{l}
\dot{x} = A x W \\[0.25cm]
y = x
\end{array}
```
where
```math
A = \begin{bmatrix}
2 & 0 \\
0 & -2
\end{bmatrix}
```
can be defined as,
```@repl defining_new_components_ex
@def_rode_system struct MyRODESystem{RH, RO, IP, OP} <: AbstractRODESystem
A::Matrix{Float64} = [2. 0.; 0 -2]
righthandside::RH = (dx, x, u, t, W) -> (dx .= A * x * W)
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(2)
input::IP = nothing
output::OP = Outport(2)
end
```
### Defining SDE Dynamical System
The RODE dynamical system given by
```math
\begin{array}{l}
dx = -x dt + dW \\[0.25cm]
y = x
\end{array}
```
can be defined as,
```@repl defining_new_components_ex
@def_sde_system mutable struct MySDESystem{DR, DF, RO, ST, IP, OP} <: AbstractSDESystem
drift::DR = (dx, x, u, t) -> (dx .= -x)
diffusion::DF = (dx, x, u, t) -> (dx .= 1)
readout::RO = (x, u, t) -> x
state::ST = [1.]
input::IP = nothing
output::OP = Outport(1)
end
```
### Defining DDE Dynamical System
The DDE dynamical system given by
```math
\begin{array}{l}
\dot{x} = -x(t - \tau) \quad t \geq 0 \\
x(t) = 1. -\tau \leq t \leq 0 \\
\end{array}
```
can be defined as,
```@repl defining_new_components_ex
_delay_feedback_system_cache = zeros(1)
_delay_feedback_system_tau = 1.
_delay_feedback_system_constlags = [1.]
_delay_feedback_system_history(cache, u, t) = (cache .= 1.)
function _delay_feedback_system_rhs(dx, x, h, u, t,
cache=_delay_feedback_system_cache, τ=_delay_feedback_system_tau)
h(cache, u, t - τ) # Update cache
dx[1] = cache[1] + x[1]
end
@def_dde_system mutable struct DelayFeedbackSystem{RH, HST, RO, IP, OP} <: AbstractDDESystem
constlags::Vector{Float64} = _delay_feedback_system_constlags
depslags::Nothing = nothing
righthandside::RH = _delay_feedback_system_rhs
history::HST = _delay_feedback_system_history
readout::RO = (x, u, t) -> x
state::Vector{Float64} = rand(1)
input::IP = nothing
output::OP = Outport(1)
end
```
### Defining Sinks
Say we want a sink type that takes the data flowing through the connections of the model and prints it. This new sink type cane be defined as follows.
```@repl defining_new_components_ex
@def_sink struct MySink{A} <: AbstractSink
action::A = actionfunc
end
actionfunc(sink::MySink, t, u) = println(t, u)
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 7789 | # [Model Construction](@id page_header)
This tutorial illustrates model construction and the relation between models and graphs. A model consists of components and connections. These components and connections can be associated with a signal-flow graph signifying the topology of the model. In the realm of graph theory, components and connections of a model are associated with nodes and branches of the signal-flow graph. As the model is modified by adding or deleting components or connections, the signal-flow graph of the model is modified accordingly to keep track of topological modifications. By associating a signal-flow graph to a model, any graph-theoretical analysis can be performed. An example to such an analysis is the determination and braking of algebraic loops.
In Jusdl, a model can be constructed either by describing it in one-shot or by gradually modifying it by adding new nodes and branches. To show the relation between models and graphs, we start with the latter.
## [Modifying Models](@id section_header)
In this tutorial, we construct the model with the following block diagram
```@raw html
<center>
<img src="../../assets/SimpleModel/simplemodel.svg" alt="model" width="60%"/>
</center>
```
and with the following signal-flow graph
```@raw html
<center>
<img src="../../assets/SignalFlow/signalflow.svg" alt="model" width="50%"/>
</center>
```
Let's start with an empty [`Model`](@ref).
```@repl model_graph_example
using Jusdl # hide
model = Model()
```
We constructed an empty model, i.e., the model has no components and connections. To modify the model, we need to add components and connections to the model. As the model is grown by adding components and connections, the components and connections are added into the model as nodes and branches (see [`Node`](@ref), [`Branch`](@ref)). Let's add our first component, a [`SinewaveGenerator`](@ref) to the `model`.
```@repl model_graph_example
addnode!(model, SinewaveGenerator(), label=:gen)
```
To add components to the `model`, we use [`addnode!`](@ref) function. As seen, our node consists of a component, an index, and a label.
```@repl model_graph_example
node1 = model.nodes[1]
node1.component
node1.idx
node1.label
```
Let us add another component, a [`Adder`](@ref), to the model,
```@repl model_graph_example
addnode!(model, Adder(signs=(+,-)), label=:adder)
```
and investigate our new node.
```@repl model_graph_example
node2 = model.nodes[2]
node2.component
node2.idx
node2.label
```
Note that as new nodes are added to the `model`, they are given an index `idx` and a label `label`. The label is not mandatory, if not specified explicitly, `nothing` is assigned as label. The reason to add components as nodes is to access them through their node index `idx` or `labels`. For instance, we can access our first node by using its node index `idx` or node label `label`.
```@repl model_graph_example
getnode(model, :gen) # Access by label
getnode(model, 1) # Access by index
```
At this point, we have two nodes in our model. Let's add two more nodes, a [`Gain`](@ref) and a [`Writer`](@ref)
```@repl model_graph_example
addnode!(model, Gain(), label=:gain)
addnode!(model, Writer(), label=:writer)
```
As the nodes are added to the `model`, its graph is modified accordingly.
```@repl model_graph_example
model.graph
```
`model` has no connections. Let's add our first connection by connecting the first pin of the output port of the node 1 (which is labelled as `:gen`) to the first input pin of input port of node 2 (which is labelled as `:adder`).
```@repl model_graph_example
addbranch!(model, :gen => :adder, 1 => 1)
```
The node labelled with `:gen` has an output port having one pin, and the node labelled with `:adder` has an input port of two pins. In our first connection, we connected the first(and the only) pin of the output port of the node labelled with `:gen` to the first pin of the input port of the node labelled with `:adder`. The connections are added to model as branches,
```@repl model_graph_example
model.branches
```
A branch between any pair of nodes can be accessed through the indexes or labels of nodes.
```@repl model_graph_example
br = getbranch(model, :gen => :adder)
br.nodepair
br.indexpair
br.links
```
Note the branch `br` has one link(see [`Link`](@ref)). This is because we connected one pin to another pin. The branch that connects ``n`` pins to each other has `n` links. Let us complete the construction of the model by adding other connections.
```@repl model_graph_example
addbranch!(model, :adder => :gain, 1 => 1)
addbranch!(model, :gain => :adder, 1 => 2)
addbranch!(model, :gain => :writer, 1 => 1)
```
## Describing Models
The second approach is to describe the whole model. In this approach the model is constructed in single-shot. The syntax here is
```julia
@defmodel modelname begin
@nodes begin
label1 = Component1(args...; kwargs...) # Node 1
label2 = Component2(args...; kwargs...) # Node 2
⋮ ⋮
labelN = ComponentN(args...; kwargs...) # Node N
end
@branches begin
src_label1[src_index1] = dst_label1[dst_index1] # Branch 1
src_label2[src_index2] = dst_label1[dst_index2] # Branch 2
⋮ ⋮
src_labelM[src_indexM] = dst_labelM[dst_indexM] # Branch M
end
end
```
Note that `modelname` is the name of the model to be compiled. The nodes of the model is defined in `@nodes begin ... end` block and the branches of the model is defined in `@branches begin ... end`. The syntax `src_label1[src_index1] = dst_label1[dst_index1]` means that there is a branch between the node labelled with `src_label1` and the node labelled with `dst_label1`.And, this branch connects the pins indexed by `src_index1` of the output port of `src_label1` to the pins indexed by `dst_index1` of the input port of `dst_label1`. The indexing of the pins here is just like any one dimensional array indexing. That is `src_index1`( or `dst_index1`) may be integer, vector of integers, vector of booleans, range, etc.
For example, the model given above can also be constructed as follows
```@repl model_graph_example_def_model_macro
using Jusdl # hide
@defmodel model begin
@nodes begin
gen = SinewaveGenerator()
adder = Adder(signs=(+,-))
gain = Gain()
writer = Writer()
end
@branches begin
gen[1] => adder[1]
adder[1] => gain[1]
gain[1] => adder[2]
gain[1] => writer[1]
end
end
```
This macro is expanded to construct the `model`.
## Usage of Signal-Flow Graph
The signal-flow graph constructed alongside of the construction of the model can be used to perform any topological analysis. An example to such an analysis is the detection of algebraic loops. For instance, our model in this tutorial has an algebraic loop consisting of the nodes labelled with `:gen` and `gain`. This loop can be detected using the signal-flow graph of the node
```@repl model_graph_example
loops = getloops(model)
```
We have one loop consisting the nodes with indexes 2 and 3.
For further analysis on model graph, we use [`LightGraphs`](https://juliagraphs.org/LightGraphs.jl/stable/) package.
```@repl model_graph_example
using LightGraphs
graph = model.graph
```
For example, the adjacency matrix of model graph can be obtained.
```@repl model_graph_example
adjacency_matrix(model.graph)
```
or inneighbors or outneighbors of a node can be obtained.
```@repl model_graph_example
inneighbors(model.graph, getnode(model, :adder).idx)
outneighbors(model.graph, getnode(model, :adder).idx)
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.2.2 | 510eb782ce371063928a9ad7069cfd2acfee8114 | docs | 3953 | # Construction and Simulation of a Simple Model
In this tutorial, we will simulate a very simple model consisting of a generator and a writer as shown in the block diagram shown below.
```@raw html
<center>
<img src="../../assets/GeneratorWriter/generatorwriter.svg" alt="model" width="35%"/>
</center>
```
## Model Simulation
Let us construct the model first. See [Model Construction](@ref page_header) for more detailed information about model construction.
```@example simple_model_ex
using Jusdl
# Describe the model
@defmodel model begin
@nodes begin
gen = SinewaveGenerator()
writer = Writer()
end
@branches begin
gen => writer
end
end
nothing # hide
```
In this simple `model`, we have a single output sinusoidal wave generator `gen` and a `writer`. In the script above, we constructed the components, connected them together and constructed the model.
We can specify simulation settings such as whether a simulation log file is be to constructed, model components are to be saved in a file, etc.
```@example simple_model_ex
simdir = "/tmp"
logtofile = true
reportsim = true
nothing # hide
```
At this point, the model is ready for simulation.
```@example simple_model_ex
t0 = 0. # Start time
dt = 0.01 # Sampling interval
tf = 10. # Final time
sim = simulate!(model, t0, dt, tf, simdir=simdir, logtofile=logtofile, reportsim=reportsim)
```
## Investigation of Simulation
First, let us observe `Simulation` instance `sim`. We start with the directory in which all simulation files are saved.
```@example simple_model_ex
foreach(println, readlines(`ls -al $(sim.path)`))
```
The simulation directory includes a log file `simlog.log` which helps the user monitor simulation steps.
```@example simple_model_ex
# Print the contents of log file
open(joinpath(sim.path, "simlog.log"), "r") do file
for line in readlines(file)
println(line)
end
end
```
`report.jld2` file, which includes the information about the simulation and model components, can be read back after the simulation.
```@repl simple_model_ex
using FileIO, JLD2
filecontent = load(joinpath(sim.path, "report.jld2"))
clock = filecontent["model/clock"]
```
## Analysis of Simulation Data
After the simulation, the data saved in simulation data files, i.e. in the files of writers, can be read back any offline data analysis can be performed.
```@example simple_model_ex
# Read the simulation data
t, x = read(getnode(model, :writer).component)
# Plot the data
using Plots
plot(t, x, xlabel="t", ylabel="x", label="")
savefig("simple_model_plot.svg"); nothing # hide
```
## A Larger Model Simulation
Consider a larger model whose block diagram is given below
```@raw html
<center>
<img src="../../assets/ModelGraph/modelgraph.svg" alt="model" width="90%"/>
</center>
```
The script below illustrates the construction and simulation of this model
```@example large_model
using Jusdl
using Plots
# Construct the model
@defmodel model begin
@nodes begin
gen1 = SinewaveGenerator(frequency=2.)
gain1 = Gain()
adder1 = Adder(signs=(+,+))
gen2 = SinewaveGenerator(frequency=3.)
adder2 = Adder(signs=(+,+,-))
gain2 = Gain()
writer = Writer()
gain3 = Gain()
end
@branches begin
gen1[1] => gain1[1]
gain1[1] => adder1[1]
adder1[1] => adder2[1]
gen2[1] => adder1[2]
gen2[1] => adder2[2]
adder2[1] => gain2[1]
gain2[1] => writer[1]
gain2[1] => gain3[1]
gain3[1] => adder2[3]
end
end
# Simulation of the model
simulate!(model, withbar=false)
# Reading and plotting the simulation data
t, x = read(getnode(model, :writer).component)
plot(t, x)
savefig("larger_model_plot.svg"); nothing # hide
```
| Jusdl | https://github.com/zekeriyasari/Causal.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 7024 | #==========================================================================================
Constructors
==========================================================================================#
function DiaSymSemiseparableCholesky(U::AbstractArray, W::AbstractArray, ds::AbstractArray)
return DiaSymSemiseparableCholesky(size(U,1),size(U,2),U,W,ds)
end
function DiaSymSemiseparableCholesky(U::AbstractArray, V::AbstractArray, σn, σf)
n, p = size(U)
W, dbar = dss_create_wdbar(σf*U, σf*V, ones(n)*σn^2)
return DiaSymSemiseparableCholesky(n, p, σf*U, W, dbar)
end
function DiaSymSemiseparableCholesky(L::DiaSymSemiseparableMatrix)
W, dbar = dss_create_wdbar(L.Ut, L.Vt, L.d)
return DiaSymSemiseparableCholesky(L.n, L.p, L.Ut, W, dbar)
end
#==========================================================================================
Defining Matrix Properties
==========================================================================================#
Matrix(K::DiaSymSemiseparableCholesky) = getproperty(K,:L)
size(K::DiaSymSemiseparableCholesky) = (K.n, K.n)
size(K::DiaSymSemiseparableCholesky,d::Int) = (1 <= d && d <=2) ? size(K)[d] : throw(ArgumentError("Invalid dimension $d"))
function getindex(K::DiaSymSemiseparableCholesky, i::Int, j::Int)
i > j && return dot(K.Ut[:,i], K.Wt[:,j])
i == j && return K.d[i]
return 0
end
function getproperty(K::DiaSymSemiseparableCholesky, d::Symbol)
if d === :U
return UpperTriangular(triu(K.Wt'*K.Ut,1) + Diagonal(K.d))
elseif d === :L
return LowerTriangular(tril(K.Ut'*K.Wt,-1) + Diagonal(K.d))
else
return getfield(K, d)
end
end
Base.propertynames(F::DiaSymSemiseparableCholesky, private::Bool=false) =
(:U, :L, (private ? fieldnames(typeof(F)) : ())...)
function Base.show(io::IO, mime::MIME{Symbol("text/plain")},
K::DiaSymSemiseparableCholesky{<:Any,<:AbstractArray,<:AbstractArray,<:AbstractArray})
summary(io, K); println(io)
show(io, mime, K.L)
end
#==========================================================================================
Defining multiplication and inverse
==========================================================================================#
function mul!(y::AbstractArray, L::DiaSymSemiseparableCholesky, b::AbstractArray)
dss_tri_mul!(y, L.Ut, L.Wt, L.d, b)
return y
end
function mul!(y::AbstractArray, L::Adjoint{<:Any,<:DiaSymSemiseparableCholesky}, b::AbstractArray)
dssa_tri_mul!(y, L.parent.Ut, L.parent.Wt, L.parent.d, b)
return y
end
function inv!(y::AbstractArray, L::DiaSymSemiseparableCholesky, b::AbstractArray)
dss_forward!(y, L.Ut, L.Wt, L.d, b)
return y
end
function inv!(y::AbstractArray, L::Adjoint{<:Any,<:DiaSymSemiseparableCholesky}, b::AbstractArray)
dssa_backward!(y, L.parent.Ut, L.parent.Wt, L.parent.d, b)
return y
end
#### Inverse of a EGRQSCholesky using the Cholesky factorization ####
function inv(L::DiaSymSemiseparableCholesky)
return L'\(L\Diagonal(ones(L.n)))
end
function inv(L::DiaSymSemiseparableCholesky, b::AbstractArray)
return L'\(L\b)
end
#==========================================================================================
Relevant Linear Algebra Routines
==========================================================================================#
function fro_norm_L(L::DiaSymSemiseparableCholesky)
return sum(squared_norm_cols(L.Ut, L.Wt, L.d))
end
function trinv(L::DiaSymSemiseparableCholesky)
dbar = L.d
Y, Z = dss_create_yz(L.Ut, L.Wt, dbar)
return sum(squared_norm_cols(Y,Z, dbar.^(-1)))
end
function tr(L::DiaSymSemiseparableCholesky)
return sum(L.d)
end
function tr(Ky::DiaSymSemiseparableCholesky, K::SymSemiseparableMatrix)
p = Ky.p
c = Ky.d
U = K.Ut
V = K.Vt
Y, Z = dss_create_yz(Ky.Ut, Ky.Wt, Ky.d)
b = 0.0
P = zeros(p,p)
R = zeros(p,p)
@inbounds for k = 1:Ky.n
yk = @view Y[:,k]
zk = @view Z[:,k]
uk = @view U[:,k]
vk = @view V[:,k]
cki = c[k]^(-1)
b += yk'*P*yk + 2*yk'*R*uk*cki + uk'*vk*(cki^2)
P += ((uk'*vk)*zk)*zk' + zk*(R*uk)' + (R*uk)*zk'
R += zk*vk';
end
return b
end
#===========================================================================================
Choleskyesky factorization of Higher-order quasiseparable matrices
===========================================================================================#
"""
dss_create_wdbar(U, V, d)
Computes `W` and `dbar` such that, `L = tril(UW',-1) + diag(ds)`.
"""
function dss_create_wdbar(U, V, d)
m, n = size(U)
P = zeros(m, m)
W = zeros(m, n)
dbar = zeros(n)
for i = 1:n
tmpU = @view U[:,i]
tmpW = V[:,i] - P*tmpU
tmpds = sqrt(tmpU'*tmpW + d[i])
tmpW = tmpW/tmpds
W[:,i] = tmpW
dbar[i] = tmpds
P += tmpW*tmpW'
end
return W, dbar
end
#### Multiplying with Ld ####
function dss_tri_mul!(Y,U,W,ds,X)
m, n = size(U)
mx = size(X, 2)
Wbar = zeros(m, mx)
@inbounds for i = 1:n
tmpW = @view W[:,i]
tmpU = @view U[:,i]
tmpX = @view X[i:i,:]
Y[i,:] = tmpU'*Wbar + ds[i]*tmpX
Wbar += tmpW*tmpX
end
end
#### Adjoint of Ld ####
function dssa_tri_mul!(Y,U,W,ds,X)
m, n = size(U)
mx = size(X, 2)
Ubar = zeros(m,mx)
@inbounds for i = n:-1:1
tmpW = @view W[:,i]
tmpU = @view U[:,i]
tmpX = @view X[i:i,:]
Y[i,:] = tmpW'*Ubar + ds[i]*tmpX;
Ubar = Ubar + tmpU*tmpX;
end
end
#### Forward substitution ####
function dss_forward!(X,U,W,ds,B)
m, n = size(U)
mx = size(B,2)
Wbar = zeros(m,mx)
@inbounds for i = 1:n
tmpU = @view U[:,i]
tmpW = @view W[:,i]
X[i:i,:] = (B[i:i,:] - tmpU'*Wbar)/ds[i]
Wbar += tmpW .* X[i:i,:]
end
end
#### Backward substitution ####
function dssa_backward!(X,U,W,ds,B)
m, n = size(U)
mx = size(B,2)
Ubar = zeros(m,mx)
@inbounds for i = n:-1:1
tmpU = @view U[:,i]
tmpW = @view W[:,i]
X[i:i,:] = (B[i:i,:] - tmpW'*Ubar)/ds[i]
Ubar += tmpU .* X[i:i,:]
end
end
#### Squared norm of columns of L = tril(UW',-1) + diag(dbar) ####
function squared_norm_cols(U,W,dbar)
m, n = size(U)
P = zeros(m, m)
c = zeros(n)
@inbounds for i = n:-1:1
tmpW = @view W[:,i]
tmpU = @view U[:,i]
c[i] = dbar[i]^2 + tmpW'*P*tmpW
P += tmpU*tmpU'
end
return c
end
#### Implicit inverse of L = tril(UW',-1) + diag(dbar) ####
function dss_create_yz(U, W,dbar)
m, n = size(U)
Y = zeros(n,m)
Z = zeros(n,m)
dss_forward!(Y, U, W, dbar, U')
dssa_backward!(Z, U, W, dbar, W')
# Probably best not to use inv
return copy(Y'), copy((Z*inv(U*Z - Diagonal(ones(m))))')
end
#### Log-determinant ####
dss_logdet(d) = sum(log,d)
newlogdet(L::DiaSymSemiseparableCholesky) = dss_logdet(L.d)
newlogdet(L::Adjoint{<:Any,<:DiaSymSemiseparableCholesky}) = dss_logdet(L.parent.d)
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 3711 | #==========================================================================================
Constructors
==========================================================================================#
function DiaSymSemiseparableMatrix(U::AbstractArray, V::AbstractArray, d::AbstractArray)
if size(U,1) == size(V,1) && size(U,2) == size(V,2) && length(d) == size(U,2)
return DiaSymSemiseparableMatrix(size(U,2),size(U,1),U,V,d);
else
error("Dimension mismatch between the generators U, V and d")
end
end
function DiaSymSemiseparableMatrix(L::SymSemiseparableMatrix, d::AbstractArray)
return DiaSymSemiseparableMatrix(L.n, L.p, L.Ut, L.Vt, d)
end
function DiaSymSemiseparableMatrix(L::DiaSymSemiseparableCholesky)
V, d = dss_create_vd(L.Ut, L.Wt, L.ds);
return DiaSymSemiseparableMatrix(L.n, L.p, L.Ut, V, d)
end
#==========================================================================================
Defining Matrix Properties
==========================================================================================#
Matrix(K::DiaSymSemiseparableMatrix) = tril(K.Ut'*K.Vt) + triu(K.Vt'*K.Ut,1) + Diagonal(K.d)
size(K::DiaSymSemiseparableMatrix) = (K.n,K.n)
LinearAlgebra.cholesky(K::DiaSymSemiseparableMatrix) = DiaSymSemiseparableCholesky(K)
function getindex(K::DiaSymSemiseparableMatrix{T}, i::Int, j::Int) where T
i > j && return dot(K.Ut[:,i],K.Vt[:,j])
j == i && return dot(K.Vt[:,i],K.Ut[:,j]) + K.d[i]
return dot(K.Vt[:,i],K.Ut[:,j])
end
Base.propertynames(F::DiaSymSemiseparableMatrix, private::Bool=false) =
(private ? fieldnames(typeof(F)) : ())
#==========================================================================================
Defining multiplication and inverse
==========================================================================================#
function mul!(y::AbstractArray, L::DiaSymSemiseparableMatrix, b::AbstractArray)
dss_mul_mat!(y, L.Ut, L.Vt, L.d, b)
return y
end
function mul!(y::AbstractArray, L::Adjoint{<:Any,<:DiaSymSemiseparableMatrix}, b::AbstractArray)
dss_mul_mat!(y, L.parent.Ut, L.parent.Vt, L.parent.d, b)
return y
end
function inv!(y, K::DiaSymSemiseparableMatrix, b::AbstractArray)
L = DiaSymSemiseparableCholesky(K)
y[:,:] = L'\(L\b)
end
function inv!(y, K::Adjoint{<:Any,<:DiaSymSemiseparableMatrix}, b::AbstractArray)
L = DiaSymSemiseparableCholesky(K.parent)
y[:,:] = L'\(L\b)
end
#===========================================================================================
Cholesky factoriaztion of: Higher-order quasiseparable matrices
===========================================================================================#
"""
dss_mul_mat!(Y, U, V, d, X)
Computes the matrix-matrix product `Y = (tril(U*V') + triu(V*U',1) + diag(d))*X`.
"""
function dss_mul_mat!(Y, U, V, d, X)
p, n = size(U)
mx = size(X,2)
Vbar = zeros(p,mx)
Ubar = U*X
@inbounds for i = 1:n
tmpV = @view V[:,i]
tmpU = @view U[:,i]
tmpX = @view X[i:i,:]
Ubar -= tmpU .* tmpX;
Vbar += tmpV .* tmpX;
Y[i,:] = tmpU'*Vbar + tmpV'*Ubar + d[i]*tmpX
end
return Y
end
"""
dss_create_vd(U, W, dbar)
Using `L = tril(U*W',-1) + Diagonal(dbar)`, compute `V` and `d` such that
`LL = tril(UV') + triu(V'*U,1) + Diagonal(d)`.
"""
function dss_create_vd(U, W, dbar)
m, n = size(U)
d = zeros(n)
V = zeros(n,m)
P = zeros(m,m)
@inbounds for i = 1:n
tmpU = @view U[:,:]
tmpW = @view W[:,:]
d[i] = dbar[i]^2 - tmpU'*tmpW
V[:,i] = P*tmpU
P += tmpW*tmpW'
end
return V, d
end
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 5555 | #==========================================================================================
Constructors
==========================================================================================#
function SymSemiseparableCholesky(U::AbstractArray, W::AbstractArray)
if size(U,1) == size(W,1) && size(U,2) == size(W,2)
return SymSemiseparableCholesky(size(U,2),size(U,1),U,W)
else
error("Dimension mismatch between the generators U and W")
end
end
function SymSemiseparableCholesky(K::SymSemiseparableMatrix)
return SymSemiseparableCholesky(K.n, K.p, K.Ut, ss_create_w(K.Ut, K.Vt))
end
#==========================================================================================
Defining Matrix Properties
==========================================================================================#
Matrix(K::SymSemiseparableCholesky) = getproperty(K,:L)
size(K::SymSemiseparableCholesky) = (K.n, K.n)
size(K::SymSemiseparableCholesky, d::Int) = (1 <= d && d <=2) ? size(K)[d] : throw(ArgumentError("Invalid dimension $d"))
function getindex(K::SymSemiseparableCholesky, i::Int, j::Int)
i >= j && return dot(K.Ut[:,i], K.Wt[:,j])
return 0
end
function getproperty(K::SymSemiseparableCholesky, d::Symbol)
if d === :U
return UpperTriangular(K.Wt'*K.Ut)
elseif d === :L
return LowerTriangular(K.Ut'*K.Wt)
else
return getfield(K, d)
end
end
# Base.propertynames(F::SymSemiseparableCholesky, private::Bool=false) =
# (:U, :L, (private ? fieldnames(typeof(F)) : ())...)
# function Base.show(io::IO, mime::MIME{Symbol("text/plain")},
# K::SymSemiseparableCholesky{<:Any,<:AbstractMatrix,<:AbstractMatrix})
# summary(io, K); println(io)
# show(io, mime, K.L)
# end
#==========================================================================================
Defining multiplication and inverse
==========================================================================================#
function mul!(y::AbstractArray, L::SymSemiseparableCholesky, b::AbstractArray)
ss_tri_mul!(y, L.Ut, L.Wt, b)
return y
end
function mul!(y::AbstractArray, L::Adjoint{<:Any,<:SymSemiseparableCholesky}, b::AbstractArray)
ssa_tri_mul!(y, L.parent.Ut, L.parent.Wt, b)
return y
end
function (\)(F::SymSemiseparableCholesky, B::AbstractVecOrMat)
X = similar(B)
ss_forward!(X,F.Ut,F.Wt,B)
return X
end
function (\)(F::Adjoint{<:Any,<:SymSemiseparableCholesky}, B::AbstractVecOrMat)
Y = similar(B)
ssa_backward!(Y,F.parent.Ut,F.parent.Wt,B)
return Y
end
newlogdet(L::SymSemiseparableCholesky) = ss_logdet(L.Ut, L.Wt)
newlogdet(L::Adjoint{<:Any,<:SymSemiseparableCholesky}) = ss_logdet(L.parent.Ut, L.parent.Wt)
function det(L::SymSemiseparableCholesky)
dd = one(eltype(L))
@inbounds for i in 1:L.n
dd *= dot(L.Ut[:,i],L.Wt[:,i])
end
return dd
end
function logdet(L::SymSemiseparableCholesky)
dd = zero(eltype(L))
@inbounds for i in 1:L.n
dd += log(dot(L.Ut[:,i],L.Wt[:,i]))
end
return dd
end
#### Inverse of a SymSemiseparableCholesky using ####
function inv(L::SymSemiseparableCholesky, b::AbstractArray)
return L'\(L\b)
end
#==========================================================================================
Defining the computations
==========================================================================================#
"""
ss_create_w(U,V)
Creates matrix `W` such that the Cholesky factorization of the SymSemiseparable(U,V) matrix
is `L = tril(U*W')` in linear complexity.
"""
function ss_create_w(U,V)
p,n = size(U)
wTw = zeros(p,p)
W = zeros(p,n)
@inbounds for j = 1:n
tmpu = @view U[:,j]
tmp = V[:,j] - wTw*tmpu
w = tmp/sqrt(abs(tmpu'*tmp))
W[:,j] = w
wTw = wTw + w*w'
end
return W
end
"""
ss_tri_mul!(Y,U,W,X)
Computes the multiplization `tril(U*W')*X = Y` in linear complexity.
"""
function ss_tri_mul!(Y,U,W,X)
m, n = size(U)
mx = size(X,2)
Wbar = zeros(m,mx)
@inbounds for i = 1:n
tmpW = @view W[:,i]
tmpU = @view U[:,i]
tmpX = @view X[i:i,:]
Wbar += tmpW .* tmpX
Y[i,:] = Wbar'*tmpU
end
end
"""
ssa_tri_mul!(Y,U,W,X)
Computes the multiplization `triu(W*U')*X = Y` in linear complexity.
"""
function ssa_tri_mul!(Y,U,W,X)
m, n = size(U)
mx = size(X,2)
Ubar = zeros(m,mx)
Ubar = Ubar + U*X
@inbounds for i = 1:n
tmpW = @view W[:,i]
tmpU = @view U[:,i]
tmpX = @view X[i:i,:]
Y[i,:] = Ubar'*tmpW
Ubar -= tmpU .* tmpX
end
end
"""
ss_forward!
Solves the linear system `tril(U*W')*X = B`.
"""
function ss_forward!(X,U,W, B)
m, n = size(U)
mx = size(B,2)
Wbar = zeros(m, mx)
@inbounds for i = 1:n
tmpU = @view U[:,i]
tmpW = @view W[:,i]
X[i,:] = (B[i:i,:] - tmpU'*Wbar)./(tmpU'*tmpW)
Wbar += tmpW .* X[i:i,:]
end
end
"""
ssa_backward!(X, U, W, B)
Solves the linear system `triu(W*U')*X = Y`.
"""
function ssa_backward!(X, U, W, B)
m,n = size(U)
mx = size(B,2)
Ubar = zeros(m,mx)
@inbounds for i = n:-1:1
tmpU = @view U[:,i]
tmpW = @view W[:,i]
X[i,:] = (B[i:i,:] - tmpW'*Ubar)/(tmpU'*tmpW)
Ubar += tmpU .* X[i:i,:]
end
end
#### Logarithm of determinant ####
function ss_logdet(U, W)
a = 0.0
@inbounds for i = 1:size(U, 1)
a += log(dot(U[i,:],W[i,:]))
end
return a
end
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 1487 | module SymSemiseparableMatrices
# Importing Relevant Packages
using LinearAlgebra
# Must be imported here, as it is relevant before "syntax.jl"
import LinearAlgebra: inv!, tr, mul!, logdet, ldiv!, cholesky, det
import Base: inv, size, eltype, adjoint, *, \, size, eltype, Matrix, getindex, getproperty
# Creating Types
struct SymSemiseparableMatrix{T,UU<:AbstractMatrix{T},VV<:AbstractMatrix{T}} <: AbstractMatrix{T}
n::Int64
p::Int64
Ut::UU
Vt::VV
end
struct SymSemiseparableCholesky{T,UU<:AbstractMatrix{T},WW<:AbstractMatrix{T}} <: AbstractMatrix{T}
n::Int64
p::Int64
Ut::UU
Wt::WW
end
struct DiaSymSemiseparableMatrix{T,UU<:AbstractMatrix{T},VV<:AbstractMatrix{T},dd<:AbstractVector{T}} <: AbstractMatrix{T}
n::Int64
p::Int64
Ut::UU
Vt::VV
d::dd
end
struct DiaSymSemiseparableCholesky{T,UU<:AbstractMatrix{T},WW<:AbstractMatrix{T},dd<:AbstractVector{T}} <: AbstractMatrix{T}
n::Int64
p::Int64
Ut::UU
Wt::WW
d::dd
end
# Properties
# include("adjointoperator.jl")
# Matrices
include("SymSemiseparableMatrix.jl")
include("SymSemiseparableCholesky.jl")
include("DiaSymSemiseparableMatrix.jl")
include("DiaSymSemiseparableCholesky.jl")
# Operator overloadings
# include("operator_overloading.jl")
# Spline Kernel
include("spline_kernel.jl")
# Exporting Relevant
export SymSemiseparableMatrix, SymSemiseparableCholesky
export DiaSymSemiseparableMatrix, DiaSymSemiseparableCholesky
export trinv
end # module
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 3462 | #==========================================================================================
Constructors
==========================================================================================#
function SymSemiseparableMatrix(U::AbstractArray, V::AbstractArray)
if size(U,1) == size(V,1) && size(U,2) == size(V,2)
return SymSemiseparableMatrix(size(U,2),size(U,1),U,V)
else
error("Dimension mismatch between generators U and V")
end
end
function SymSemiseparableMatrix(L::SymSemiseparableCholesky)
return SymSemiseparableMatrix(L.n, L.p, L.Ut, ss_create_v(L.Ut, L.Wt))
end
#==========================================================================================
Defining Matrix Properties
==========================================================================================#
Matrix(K::SymSemiseparableMatrix) = tril(K.Ut'*K.Vt) + triu(K.Vt'*K.Ut,1)
size(K::SymSemiseparableMatrix) = (K.n,K.n)
LinearAlgebra.cholesky(K::SymSemiseparableMatrix) = SymSemiseparableCholesky(K)
function LinearAlgebra.cholesky(K::SymSemiseparableMatrix, sigma)
Wt, dbar = dss_create_wdbar(K.Ut,K.Vt,ones(K.n)*sigma)
return DiaSymSemiseparableCholesky(K.n,K.p,K.Ut,Wt,dbar,)
end
function getindex(K::SymSemiseparableMatrix{T}, i::Int, j::Int) where T
i > j && return dot(K.Ut[:,i],K.Vt[:,j])
return dot(K.Ut[:,j],K.Vt[:,i])
end
Base.propertynames(F::SymSemiseparableMatrix, private::Bool=false) =
(private ? fieldnames(typeof(F)) : ())
logdet(K::SymSemiseparableMatrix) = 2.0*logdet(cholesky(K))
det(K::SymSemiseparableMatrix) = det(cholesky(K))^2
#==========================================================================================
Defining multiplication and inverse
==========================================================================================#
function mul!(y::AbstractArray, L::SymSemiseparableMatrix, x::AbstractArray)
ss_mul_mat!(y, L.Ut, L.Vt, x)
return y
end
function mul!(y::AbstractArray, L::Adjoint{<:Any,<:SymSemiseparableMatrix}, x::AbstractArray)
ss_mul_mat!(y, L.parent.Ut, L.parent.Vt, x)
return y
end
function (\)(K::SymSemiseparableMatrix, x::AbstractVecOrMat)
L = cholesky(K)
return L'\(L\x)
end
function (\)(K::Adjoint{<:Any,<:SymSemiseparableMatrix}, x::AbstractVecOrMat)
L = cholesky(K.parent)
return L'\(L\x)
end
#==========================================================================================
Defining the Linear Algebra
==========================================================================================#
"""
ss_mul_mat!(Y, U, V, X)
Computes the matrix-matrix product `Y = (tril(U'*V) + triu(V'*U,1))*X` in linear complexity.
"""
function ss_mul_mat!(Y, U, V, X)
m, n = size(U)
mx = size(X,2)
Vbar = zeros(m,mx)
Ubar = U*X
@inbounds for i = 1:n
tmpV = @view V[:,i]
tmpU = @view U[:,i]
Ubar -= tmpU .* X[i:i,:]
Vbar += tmpV .* X[i:i,:]
Y[i,:] = Vbar'*tmpU + Ubar'*tmpV
end
end
"""
ss_create_v(U, W)
Using `L = tril(U*W')`, compute `V` such that `LL = tril(UV') + triu(V'*U,1)`.
"""
function ss_create_v(U, W)
m,n = size(U)
V = zeros(n,m)
P = zeros(m,m)
@inbounds for i = 1:n
tmpW = @view W[:,i]
tmpU = @view U[:,i]
tmpV = tmpW*(tmpU'*tmpW)
V[i,:] = tmpV + P*tmpU
P += tmpW*tmpW'
end
return V
end
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 2958 | """
alpha(p::Int)
Returns coefficients for the spline kernel of order `p`.
"""
function alpha(p::Int)
if p < 1
throw(DomainError("Spline order has to be strictly positive"))
end
a = zeros(p)
for i = 0:p-1
for j = 0:i
for k = i:p-1
a[i+1] = a[i+1] + (-1.0)^(k-j)/((k+j+1)*
factorial(j)*
factorial(p-1)*
factorial(p-1-k)*
factorial(i-j)*
factorial(k-i))
end
end
end
return a
end
"""
spline_kernel(t, p)
Returns generators `U` and `V` for the spline kernel of order `p` given a list of knots `t`.
"""
function spline_kernel(t::AbstractArray, p::Int)
fp = factorial.(p-1:-1:0)
a = alpha(p).*fp
Ut = (repeat(t,p,1).^Vector(p-1:-1:0))./fp
Vt = (repeat(t,p,1).^Vector(p:2*p-1)).*a
return Ut,Vt
end
"""
spline_kernel_matrix(U, V)
Returns the dense spline kernel matrix with generators `U` and `V`.
"""
function spline_kernel_matrix(U, V)
return tril(U*V') + triu(V*U',1)
end
"""
spline_kernel_matrix(U, V, d)
Returns the dense spline kernel matrix with generators `U` and `V` plus `Diagonal(d)`.
"""
function spline_kernel_matrix(U, V, d )
return spline_kernel_matrix(U, V) + Diagonal(d)
end
"""
logp(Σ, T, y, σf, σn)
Generalized Log-likelihood evalation for the spline kernel.
"""
function logp(Σ, T, y, σf, σn)
m = rank(T)
n = length(y)
Ki = cholesky(σf^2*Σ + σn^2*I)
if LinearAlgebra.issuccess(Ki) == false
throw(DomainError("Cholesky Factorization failed"))
end
A = T'*(Ki\T)
C = (Ki\T)*(A\(T'*inv(Ki)))
lp = -0.5*y'*(Ki\y) +
0.5*y'*(C*y) +
-0.5*logdet(Ki) +
-0.5*logdet(A) +
-(n-m)*0.5*log(2*π)
return lp
end
"""
dlogp(Σ, T, y, σf, σn)
Derivatives of the generalized Log-likelihood for the spline kernel.
"""
function dlogp(Σ, T, y, σf, σn)
Ki = cholesky(σf^2*Σ + σn^2*I)
if LinearAlgebra.issuccess(Ki) == false
throw(DomainError("Cholesky Factorization failed"))
end
A = T'*(Ki\T)
# TO_DO: Solving for the identity?
dKf = 2.0*σf*Σ
dAf = -T'*(Ki\dKf)*(Ki\T)
dKn = 2.0*σn*I
dAn = -T'*(inv(Ki)*dKn)*(Ki\T)
Pf = Ki\dKf*inv(Ki)
Pn = Ki\(dKn*inv(Ki))
G = T*(A\(T'*(Ki\y)))
dlpf = 0.5*y'*(Pf*y) +
0.5*(-2*(y'*Pf)*G + G'*Pf*G) +
-0.5*tr(Ki\dKf) +
-0.5*tr(A\dAf)
dlpn = 0.5*y'*(Pn*y) +
0.5*(-2*(y'*Pn)*G + G'*Pn*G) +
-0.5*tr(inv(Ki)*dKn) +
-0.5*tr(A\dAn)
return [dlpf; dlpn]
end
"""
create_T(t, m)
Creates `m`-order Taylor-polynomial basis from the knots in `t`.
"""
function create_T(t, m)
T = ones(length(t), m)
for ν = 2:m
T[:, ν] = t.^(ν-1)/factorial(ν - 1)
end
return T
end
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 467 | using SymSemiseparableMatrices
using LinearAlgebra
import SymSemiseparableMatrices: spline_kernel_matrix, spline_kernel
U, V = spline_kernel(Vector(0.1:0.01:1), 2); # Creating Input Generators resulting in a PSD K
K = SymSemiseparable(U,V); # Generator symmetric semiseparable matrix
x = ones(K.n); # Test vector
K*x
K'*x
K*(K\x)
L = SymSemiseparableChol(K); # Creating Cholesky factorization
L*x
L'*x
L\x
L'\x
Kdiag = DiaSymSemiseparable(U,V,rand(size(U,1)))
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 315 | using SymSemiseparableMatrices
using Test
using LinearAlgebra
import SymSemiseparableMatrices: spline_kernel, spline_kernel_matrix
@testset "SymSemiseparableMatrices.jl" begin
include("test_symsep.jl")
include("test_symsepchol.jl")
include("test_diasymsep.jl")
include("test_diasymsepchol.jl")
end
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 1677 | using SymSemiseparableMatrices, LinearAlgebra, Test
import SymSemiseparableMatrices: spline_kernel, spline_kernel_matrix
# Removing t = 0, such that Σ is invertible
n = 500.0;
t = Vector(0.1:1/n:1)
# Creating a test matrix Σ = tril(UV') + triu(VU',1) that is PSD
p = 2
Ut, Vt = spline_kernel(t', p)
K = DiaSymSemiseparableMatrix(Ut,Vt,ones(size(Ut,2)))
Σ = Matrix(K)
chol = cholesky(Σ)
L = cholesky(K)
x = randn(size(K,1))
# Testing inverses (Using Cholesky factorizations)
B = randn(length(t),10)
@test L\B ≈ chol.L\B
@test L'\B ≈ chol.U\B
@test L*B ≈ chol.L*B
@test L'*B ≈ chol.U*B
# Testing logdet
@test logdet(L) ≈ logdet(chol.L)
@test det(L) ≈ det(chol.L)
# Testing traces and norm
M = SymSemiseparableMatrix(Ut,Vt)
Ky = L
K = M
U = K.Ut
V = K.Vt
c = Ky.d
Y, Z = SymSemiseparableMatrices.dss_create_yz(Ky.Ut, Ky.Wt, Ky.d)
b = 0.0
P = zeros(p,p)
R = zeros(p,p)
@test isapprox(tr(L,M), tr(chol\Matrix(M)), atol=1e-6)
# @test trinv(L) ≈ tr(chol\Diagonal(ones(size(L,1))))
# @test SymEGRSSMatrices.fro_norm_L(L) ≈ norm(chol.L[:])^2
# Testing show
@test L.L ≈ tril(Ut'*L.Wt,-1) + Diagonal(L.d)
@test L.U ≈ triu(L.Wt'*Ut,1) + Diagonal(L.d)
@test Matrix(L) ≈ tril(L.Ut'*L.Wt,-1) + Diagonal(L.d)
@test L[3,1] ≈ chol.L[3,1]
@test L[2,2] ≈ chol.L[2,2]
@test L[1,3] ≈ chol.L[1,3]
# # Testing explicit-implicit-inverse
U = L.Ut
W = L.Wt
dbar = L.d
Yt, Zt = SymSemiseparableMatrices.dss_create_yz(L.Ut,L.Wt,L.d)
@test tril(Yt'*Zt,-1) + Diagonal(L.d.^(-1)) ≈ inv(chol.L)
@test L*(tril(Yt'*Zt,-1) + Diagonal(L.d.^(-1))) ≈ I
@test L'*(triu(Zt'*Yt,1) + Diagonal(L.d.^(-1))) ≈ I
@test SymSemiseparableMatrices.squared_norm_cols(Yt,Zt,L.d.^(-1)) ≈ sum(inv(chol.L).^2,dims=1)' | SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 633 | # Removing t = 0, such that Σ is invertible
t = Vector(0.1:0.1:100)
p = 2
# Creating generators U,V that result in a positive-definite matrix Σ
Ut, Vt = spline_kernel(t', p)
K = DiaSymSemiseparableMatrix(Ut,Vt,ones(size(Ut,2)))
x = randn(size(K,1))
Kfull = Matrix(K)
# Testing multiplication
@test K*x ≈ Kfull*x
@test K'*x ≈ Kfull'*x
# Testing linear solve
@test K\x ≈ Kfull\x
# Testing (log)determinant
@test logdet(K) ≈ logdet(Kfull)
@test det(K) ≈ det(Kfull)
# Testing show
@test Matrix(K) ≈ tril(K.Ut'*K.Vt) + triu(K.Vt'*K.Ut,1) + Diagonal(K.d)
@test Kfull[3,1] ≈ K[3,1]
@test Kfull[2,2] ≈ K[2,2]
@test Kfull[1,3] ≈ K[1,3]
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 1384 | # Removing t = 0, such that Σ is invertible
n = 500.0;
t = Vector(0.1:1/n:1)
# Creating a test matrix Σ = tril(UV') + triu(VU',1) that is PSD
p = 2
Ut, Vt = spline_kernel(t', p)
K = DiaSymSemiseparableMatrix(Ut,Vt,ones(size(Ut,2)))
Σ = Matrix(K)
chol = cholesky(Σ)
L = cholesky(K)
x = randn(size(K,1))
# Testing inverses (Using Cholesky factorizations)
B = randn(length(t),10)
@test L\B ≈ chol.L\B
@test L'\B ≈ chol.U\B
@test L*B ≈ chol.L*B
@test L'*B ≈ chol.U*B
# Testing logdet
@test logdet(L) ≈ logdet(chol.L)
@test det(L) ≈ det(chol.L)
# Testing traces and norm
M = SymSemiseparableMatrix(Ut,Vt)
@test isapprox(tr(L,M), tr(chol\Matrix(M)), atol=1e-6)
@test trinv(L) ≈ tr(chol\Diagonal(ones(size(L,1))))
@test SymSemiseparableMatrices.fro_norm_L(L) ≈ norm(chol.L[:])^2
# Testing show
@test L.L ≈ tril(Ut'*L.Wt,-1) + Diagonal(L.d)
@test L.U ≈ triu(L.Wt'*Ut,1) + Diagonal(L.d)
@test Matrix(L) ≈ tril(L.Ut'*L.Wt,-1) + Diagonal(L.d)
@test L[3,1] ≈ chol.L[3,1]
@test L[2,2] ≈ chol.L[2,2]
@test L[1,3] ≈ chol.L[1,3]
# # Testing explicit-implicit-inverse
Yt, Zt = SymSemiseparableMatrices.dss_create_yz(L.Ut,L.Wt,L.d)
@test tril(Yt'*Zt,-1) + Diagonal(L.d.^(-1)) ≈ inv(chol.L)
@test L*(tril(Yt'*Zt,-1) + Diagonal(L.d.^(-1))) ≈ I
@test L'*(triu(Zt'*Yt,1) + Diagonal(L.d.^(-1))) ≈ I
@test SymSemiseparableMatrices.squared_norm_cols(Yt,Zt,L.d.^(-1)) ≈ sum(inv(chol.L).^2,dims=1)'
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 490 | t = Vector(0.1:0.1:10)
n = length(t); p = 2;
Ut, Vt = spline_kernel(t', p)
K = SymSemiseparableMatrix(Ut,Vt)
x = randn(size(K,1))
Kfull = Matrix(K)
# Testing multiplication
@test K*x ≈ Kfull*x
@test K'*x ≈ Kfull'*x
# Testing linear solves
@test K\x ≈ Kfull\x
# Testing (log)determinant
@test logdet(K) ≈ logdet(Kfull)
@test det(K) ≈ det(Kfull)
# Testing show
@test Matrix(K) ≈ tril(Ut'*Vt) + triu(Vt'*Ut,1)
@test Kfull[3,1] ≈ K[3,1]
@test Kfull[2,2] ≈ K[2,2]
@test Kfull[1,3] ≈ K[1,3]
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | code | 923 | # Removing t = 0, such that Σ is invertible
t = Vector(0.1:0.1:10)
p = 2
# Creating generators U,V that result in a positive-definite matrix Σ
Ut, Vt = spline_kernel(t', p)
K = SymSemiseparableMatrix(Ut,Vt)
Σ = Matrix(K)
chol = cholesky(Σ)
# Creating a symmetric extended generator representable semiseperable matrix
# Calculating its Cholesky factorization
L = cholesky(K)
# Creating a test vector
xt = ones(size(K,1),10)
# Testing size
@test size(L,1) == length(t)
@test size(L,2) == length(t)
# Testing inverses (Using Cholesky factorizations)
@test chol.L\xt ≈ L\xt
@test chol.U\xt ≈ L'\xt
@test chol.L*xt ≈ L*xt
@test chol.L'*xt ≈ L'*xt
# Testing logdet and det
@test logdet(L) ≈ logdet(chol.L)
@test det(L) ≈ det(chol.L)
# Testing show
@test L.L ≈ tril(Ut'*L.Wt)
@test L.U ≈ triu(L.Wt'*Ut)
@test Matrix(L) ≈ tril(Ut'*L.Wt)
@test L[3,1] ≈ chol.L[3,1]
@test L[2,2] ≈ chol.L[2,2]
@test L[1,3] ≈ chol.L[1,3]
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 0.1.1 | cc58d0644d2945f0220ce5eac16e15ad2269434a | docs | 4432 | # SymSemiseparableMatrices.jl
[](https://github.com/mipals/SymSemiseparableMatrices.jl/actions/workflows/CI.yml)
[](https://codecov.io/gh/mipals/SymSemiseparableMatrices.jl)
## Description
A package for efficiently computing with symmetric extended generator representable semiseparable matrices (EGRSS Matrices) and a varient with added diagonal terms. In short this means matrices of the form
```julia
K = tril(U*V^T) + triu(V*U^T,1)
```
as well as
```julia
K = tril(U*V^T) + triu(V*U^T,1) + diag(d)
```
All implemented algorithms (multiplication, Cholesky factorization, forward/backward substitution as well as various traces and determinants) run linear in time and memory w.r.t. to the number of data points ```n```.
A more in-depth descriptions of the algorithms can be found in [1] or [here](https://github.com/mipals/SmoothingSplines.jl/blob/master/mt_mikkel_paltorp.pdf).
## Usage
Adding the package can be done through
```
(@v1.7) pkg> add SymSemiseparableMatrices
```
First we need to create generators U and V that represent the symmetric matrix, ```K = tril(UV') + triu(VU',1)``` as well a test vector ```x```.
```julia
julia> using SymSemiseparableMatrices
julia> import SymSemiseparableMatrices: spline_kernel
julia> U, V = spline_kernel(Vector(0.1:0.01:1), 2); # Creating input such that K is PD
julia> K = SymSemiseparable(U,V); # Symmetric generator representable semiseparable matrix
julia> x = ones(size(K)); # Test vector
```
We can now compute products with ```K``` and ```K'```. The result are the same as ```K``` is symmetric.
```julia
julia> K*x
91×1 Array{Float64,2}:
0.23508333333333334
0.28261583333333334
0.3341535
0.3896073333333333
0.44888933333333336
0.5119124999999999
⋮
11.977057499999997
12.146079333333331
12.31510733333333
12.484138499999995
12.65317083333333
julia> K'*x
91×1 Array{Float64,2}:
0.23508333333333334
0.28261583333333334
0.3341535
0.3896073333333333
0.44888933333333336
0.5119124999999999
⋮
11.977057499999997
12.146079333333331
12.31510733333333
12.484138499999995
12.65317083333333
```
Furthermore from the ```SymSemiseparableMatrix``` structure we can efficiently compute the Cholesky factorization as
```julia
julia> L = cholesky(K); # Computing the Cholesky factorization of K
julia> K*(L'\(L\x))
91×1 Array{Float64,2}:
1.0000000000000036
0.9999999999999982
0.9999999999999956
0.9999999999999944
0.9999999999999951
0.999999999999995
⋮
0.9999999999996279
0.9999999999996153
0.9999999999996028
0.9999999999995898
0.9999999999995764
```
Now ```L``` represents a Cholesky factorization with of form ```L = tril(UW')```, requiring only ```O(np)``` storage.
A struct for the dealing with symmetric matrices of the form, ```K = tril(UV') + triu(VU',1) + diag(d)``` called ```DiaSymSemiseparableMatrix``` is also implemented. The usage is similar to that of ```DiaSymSemiseparableMatrix``` and can be created as follows
```julia
julia> U, V = spline_kernel(Vector(0.1:0.01:1)', 2); # Creating input such that K is PD
julia> K = DiaSymSemiseparableMatrix(U,V,rand(size(U,2)); # Symmetric EGRSS matrix + diagonal
```
The Cholesky factorization of this matrix can be computed using ```cholesky```. Note however here that ```L``` represents a matrix of the form ```L = tril(UW',-1) + diag(c)```
## Benchmarks
### Computing Cholesky factorization of ```K = tril(UV') + triu(VU',1)```
### Computing Cholesky factorization of ```K = tril(UV') + triu(VU',1) + diag(d)```
### Solving linear systems using a Cholesky factorization with the form ```L = tril(UW')```
## References
[1] M. S. Andersen and T. Chen, “Smoothing Splines and Rank Structured Matrices: Revisiting the Spline Kernel,” SIAM Journal on Matrix Analysis and Applications, 2020.
[2] J. Keiner. "Fast Polynomial Transforms." Logos Verlag Berlin, 2011.
| SymSemiseparableMatrices | https://github.com/mipals/SymSemiseparableMatrices.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 931 | using StableLinearAlgebra
using Documenter
using DocumenterCitations
using LinearAlgebra
DocMeta.setdocmeta!(StableLinearAlgebra, :DocTestSetup, :(using StableLinearAlgebra); recursive=true)
bib = CitationBibliography(joinpath(@__DIR__, "references.bib"), sorting = :nyt)
makedocs(
bib,
modules=[StableLinearAlgebra],
authors="Benjamin Cohen-Stead <[email protected]>",
repo="https://github.com/cohensbw/StableLinearAlgebra.jl/blob/{commit}{path}#{line}",
sitename="StableLinearAlgebra.jl",
format=Documenter.HTML(;
prettyurls=get(ENV, "CI", "false") == "true",
canonical="https://cohensbw.github.io/StableLinearAlgebra.jl",
assets=String[],
),
pages=[
"Home" => "index.md",
"Public API" => "public_api.md",
"Developer API" => "developer_api.md"
],
)
deploydocs(;
repo="github.com/cohensbw/StableLinearAlgebra.jl",
devbranch="master",
)
| StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 7569 | @doc raw"""
LDR{T<:Number, E<:Real} <: Factorization{T}
Represents the matrix factorization ``A = L D R`` for a square matrix ``A``,
where ``L`` is a unitary matrix, ``D`` is a diagonal matrix of strictly positive real numbers,
and ``R`` is defined such that ``|\det R| = 1``.
This factorization is based on a column-pivoted QR decomposition ``A P = Q R',`` such that
```math
\begin{align*}
L &:= Q \\
D &:= \vert \textrm{diag}(R') \vert \\
R &:= \vert \textrm{diag}(R') \vert^{-1} R' P^T\\
\end{align*}
```
# Fields
- `L::Matrix{T}`: The left unitary matrix ``L`` in a [`LDR`](@ref) factorization.
- `d::Vector{E}`: A vector representing the diagonal matrix ``D`` in a [`LDR`](@ref) facotorization.
- `R::Matrix{T}`: The right matrix ``R`` in a [`LDR`](@ref) factorization.
"""
struct LDR{T<:Number, E<:AbstractFloat} <: Factorization{T}
"The left unitary matrix ``L``."
L::Matrix{T}
"Vector representing diagonal matrix ``D``."
d::Vector{E}
"The right upper triangular matrix ``R``."
R::Matrix{T}
end
@doc raw"""
LDRWorkspace{T<:Number}
A workspace to avoid dyanmic memory allocations when performing computations
with a [`LDR`](@ref) factorization.
# Fields
- `qr_ws::QRWorkspace{T,E}`: [`QRWorkspace`](@ref) for calculating column pivoted QR factorization without dynamic memory allocations.
- `lu_ws::LUWorkspace{T}`: [`LUWorkspace`](@ref) for calculating LU factorization without dynamic memory allocations.
- `M::Matrix{T}`: Temporary storage matrix for avoiding dynamic memory allocations. This matrix is used/modified when a [`LDR`](@ref) factorization is calculated.
- `M′::Matrix{T}`: Temporary storage matrix for avoiding dynamic memory allocations.
- `M″::Matrix{T}`: Temporary storage matrix for avoiding dynamic memory allocations.
- `v::Vector{T}`: Temporary storage vector for avoiding dynamic memory allocations.
"""
struct LDRWorkspace{T<:Number, E<:AbstractFloat}
"Workspace for calculating column pivoted QR factorization without allocations."
qr_ws::QRWorkspace{T,E}
"Workspace for calculating LU factorization without allocations."
lu_ws::LUWorkspace{T}
"Temporary storage matrix. This matrix is used/modified when a [`LDR`](@ref) factorization are calculated."
M::Matrix{T}
"Temporary storage matrix."
M′::Matrix{T}
"Temporary storage matrix."
M″::Matrix{T}
"Temporary storage vector."
v::Vector{E}
end
@doc raw"""
ldr(A::AbstractMatrix{T}) where {T}
Allocate an [`LDR`](@ref) factorization based on `A`, but does not calculate its [`LDR`](@ref) factorization,
instead initializing the factorization to the identity matrix.
"""
function ldr(A::AbstractMatrix{T}) where {T}
n = checksquare(A)
E = real(T)
L = zeros(T,n,n)
d = zeros(E,n)
R = zeros(T,n,n)
F = LDR{T,E}(L,d,R)
ldr!(F, I)
return F
end
@doc raw"""
ldr(A::AbstractMatrix{T}, ws::LDRWorkspace{T}) where {T}
Return the [`LDR`](@ref) factorization of the matrix `A`.
"""
function ldr(A::AbstractMatrix{T}, ws::LDRWorkspace{T}) where {T}
F = ldr(A)
ldr!(F, A, ws)
return F
end
@doc raw"""
ldr(F::LDR{T}, ignore...) where {T}
Return a copy of the [`LDR`](@ref) factorization `F`.
"""
function ldr(F::LDR{T}, ignore...) where {T}
L = copy(F.L)
d = copy(F.d)
R = copy(F.R)
return LDR(L,d,R)
end
@doc raw"""
ldr!(F::LDR{T}, A::AbstractMatrix{T}, ws::LDRWorkspace{T}) where {T}
Calculate the [`LDR`](@ref) factorization `F` for the matrix `A`.
"""
function ldr!(F::LDR{T}, A::AbstractMatrix{T}, ws::LDRWorkspace{T}) where {T}
copyto!(F.L, A)
return ldr!(F, ws)
end
@doc raw"""
ldr!(F::LDR{T}, I::UniformScaling, ignore...) where {T}
Set the [`LDR`](@ref) factorization equal to the identity matrix.
"""
function ldr!(F::LDR{T}, I::UniformScaling, ignore...) where {T}
(; L, d, R) = F
copyto!(L, I)
fill!(d, 1)
copyto!(R, I)
return nothing
end
@doc raw"""
ldr!(Fout::LDR{T}, Fin::LDR{T}, ignore...) where {T}
Copy the [`LDR`](@ref) factorization `Fin` to `Fout`.
"""
function ldr!(Fout::LDR{T}, Fin::LDR{T}, ignore...) where {T}
copyto!(Fout.L, Fin.L)
copyto!(Fout.d, Fin.d)
copyto!(Fout.R, Fin.R)
return nothing
end
@doc raw"""
ldr!(F::LDR, ws::LDRWorkspace{T}) where {T}
Calculate the [`LDR`](@ref) factorization for the matrix `F.L`.
"""
function ldr!(F::LDR, ws::LDRWorkspace{T}) where{T}
(; qr_ws, M) = ws
(; L, d, R) = F
# calclate QR decomposition
LAPACK.geqp3!(L, qr_ws)
# extract upper triangular matrix R
copyto!(M, L)
triu!(M)
# set D = Diag(R), represented by vector d
@fastmath @inbounds for i in 1:size(L,1)
d[i] = abs(M[i,i])
end
# calculate R = D⁻¹⋅R
ldiv_D!(d, M)
# calculate R⋅Pᵀ
mul_P!(R, M, qr_ws.jpvt)
# construct L (same as Q) matrix
LAPACK.orgqr!(L, qr_ws)
return nothing
end
@doc raw"""
ldrs(A::AbstractMatrix{T}, N::Int) where {T}
Return a vector of [`LDR`](@ref) factorizations of length `N`, where each one represents the
identity matrix of the same size as ``A``.
"""
function ldrs(A::AbstractMatrix{T}, N::Int) where {T}
Fs = LDR{T,real(T)}[]
for i in 1:N
push!(Fs, ldr(A))
end
return Fs
end
@doc raw"""
ldrs(A::AbstractMatrix{T}, N::Int, ws::LDRWorkspace{T,E}) where {T,E}
Return a vector of [`LDR`](@ref) factorizations of length `N`, where each one represents the matrix `A`.
"""
function ldrs(A::AbstractMatrix{T}, N::Int, ws::LDRWorkspace{T,E}) where {T,E}
Fs = LDR{T,E}[]
F = ldr(A, ws)
push!(Fs, F)
for i in 2:N
push!(Fs, ldr(F))
end
return Fs
end
@doc raw"""
ldrs(A::AbstractArray{T,3}, ws::LDRWorkspace{T,E}) where {T,E}
Return a vector of [`LDR`](@ref) factorizations of length `size(A, 3)`, where there is an
[`LDR`](@ref) factorization for each matrix `A[:,:,i]`.
"""
function ldrs(A::AbstractArray{T,3}, ws::LDRWorkspace{T,E}) where {T,E}
Fs = LDR{T,E}[]
for i in axes(A,3)
Aᵢ = @view A[:,:,i]
push!(Fs, ldr(Aᵢ, ws))
end
return Fs
end
@doc raw"""
ldrs!(Fs::AbstractVector{LDR{T,E}}, A::AbstractArray{T,3}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the [`LDR`](@ref) factorization `Fs[i]` for the matrix `A[:,:,i]`.
"""
function ldrs!(Fs::AbstractVector{LDR{T,E}}, A::AbstractArray{T,3}, ws::LDRWorkspace{T,E}) where {T,E}
for i in eachindex(Fs)
Aᵢ = @view A[:,:,i]
ldr!(Fs[i], Aᵢ, ws)
end
return nothing
end
@doc raw"""
ldr_workspace(A::AbstractMatrix)
ldr_workspace(F::LDR)
Return a [`LDRWorkspace`](@ref) that can be used to avoid dynamic memory allocations.
"""
function ldr_workspace(A::AbstractMatrix{T}) where {T}
E = real(T)
n = checksquare(A)
M = zeros(T, n, n)
M′ = zeros(T, n, n)
M″ = zeros(T, n, n)
v = zeros(E, n)
copyto!(M, I)
qr_ws = QRWorkspace(M)
lu_ws = LUWorkspace(M)
return LDRWorkspace(qr_ws, lu_ws, M, M′, M″, v)
end
ldr_workspace(F::LDR) = ldr_workspace(F.L)
@doc raw"""
copyto!(ldrws_out::LDRWorkspace{T,E}, ldrws_in::LDRWorkspace{T,E}) where {T,E}
Copy the contents of `ldrws_in` into `ldrws_out`.
"""
function copyto!(ldrws_out::LDRWorkspace{T,E}, ldrws_in::LDRWorkspace{T,E}) where {T,E}
copyto!(ldrws_out.qr_ws, ldrws_in.qr_ws)
copyto!(ldrws_out.lu_ws, ldrws_in.lu_ws)
copyto!(ldrws_out.M, ldrws_in.M)
copyto!(ldrws_out.M′, ldrws_in.M′)
copyto!(ldrws_out.M″, ldrws_in.M″)
copyto!(ldrws_out.v, ldrws_in.v)
return nothing
end | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 1122 | module StableLinearAlgebra
using LinearAlgebra
import LinearAlgebra: adjoint!, lmul!, rmul!, mul!, ldiv!, rdiv!, logabsdet
import Base: eltype, size, copyto!
# define developer functions/methods
include("developer_functions.jl")
# imports for wrapping LAPACK functions to avoid dynamic memory allocations
using Base: require_one_based_indexing
using LinearAlgebra: checksquare
using LinearAlgebra: BlasInt, BlasFloat
using LinearAlgebra.BLAS: @blasfunc
using LinearAlgebra.LAPACK: chklapackerror, chkstride1, chktrans
using LinearAlgebra.LAPACK
const liblapack = LinearAlgebra.LAPACK.liblapack
include("qr.jl") # wrap LAPACK column-pivoted QR factorization
export QRWorkspace
include("lu.jl") # wrap LAPACK LU factorization (for determinants and matrix inversion)
export LUWorkspace, inv_lu!, det_lu!, ldiv_lu!
# define LDR factorization
include("LDR.jl")
export LDR, LDRWorkspace, ldr, ldr!, ldrs, ldrs!, ldr_workspace
# define overloaded functions/methods
include("overloaded_functions.jl")
# define exported functions/methods
include("exported_functions.jl")
export inv_IpA!, inv_IpUV!, inv_UpV!, inv_invUpV!
end | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 5110 | @doc raw"""
det_D(d::AbstractVector{T}) where {T}
Given a diagonal matrix ``D`` represented by the vector `d`,
return ``\textrm{sign}(\det D)`` and ``\log(|\det A|).``
"""
function det_D(d::AbstractVector{T}) where {T}
logdetD = zero(real(T))
sgndetD = oneunit(T)
for i in eachindex(d)
logdetD += log(abs(d[i]))
sgndetD *= sign(d[i])
end
return logdetD, sgndetD
end
@doc raw"""
mul_D!(A, d, B)
Calculate the matrix product ``A = D \cdot B,`` where ``D`` is a diagonal matrix
represented by the vector `d`.
"""
function mul_D!(A::AbstractMatrix, d::AbstractVector, B::AbstractMatrix)
@inbounds @fastmath for c in axes(B,2)
for r in eachindex(d)
A[r,c] = d[r] * B[r,c]
end
end
return nothing
end
@doc raw"""
mul_D!(A, B, d)
Calculate the matrix product ``A = B \cdot D,`` where ``D`` is a diagonal matrix
represented by the vector `d`.
"""
function mul_D!(A::AbstractMatrix, B::AbstractMatrix, d::AbstractVector)
@inbounds @fastmath for c in eachindex(d)
for r in axes(A,1)
A[r,c] = B[r,c] * d[c]
end
end
return nothing
end
@doc raw"""
div_D!(A, d, B)
Calculate the matrix product ``A = D^{-1} \cdot B,`` where ``D`` is a diagonal matrix
represented by the vector `d`.
"""
function div_D!(A::AbstractMatrix, d::AbstractVector, B::AbstractMatrix)
@inbounds @fastmath for c in axes(B,2)
for r in eachindex(d)
A[r,c] = B[r,c] / d[r]
end
end
return nothing
end
@doc raw"""
div_D!(A, B, d)
Calculate the matrix product ``A = B \cdot D^{-1},`` where ``D`` is a diagonal matrix
represented by the vector `d`.
"""
function div_D!(A::AbstractMatrix, B::AbstractMatrix, d::AbstractVector)
@inbounds @fastmath for c in eachindex(d)
for r in axes(B,1)
A[r,c] = B[r,c] / d[c]
end
end
return nothing
end
@doc raw"""
lmul_D!(d, M)
In-place calculation of the matrix product ``M = D \cdot M,`` where ``D`` is a diagonal
matrix represented by the vector `d`.
"""
function lmul_D!(d::AbstractVector, M::AbstractMatrix)
@inbounds @fastmath for c in axes(M,2)
for r in eachindex(d)
M[r,c] *= d[r]
end
end
return nothing
end
@doc raw"""
rmul_D!(M, d)
In-place calculation of the matrix product ``M = M \cdot D,`` where ``D`` is a diagonal
matrix represented by the vector `d`.
"""
function rmul_D!(M::AbstractMatrix, d::AbstractVector)
@inbounds @fastmath for c in eachindex(d)
for r in axes(M,1)
M[r,c] *= d[c]
end
end
return nothing
end
@doc raw"""
ldiv_D!(d, M)
In-place calculation of the matrix product ``M = D^{-1} \cdot M,`` where ``D`` is a diagonal
matrix represented by the vector `d`.
"""
function ldiv_D!(d::AbstractVector, M::AbstractMatrix)
@inbounds @fastmath for c in axes(M,2)
for r in eachindex(d)
M[r,c] /= d[r]
end
end
return nothing
end
@doc raw"""
rdiv_D!(M, d)
In-place calculation of the matrix product ``M = M \cdot D^{-1},`` where ``D`` is a diagonal
matrix represented by the vector `d`.
"""
function rdiv_D!(M::AbstractMatrix, d::AbstractVector)
@inbounds @fastmath for c in eachindex(d)
for r in axes(M,1)
M[r,c] /= d[c]
end
end
return nothing
end
@doc raw"""
mul_P!(A, p, B)
Evaluate the matrix product ``A = P \cdot B,`` where ``P`` is a permutation matrix
represented by the vector of integers `p`.
"""
function mul_P!(A::AbstractMatrix, p::AbstractVector{Int}, B::AbstractMatrix)
@views @. A = B[p,:]
return nothing
end
@doc raw"""
mul_P!(A, B, p)
Evaluate the matrix product ``A = B \cdot P,`` where ``P`` is a permutation matrix
represented by the vector of integers `p`.
"""
function mul_P!(A::AbstractMatrix, B::AbstractMatrix, p::AbstractVector{Int})
A′ = @view A[:,p]
@. A′ = B
return nothing
end
@doc raw"""
inv_P!(p⁻¹, p)
Calculate the inverse/transpose ``P^{-1}=P^T`` of a permuation ``P`` represented by
the vector `p`, writing the result to `p⁻¹`.
"""
function inv_P!(p⁻¹::Vector{Int}, p::Vector{Int})
sortperm!(p⁻¹, p)
return nothing
end
@doc raw"""
perm_sign(p::AbstractVector{Int})
Calculate the sign/parity of the permutation `p`, ``\textrm{sgn}(p) = \pm 1.``
"""
function perm_sign(p::AbstractVector{Int})
N = length(p)
sgn = 0
# iterate over elements in permuation
@fastmath @inbounds for i in eachindex(p)
# if element has not been assigned to a cycle
if p[i] <= N
k = 1
j = i
# calculate cycle containing current element
while p[j] != i
tmp = j
j = p[j]
p[tmp] += N # mark element as assigned to cycle
k += 1
end
p[j] += N # mark element as assigned to cycle
sgn += (k-1)%2
end
end
# set sgn = ±1
sgn = 1 - 2*(sgn%2)
# restore permutation
@. p = p - N
return sgn
end | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 13490 | # @doc raw"""
# adjoint_inv_ldr!(A⁻ᵀ::LDR{T}, A::AbstractMatrix{T}, ws::LDRWorkspace{T}) where {T}
# Given a matrix ``A,`` calculate the [`LDR`](@ref) factorization ``(A^{-1})^{\dagger},``
# storing the result in `A⁻ᵀ`.
# # Algorithm
# By calculating the pivoted QR factorization of `A`, we can calculate the [`LDR`](@ref)
# facorization `(A^{-1})^{\dagger} = L_0 D_0 R_0` using the procedure
# ```math
# \begin{align*}
# (A^{-1})^{\dagger}:= & ([QRP^{T}]^{-1})^{\dagger}\\
# = & ([Q\,\textrm{|diag}(R)|\,|\textrm{diag}(R)|^{-1}\,RP^{T}]^{-1})^{\dagger}\\
# = & [\overset{R_{0}^{\dagger}}{\overbrace{PR^{-1}|\textrm{diag}(R)}|}\,\overset{D_{0}}{\overbrace{|\textrm{diag}(R)|^{-1}}}\,\overset{L_{0}^{\dagger}}{\overbrace{Q^{\dagger}}}]^{\dagger}\\
# = & [R_{0}^{\dagger}D_{0}L_{0}^{\dagger}]^{\dagger}\\
# = & L_{0}D_{0}R_{0}.
# \end{align*}
# ```
# """
# function adjoint_inv_ldr!(A⁻ᵀ::LDR{T}, A::AbstractMatrix{T}, ws::LDRWorkspace{T}) where {T}
# # calculate A = Q⋅R⋅Pᵀ
# copyto!(A⁻ᵀ.L, A)
# LAPACK.geqp3!(A⁻ᵀ.L, ws.qr_ws)
# copyto!(A⁻ᵀ.R, A⁻ᵀ.L)
# triu!(A⁻ᵀ.R) # R (set lower triangular to 0)
# pᵀ = ws.qr_ws.jpvt
# p = ws.lu_ws.ipiv
# inv_P!(p, pᵀ) # P
# LAPACK.orgqr!(Aᵀ.L, ws.qr_ws) # L₀ = Q
# @fastmath @inbounds for i in eachindex(A⁻ᵀ.d)
# A⁻ᵀ.d[i] = inv(abs(A⁻ᵀ.R[i,i])) # D₀ = |diag(R)|⁻¹
# end
# R′ = A⁻ᵀ.R
# lmul_D!(A⁻ᵀ.d, R′) # R′ := |diag(R)|⁻¹⋅R
# R″ = R′
# LinearAlgebra.inv!(UpperTriangular(R″)) # R″ = (R′)⁻¹ = R⁻¹⋅|diag(R)|
# R₀ᵀ = ws.M
# mul_P!(R₀ᵀ, p, R″) # R₀ᵀ = P⋅R″ = P⋅R⁻¹⋅diag(R)
# adjoint(A⁻ᵀ.R, R₀ᵀ) # R₀ = [P⋅R⁻¹⋅diag(R)]ᵀ
# return nothing
# end
@doc raw"""
inv_IpA!(G::AbstractMatrix{T}, A::LDR{T,E}, ws::LDRWorkspace{T,E})::Tuple{E,T} where {T,E}
Calculate the numerically stable inverse ``G := [I + A]^{-1},`` where ``G`` is a matrix,
and ``A`` is represented by a [`LDR`](@ref) factorization. This method also returns
``\log( \vert \det G\vert )`` and ``\textrm{sign}(\det G).``
# Algorithm
The numerically stable inverse ``G := [I + A]^{-1}`` is calculated using the procedure
```math
\begin{align*}
G:= & [I+A]^{-1}\\
= & [I+L_{a}D_{a}R_{a}]^{-1}\\
= & [I+L_{a}D_{a,\min}D_{a,\max}R_{a}]^{-1}\\
= & [(R_{a}^{-1}D_{a,\max}^{-1}+L_{a}D_{a,\min})D_{a,\max}R_{a}]^{-1}\\
= & R_{a}^{-1}D_{a,\max}^{-1}[\overset{M}{\overbrace{R_{a}^{-1}D_{a,\max}^{-1}+L_{a}D_{a,\min}}}]^{-1}\\
= & R_{a}^{-1}D_{a,\max}^{-1}M^{-1},
\end{align*}
```
where ``D_{a,\min} = \min(D_a, 1)`` and ``D_{a,\max} = \max(D_a, 1).``
Intermediate matrix inversions and relevant determinant calculations are performed
via LU factorizations with partial pivoting.
"""
function inv_IpA!(G::AbstractMatrix{T}, A::LDR{T,E}, ws::LDRWorkspace{T,E})::Tuple{E,T} where {T,E}
Lₐ = A.L
dₐ = A.d
Rₐ = A.R
# calculate Rₐ⁻¹
Rₐ⁻¹ = ws.M′
copyto!(Rₐ⁻¹, Rₐ)
logdetRₐ⁻¹, sgndetRₐ⁻¹ = inv_lu!(Rₐ⁻¹, ws.lu_ws)
# calculate D₋ = min(Dₐ, 1)
d₋ = ws.v
@. d₋ = min(dₐ, 1)
# calculate Lₐ⋅D₋
mul_D!(ws.M, Lₐ, d₋)
# calculate D₊ = max(Dₐ, 1)
d₊ = ws.v
@. d₊ = max(dₐ, 1)
# calculate sign(det(D₊)) and log(|det(D₊)|)
logdetD₊, sgndetD₊ = det_D(d₊)
# calculate Rₐ⁻¹⋅D₊⁻¹
Rₐ⁻¹D₊ = Rₐ⁻¹
rdiv_D!(Rₐ⁻¹D₊, d₊)
# calculate M = Rₐ⁻¹⋅D₊⁻¹ + Lₐ⋅D₋
axpy!(1.0, Rₐ⁻¹D₊, ws.M)
# calculate M⁻¹ = [Rₐ⁻¹⋅D₊⁻¹ + Lₐ⋅D₋]⁻¹
M⁻¹ = ws.M
logdetM⁻¹, sgndetM⁻¹ = inv_lu!(M⁻¹, ws.lu_ws)
# calculate G = Rₐ⁻¹⋅D₊⁻¹⋅M⁻¹
mul!(G, Rₐ⁻¹D₊, M⁻¹)
# calculate sign(det(G)) and log(|det(G)|)
sgndetG = sgndetRₐ⁻¹ * conj(sgndetD₊) * sgndetM⁻¹
logdetG = -logdetD₊ + logdetM⁻¹
return real(logdetG), sgndetG
end
@doc raw"""
inv_IpUV!(G::AbstractMatrix{T}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E})::Tuple{E,T} where {T,E}
Calculate the numerically stable inverse ``G := [I + UV]^{-1},`` where ``G`` is a matrix and
``U`` and ``V`` are represented by [`LDR`](@ref) factorizations. This method also returns
``\log( \vert \det G\vert )`` and ``\textrm{sign}(\det G).``
# Algorithm
The numerically stable inverse ``G := [I + UV]^{-1}`` is calculated using the procedure
```math
\begin{align*}
G:= & [I+UV]^{-1}\\
= & [I+L_{u}D_{u}R_{u}L_{v}D_{v}R_{v}]^{-1}\\
= & [I+L_{u}D_{u,\max}D_{u,\min}R_{u}L_{v}D_{v,\min}D_{v,\max}R_{v}]^{-1}\\
= & [L_{u}D_{u,\max}(D_{u,\max}^{-1}L_{u}^{\dagger}R_{v}^{-1}D_{v,\max}^{-1}+D_{u,\min}R_{u}L_{v}D_{v,\min})D_{v,\max}R_{v}]^{-1}\\
= & R_{v}^{-1}D_{v,\max}^{-1}[\overset{M}{\overbrace{D_{u,\max}^{-1}L_{u}^{\dagger}R_{v}^{-1}D_{v,\max}^{-1}+D_{u,\min}R_{u}L_{v}D_{v,\min}}}]^{-1}D_{u,\max}^{-1}L_{u}^{\dagger}\\
= & R_{v}^{-1}D_{v,\max}^{-1}M^{-1}D_{u,\max}^{-1}L_{u}^{\dagger}
\end{align*}
```
Intermediate matrix inversions and relevant determinant calculations are performed
via LU factorizations with partial pivoting.
"""
function inv_IpUV!(G::AbstractMatrix{T}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E})::Tuple{E,T} where {T,E}
Lᵤ = U.L
dᵤ = U.d
Rᵤ = U.R
Lᵥ = V.L
dᵥ = V.d
Rᵥ = V.R
# calculate sign(det(Lᵤ)) and log(|det(Lᵤ)|)
copyto!(ws.M, Lᵤ)
logdetLᵤ, sgndetLᵤ = det_lu!(ws.M, ws.lu_ws)
# calculate Rᵥ⁻¹, sign(det(Rᵥ⁻¹)) and log(|det(Rᵥ⁻¹)|)
Rᵥ⁻¹ = ws.M′
copyto!(Rᵥ⁻¹, Rᵥ)
logdetRᵥ⁻¹, sgndetRᵥ⁻¹ = inv_lu!(Rᵥ⁻¹, ws.lu_ws)
# calcuate Dᵥ₊ = max(Dᵥ, 1)
dᵥ₊ = ws.v
@. dᵥ₊ = max(dᵥ, 1)
# calculate sign(det(Dᵥ₊)) and log(|det(Dᵥ₊)|)
logdetDᵥ₊, sgndetDᵥ₊ = det_D(dᵥ₊)
# calculate Rᵥ⁻¹⋅Dᵥ₊⁻¹
rdiv_D!(Rᵥ⁻¹, dᵥ₊)
Rᵥ⁻¹Dᵥ₊⁻¹ = Rᵥ⁻¹
# calcuate Dᵤ₊ = max(Dᵤ, 1)
dᵤ₊ = ws.v
@. dᵤ₊ = max(dᵤ, 1)
# calculate sign(det(Dᵥ₊)) and log(|det(Dᵥ₊)|)
logdetDᵤ₊, sgndetDᵤ₊ = det_D(dᵤ₊)
# calcualte Dᵤ₊⁻¹⋅Lᵤᵀ
adjoint!(ws.M, Lᵤ)
ldiv_D!(dᵤ₊, ws.M)
Dᵤ₊⁻¹Lᵤᵀ = ws.M
# calculate Dᵤ₋ = min(Dᵤ, 1)
dᵤ₋ = ws.v
@. dᵤ₋ = min(dᵤ, 1)
# calculate Dᵤ₋⋅Rᵤ⋅Lᵥ
mul!(G, Rᵤ, Lᵥ) # Rᵤ⋅Lᵥ
lmul_D!(dᵤ₋, G) # Dᵤ₋⋅Rᵤ⋅Lᵥ
# calculate Dᵥ₋ = min(Dᵥ, 1)
dᵥ₋ = ws.v
@. dᵥ₋ = min(dᵥ, 1)
# caluclate Dᵤ₋⋅Rᵤ⋅Lᵥ⋅Dᵥ₋
rmul_D!(G, dᵥ₋)
# caluclate Dᵤ₊⁻¹⋅Lᵤᵀ⋅Rᵥ⁻¹⋅Dᵥ₊⁻¹
mul!(ws.M″, Dᵤ₊⁻¹Lᵤᵀ, Rᵥ⁻¹Dᵥ₊⁻¹)
# calculate M = Dᵤ₊⁻¹⋅Lᵤᵀ⋅Rᵥ⁻¹⋅Dᵥ₊⁻¹ + Dᵤ₋⋅Rᵤ⋅Lᵥ⋅Dᵥ₋
M = G
axpy!(1.0, ws.M″, M)
# calculate M⁻¹, sign(det(M)) and log(|det(M)|)
M⁻¹ = G
logdetM⁻¹, sgndetM⁻¹ = inv_lu!(M⁻¹, ws.lu_ws)
# calculate G = Rᵥ⁻¹⋅Dᵥ₊⁻¹⋅M⁻¹⋅Dᵤ₊⁻¹⋅Lᵤᵀ
mul!(ws.M″, M⁻¹, Dᵤ₊⁻¹Lᵤᵀ) # M⁻¹⋅Dᵤ₊⁻¹⋅Lᵤᵀ
mul!(G, Rᵥ⁻¹Dᵥ₊⁻¹, ws.M″) # G = Rᵥ⁻¹⋅Dᵥ₊⁻¹⋅M⁻¹⋅Dᵤ₊⁻¹⋅Lᵤᵀ
# calculate sign(det(G)) and log(|det(G)|)
sgndetG = sgndetRᵥ⁻¹ * conj(sgndetDᵥ₊) * sgndetM⁻¹ * conj(sgndetDᵤ₊) * conj(sgndetLᵤ)
logdetG = -logdetDᵥ₊ + logdetM⁻¹ - logdetDᵤ₊
return real(logdetG), sgndetG
end
@doc raw"""
inv_UpV!(G::AbstractMatrix{T}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E})::Tuple{E,T} where {T,E}
Calculate the numerically stable inverse ``G := [U+V]^{-1},`` where ``G`` is a matrix and ``U``
and ``V`` are represented by [`LDR`](@ref) factorizations. This method also returns
``\log( \vert \det G\vert )`` and ``\textrm{sign}(\det G).``
# Algorithm
The numerically stable inverse ``G := [U+V]^{-1}`` is calculated using the procedure
```math
\begin{align*}
G:= & [U+V]^{-1}\\
= & [\overset{D_{u,\max}D_{u,\min}}{L_{u}\overbrace{D_{u}}R_{u}}+\overset{D_{v,\min}D_{v,\max}}{L_{v}\overbrace{D_{v}}R_{v}}]^{-1}\\
= & [L_{u}D_{u,\max}D_{u,\min}R_{u}+L_{v}D_{v,\min}D_{v,\max}R_{v}]^{-1}\\
= & [L_{u}D_{u,\max}(D_{u,\min}R_{u}R_{v}^{-1}D_{v,\max}^{-1}+D_{u,\max}^{-1}L_{u}^{\dagger}L_{v}D_{v,\min})D_{v,\max}R_{v}]^{-1}\\
= & R_{v}^{-1}D_{v,\max}^{-1}[\overset{M}{\overbrace{D_{u,\min}R_{u}R_{v}^{-1}D_{v,\max}^{-1}+D_{u,\max}^{-1}L_{u}^{\dagger}L_{v}D_{v,\min}}}]^{-1}D_{u,\max}^{-1}L_{u}^{\dagger}\\
= & R_{v}^{-1}D_{v,\max}^{-1}M^{-1}D_{u,\max}^{-1}L_{u}^{\dagger},
\end{align*}
```
where
```math
\begin{align*}
D_{u,\min} = & \min(D_u,1)\\
D_{u,\max} = & \max(D_u,1)\\
D_{v,\min} = & \min(D_v,1)\\
D_{v,\max} = & \max(D_v,1),
\end{align*}
```
and all intermediate matrix inversions and determinant calculations are performed via LU factorizations with partial pivoting.
"""
function inv_UpV!(G::AbstractMatrix{T}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E})::Tuple{E,T} where {T,E}
Lᵤ = U.L
dᵤ = U.d
Rᵤ = U.R
Lᵥ = V.L
dᵥ = V.d
Rᵥ = V.R
# calculate sign(det(Lᵤ)) and log(|det(Lᵤ)|)
copyto!(ws.M, Lᵤ)
logdetLᵤ, sgndetLᵤ = det_lu!(ws.M, ws.lu_ws)
# calculate Rᵥ⁻¹, sign(det(Rᵥ⁻¹)) and log(|det(Rᵥ⁻¹)|)
Rᵥ⁻¹ = ws.M′
copyto!(Rᵥ⁻¹, Rᵥ)
logdetRᵥ⁻¹, sgndetRᵥ⁻¹ = inv_lu!(Rᵥ⁻¹, ws.lu_ws)
# calcuate Dᵥ₊ = max(Dᵥ, 1)
dᵥ₊ = ws.v
@. dᵥ₊ = max(dᵥ, 1)
# calculate sign(det(Dᵥ₊)) and log(|det(Dᵥ₊)|)
logdetDᵥ₊, sgndetDᵥ₊ = det_D(dᵥ₊)
# calculate Rᵥ⁻¹⋅Dᵥ₊⁻¹
rdiv_D!(Rᵥ⁻¹, dᵥ₊)
Rᵥ⁻¹Dᵥ₊⁻¹ = Rᵥ⁻¹
# calcuate Dᵤ₊ = max(Dᵤ, 1)
dᵤ₊ = ws.v
@. dᵤ₊ = max(dᵤ, 1)
# calculate sign(det(Dᵥ₊)) and log(|det(Dᵥ₊)|)
logdetDᵤ₊, sgndetDᵤ₊ = det_D(dᵤ₊)
# calcualte Dᵤ₊⁻¹⋅Lᵤᵀ
adjoint!(ws.M, Lᵤ)
ldiv_D!(dᵤ₊, ws.M)
Dᵤ₊⁻¹Lᵤᵀ = ws.M
# calculate Dᵤ₋ = min(Dᵤ, 1)
dᵤ₋ = ws.v
@. dᵤ₋ = min(dᵤ, 1)
# calculate Dᵤ₋⋅Rᵤ⋅Rᵥ⁻¹⋅Dᵥ₊⁻¹
mul!(G, Rᵤ, Rᵥ⁻¹Dᵥ₊⁻¹) # Rᵤ⋅Rᵥ⁻¹⋅Dᵥ₊⁻¹
lmul_D!(dᵤ₋, G) # Dᵤ₋⋅[Rᵤ⋅Rᵥ⁻¹⋅Dᵥ₊]
# calculate Dᵥ₋ = min(Dᵥ, 1)
dᵥ₋ = ws.v
@. dᵥ₋ = min(dᵥ, 1)
# calculate Dᵤ₊⁻¹⋅Lᵤᵀ⋅Lᵥ⋅Dᵥ₋
mul!(ws.M″, Dᵤ₊⁻¹Lᵤᵀ, Lᵥ)
rmul_D!(ws.M″, dᵥ₋)
# calculate M = Dᵤ₋⋅Rᵤ⋅Rᵥ⁻¹⋅Dᵥ₊ + Dᵤ₊⁻¹⋅Lᵤᵀ⋅Lᵥ⋅Dᵥ₋
M = G
axpy!(1.0, ws.M″, M)
# calculate M⁻¹, sign(det(M)) and log(|det(M)|)
M⁻¹ = G
logdetM⁻¹, sgndetM⁻¹ = inv_lu!(M⁻¹, ws.lu_ws)
# calculate G = Rᵥ⁻¹⋅Dᵥ₊⁻¹⋅M⁻¹⋅Dᵤ₊⁻¹⋅Lᵤᵀ
mul!(ws.M″, Rᵥ⁻¹Dᵥ₊⁻¹, M⁻¹) # [Rᵥ⁻¹⋅Dᵥ₊⁻¹]⋅M⁻¹
mul!(G, ws.M″, Dᵤ₊⁻¹Lᵤᵀ) # G = [Rᵥ⁻¹⋅Dᵥ₊⁻¹⋅M⁻¹]⋅Dᵤ₊⁻¹⋅Lᵤᵀ
# calculate sign(det(G)) and log(|det(G)|)
sgndetG = sgndetRᵥ⁻¹ * conj(sgndetDᵥ₊) * sgndetM⁻¹ * conj(sgndetDᵤ₊) * conj(sgndetLᵤ)
logdetG = -logdetDᵥ₊ + logdetM⁻¹ - logdetDᵤ₊
return real(logdetG), sgndetG
end
@doc raw"""
inv_invUpV!(G::AbstractMatrix{T}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E})::Tuple{E,T} where {T,E}
Calculate the numerically stable inverse ``G := [U^{-1}+V]^{-1},`` where ``G`` is a matrix and ``U``
and ``V`` are represented by [`LDR`](@ref) factorizations. This method also returns
``\log( \vert \det G\vert )`` and ``\textrm{sign}(\det G).``
# Algorithm
The numerically stable inverse ``G := [U^{-1}+V]^{-1}`` is calculated using the procedure
```math
\begin{align*}
G:= & [U^{-1}+V]^{-1}\\
= & [\overset{D_{u,\max}D_{u,\min}}{(L_{u}\overbrace{D_{u}}R_{u})^{-1}}+\overset{D_{v,\min}D_{v,\max}}{L_{v}\overbrace{D_{v}}R_{v}}]^{-1}\\
= & [(L_{u}D_{u,\max}D_{u,\min}R_{u})^{-1}+L_{v}D_{v,\min}D_{v,\max}R_{v}]^{-1}\\
= & [R_{u}^{-1}D_{u,\min}^{-1}D_{u,\max}^{-1}L_{u}^{\dagger}+L_{v}D_{v,\min}D_{v,\max}R_{v}]^{-1}\\
= & [R_{u}^{-1}D_{u,\min}^{-1}(D_{u,\max}^{-1}L_{u}^{\dagger}R_{v}^{-1}D_{v,\max}^{-1}+D_{u,\min}R_{u}L_{v}D_{v,\min})D_{v,\max}R_{v}]^{-1}\\
= & R_{v}^{-1}D_{v,\max}^{-1}[\overset{M}{\overbrace{D_{u,\max}^{-1}L_{u}^{\dagger}R_{v}^{-1}D_{v,\max}^{-1}+D_{u,\min}R_{u}L_{v}D_{v,\min}}}]^{-1}D_{u,\min}R_{u}\\
= & R_{v}^{-1}D_{v,\max}^{-1}M^{-1}D_{u,\min}R_{u}
\end{align*}
```
where
```math
\begin{align*}
D_{u,\min} = & \min(D_u,1)\\
D_{u,\max} = & \max(D_u,1)\\
D_{v,\min} = & \min(D_v,1)\\
D_{v,\max} = & \max(D_v,1),
\end{align*}
```
and all intermediate matrix inversions and determinant calculations are performed via LU factorizations with partial pivoting.
"""
function inv_invUpV!(G::AbstractMatrix{T}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E})::Tuple{E,T} where {T,E}
Lᵤ = U.L
dᵤ = U.d
Rᵤ = U.R
Lᵥ = V.L
dᵥ = V.d
Rᵥ = V.R
# calcualte sign(det(Rᵤ)) and log(|det(Rᵤ)|)
copyto!(ws.M′, Rᵤ)
logdetRᵤ, sgndetRᵤ = det_lu!(ws.M′, ws.lu_ws)
# calculate Dᵤ₋ = min(Dᵤ, 1)
dᵤ₋ = ws.v
@. dᵤ₋ = min(dᵤ, 1)
# calculate sign(det(Dᵤ₋)) and log(|det(Dᵤ₋)|)
logdetDᵤ₋, sgndetDᵤ₋ = det_D(dᵤ₋)
# calculate Dᵤ₋⋅Rᵤ
Dᵤ₋Rᵤ = ws.M′
copyto!(Dᵤ₋Rᵤ, Rᵤ)
lmul_D!(dᵤ₋, Dᵤ₋Rᵤ)
# calculate Rᵥ⁻¹, sign(det(Rᵥ⁻¹)) and log(|det(Rᵥ⁻¹)|)
Rᵥ⁻¹ = ws.M″
copyto!(Rᵥ⁻¹, Rᵥ)
logdetRᵥ⁻¹, sgndetRᵥ⁻¹ = inv_lu!(Rᵥ⁻¹, ws.lu_ws)
# calculate Dᵥ₊ = max(Dᵥ, 1)
dᵥ₊ = ws.v
@. dᵥ₊ = max(dᵥ, 1)
# calculate sign(det(Dᵥ₊)) and log(|det(Dᵥ₊)|)
logdetDᵥ₊, sgndetDᵥ₊ = det_D(dᵥ₊)
# calculate Rᵥ⁻¹⋅Dᵥ₊⁻¹
Rᵥ⁻¹Dᵥ₊⁻¹ = Rᵥ⁻¹
rdiv_D!(Rᵥ⁻¹Dᵥ₊⁻¹, dᵥ₊)
# calculate Dᵥ₋ = min(Dᵥ, 1)
dᵥ₋ = ws.v
@. dᵥ₋ = min(dᵥ, 1)
# calculate Dᵤ₋⋅Rᵤ⋅Lᵥ⋅Dᵥ₋
mul!(G, Dᵤ₋Rᵤ, Lᵥ) # Dᵤ₋⋅Rᵤ⋅Lᵥ
rmul_D!(G, dᵥ₋) # [Dᵤ₋⋅Rᵤ⋅Lᵥ]⋅Dᵥ₋
# calculate Dᵤ₊ = max(Dᵤ, 1)
dᵤ₊ = ws.v
@. dᵤ₊ = max(dᵤ, 1)
# calculate Dᵤ₊⁻¹⋅Lᵤᵀ⋅Rᵥ⁻¹⋅Dᵥ₊⁻¹
Lᵤᵀ = adjoint(Lᵤ)
mul!(ws.M, Lᵤᵀ, Rᵥ⁻¹Dᵥ₊⁻¹) # Lᵤᵀ⋅[Rᵥ⁻¹⋅Dᵥ₊⁻¹]
ldiv_D!(dᵤ₊, ws.M) # Dᵤ₊⁻¹⋅[Lᵤᵀ⋅Rᵥ⁻¹⋅Dᵥ₊⁻¹]
# calculate Dᵤ₊⁻¹⋅Lᵤᵀ⋅Rᵥ⁻¹⋅Dᵥ₊⁻¹ + Dᵤ₋⋅Rᵤ⋅Lᵥ⋅Dᵥ₋
axpy!(1.0, ws.M, G)
# calculate M⁻¹, sign(det(M⁻¹)) and log(|det(M⁻¹)|)
M⁻¹ = G
logdetM⁻¹, sgndetM⁻¹ = inv_lu!(M⁻¹, ws.lu_ws)
# calculate G := Rᵥ⁻¹⋅Dᵥ₊⁻¹⋅M⁻¹⋅Dᵤ₋⋅Rᵤ
mul!(ws.M, M⁻¹, Dᵤ₋Rᵤ) # M⁻¹⋅Dᵤ₋⋅Rᵤ
mul!(G, Rᵥ⁻¹Dᵥ₊⁻¹, ws.M) # G := Rᵥ⁻¹⋅Dᵥ₊⁻¹⋅[M⁻¹⋅Dᵤ₋⋅Rᵤ]
# calcualte sign(det(G)) and log(|det(G)|)
sgndetG = sgndetRᵥ⁻¹ * conj(sgndetDᵥ₊) * sgndetM⁻¹ * sgndetDᵤ₋ * sgndetRᵤ
logdetG = -logdetDᵥ₊ + logdetM⁻¹ + logdetDᵤ₋
return real(logdetG), sgndetG
end | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 6328 | import LinearAlgebra.LAPACK: getrf!, getri!, getrs!
@doc raw"""
LUWorkspace{T<:Number, E<:Real}
Allocated space for calcuating the pivoted QR factorization using the LAPACK
routine `getrf!`. Also interfaces with the `getri!` and `getrs!` routines for
inverting matrices and solving linear systems respectively.
"""
struct LUWorkspace{T<:Number}
work::Vector{T}
ipiv::Vector{Int}
end
# copy the state of one LUWorkspace into another
function copyto!(luws_out::LUWorkspace{T}, luws_in::LUWorkspace{T}) where {T}
copyto!(luws_out.work, luws_in.work)
copyto!(luws_out.ipiv, luws_in.ipiv)
return nothing
end
# wrap geqp3 and orgqr LAPACK methods
for (getrf, getri, getrs, elty, relty) in ((:dgetrf_, :dgetri_, :dgetrs_, :Float64, :Float64),
(:sgetrf_, :sgetri_, :sgetrs_, :Float32, :Float32),
(:zgetrf_, :zgetri_, :zgetrs_, :ComplexF64, :Float64),
(:cgetrf_, :cgetri_, :cgetrs_, :ComplexF32, :Float32))
@eval begin
# returns LUWorkspace
function LUWorkspace(A::StridedMatrix{$elty})
# calculate LU factorization
n = checksquare(A)
require_one_based_indexing(A)
chkstride1(A)
A′ = copy(A)
lda = max(1, stride(A′, 2))
info = Ref{BlasInt}()
ipiv = zeros(Int, n)
ccall((@blasfunc($getrf), liblapack), Cvoid,
(Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty},
Ref{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
n, n, A′, lda, ipiv, info)
chklapackerror(info[])
# perform matrix inversion method once to resize workspace
lwork = BlasInt(-1)
work = Vector{$elty}(undef, 1)
ccall((@blasfunc($getri), liblapack), Cvoid,
(Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt},
Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt}),
n, A, lda, ipiv, work, lwork, info)
chklapackerror(info[])
lwork = BlasInt(real(work[1]))
resize!(work, lwork)
return LUWorkspace(work, ipiv)
end
# calculates LU factorization
function getrf!(A::AbstractMatrix{$elty}, ws::LUWorkspace{$elty})
require_one_based_indexing(A)
chkstride1(A)
n = checksquare(A)
lda = max(1, stride(A, 2))
info = Ref{BlasInt}()
fill!(ws.ipiv, 0)
ccall((@blasfunc($getrf), liblapack), Cvoid,
(Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty},
Ref{BlasInt}, Ptr{BlasInt}, Ptr{BlasInt}),
n, n, A, lda, ws.ipiv, info)
chklapackerror(info[])
return nothing
end
# calculate matrix inverse of LU factorization
function getri!(A::AbstractMatrix{$elty}, ws::LUWorkspace{$elty})
require_one_based_indexing(A, ws.ipiv)
chkstride1(A, ws.ipiv)
n = checksquare(A)
lda = max(1,stride(A, 2))
info = Ref{BlasInt}()
ccall((@blasfunc($getri), liblapack), Cvoid,
(Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt},
Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt}),
n, A, lda, ws.ipiv, ws.work, length(ws.work), info)
chklapackerror(info[])
return nothing
end
# solve the linear system A⋅X = B, where A is represented by LU factorization and B is overwritten in-place
function getrs!(A::AbstractMatrix{$elty}, B::AbstractVecOrMat{$elty}, ws::LUWorkspace{$elty}, trans::AbstractChar='N')
require_one_based_indexing(A, B)
chktrans(trans)
chkstride1(A, B)
n = checksquare(A)
@assert n == length(ws.ipiv) WorkspaceSizeError(length(ws.ipiv), n)
if n != size(B, 1)
throw(DimensionMismatch("B has leading dimension $(size(B,1)), but needs $n"))
end
info = Ref{BlasInt}()
ccall((@blasfunc($getrs), liblapack), Cvoid,
(Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt},
Ptr{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt}, Clong),
trans, n, size(B,2), A, max(1,stride(A,2)), ws.ipiv, B, max(1,stride(B,2)), info, 1)
chklapackerror(info[])
return nothing
end
end
end
@doc raw"""
det_lu!(A::AbstractMatrix{T}, ws::LUWorkspace{T}) where {T}
Return ``\log(|\det A|)`` and ``\textrm{sign}(\det A).``
Note that ``A`` is left modified by this function.
"""
function det_lu!(A::AbstractMatrix{T}, ws::LUWorkspace{T}) where {T}
# calculate LU factorization
LAPACK.getrf!(A, ws)
# calculate det(A)
logdetA = zero(real(T)) # logdetA = 0
sgndetA = oneunit(T) # sgndetA = 1
@fastmath @inbounds for i in axes(A,1)
logdetA += log(abs(A[i,i]))
sgndetA *= sign(A[i,i])
if i != ws.ipiv[i]
sgndetA = -sgndetA
end
end
return real(logdetA), sgndetA
end
@doc raw"""
inv_lu!(A::AbstractMatrix{T}, ws::LUWorkspace{T}) where {T}
Calculate the inverse of the matrix `A`, overwriting `A` in-place.
Also return ``\log(|\det A^{-1}|)`` and ``\textrm{sign}(\det A^{-1}).``
"""
function inv_lu!(A::AbstractMatrix{T}, ws::LUWorkspace{T}) where {T}
# calculate LU factorization of A and determinant at the same time
logdetA, sgndetA = det_lu!(A, ws)
# calculate matrix inverse
LAPACK.getri!(A, ws)
return real(-logdetA), conj(sgndetA)
end
@doc raw"""
ldiv_lu!(A::AbstractMatrix{T}, B::AbstractMatrix{T}, ws::LUWorkspace{T}) where {T}
Calculate ``B:= A^{-1} B,`` modifying ``B`` in-place. The matrix ``A`` is over-written as well.
Also return ``\log(|\det A^{-1}|)`` and ``\textrm{sign}(\det A^{-1}).``
"""
function ldiv_lu!(A::AbstractMatrix{T}, B::AbstractMatrix{T}, ws::LUWorkspace{T}) where {T}
# calculate LU factorization of A and determinant at the same time
logdetA, sgndetA = det_lu!(A, ws)
# calculate the matrix product A⁻¹⋅B
LAPACK.getrs!(A, B, ws)
return real(-logdetA), conj(sgndetA)
end | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 20545 | ###############################
## OVERLOADING Base.eltype() ##
###############################
@doc raw"""
eltype(LDR{T}) where {T}
Return the matrix element type `T` of the [`LDR`](@ref) factorization `F`.
"""
eltype(F::LDR{T}) where {T} = T
#############################
## OVERLOADING Base.size() ##
#############################
@doc raw"""
size(F::LDR, dim...)
Return the size of the [`LDR`](@ref) factorization `F`.
"""
size(F::LDR, dim...) = size(F.L, dim...)
################################
## OVERLOADING Base.copyto!() ##
################################
@doc raw"""
copyto!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Copy the matrix represented by the [`LDR`](@ref) factorization `V` into the matrix `U`.
"""
function copyto!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
(; L, d, R) = V
(; M) = ws
copyto!(M, R) # R
lmul_D!(d, M) # D⋅R
mul!(U, L, M) # U = L⋅D⋅R
return nothing
end
@doc raw"""
copyto!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E} = ldr!(U,V,ws)
copyto!(U::LDR, I::UniformScaling, ignore...) = ldr!(U,I)
Copy the matrix `V` to the [`LDR`](@ref) factorization `U`, calculating the
[`LDR`](@ref) factorization to represent `V`.
"""
copyto!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E} = ldr!(U,V,ws)
copyto!(U::LDR, I::UniformScaling, ignore...) = ldr!(U,I)
@doc raw"""
copyto!(U::LDR{T,E}, V::LDR{T,E}, ignore...) where {T,E}
Copy the ['LDR'](@ref) factorization `V` to `U`.
"""
copyto!(U::LDR{T,E}, V::LDR{T,E}, ignore...) where {T,E} = ldr!(U, V)
##########################################
## OVERLOADING LinearAlgebra.adjoint!() ##
##########################################
@doc raw"""
adjoint!(Aᵀ::AbstractMatrix{T}, A::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Given an [`LDR`](@ref) factorization ``A``, construct the matrix representing its adjoint ``A^{\dagger}.``
"""
function adjoint!(Aᵀ::AbstractMatrix{T}, A::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
(; L, d, R) = A
Rᵀ = ws.M′
adjoint!(Rᵀ, R)
adjoint!(ws.M, L) # Lᵀ
lmul_D!(d, ws.M) # D⋅Lᵀ
mul!(Aᵀ, Rᵀ, ws.M) # Rᵀ⋅D⋅Lᵀ
return nothing
end
#######################################
## OVERLOADING LinearAlgebra.lmul!() ##
#######################################
@doc raw"""
lmul!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate ``V := U V`` where ``U`` is a [`LDR`](@ref) factorization and ``V`` is a matrix.
"""
function lmul!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
# calculate V := Lᵤ⋅Dᵤ⋅Rᵤ⋅V
mul!(ws.M, U.R, V) # Rᵤ⋅V
lmul_D!(U.d, ws.M) # Dᵤ⋅Rᵤ⋅V
mul!(V, U.L, ws.M) # V := Lᵤ⋅Dᵤ⋅Rᵤ⋅V
return nothing
end
@doc raw"""
lmul!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``V := U V,`` where ``U`` is a matrix and ``V`` is an [`LDR`](@ref) factorization.
# Algorithm
Calculate ``V := U V`` using the procedure
```math
\begin{align*}
V:= & UV\\
= & \overset{L_{0}D_{0}R_{0}}{\overbrace{U[L_{v}D_{v}}}R_{v}]\\
= & \overset{L_{1}}{\overbrace{L_{0}}}\,\overset{D_{1}}{\overbrace{D_{0}}}\,\overset{R_{1}}{\overbrace{R_{0}R_{v}}}\\
= & L_{1}D_{1}R_{1}.
\end{align*}
```
"""
function lmul!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
# record original Rᵥ matrix
Rᵥ = ws.M′
copyto!(Rᵥ, V.R)
# calculate product U⋅Lᵥ⋅Dᵥ
mul!(ws.M, U, V.L) # U⋅Lᵥ
mul_D!(V.L, ws.M, V.d) # U⋅Lᵥ⋅Dᵥ
# calcualte [L₀⋅D₀⋅R₀] = U⋅Lᵥ⋅Dᵥ
ldr!(V, ws)
# calcualte R₁ = R₀⋅Rᵥ
mul!(ws.M, V.R, Rᵥ)
copyto!(V.R, ws.M)
return nothing
end
@doc raw"""
lmul!(U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``V := U V,`` where ``U`` and ``V`` are both [`LDR`](@ref) factorizations.
# Algorithm
Calculate ``V := U V`` using the procedure
```math
\begin{align*}
V:= & UV\\
= & [L_{u}D_{u}\overset{M}{\overbrace{R_{u}][L_{v}}}D_{v}R_{v}]\\
= & L_{u}\overset{L_{0}D_{0}R_{0}}{\overbrace{D_{u}MD_{v}}}R_{v}\\
= & \overset{L_{1}}{\overbrace{L_{u}L_{0}}}\,\overset{D_{1}}{\overbrace{D_{0}}}\,\overset{R_{1}}{\overbrace{R_{0}R_{v}}}\\
= & L_{1}D_{1}R_{1}.
\end{align*}
```
"""
function lmul!(U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
# record original Rᵥ
Rᵥ = ws.M′
copyto!(Rᵥ, V.R)
# calculate M = Rᵤ⋅Lᵥ
mul!(ws.M, U.R, V.L)
# calculate Dᵤ⋅M⋅Dᵥ
rmul_D!(ws.M, V.d) # M⋅Dᵥ
mul_D!(V.L, U.d, ws.M) # Dᵤ⋅M⋅Dᵥ
# calculate [L₀⋅D₀⋅R₀] = Dᵤ⋅M⋅Dᵥ
ldr!(V, ws)
# calculate L₁ = Lᵤ⋅L₀
mul!(ws.M, U.L, V.L)
copyto!(V.L, ws.M)
# calculate R₁ = R₀⋅Rᵥ
mul!(ws.M, V.R, Rᵥ)
copyto!(V.R, ws.M)
return nothing
end
#######################################
## OVERLOADING LinearAlgebra.rmul!() ##
#######################################
@doc raw"""
rmul!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate ``U := U V`` where ``U`` is a matrix and ``V`` is a [`LDR`](@ref) factorization.
"""
function rmul!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
# calculate U := U⋅Lᵥ⋅Dᵥ⋅Rᵥ
mul!(ws.M, U, V.L) # U⋅Lᵥ
rmul_D!(ws.M, V.d) # U⋅Lᵥ⋅Dᵥ
mul!(U, ws.M, V.R) # U := U⋅Lᵥ⋅Dᵥ⋅Rᵥ
return nothing
end
@doc raw"""
rmul!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``U := U V,`` where ``U`` is a [`LDR`](@ref) factorization and ``V`` is a matrix.
# Algorithm
Calculate ``U := U V`` using the procedure
```math
\begin{align*}
U:= & UV\\
= & [L_{u}\overset{L_{0}D_{0}R_{0}}{\overbrace{D_{u}R_{u}]V}}\\
= & \overset{L_{1}}{\overbrace{L_{u}L_{0}}}\,\overset{D_{1}}{\overbrace{D_{0}}}\,\overset{R_{1}}{\overbrace{R_{0}}}\\
= & L_{1}D_{1}R_{1}.
\end{align*}
```
"""
function rmul!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
# record intial Lₐ
Lᵤ = ws.M′
copyto!(Lᵤ, U.L)
# calculate Dᵤ⋅Rᵤ⋅V
mul!(U.L, U.R, V)
lmul_D!(U.d, U.L)
# calculate [L₀⋅D₀⋅R₀] = Dᵤ⋅Rᵤ⋅V
ldr!(U, ws)
# calculate L₁ = Lᵤ⋅L₀
mul!(ws.M, Lᵤ, U.L)
copyto!(U.L, ws.M)
return nothing
end
@doc raw"""
rmul!(U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``U := U V,`` where both ``U`` and ``V`` are [`LDR`](@ref) factorizations.
# Algorithm
Calculate ``U := U V`` using the procedure
```math
\begin{align*}
U:= & UV\\
= & [L_{u}D_{u}\overset{M}{\overbrace{R_{u}][L_{v}}}D_{v}R_{v}]\\
= & L_{u}\overset{L_{0}D_{0}R_{0}}{\overbrace{D_{u}MD_{v}}}R_{v}\\
= & \overset{L_{1}}{\overbrace{L_{u}L_{0}}}\,\overset{D_{1}}{\overbrace{D_{0}}}\,\overset{R_{1}}{\overbrace{R_{0}R_{v}}}\\
= & L_{1}D_{1}R_{1}.
\end{align*}
```
"""
function rmul!(U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
# record initial Lᵤ
Lᵤ = ws.M′
copyto!(Lᵤ, U.L)
# calculate M = Rᵤ⋅Lᵥ
mul!(ws.M, U.R, V.L)
# calculate Dᵤ⋅Rᵤ⋅Lᵥ⋅Dᵥ
rmul_D!(ws.M, V.d)
mul_D!(U.L, U.d, ws.M)
# calculate [L₀⋅D₀⋅R₀] = Dᵤ⋅Rᵤ⋅Lᵥ⋅Dᵥ
ldr!(U, ws)
# L₁ = Lᵤ⋅L₀
mul!(ws.M, Lᵤ, U.L)
copyto!(U.L, ws.M)
# R₁ = R₀⋅Rᵥ
mul!(ws.M, U.R, V.R)
copyto!(U.R, ws.M)
return nothing
end
######################################
## OVERLOADING LinearAlgebra.mul!() ##
######################################
@doc raw"""
mul!(H::AbstractMatrix{T}, U::LDR{T,E}, V::AbstractMatrix{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the matrix product ``H := U V``, where ``H`` and ``V`` are matrices and ``U`` is
a [`LDR`](@ref) factorization.
"""
function mul!(H::AbstractMatrix{T}, U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, V)
lmul!(U, H, ws)
return nothing
end
@doc raw"""
mul!(H::AbstractMatrix{T}, U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the matrix product ``H := U V``, where ``H`` and ``U`` are matrices and ``V`` is
a [`LDR`](@ref) factorization.
"""
function mul!(H::AbstractMatrix{T}, U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, U)
rmul!(H, V, ws)
return nothing
end
@doc raw"""
mul!(H::LDR{T,E}, U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``H := U V``, where ``U`` is matrix, and ``H`` and
``V`` are both [`LDR`](@ref) factorization. For the algorithm refer to documentation for [`lmul!`](@ref).
"""
function mul!(H::LDR{T,E}, U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, V)
lmul!(U, H, ws)
return nothing
end
@doc raw"""
mul!(H::LDR{T,E}, U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``H := U V``, where ``V`` is matrix, and ``H`` and
``U`` are both [`LDR`](@ref) factorizations. For the algorithm refer to the documentation for [`rmul!`](@ref).
"""
function mul!(H::LDR{T,E}, U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, U)
rmul!(H, V, ws)
return nothing
end
@doc raw"""
mul!(H::LDR{T,E}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable matrix product ``H := U V,`` where ``H,`` ``U`` and ``V`` are all
[`LDR`](@ref) factorizations. For the algorithm refer to the documentation for [`lmul!`](@ref).
"""
function mul!(H::LDR{T,E}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, V)
lmul!(U, H, ws)
return nothing
end
#######################################
## OVERLOADING LinearAlgebra.ldiv!() ##
#######################################
@doc raw"""
ldiv!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate ``V := U^{-1} V,`` where ``V`` is a matrix, and ``U`` is an [`LDR`](@ref) factorization.
"""
function ldiv!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
# calculate V := U⁻¹⋅V = [Lᵤ⋅Dᵤ⋅Rᵤ]⁻¹⋅V = Rᵤ⁻¹⋅Dᵤ⁻¹⋅Lᵤ⁻¹⋅V
Lᵤ = ws.M
copyto!(Lᵤ, U.L)
ldiv_lu!(Lᵤ, V, ws.lu_ws) # Lᵤ⁻¹⋅V
ldiv_D!(U.d, V) # Dᵤ⁻¹⋅Lᵤ⁻¹⋅V
Rᵤ = ws.M
copyto!(Rᵤ, U.R)
ldiv_lu!(Rᵤ, V, ws.lu_ws) # V := Rᵤ⁻¹⋅Dᵤ⁻¹⋅Lᵤ⁻¹⋅V
return nothing
end
@doc raw"""
ldiv!(H::AbstractMatrix{T}, U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate ``H := U^{-1} V,`` where ``H`` and ``V`` are matrices, and ``U`` is an [`LDR`](@ref) factorization.
"""
function ldiv!(H::AbstractMatrix{T}, U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, V)
ldiv!(U, H, ws)
return nothing
end
@doc raw"""
ldiv!(U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``V := U^{-1}V`` where both ``U`` and ``V`` are [`LDR`](@ref) factorizations.
Note that an intermediate LU factorization is required to calucate the matrix inverse ``R_u^{-1},`` in addition to the
intermediate [`LDR`](@ref) factorization that needs to occur.
# Algorithm
Calculate ``V := U^{-1}V`` using the procedure
```math
\begin{align*}
V:= & U^{-1}V\\
= & [L_{u}D_{u}R_{u}]^{-1}[L_{v}D_{v}R_{v}]\\
= & R_{u}^{-1}D_{u}^{-1}\overset{M}{\overbrace{L_{u}^{\dagger}L_{v}}}D_{v}R_{v}\\
= & \overset{L_{0}D_{0}R_{0}}{\overbrace{R_{u}^{-1}D_{u}^{-1}MD_{v}}}R_{v}\\
= & \overset{L_{1}}{\overbrace{L_{0}}}\,\overset{D_{1}}{\overbrace{D_{0}^{\phantom{1}}}}\,\overset{R_{1}}{\overbrace{R_{0}R_{v}^{\phantom{1}}}}\\
= & L_{1}D_{1}R_{1}.
\end{align*}
```
"""
function ldiv!(U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
# calculate Lᵤᵀ⋅Lᵥ
Lᵤᵀ = adjoint(U.L)
mul!(ws.M, Lᵤᵀ, V.L)
copyto!(V.L, ws.M)
# record initial Rᵥ
Rᵥ = ws.M′
copyto!(Rᵥ, V.R)
# calculate Rᵤ⁻¹⋅Dᵤ⁻¹⋅Lᵤᵀ⋅Lᵥ⋅Dᵥ
rmul_D!(V.L, V.d) # [Lᵤᵀ⋅Lᵥ]⋅Dᵥ
ldiv_D!(U.d, V.L) # Dᵤ⁻¹⋅[Lᵤᵀ⋅Lᵥ⋅Dᵥ]
Rᵤ = ws.M
copyto!(Rᵤ, U.R)
ldiv_lu!(Rᵤ, V.L, ws.lu_ws) # Rᵤ⁻¹⋅[Dᵤ⁻¹⋅Lᵤᵀ⋅Lᵥ⋅Dᵥ]
# calculate [L₀⋅D₀⋅R₀] = Rᵤ⁻¹⋅Dᵤ⁻¹⋅Lᵤᵀ⋅Lᵥ⋅Dᵥ
ldr!(V, ws)
# calculate R₁ = R₀⋅Rᵥ
mul!(ws.M, V.R, Rᵥ)
copyto!(V.R, ws.M)
return nothing
end
@doc raw"""
ldiv!(H::LDR{T,E}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``H := U^{-1} V,`` where ``H,`` ``U`` and ``V`` are all [`LDR`](@ref) factorizations.
Note that an intermediate LU factorization is required to calucate the matrix inverse ``R_u^{-1},`` in addition to the
intermediate [`LDR`](@ref) factorization that needs to occur.
"""
function ldiv!(H::LDR{T,E}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, V)
ldiv!(U, H, ws)
return nothing
end
@doc raw"""
ldiv!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``V := U^{-1} V,`` where ``U`` is a matrix and ``V`` is a [`LDR`](@ref) factorization.
Note that an intermediate LU factorization is required as well to calucate the matrix inverse ``U^{-1},`` in addition to the
intermediate [`LDR`](@ref) factorization that needs to occur.
# Algorithm
The numerically stable procdure used to evaluate ``V := U^{-1} V`` is
```math
\begin{align*}
V:= & U^{-1}V\\
= & \overset{L_{0}D_{0}R_{0}}{\overbrace{U^{-1}[L_{v}D_{v}}}R_{v}]\\
= & \overset{L_{1}}{\overbrace{L_{0}}}\,\overset{D_{1}}{\overbrace{D_{0}}}\,\overset{R_{1}}{\overbrace{R_{0}R_{v}}}\\
= & L_{1}D_{1}R_{1}.
\end{align*}
```
"""
function ldiv!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
# store Rᵥ for later
Rᵥ = ws.M′
copyto!(Rᵥ, V.R)
# calculate U⁻¹⋅Lᵥ⋅Dᵥ
rmul_D!(V.L, V.d) # Lᵥ⋅Dᵥ
copyto!(ws.M, U)
ldiv_lu!(ws.M, V.L, ws.lu_ws) # U⁻¹⋅Lᵥ⋅Dᵥ
# calculate [L₀⋅D₀⋅R₀] = U⁻¹⋅Lᵥ⋅Dᵥ
ldr!(V, ws)
# R₁ = R₀⋅Rᵥ
mul!(ws.M, V.R, Rᵥ)
copyto!(V.R, ws.M)
return nothing
end
@doc raw"""
ldiv!(H::LDR{T,E}, U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``H := U^{-1} V,`` where ``H`` and ``V`` are [`LDR`](@ref)
factorizations and ``U`` is a matrix. Note that an intermediate LU factorization is required to
calculate ``U^{-1},`` in addition to the intermediate [`LDR`](@ref) factorization that needs to occur.
"""
function ldiv!(H::LDR{T,E}, U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T}) where {T,E}
copyto!(H, V)
ldiv!(U, H, ws)
return nothing
end
#######################################
## OVERLOADING LinearAlgebra.rdiv!() ##
#######################################
@doc raw"""
rdiv!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the matrix product ``U := U V^{-1},`` where ``V`` is an [`LDR`](@ref) factorization and ``U`` is a matrix.
Note that this requires two intermediate LU factorizations to calculate ``L_v^{-1}`` and ``R_v^{-1}``.
"""
function rdiv!(U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
# U := U⋅Rᵥ⁻¹⋅Dᵥ⁻¹⋅Lᵥ⁻¹
copyto!(ws.M, I)
Lᵥ = ws.M′
copyto!(Lᵥ, V.L)
ldiv_lu!(Lᵥ, ws.M, ws.lu_ws) # Lᵥ⁻¹
ldiv_D!(V.d, ws.M) # Dᵥ⁻¹⋅Lᵥ⁻¹
Rᵥ = ws.M′
copyto!(Rᵥ, V.R)
ldiv_lu!(Rᵥ, ws.M, ws.lu_ws) # Rᵥ⁻¹⋅Dᵥ⁻¹⋅Lᵥ⁻¹
mul!(ws.M′, U, ws.M) # U⋅Rᵥ⁻¹⋅Dᵥ⁻¹⋅Lᵥ⁻¹
copyto!(U, ws.M′) # U := U⋅Rᵥ⁻¹⋅Dᵥ⁻¹⋅Lᵥ⁻¹
return nothing
end
@doc raw"""
rdiv!(H::AbstractMatrix{T}, U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the matrix product ``H := U V^{-1},`` where ``H`` and ``U`` are matrices and ``V`` is a [`LDR`](@ref) factorization.
Note that this requires two intermediate LU factorizations to calculate ``L_v^{-1}`` and ``R_v^{-1}``.
"""
function rdiv!(H::AbstractMatrix{T}, U::AbstractMatrix{T}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, U)
rdiv!(H, V, ws)
return nothing
end
@doc raw"""
rdiv!(U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``U := U V^{-1}`` where both ``U`` and ``V`` are [`LDR`](@ref) factorizations.
Note that an intermediate LU factorization is required to calucate the matrix inverse ``L_v^{-1},`` in addition to the
intermediate [`LDR`](@ref) factorization that needs to occur.
# Algorithm
Calculate ``U := UV^{-1}`` using the procedure
```math
\begin{align*}
U:= & UV^{-1}\\
= & [L_{u}D_{u}R_{u}][L_{v}D_{v}R_{v}]^{-1}\\
= & L_{u}D_{u}\overset{M}{\overbrace{R_{u}R_{v}^{-1}}}D_{v}^{-1}L_{v}^{\dagger}\\
= & L_{u}\overset{L_{0}D_{0}R_{0}}{\overbrace{D_{u}MD_{v}^{-1}}}L_{v}^{\dagger}\\
= & \overset{L_{1}}{\overbrace{L_{u}L_{0}^{\phantom{1}}}}\,\overset{D_{1}}{\overbrace{D_{0}^{\phantom{1}}}}\,\overset{R_{1}}{\overbrace{R_{0}L_{v}^{\dagger}}}\\
= & L_{1}D_{1}R_{1}.
\end{align*}
```
"""
function rdiv!(U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
# calculate Rᵥ⁻¹
Rᵥ⁻¹ = ws.M′
copyto!(Rᵥ⁻¹, V.R)
inv_lu!(Rᵥ⁻¹, ws.lu_ws)
# calculate M = Rᵤ⋅Rᵥ⁻¹
mul!(ws.M, U.R, Rᵥ⁻¹)
# record original Lᵤ matrix
Lᵤ = ws.M′
copyto!(Lᵤ, U.L)
# calculate Dᵤ⋅M⋅Dᵥ⁻¹
div_D!(U.L, ws.M, V.d)
lmul_D!(U.d, U.L)
# calculate [L₀⋅D₀⋅R₀] = Dᵤ⋅M⋅Dᵥ⁻¹
ldr!(U, ws)
# L₁ = Lᵤ⋅L₀
mul!(ws.M, Lᵤ, U.L)
copyto!(U.L, ws.M)
# calculate Rᵥ = R₀⋅Lᵥᵀ
Lᵥᵀ = adjoint(V.L)
mul!(ws.M, U.R, Lᵥᵀ)
copyto!(U.R, ws.M)
return nothing
end
@doc raw"""
rdiv!(H::LDR{T,E}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``H := U V^{-1}`` where ``H,`` ``U`` and ``V`` are all [`LDR`](@ref) factorizations.
Note that an intermediate LU factorization is required to calucate the matrix inverse ``L_v^{-1},`` in addition to the
intermediate [`LDR`](@ref) factorization that needs to occur.
"""
function rdiv!(H::LDR{T,E}, U::LDR{T,E}, V::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, U)
rdiv!(H, V, ws)
return nothing
end
@doc raw"""
rdiv!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``U := U V^{-1},`` where ``V`` is a matrix and ``U`` is an [`LDR`](@ref) factorization.
Note that an intermediate LU factorization is required as well to calucate the matrix inverse ``V^{-1},`` in addition to the
intermediate [`LDR`](@ref) factorization that needs to occur.
# Algorithm
The numerically stable procdure used to evaluate ``U := U V^{-1}`` is
```math
\begin{align*}
U:= & UV^{-1}\\
= & [L_{u}\overset{L_{0}D_{0}R_{0}}{\overbrace{D_{u}R_{u}]V^{-1}}}\\
= & \overset{L_{1}}{\overbrace{L_{u}L_{0}}}\,\overset{D_{1}}{\overbrace{D_{0}}}\,\overset{R_{1}}{\overbrace{R_{0}}}\\
= & L_{1}D_{1}R_{1}.
\end{align*}
```
"""
function rdiv!(U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
# record intial Lᵤ
Lᵤ = ws.M′
copyto!(Lᵤ, U.L)
# calculate Dᵤ⋅Rᵤ⋅V⁻¹
copyto!(ws.M, V)
inv_lu!(ws.M, ws.lu_ws) # V⁻¹
mul!(U.L, U.R, ws.M) # Rᵤ⋅V⁻¹
lmul_D!(U.d, U.L) # Dᵤ⋅Rᵤ⋅V⁻¹
# calcualte [L₀⋅D₀⋅R₀] = Dᵤ⋅Rᵤ⋅V⁻¹
ldr!(U, ws)
# calculate L₁ = Lᵤ⋅L₀
mul!(ws.M, Lᵤ, U.L)
copyto!(U.L, ws.M)
return nothing
end
@doc raw"""
rdiv!(H::LDR{T,E}, U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
Calculate the numerically stable product ``H := U V^{-1},`` where ``V`` is a matrix and ``H`` and ``U`` is an [`LDR`](@ref) factorization.
Note that an intermediate LU factorization is required as well to calucate the matrix inverse ``V^{-1},`` in addition to the
intermediate [`LDR`](@ref) factorization that needs to occur.
"""
function rdiv!(H::LDR{T,E}, U::LDR{T,E}, V::AbstractMatrix{T}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(H, U)
rdiv!(H, V, ws)
return nothing
end
###########################################
## OVERLOADING LinearAlgebra.logabsdet() ##
###########################################
@doc raw"""
logabsdet(A::LDR{T}, ws::LDRWorkspace{T}) where {T}
Calculate ``\log(\vert \det A \vert)`` and ``\textrm{sign}(\det A)`` for the
[`LDR`](@ref) factorization ``A.``
"""
function logabsdet(A::LDR{T,E}, ws::LDRWorkspace{T,E}) where {T,E}
copyto!(ws.M, A.L)
logdetL, sgndetL = det_lu!(ws.M, ws.lu_ws)
logdetD, sgndetD = det_D(A.d)
copyto!(ws.M, A.R)
logdetR, sgndetR = det_lu!(ws.M, ws.lu_ws)
logdetA = logdetL + logdetD + logdetR
sgndetA = sgndetL * sgndetD * sgndetR
return logdetA, sgndetA
end | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 4366 | import LinearAlgebra.LAPACK: geqp3!, orgqr!
@doc raw"""
QRWorkspace{T<:Number, E<:Real}
Allocated space for calcuating the pivoted QR factorization using the LAPACK
routines `geqp3!` and `orgqr!` while avoiding dynamic memory allocations.
"""
struct QRWorkspace{T<:Number, E<:Real}
work::Vector{T}
rwork::Vector{E}
τ::Vector{T}
jpvt::Vector{Int}
end
# copy the state of one QRWorkspace into another
function copyto!(qrws_out::QRWorkspace{T,E}, qrws_in::QRWorkspace{T,E}) where {T,E}
copyto!(qrws_out.work, qrws_in.work)
copyto!(qrws_out.rwork, qrws_in.rwork)
copyto!(qrws_out.τ, qrws_in.τ)
copyto!(qrws_out.jpvt, qrws_in.jpvt)
return nothing
end
# wrap geqp3 and orgqr LAPACK methods
for (geqp3, orgqr, elty, relty) in ((:dgeqp3_, :dorgqr_, :Float64, :Float64),
(:sgeqp3_, :sorgqr_, :Float32, :Float32),
(:zgeqp3_, :zungqr_, :ComplexF64, :Float64),
(:cgeqp3_, :cungqr_, :ComplexF32, :Float32))
@eval begin
# method returns QRWorkspace for given matrix A
function QRWorkspace(A::StridedMatrix{$elty})
# allocate for geqp3/QR decomposition calculation
n = checksquare(A)
require_one_based_indexing(A)
chkstride1(A)
A′ = copy(A)
Rlda = max(1, stride(A′, 2))
jpvt = zeros(BlasInt, n)
τ = zeros($elty, n)
work = Vector{$elty}(undef, 1)
lwork = BlasInt(-1)
info = Ref{BlasInt}()
if $elty <: Complex
rwork = Vector{$relty}(undef, 2n)
ccall((@blasfunc($geqp3), liblapack), Cvoid,
(Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt},
Ptr{$elty}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}),
n, n, A′, Rlda, jpvt, τ, work, lwork, rwork, info)
else
rwork = Vector{$relty}(undef, 0)
ccall((@blasfunc($geqp3), liblapack), Cvoid,
(Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt},
Ptr{$elty}, Ptr{$elty}, Ref{BlasInt}, Ref{BlasInt}),
n, n, A′, Rlda, jpvt, τ, work, lwork, info)
end
chklapackerror(info[])
lwork = BlasInt(real(work[1]))
resize!(work, lwork)
return QRWorkspace(work, rwork, τ, jpvt)
end
# method for calculating QR decomposition
function geqp3!(A::AbstractMatrix{$elty}, ws::QRWorkspace{$elty})
require_one_based_indexing(A)
chkstride1(A)
n = checksquare(A)
lda = stride(A, 2)
info = Ref{BlasInt}()
fill!(ws.jpvt, 0) # not sure why I need to do this, but I do
if $elty <: Complex
ccall((@blasfunc($geqp3), liblapack), Cvoid,
(Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt},
Ptr{$elty}, Ptr{$elty}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}),
n, n, A, lda, ws.jpvt, ws.τ, ws.work, length(ws.work), ws.rwork, info)
else
ccall((@blasfunc($geqp3), liblapack), Cvoid,
(Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt},
Ptr{$elty}, Ptr{$elty}, Ref{BlasInt}, Ref{BlasInt}),
n, n, A, lda, ws.jpvt, ws.τ, ws.work, length(ws.work), info)
end
chklapackerror(info[])
return nothing
end
# method for constructing Q matrix
function orgqr!(A::AbstractMatrix{$elty}, ws::QRWorkspace{$elty})
require_one_based_indexing(A, ws.τ)
chkstride1(A, ws.τ)
n = checksquare(A)
k = length(ws.τ)
info = Ref{BlasInt}()
ccall((@blasfunc($orgqr), liblapack), Cvoid,
(Ref{BlasInt}, Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty},
Ref{BlasInt}, Ptr{$elty}, Ptr{$elty}, Ref{BlasInt}, Ptr{BlasInt}),
n, n, k, A, max(1,stride(A,2)), ws.τ, ws.work, length(ws.work), info)
chklapackerror(info[])
return nothing
end
end
end | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | code | 6592 | using StableLinearAlgebra
using LinearAlgebra
using Test
using LatticeUtilities
# construct and diagonalize hamiltonian matrix for square lattice tight binding model
function hamiltonian(L, t, μ)
unit_cell = UnitCell(lattice_vecs = [[1.,0.],[0.,1.]], basis_vecs = [[0.,0.]])
lattice = Lattice(L = [L,L], periodic = [true,true])
bond_x = Bond(orbitals = (1,1), displacement = [1,0])
bond_y = Bond(orbitals = (1,1), displacement = [0,1])
neighbor_table = build_neighbor_table([bond_x, bond_y], unit_cell, lattice)
Nsites = nsites(unit_cell, lattice)
Nbonds = size(neighbor_table, 2)
H = zeros(typeof(t),Nsites,Nsites)
for n in 1:Nbonds
i = neighbor_table[1,n]
j = neighbor_table[2,n]
H[j,i] = -t
H[i,j] = conj(-t)
end
for i in 1:Nsites
H[i,i] = -μ
end
ϵ, U = eigen(H)
return ϵ, U, H
end
# calculate the greens function given the eigenenergies and eigenstates
function greens(τ,β,ϵ,U)
gτ = similar(ϵ)
@. gτ = exp(-τ*ϵ)/(1+exp(-β*ϵ))
Gτ = U * Diagonal(gτ) * adjoint(U)
logdetGτ, sgndetGτ = logabsdet(Diagonal(gτ))
return Gτ, sgndetGτ, logdetGτ
end
# calculate propagator matrix B(τ) given eigenenergies and eigenstates
function propagator(τ,ϵ,U)
bτ = similar(ϵ)
@. bτ = exp(-τ*ϵ)
Bτ = U * Diagonal(bτ) * adjoint(U)
logdetBτ, sgndetBτ = logabsdet(Diagonal(bτ))
logdetBτ = -τ * sum(ϵ)
return Bτ, logdetBτ, sgndetBτ
end
@testset "StableLinearAlgebra.jl" begin
# system parameters
L = 4 # linear system size
t = 1.0 # nearest neighbor hopping
μ = 0.0 # chemical potential
β = 40.0 # inverse temperature
Δτ = 0.1 # discretization in imaginary time
Lτ = round(Int,β/Δτ) # length of imaginary time axis
nₛ = 10 # stabalization frequency
Nₛ = Lτ ÷ nₛ # number of reduced propagator matrices
# hamitlonian eigenenergies and eigenstates
ϵ, U, H = hamiltonian(L, t, μ)
# number of sites in lattice
N = size(H,1)
# propagator matrix
B, logdetB, sgndetB = propagator(Δτ, ϵ, U)
# inverse propagator matrix
B⁻¹, logdetB⁻¹, sgndetB⁻¹ = propagator(-Δτ, ϵ, U)
# long propagators
B_β = propagator(β, ϵ, U)
# greens functions
G_0, sgndetG_0, logdetG_0 = greens(0, β, ϵ, U) # G(τ=0)
G_βo2, sgndetG_βo2, logdetG_βo2 = greens(β/2, β, ϵ, U) # G(τ=β/2)
# temporary storage matrices
A = similar(B)
G = similar(B)
# partial propagator matrix product
B̄ = Matrix{eltype(B)}(I,N,N)
B̄⁻¹ = Matrix{eltype(B)}(I,N,N)
for i in 1:nₛ
mul!(A, B, B̄)
copyto!(B̄, A)
mul!(A, B̄⁻¹, B⁻¹)
copyto!(B̄⁻¹, A)
end
# initialize LDR workspace
ws = ldr_workspace(B̄)
# testing ldr and logabsdet
A = rand(N,N)
A = I + 0.1*A
F = ldr(A, ws)
logdetF, sgndetF = logabsdet(F, ws)
logdetA, sgndetA = logabsdet(A)
logdetF ≈ logdetA
sgndetF ≈ sgndetA
# testing ldr and copyto!
F = ldr(B̄)
copyto!(A, F, ws)
@test A ≈ I
# testing ldr and copyto!
F = ldr(B̄, ws)
copyto!(A, F, ws)
@test A ≈ B̄
# testing ldr!
ldr!(F, B̄, ws)
copyto!(A, F, ws)
@test A ≈ B̄
# testing ldrs
n = 3
Fs = ldrs(B̄, n)
@testset for i in 1:n
copyto!(A, Fs[i], ws)
@test A ≈ I
end
# testing ldrs
n = 3
Fs = ldrs(B̄, n, ws)
@testset for i in 1:n
copyto!(A, Fs[i], ws)
@test A ≈ B̄
end
# testing adjoint!
A = randn(N,N)
ldr!(F, A, ws)
adjoint!(G, F, ws)
@test G ≈ adjoint(A)
# testing lmul! and inv_IpA!
fill!(G, 0)
copyto!(F, I, ws)
for i in 1:Nₛ
lmul!(B̄, F, ws)
end
logdetG, sgndetG = inv_IpA!(G, F, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing lmul! and inv_IpA!
copyto!(F, I, ws)
F_B̄ = ldr(B̄, ws)
for i in 1:Nₛ
lmul!(F_B̄, F, ws)
end
logdetG, sgndetG = inv_IpA!(G, F, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing rmul! and inv_IpA!
copyto!(F, I, ws)
for i in 1:Nₛ
rmul!(F, B̄, ws)
end
logdetG, sgndetG = inv_IpA!(G, F, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing rmul! and inv_IpA!
copyto!(F, I, ws)
F_B̄ = ldr(B̄, ws)
for i in 1:Nₛ
rmul!(F, F_B̄, ws)
end
logdetG, sgndetG = inv_IpA!(G, F, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing ldiv! and inv_IpA!
copyto!(F, I, ws)
F_B̄⁻¹ = ldr(B̄⁻¹, ws)
for i in 1:Nₛ
ldiv!(F_B̄⁻¹, F, ws)
end
logdetG, sgndetG = inv_IpA!(G, F, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing ldiv! and inv_IpA!
copyto!(F, I, ws)
for i in 1:Nₛ
ldiv!(B̄⁻¹, F, ws)
end
logdetG, sgndetG = inv_IpA!(G, F, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing ldiv!
F_B̄ = ldr(B̄, ws)
copyto!(A, B̄)
ldiv!(F_B̄, A, ws)
@test A ≈ I
# testing rdiv! and inv_IpA!
copyto!(F, I, ws)
F_B̄⁻¹ = ldr(B̄⁻¹, ws)
for i in 1:Nₛ
rdiv!(F, F_B̄⁻¹, ws)
end
logdetG, sgndetG = inv_IpA!(G, F, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing rdiv! and inv_IpA!
copyto!(F, I, ws)
for i in 1:Nₛ
rdiv!(F, B̄⁻¹, ws)
end
logdetG, sgndetG = inv_IpA!(G, F, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing rdiv!
F_B̄ = ldr(B̄, ws)
copyto!(A, B̄)
rdiv!(A, F_B̄, ws)
@test A ≈ I
# testing inv_IpUV!
F′ = ldr(F)
copyto!(F, I, ws)
copyto!(F′, I, ws)
for i in 1:Nₛ÷2
rmul!(F, B̄, ws)
end
for i in Nₛ÷2+1:Nₛ
rmul!(F′, B̄, ws)
end
logdetG, sgndetG = inv_IpUV!(G, F, F′, ws)
@test G ≈ G_0
@test sgndetG ≈ sgndetG_0
@test logdetG ≈ logdetG_0
# testing inv_UpV!
F′ = ldr(B̄⁻¹)
copyto!(F, I, ws)
for i in 1:Nₛ÷2
lmul!(B̄, F, ws)
rmul!(F′, B̄⁻¹, ws)
end
logdetG, sgndetG = inv_UpV!(G, F′, F, ws)
@test G ≈ G_βo2
@test sgndetG ≈ sgndetG_βo2
@test logdetG ≈ logdetG_βo2
# testing inv_invUpV!
copyto!(F, I, ws)
for i in 1:Nₛ÷2
lmul!(B̄, F, ws)
end
logdetG, sgndetG = inv_invUpV!(G, F, F, ws)
@test G ≈ G_βo2
@test sgndetG ≈ sgndetG_βo2
@test logdetG ≈ logdetG_βo2
end
| StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | docs | 1434 | # StableLinearAlgebra.jl
[](https://cohensbw.github.io/StableLinearAlgebra.jl/stable)
[](https://cohensbw.github.io/StableLinearAlgebra.jl/dev)
[](https://github.com/cohensbw/StableLinearAlgebra.jl/actions/workflows/CI.yml?query=branch%3Amaster)
[](https://codecov.io/gh/cohensbw/StableLinearAlgebra.jl)
Documentation for [StableLinearAlgebra.jl](https://github.com/cohensbw/StableLinearAlgebra.jl).
This package exports an LDR matrix factorization type for square matrices, along with a corresponding collection of functions for calculating numerically stable matrix products and matrix inverses. The methods exported by the package are essential
for implementing a determinant quantum Monte Carlo (DQMC) code for simulating interacting itinerant electrons on a lattice.
A very similar Julia package implementing and exporting many of the same algorithms is [`StableDQMC.jl`](https://github.com/carstenbauer/StableDQMC.jl).
## Installation
To install [`StableLinearAlgebra.jl`](https://github.com/cohensbw/StableLinearAlgebra.jl) run following in the Julia REPL:
```julia
] add StableLinearAlgebra
``` | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | docs | 493 | # Developer API
```@docs
StableLinearAlgebra.det_D
StableLinearAlgebra.mul_D!
StableLinearAlgebra.div_D!
StableLinearAlgebra.lmul_D!
StableLinearAlgebra.rmul_D!
StableLinearAlgebra.ldiv_D!
StableLinearAlgebra.rdiv_D!
StableLinearAlgebra.mul_P!
StableLinearAlgebra.inv_P!
StableLinearAlgebra.perm_sign
```
## LAPACK LinearAlgebra
```@docs
StableLinearAlgebra.QRWorkspace
StableLinearAlgebra.LUWorkspace
StableLinearAlgebra.inv_lu!
StableLinearAlgebra.ldiv_lu!
StableLinearAlgebra.det_lu!
``` | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | docs | 926 | ```@meta
CurrentModule = StableLinearAlgebra
```
# StableLinearAlgebra.jl
Documentation for [StableLinearAlgebra.jl](https://github.com/cohensbw/StableLinearAlgebra.jl).
This package exports an [`LDR`](@ref) matrix factorization type for square matrices, along with a corresponding collection of functions for calculating numerically stable matrix products and matrix inverses. The methods exported by the package are essential
for implementing a determinant quantum Monte Carlo (DQMC) code for simulating interacting itinerant electrons on a lattice.
A very similar Julia package implementing and exporting many of the same algorithms is [`StableDQMC.jl`](https://github.com/carstenbauer/StableDQMC.jl).
## Installation
To install [`StableLinearAlgebra.jl`](https://github.com/cohensbw/StableLinearAlgebra.jl) run following in the Julia REPL:
```julia
] add StableLinearAlgebra
```
## References
```@bibliography
```
| StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 1.4.2 | f2b168c9595913b2dcc2dee6910392edc4504da4 | docs | 809 | # Public API
## LDR Factorization
- [`LDR`](@ref)
- [`LDRWorkspace`](@ref)
- [`ldr`](@ref)
- [`ldr!`](@ref)
- [`ldrs`](@ref)
- [`ldrs!`](@ref)
- [`ldr_workspace`](@ref)
```@docs
LDR
LDRWorkspace
ldr
ldr!
ldrs
ldrs!
ldr_workspace
```
## Overloaded Functions
- [`eltype`](@ref)
- [`size`](@ref)
- [`copyto!`](@ref)
- [`adjoint!`](@ref)
- [`lmul!`](@ref)
- [`rmul!`](@ref)
- [`mul!`](@ref)
- [`ldiv!`](@ref)
- [`rdiv!`](@ref)
- [`logabsdet`](@ref)
```@docs
Base.eltype
Base.size
Base.copyto!
LinearAlgebra.adjoint!
LinearAlgebra.lmul!
LinearAlgebra.rmul!
LinearAlgebra.mul!
LinearAlgebra.ldiv!
LinearAlgebra.rdiv!
LinearAlgebra.logabsdet
```
## Exported Function
- [`inv_IpA!`](@ref)
- [`inv_IpUV!`](@ref)
- [`inv_UpV!`](@ref)
- [`inv_invUpV!`](@ref)
```@docs
inv_IpA!
inv_IpUV!
inv_UpV!
inv_invUpV!
``` | StableLinearAlgebra | https://github.com/SmoQySuite/StableLinearAlgebra.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 1208 | using Documenter, BioSequences
DocMeta.setdocmeta!(BioSequences, :DocTestSetup, :(using BioSequences); recursive=true)
makedocs(
format = Documenter.HTML(),
sitename = "BioSequences.jl",
pages = [
"Home" => "index.md",
"Biological Symbols" => "symbols.md",
"BioSequences Types" => "types.md",
"Constructing sequences" => "construction.md",
"Indexing & modifying sequences" => "transforms.md",
"Predicates" => "predicates.md",
"Random sequences" => "random.md",
"Pattern matching and searching" => "sequence_search.md",
"Iteration" => "iteration.md",
"Counting" => "counting.md",
"I/O" => "io.md",
"Implementing custom types" => "interfaces.md"
],
authors = "Sabrina Jaye Ward, Jakob Nissen, D.C.Jones, Kenta Sato, The BioJulia Organisation and other contributors.",
checkdocs = :all,
)
deploydocs(
repo = "github.com/BioJulia/BioSequences.jl.git",
push_preview = true,
deps = nothing,
make = nothing
)
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 5912 | ### BioSequences.jl
###
### A julia package for the representation and manipulation of biological sequences.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE
module BioSequences
export
###
### Symbols
###
# Types & aliases
NucleicAcid,
DNA,
RNA,
DNA_A,
DNA_C,
DNA_G,
DNA_T,
DNA_M,
DNA_R,
DNA_W,
DNA_S,
DNA_Y,
DNA_K,
DNA_V,
DNA_H,
DNA_D,
DNA_B,
DNA_N,
DNA_Gap,
ACGT,
ACGTN,
RNA_A,
RNA_C,
RNA_G,
RNA_U,
RNA_M,
RNA_R,
RNA_W,
RNA_S,
RNA_Y,
RNA_K,
RNA_V,
RNA_H,
RNA_D,
RNA_B,
RNA_N,
RNA_Gap,
ACGU,
ACGUN,
AminoAcid,
AA_A,
AA_R,
AA_N,
AA_D,
AA_C,
AA_Q,
AA_E,
AA_G,
AA_H,
AA_I,
AA_L,
AA_K,
AA_M,
AA_F,
AA_P,
AA_S,
AA_T,
AA_W,
AA_Y,
AA_V,
AA_O,
AA_U,
AA_B,
AA_J,
AA_Z,
AA_X,
AA_Term,
AA_Gap,
# Predicates
isGC,
iscompatible,
isambiguous,
iscertain,
isgap,
ispurine,
ispyrimidine,
###
### Alphabets
###
# Types & aliases
Alphabet,
NucleicAcidAlphabet,
DNAAlphabet,
RNAAlphabet,
AminoAcidAlphabet,
###
### BioSequences
###
join!,
# Type & aliases
BioSequence,
NucSeq,
AASeq,
# Predicates
ispalindromic,
hasambiguity,
isrepetitive,
iscanonical,
# Transformations
canonical,
canonical!,
complement,
complement!,
reverse_complement,
reverse_complement!,
ungap,
ungap!,
join!,
###
### LongSequence
###
# Type & aliases
LongSequence,
LongNuc,
LongDNA,
LongRNA,
LongAA,
LongSubSeq,
# Random
SamplerUniform,
SamplerWeighted,
randseq,
randdnaseq,
randrnaseq,
randaaseq,
###
### Sequence literals
###
@dna_str,
@rna_str,
@aa_str,
@biore_str,
@prosite_str,
BioRegex,
BioRegexMatch,
matched,
captured,
alphabet, # TODO: Resolve the use of alphabet - it's from BioSymbols.jl
symbols,
gap,
mismatches,
matches,
n_ambiguous,
n_gaps,
n_certain,
gc_content,
translate!,
translate,
ncbi_trans_table,
# Search
ExactSearchQuery,
ApproximateSearchQuery,
PFM,
PWM,
PWMSearchQuery,
maxscore,
scoreat,
seqmatrix,
majorityvote
using BioSymbols
import Twiddle: enumerate_nibbles,
count_0000_nibbles,
count_1111_nibbles,
count_nonzero_nibbles,
count_00_bitpairs,
count_01_bitpairs,
count_10_bitpairs,
count_11_bitpairs,
count_nonzero_bitpairs,
repeatpattern
using Random
include("alphabet.jl")
# Load the bit-twiddling internals that optimised BioSequences methods depend on.
include("bit-manipulation/bit-manipulation.jl")
# The generic, abstract BioSequence type
include("biosequence/biosequence.jl")
# The definition of the LongSequence concrete type, and its method overloads...
include("longsequences/longsequence.jl")
include("longsequences/hash.jl")
include("longsequences/randseq.jl")
include("geneticcode.jl")
# Pattern searching in sequences...
include("search/ExactSearchQuery.jl")
include("search/ApproxSearchQuery.jl")
include("search/re.jl")
include("search/pwm.jl")
struct Search{Q,I}
query::Q
itr::I
overlap::Bool
end
const DEFAULT_OVERLAP = true
search(query, itr; overlap = DEFAULT_OVERLAP) = Search(query, itr, overlap)
function Base.iterate(itr::Search, state=firstindex(itr.itr))
val = findnext(itr.query, itr.itr, state)
val === nothing && return nothing
state = itr.overlap ? first(val) + 1 : last(val) + 1
return val, state
end
const HasRangeEltype = Union{<:ExactSearchQuery, <:ApproximateSearchQuery, <:Regex}
Base.eltype(::Type{<:Search{Q}}) where {Q<:HasRangeEltype} = UnitRange{Int}
Base.eltype(::Type{<:Search}) = Int
Base.IteratorSize(::Type{<:Search}) = Base.SizeUnknown()
"""
findall(pattern, sequence::BioSequence[,rng::UnitRange{Int}]; overlap::Bool=true)::Vector
Find all occurrences of `pattern` in `sequence`.
The return value is a vector of ranges of indices where the matching sequences were found.
If there are no matching sequences, the return value is an empty vector.
The search is restricted to the specified range when `rng` is set.
With the keyword argument `overlap` set as `true`, the start index for the next search gets set to the start of the current match plus one; if set to `false`, the start index for the next search gets set to the end of the current match plus one.
The default value for the keyword argument `overlap` is `true`.
The `pattern` can be a `Biosymbol` or a search query.
See also [`ExactSearchQuery`](@ref), [`ApproximateSearchQuery`](@ref), [`PWMSearchQuery`](@ref).
# Examples
```jldoctest
julia> seq = dna"ACACACAC";
julia> findall(DNA_A, seq)
4-element Vector{Int64}:
1
3
5
7
julia> findall(ExactSearchQuery(dna"ACAC"), seq)
3-element Vector{UnitRange{Int64}}:
1:4
3:6
5:8
julia> findall(ExactSearchQuery(dna"ACAC"), seq; overlap=false)
2-element Vector{UnitRange{Int64}}:
1:4
5:8
julia> findall(ExactSearchQuery(dna"ACAC"), seq, 2:7; overlap=false)
1-element Vector{UnitRange{Int64}}:
3:6
```
"""
function Base.findall(pat, seq::BioSequence; overlap::Bool = DEFAULT_OVERLAP)
return collect(search(pat, seq; overlap))
end
# Fix ambiguity with Base's findall
Base.findall(f::Function, seq::BioSequence) = collect(search(f, seq; overlap=DEFAULT_OVERLAP))
function Base.findall(pat, seq::BioSequence, rng::UnitRange{Int}; overlap::Bool = DEFAULT_OVERLAP)
v = view(seq, rng)
itr = search(pat, v; overlap)
return map(x->parentindices(v)[1][x], itr)
end
include("workload.jl")
end # module BioSequences
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 9657 | ###
### Alphabet
###
###
### Alphabets of biological symbols.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
"""
Alphabet
`Alphabet` is the most important type trait for `BioSequence`. An `Alphabet`
represents a set of biological symbols encoded by a sequence, e.g. A, C, G
and T for a DNA Alphabet that requires only 2 bits to represent each symbol.
# Extended help
* Subtypes of Alphabet are singleton structs that may or may not be parameterized.
* Alphabets span over a *finite* set of biological symbols.
* The alphabet controls the encoding from some internal "encoded data" to a BioSymbol
of the alphabet's element type, as well as the decoding, the inverse process.
* An `Alphabet`'s `encode` method must not produce invalid data.
Every subtype `A` of `Alphabet` must implement:
* `Base.eltype(::Type{A})::Type{S}` for some eltype `S`, which must be a `BioSymbol`.
* `symbols(::A)::Tuple{Vararg{S}}`. This gives tuples of all symbols in the set of `A`.
* `encode(::A, ::S)::E` encodes a symbol to an internal data eltype `E`.
* `decode(::A, ::E)::S` decodes an internal data eltype `E` to a symbol `S`.
* Except for `eltype` which must follow Base conventions, all functions operating
on `Alphabet` should operate on instances of the alphabet, not the type.
If you want interoperation with existing subtypes of `BioSequence`,
the encoded representation `E` must be of type `UInt`, and you must also implement:
* `BitsPerSymbol(::A)::BitsPerSymbol{N}`, where the `N` must be zero
or a power of two in [1, 2, 4, 8, 16, 32, [64 for 64-bit systems]].
For increased performance, see [`BioSequences.AsciiAlphabet`](@ref)
"""
abstract type Alphabet end
"""
function has_interface(::Type{Alphabet}, A::Alphabet)
Returns whether `A` conforms to the `Alphabet` interface.
"""
function has_interface(::Type{Alphabet}, A::Alphabet)
try
eltype(typeof(A)) <: BioSymbol || return false
syms = symbols(A)
(syms isa Tuple{Vararg{eltype(typeof(A))}} && length(syms) > 0) || return false
codes = map(i -> encode(A, i), syms)
codes isa (NTuple{N, T} where {N, T <: Union{UInt8, UInt16, UInt32, UInt64}}) || return false
recodes = map(i -> decode(A, i), codes)
syms == recodes || return false
bps = BitsPerSymbol(A)
bps isa BitsPerSymbol || return false
in(BioSequences.bits_per_symbol(A), (0, 1, 2, 4, 8, 16, 32, 64)) || return false
catch error
error isa MethodError && return false
rethrow(error)
end
return true
end
"""
The number of bits required to represent a packed symbol encoding in a vector of bits.
"""
bits_per_symbol(A::Alphabet) = bits_per_symbol(BitsPerSymbol(A))
Base.length(A::Alphabet) = length(symbols(A))
## Bits per symbol
struct BitsPerSymbol{N} end
bits_per_symbol(::BitsPerSymbol{N}) where N = N
"Compute whether all bitpatterns represent valid symbols for an alphabet"
iscomplete(A::Alphabet) = Val(length(symbols(A)) === 1 << bits_per_symbol(A))
## Encoders & Decoders
"""
encode(::Alphabet, x::S)
Encode BioSymbol `S` to an internal representation using an `Alphabet`.
This decoding is checked to enforce valid data element.
"""
function encode end
struct EncodeError{A<:Alphabet,T} <: Exception
val::T
end
EncodeError(::A, val::T) where {A,T} = EncodeError{A,T}(val)
function Base.showerror(io::IO, err::EncodeError{A}) where {A}
print(io, "cannot encode ", err.val, " in ", A)
end
"""
decode(::Alphabet, x::E)
Decode internal representation `E` to a `BioSymbol` using an `Alphabet`.
"""
function decode end
function Base.iterate(a::Alphabet, state = 1)
state > length(a) && return nothing
@inbounds sym = symbols(a)[state]
return sym, state + 1
end
## Nucleic acid alphabets
"""
Alphabet of nucleic acids. Parameterized by the number of bits per symbol, by
default only `2` or `4`-bit variants exists.
"""
abstract type NucleicAcidAlphabet{N} <: Alphabet end
"""
DNA nucleotide alphabet.
`DNAAlphabet` has a parameter `N` which is a number that determines the
`BitsPerSymbol` trait. Currently supported values of `N` are 2 and 4.
"""
struct DNAAlphabet{N} <: NucleicAcidAlphabet{N} end
Base.eltype(::Type{<:DNAAlphabet}) = DNA
"""
RNA nucleotide alphabet.
`RNAAlphabet` has a parameter `N` which is a number that determines the
`BitsPerSymbol` trait. Currently supported values of `N` are 2 and 4.
"""
struct RNAAlphabet{N} <: NucleicAcidAlphabet{N} end
Base.eltype(::Type{<:RNAAlphabet}) = RNA
symbols(::DNAAlphabet{2}) = (DNA_A, DNA_C, DNA_G, DNA_T)
symbols(::RNAAlphabet{2}) = (RNA_A, RNA_C, RNA_G, RNA_U)
function symbols(::DNAAlphabet{4})
(DNA_Gap, DNA_A, DNA_C, DNA_M, DNA_G, DNA_R, DNA_S, DNA_V,
DNA_T, DNA_W, DNA_Y, DNA_H, DNA_K, DNA_D, DNA_B, DNA_N)
end
function symbols(::RNAAlphabet{4})
(RNA_Gap, RNA_A, RNA_C, RNA_M, RNA_G, RNA_R, RNA_S, RNA_V,
RNA_U, RNA_W, RNA_Y, RNA_H, RNA_K, RNA_D, RNA_B, RNA_N)
end
BitsPerSymbol(::A) where A <: NucleicAcidAlphabet{2} = BitsPerSymbol{2}()
BitsPerSymbol(::A) where A <: NucleicAcidAlphabet{4} = BitsPerSymbol{4}()
## Encoding and decoding DNA and RNA alphabet symbols
# A nucleotide with bitvalue B has kmer-bitvalue kmerbits[B+1].
# ambiguous nucleotides have no kmervalue, here set to 0xff
const twobitnucs = (0xff, 0x00, 0x01, 0xff,
0x02, 0xff, 0xff, 0xff,
0x03, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff)
for A in (DNAAlphabet, RNAAlphabet)
T = eltype(A)
@eval begin
# 2-bit encoding
@inline function encode(::$(A){2}, nt::$(T))
if count_ones(nt) != 1 || !isvalid(nt)
throw(EncodeError($(A){2}(), nt))
end
return convert(UInt, @inbounds twobitnucs[reinterpret(UInt8, nt) + 0x01])
end
@inline function decode(::$(A){2}, x::UInt)
return reinterpret($(T), 0x01 << (x & 0x03))
end
@inline decode(::$(A){2}, x::Unsigned) = decode($(A){2}(), UInt(x))
# 4-bit encoding
@inline function encode(::$(A){4}, nt::$(T))
if !isvalid(nt)
throw(EncodeError($(A){4}(), nt))
end
return convert(UInt, reinterpret(UInt8, nt))
end
@inline function decode(::$(A){4}, x::UInt)
return reinterpret($(T), x % UInt8)
end
@inline decode(::$(A){4}, x::Unsigned) = decode($(A){4}(), UInt(x))
end
end
### Promotion of nucletid acid alphabets
for alph in (DNAAlphabet, RNAAlphabet)
@eval function Base.promote_rule(::Type{A}, ::Type{B}) where {A<:$alph,B<:$alph}
# TODO: Resolve this use of bits_per_symbol.
return $alph{max(bits_per_symbol(A()),bits_per_symbol(B()))}
end
end
## Amino acid alphabet
"""
Amino acid alphabet.
"""
struct AminoAcidAlphabet <: Alphabet end
BitsPerSymbol(::AminoAcidAlphabet) = BitsPerSymbol{8}()
Base.eltype(::Type{AminoAcidAlphabet}) = AminoAcid
function symbols(::AminoAcidAlphabet)
(AA_A, AA_R, AA_N, AA_D, AA_C, AA_Q, AA_E, AA_G, AA_H,
AA_I, AA_L, AA_K, AA_M, AA_F, AA_P, AA_S, AA_T, AA_W,
AA_Y, AA_V, AA_O, AA_U, AA_B, AA_J, AA_Z, AA_X, AA_Term, AA_Gap)
end
@inline function encode(::AminoAcidAlphabet, aa::AminoAcid)
if reinterpret(UInt8, aa) > reinterpret(UInt8, AA_Gap)
throw(EncodeError(AminoAcidAlphabet(), aa))
end
return convert(UInt, reinterpret(UInt8, aa))
end
@inline function decode(::AminoAcidAlphabet, x::UInt)
return reinterpret(AminoAcid, x % UInt8)
end
@inline function decode(::AminoAcidAlphabet, x::Unsigned)
return decode(AminoAcidAlphabet(), UInt(x))
end
# AsciiAlphabet trait - add to user defined type to use speedups.
# Must define methods codetype, BioSymbols.stringbyte, ascii_encode
"Abstract trait for ASCII/Unicode dispatch. See `AsciiAlphabet`"
abstract type AlphabetCode end
"""
AsciiAlphabet
Trait for alphabet using ASCII characters as String representation.
Define `codetype(A) = AsciiAlphabet()` for a user-defined `Alphabet` A to gain speed.
Methods needed: `BioSymbols.stringbyte(::eltype(A))` and `ascii_encode(A, ::UInt8)`.
"""
struct AsciiAlphabet <: AlphabetCode end
"Trait for alphabet using Unicode. See `AsciiAlphabet`"
struct UnicodeAlphabet <: AlphabetCode end
function codetype(::A) where {A <: Union{DNAAlphabet{2}, DNAAlphabet{4},
RNAAlphabet{2}, RNAAlphabet{4},
AminoAcidAlphabet}}
return AsciiAlphabet()
end
codetype(::Alphabet) = UnicodeAlphabet()
"""
ascii_encode(::Alphabet, b::UInt8)::UInt8
Encode the ASCII character represented by `b` to the internal alphabet encoding.
For example, the input byte `UInt8('C')` is encoded to `0x01` and `0x02` for
2- and 4-bit DNA alphabets, reprectively.
This method is only needed if the `Alphabet` is an `AsciiAlphabet`.
See also: [`BioSequences.AsciiAlphabet`](@ref)
"""
function ascii_encode end
for (anum, atype) in enumerate((DNAAlphabet{4}, DNAAlphabet{2}, RNAAlphabet{4},
RNAAlphabet{2}, AminoAcidAlphabet))
tablename = Symbol("BYTE_TO_ALPHABET_CHAR" * string(anum))
@eval begin
alph = $(atype)()
syms = symbols(alph)
const $(tablename) = let
bytes = fill(0x80, 256)
for symbol in syms
bytes[UInt8(Char(symbol)) + 1] = encode(alph, symbol)
bytes[UInt8(lowercase(Char(symbol))) + 1] = encode(alph, symbol)
end
Tuple(bytes)
end
ascii_encode(::$(atype), x::UInt8) = @inbounds $(tablename)[x + 1]
end
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 16069 | ###
### Genetic Code
###
###
### Genetic code table and translator from RNA to amino acid sequence.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
const XNA = Union{DNA, RNA}
function unambiguous_codon(a::XNA, b::XNA, c::XNA)
@inbounds begin
bits = twobitnucs[reinterpret(UInt8, a) + 0x01] << 4 |
twobitnucs[reinterpret(UInt8, b) + 0x01] << 2 |
twobitnucs[reinterpret(UInt8, c) + 0x01]
end
#reinterpret(RNACodon, bits % UInt64)
return bits % UInt64
end
# A genetic code is a table mapping RNA 3-mers (i.e. RNAKmer{3}) to AminoAcids.
"Type representing a Genetic Code"
struct GeneticCode <: AbstractDict{UInt64, AminoAcid}
name::String
tbl::NTuple{64, AminoAcid}
end
###
### Basic Functions
###
function Base.getindex(code::GeneticCode, codon::UInt64)
return @inbounds code.tbl[codon + one(UInt64)]
end
Base.copy(code::GeneticCode) = code
Base.length(code::GeneticCode) = 64
Base.show(io::IO, code::GeneticCode) = print(io, code.name)
function Base.show(io::IO, ::MIME"text/plain", code::GeneticCode)
print(io, code.name)
rna = rna"ACGU"
for x in rna, y in rna
println(io)
print(io, " ")
for z in rna
codon = unambiguous_codon(x, y, z)
aa = code[codon]
print(io, x, y, z, ": ", aa)
if z != RNA_U
print(io, " ")
end
end
end
end
###
### Iterating through genetic code
###
function Base.iterate(code::GeneticCode, x = UInt64(0))
if x > UInt64(0b111111)
return nothing
else
return (x, @inbounds code[x]), x + 1
end
end
###
### Default genetic codes
###
struct TransTables
tables::Dict{Int,GeneticCode}
bindings::Dict{Int,Symbol}
function TransTables()
return new(Dict(), Dict())
end
end
Base.getindex(trans::TransTables, key::Integer) = trans.tables[Int(key)]
function Base.show(io::IO, trans::TransTables)
print(io, "Translation Tables:")
ids = sort(collect(keys(trans.tables)))
for id in ids
println(io)
print(io, lpad(id, 3), ". ")
show(io, trans.tables[id])
if haskey(trans.bindings, id)
print(io, " (", trans.bindings[id], ")")
end
end
end
"""
Genetic code list of NCBI.
The standard genetic code is `ncbi_trans_table[1]` and others can be shown by
`show(ncbi_trans_table)`.
For more details, consult the next link:
http://www.ncbi.nlm.nih.gov/Taxonomy/taxonomyhome.html/index.cgi?chapter=cgencodes.
"""
const ncbi_trans_table = TransTables()
macro register_ncbi_gencode(id, bind, tbl)
quote
gencode = parse_gencode($tbl)
const $(esc(bind)) = gencode
ncbi_trans_table.tables[$id] = gencode
ncbi_trans_table.bindings[$id] = Symbol($(string(bind)))
end
end
function parse_gencode(s)
name, _, aas, _, base1, base2, base3 = split(chomp(s), '\n')
name = split(name, ' ', limit = 2)[2] # drop number
codearr = fill(AA_X, 4^3)
@assert length(aas) == 73
for i in 10:73
aa = AminoAcid(aas[i])
b1 = DNA(base1[i])
b2 = DNA(base2[i])
b3 = DNA(base3[i])
codon = unambiguous_codon(b1, b2, b3)
codearr[codon + one(UInt64)] = aa
end
return GeneticCode(name, NTuple{64, AminoAcid}(codearr))
end
# Genetic codes translation tables are taken from the NCBI taxonomy database.
@register_ncbi_gencode 1 standard_genetic_code """
1. The Standard Code
AAs = FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = ---M---------------M---------------M----------------------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 2 vertebrate_mitochondrial_genetic_code """
2. The Vertebrate Mitochondrial Code
AAs = FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIMMTTTTNNKKSS**VVVVAAAADDEEGGGG
Starts = --------------------------------MMMM---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 3 yeast_mitochondrial_genetic_code """
3. The Yeast Mitochondrial Code
AAs = FFLLSSSSYY**CCWWTTTTPPPPHHQQRRRRIIMMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = ----------------------------------MM----------------------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 4 mold_mitochondrial_genetic_code """
4. The Mold, Protozoan, and Coelenterate Mitochondrial Code and the Mycoplasma/Spiroplasma Code
AAs = FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = --MM---------------M------------MMMM---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 5 invertebrate_mitochondrial_genetic_code """
5. The Invertebrate Mitochondrial Code
AAs = FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIMMTTTTNNKKSSSSVVVVAAAADDEEGGGG
Starts = ---M----------------------------MMMM---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 6 ciliate_nuclear_genetic_code """
6. The Ciliate, Dasycladacean and Hexamita Nuclear Code
AAs = FFLLSSSSYYQQCC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = -----------------------------------M----------------------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 9 echinoderm_mitochondrial_genetic_code """
9. The Echinoderm and Flatworm Mitochondrial Code
AAs = FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIIMTTTTNNNKSSSSVVVVAAAADDEEGGGG
Starts = -----------------------------------M---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 10 euplotid_nuclear_genetic_code """
10. The Euplotid Nuclear Code
AAs = FFLLSSSSYY**CCCWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = -----------------------------------M----------------------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 11 bacterial_plastid_genetic_code """
11. The Bacterial, Archaeal and Plant Plastid Code
AAs = FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = ---M---------------M------------MMMM---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 12 alternative_yeast_nuclear_genetic_code """
12. The Alternative Yeast Nuclear Code
AAs = FFLLSSSSYY**CC*WLLLSPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = -------------------M---------------M----------------------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 13 ascidian_mitochondrial_genetic_code """
13. The Ascidian Mitochondrial Code
AAs = FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIMMTTTTNNKKSSGGVVVVAAAADDEEGGGG
Starts = ---M------------------------------MM---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 14 alternative_flatworm_mitochondrial_genetic_code """
14. The Alternative Flatworm Mitochondrial Code
AAs = FFLLSSSSYYY*CCWWLLLLPPPPHHQQRRRRIIIMTTTTNNNKSSSSVVVVAAAADDEEGGGG
Starts = -----------------------------------M----------------------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 16 chlorophycean_mitochondrial_genetic_code """
16. Chlorophycean Mitochondrial Code
AAs = FFLLSSSSYY*LCC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = -----------------------------------M----------------------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 21 trematode_mitochondrial_genetic_code """
21. Trematode Mitochondrial Code
AAs = FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIMMTTTTNNNKSSSSVVVVAAAADDEEGGGG
Starts = -----------------------------------M---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 22 scenedesmus_obliquus_mitochondrial_genetic_code """
22. Scenedesmus obliquus Mitochondrial Code
AAs = FFLLSS*SYY*LCC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = -----------------------------------M----------------------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 23 thraustochytrium_mitochondrial_genetic_code """
23. Thraustochytrium Mitochondrial Code
AAs = FF*LSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = --------------------------------M--M---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 24 pterobrachia_mitochondrial_genetic_code """
24. Pterobranchia Mitochondrial Code
AAs = FFLLSSSSYY**CCWWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSSKVVVVAAAADDEEGGGG
Starts = ---M---------------M---------------M---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
@register_ncbi_gencode 25 candidate_division_sr1_genetic_code """
25. Candidate Division SR1 and Gracilibacteria Code
AAs = FFLLSSSSYY**CCGWLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG
Starts = ---M-------------------------------M---------------M------------
Base1 = TTTTTTTTTTTTTTTTCCCCCCCCCCCCCCCCAAAAAAAAAAAAAAAAGGGGGGGGGGGGGGGG
Base2 = TTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGGTTTTCCCCAAAAGGGG
Base3 = TCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAGTCAG
"""
###
### Translation
###
"""
translate(seq, code=standard_genetic_code, allow_ambiguous_codons=true, alternative_start=false)
Translate an `LongRNA` or a `LongDNA` to an `LongAA`.
Translation uses genetic code `code` to map codons to amino acids. See
`ncbi_trans_table` for available genetic codes.
If codons in the given sequence cannot determine a unique amino acid, they
will be translated to `AA_X` if `allow_ambiguous_codons` is `true` and otherwise
result in an error. For organisms that utilize alternative start codons, one
can set `alternative_start=true`, in which case the first codon will always be
converted to a methionine.
"""
function translate(ntseq::SeqOrView;
code::GeneticCode = standard_genetic_code,
allow_ambiguous_codons::Bool = true,
alternative_start::Bool = false
)
len = div((length(ntseq) % UInt) * 11, 32)
translate!(LongAA(undef, len), ntseq; code = code,
allow_ambiguous_codons = allow_ambiguous_codons, alternative_start = alternative_start)
end
function translate!(aaseq::LongAA,
ntseq::SeqOrView{<:NucleicAcidAlphabet{2}};
code::GeneticCode = standard_genetic_code,
allow_ambiguous_codons::Bool = true,
alternative_start::Bool = false
)
n_aa, remainder = divrem(length(ntseq) % UInt, 3)
iszero(remainder) || error("LongRNA length is not divisible by three. Cannot translate.")
resize!(aaseq, n_aa)
@inbounds for i in 1:n_aa
a = ntseq[3i-2]
b = ntseq[3i-1]
c = ntseq[3i]
codon = unambiguous_codon(a, b, c)
aaseq[i] = code[codon]
end
alternative_start && !isempty(aaseq) && (@inbounds aaseq[1] = AA_M)
aaseq
end
function translate!(aaseq::LongAA,
ntseq::SeqOrView{<:NucleicAcidAlphabet{4}};
code::GeneticCode = standard_genetic_code,
allow_ambiguous_codons::Bool = true,
alternative_start::Bool = false
)
n_aa, remainder = divrem(length(ntseq) % UInt, 3)
iszero(remainder) || error("LongRNA length is not divisible by three. Cannot translate.")
resize!(aaseq, n_aa)
@inbounds for i in 1:n_aa
a = reinterpret(RNA, ntseq[3i-2])
b = reinterpret(RNA, ntseq[3i-1])
c = reinterpret(RNA, ntseq[3i])
if isgap(a) | isgap(b) | isgap(c)
error("Cannot translate nucleotide sequences with gaps.")
elseif iscertain(a) & iscertain(b) & iscertain(c)
aaseq[i] = code[unambiguous_codon(a, b, c)]
else
aaseq[i] = try_translate_ambiguous_codon(code, a, b, c, allow_ambiguous_codons)
end
end
alternative_start && !isempty(aaseq) && (@inbounds aaseq[1] = AA_M)
aaseq
end
function try_translate_ambiguous_codon(
code::GeneticCode,
x::RNA,
y::RNA,
z::RNA,
allow_ambiguous::Bool
)::AminoAcid
((a, b, c), unambigs) = Iterators.peel(
Iterators.product(map(UnambiguousRNAs, (x, y, z))...)
)
aa = @inbounds code[unambiguous_codon(a, b, c)]
@inbounds for (a, b, c) in unambigs
aa_new = code[unambiguous_codon(a, b, c)]
aa_new == aa && continue
allow_ambiguous || error("codon ", a, b, c, " cannot be unambiguously translated")
aa = if aa_new in (AA_N, AA_D) && aa in (AA_N, AA_D, AA_B)
AA_B
elseif aa_new in (AA_I, AA_L) && aa in (AA_I, AA_L, AA_J)
AA_J
elseif aa_new in (AA_Q, AA_E) && aa in (AA_Q, AA_E, AA_Z)
AA_Z
else
AA_X
end
aa == AA_X && break
end
return aa
end
struct UnambiguousRNAs
x::RNA
end
Base.eltype(::Type{UnambiguousRNAs}) = RNA
Base.length(x::UnambiguousRNAs) = count_ones(reinterpret(UInt8, x.x))
function Base.iterate(x::UnambiguousRNAs, state=reinterpret(UInt8, x.x))
iszero(state) && return nothing
rna = reinterpret(RNA, 0x01 << (trailing_zeros(state) & 7))
(rna, state & (state - 0x01))
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 1786 | using BioSequences
using PrecompileTools
# BioSequences define a whole bunch of types and methods, most of which is never used in any workload.
# This workload here uses what I consider to be the most common operations,
# on the most common types.
# This is intended to strike a balance between precompilign that which the user probably needs, while
# not wasting time loading code the user will never use.
# The code not cached here will have to be precompiled in downstream packages
@compile_workload begin
seqs = [
aa"TAGCW"
dna"ATCGA"
]
for seq in [seqs; map(i -> view(i, 1:5), seqs)]
# printing
String(seq)
print(IOBuffer(), seq)
hash(seq)
# indexing
seq[1]
seq[2:3]
seq[2] = seq[3]
seq[2:3] = seq[3:4]
# join
join([seq, seq])
join((first(seq), last(seq)))
# pred
hasambiguity(seq)
# transformations
reverse(seq)
ungap(seq)
q1 = ExactSearchQuery(seq[1:2])
findfirst(q1, seq)
findlast(q1, seq)
findall(q1, seq)
occursin(q1, seq)
q2 = ApproximateSearchQuery(seq[2:4])
findfirst(q2, 1, seq)
findlast(q2, 1, seq)
occursin(q2, 1, seq)
end
for seq in seqs
seq[[true, false, true, true, false]]
seq[collect(2:3)]
ungap!(seq)
end
# Nucleotide
for seq in seqs[2:2]
ispalindromic(seq)
iscanonical(seq)
canonical(seq)
reverse_complement!(seq)
reverse_complement(seq)
complement(seq)
translate(seq[1:3])
gc_content(seq)
end
# Random
randdnaseq(5)
randrnaseq(5)
randaaseq(5)
randseq(DNAAlphabet{2}(), 10)
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 7526 | ###
### An abstract biological sequence type.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
"""
BioSequence{A <: Alphabet}
`BioSequence` is the main abstract type of `BioSequences`.
It abstracts over the internal representation of different biological sequences,
and is parameterized by an `Alphabet`, which controls the element type.
# Extended help
Its subtypes are characterized by:
* Being a linear container type with random access and indices `Base.OneTo(length(x))`.
* Containing zero or more internal data elements of type `encoded_data_eltype(typeof(x))`.
* Being associated with an `Alphabet`, `A` by being a subtype of `BioSequence{A}`.
A `BioSequence{A}` is indexed by an integer. The biosequence subtype, the index
and the alphabet `A` determine how to extract the internal encoded data.
The alphabet decides how to decode the data to the element type of the biosequence.
Hence, the element type and container type of a `BioSequence` are separated.
Subtypes `T` of `BioSequence` must implement the following, with `E` begin an
encoded data type:
* `Base.length(::T)::Int`
* `encoded_data_eltype(::Type{T})::Type{E}`
* `extract_encoded_element(::T, ::Integer)::E`
* `copy(::T)`
* T must be able to be constructed from any iterable with `length` defined and
with a known, compatible element type.
Furthermore, mutable sequences should implement
* `encoded_setindex!(::T, ::E, ::Integer)`
* `T(undef, ::Int)`
* `resize!(::T, ::Int)`
For compatibility with existing `Alphabet`s, the encoded data eltype must be `UInt`.
"""
abstract type BioSequence{A<:Alphabet} end
"""
has_interface(::Type{BioSequence}, ::T, syms::Vector, mutable::Bool, compat::Bool=true)
Check if type `T` conforms to the `BioSequence` interface. A `T` is constructed from the vector
of element types `syms` which must not be empty.
If the `mutable` flag is set, also check the mutable interface.
If the `compat` flag is set, check for compatibility with existing alphabets.
"""
function has_interface(
::Type{BioSequence},
::Type{T},
syms::Vector,
mutable::Bool,
compat::Bool=true
) where {T <: BioSequence}
try
isempty(syms) && error("Vector syms must not be empty")
first(syms) isa eltype(T) || error("Vector is of wrong element type")
seq = T((i for i in syms))
length(seq) > 0 || return false
eachindex(seq) === Base.OneTo(length(seq)) || return false
E = encoded_data_eltype(T)
e = extract_encoded_element(seq, 1)
e isa E || return false
(!compat || E == UInt) || return false
copy(seq) isa typeof(seq) || return false
if mutable
encoded_setindex!(seq, e, 1)
T(undef, 5) isa T || return false
isempty(resize!(seq, 0)) || return false
end
catch error
error isa MethodError && return false
rethrow(error)
end
return true
end
Base.eachindex(x::BioSequence) = Base.OneTo(length(x))
Base.firstindex(::BioSequence) = 1
Base.lastindex(x::BioSequence) = length(x)
Base.keys(seq::BioSequence) = eachindex(seq)
Base.nextind(::BioSequence, i::Integer) = Int(i) + 1
Base.prevind(::BioSequence, i::Integer) = Int(i) - 1
Base.size(x::BioSequence) = (length(x),)
Base.eltype(::Type{<:BioSequence{A}}) where {A <: Alphabet} = eltype(A)
Base.eltype(x::BioSequence) = eltype(typeof(x))
Alphabet(::Type{<:BioSequence{A}}) where {A <: Alphabet} = A()
Alphabet(x::BioSequence) = Alphabet(typeof(x))
Base.isempty(x::BioSequence) = iszero(length(x))
Base.empty(::Type{T}) where {T <: BioSequence} = T(eltype(T)[])
Base.empty(x::BioSequence) = empty(typeof(x))
BitsPerSymbol(x::BioSequence) = BitsPerSymbol(Alphabet(typeof(x)))
Base.hash(s::BioSequence, x::UInt) = foldl((a, b) -> hash(b, a), s, init=x)
function Base.similar(seq::BioSequence, len::Integer=length(seq))
return typeof(seq)(undef, len)
end
# Fast path for iterables we know are stateless
function join!(seq::BioSequence, it::Union{Vector, Tuple, Set})
_join!(resize!(seq, reduce((a, b) -> a + joinlen(b), it, init=0)), it, Val(true))
end
"""
join!(seq::BioSequence, iter)
Concatenate all biosequences/biosymbols in `iter` into `seq`, resizing it to fit.
# Examples
```
julia> join(LongDNA(), [dna"TAG", dna"AAC"])
6nt DNA Sequence:
TAGAAC
```
see also [`join`](@ref)
"""
join!(seq::BioSequence, it) = _join!(seq, it, Val(false))
# B is whether the size of the destination seq is already
# known to be the final size
function _join!(seq::BioSequence, it, ::Val{B}) where B
len = 0
oldlen = length(seq)
for i in it
pluslen = joinlen(i)
if !B && oldlen < (len + pluslen)
resize!(seq, len + pluslen)
end
if i isa BioSymbol
seq[len + 1] = i
else
copyto!(seq, len + 1, i, 1, length(i))
end
len += pluslen
end
seq
end
"""
join(::Type{T <: BioSequence}, seqs)
Concatenate all the biosequences/biosymbols in `seqs` to a biosequence of type `T`.
# Examples
```
julia> join(LongDNA, [dna"TAG", dna"AAC"])
6nt DNA Sequence:
TAGAAC
```
see also [`join!`](@ref)
"""
function Base.join(::Type{T}, it::Union{Vector, Tuple, Set}) where {T <: BioSequence}
_join!(T(undef, reduce((a, b) -> a + joinlen(b), it, init=0)), it, Val(true))
end
# length is intentionally not implemented for BioSymbol
joinlen(x::Union{BioSequence, BioSymbol}) = x isa BioSymbol ? 1 : length(x)
function Base.join(::Type{T}, it) where {T <: BioSequence}
_join!(empty(T), it, Val(false))
end
Base.repeat(chunk::BioSequence, n::Integer) = join(typeof(chunk), (chunk for i in 1:n))
Base.:^(x::BioSequence, n::Integer) = repeat(x, n)
# Concatenation and Base.repeat operators
function Base.:*(fst::BioSequence, rest::BioSequence...)
T = typeof(fst)
join(T, (fst, rest...))
end
"""
encoded_data_eltype(::Type{<:BioSequence})
Returns the element type of the encoded data of the `BioSequence`.
This is the return type of `extract_encoded_element`, i.e. the data
type that stores the biological symbols in the biosequence.
See also: [`BioSequence`](@ref)
"""
function encoded_data_eltype end
"""
extract_encoded_element(::BioSequence{A}, i::Integer)
Returns the encoded element at position `i`. This data can be
decoded using `decode(A(), data)` to yield the element type of
the biosequence.
See also: [`BioSequence`](@ref)
"""
function extract_encoded_element end
"""
encoded_setindex!(seq::BioSequence, x::E, i::Integer)
Given encoded data `x` of type `encoded_data_eltype(typeof(seq))`,
sets the internal sequence data at the given index.
See also: [`BioSequence`](@ref)
"""
function encoded_setindex! end
# Specific biosequences
"""
An alias for `BioSequence{<:NucleicAcidAlphabet}`
"""
const NucleotideSeq = BioSequence{<:NucleicAcidAlphabet}
"An alias for `BioSequence{<:NucleicAcidAlphabet}`"
const NucSeq{N} = BioSequence{<:NucleicAcidAlphabet{N}}
"An alias for `BioSequence{DNAAlphabet{N}}`"
const DNASeq{N} = BioSequence{DNAAlphabet{N}}
"An alias for `BioSequence{RNAAlphabet{N}}`"
const RNASeq{N} = BioSequence{RNAAlphabet{N}}
"""
An alias for `BioSequence{AminoAcidAlphabet}`
"""
const AASeq = BioSequence{AminoAcidAlphabet}
# The generic functions for any BioSequence...
include("indexing.jl")
include("conversion.jl")
include("predicates.jl")
include("find.jl")
include("printing.jl")
include("transformations.jl")
include("counting.jl")
include("copying.jl")
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 675 | ###
### Conversion & Promotion
###
###
### Conversion methods for biological sequences.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
function (::Type{S})(seq::BioSequence) where {S <: AbstractString}
_string(S, seq, codetype(Alphabet(seq)))
end
@static if VERSION >= v"1.8"
Base.LazyString(seq::BioSequence) = LazyString(string(seq))
end
function _string(::Type{S}, seq::BioSequence, ::AlphabetCode) where {S<:AbstractString}
return S([Char(x) for x in seq])
end
function _string(::Type{String}, seq::BioSequence, ::AsciiAlphabet)
String([stringbyte(s) for s in seq])
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 1181 |
function Base.copy!(dst::BioSequence, src::BioSequence)
resize!(dst, length(src))
copyto!(dst, src)
end
"""
copyto!(dst::LongSequence, src::BioSequence)
Equivalent to `copyto!(dst, 1, src, 1, length(src))`
"""
function Base.copyto!(dst::BioSequence, src::BioSequence)
copyto!(dst, 1, src, 1, length(src))
end
"""
copyto!(dst::BioSequence, soff, src::BioSequence, doff, N)
In-place copy `N` elements from `src` starting at `soff` to `dst`, starting at `doff`.
The length of `dst` must be greater than or equal to `N + doff - 1`.
The first N elements of `dst` are overwritten,
the other elements are left untouched. The alphabets of `src` and `dst` must be compatible.
# Examples
```
julia> seq = copyto!(dna"AACGTM", 1, dna"TAG", 1, 3)
6nt DNA Sequence:
TAGGTM
julia> copyto!(seq, 2, rna"UUUU", 1, 4)
6nt DNA Sequence:
TTTTTM
```
"""
function Base.copyto!(dst::BioSequence{A}, doff::Integer,
src::BioSequence, soff::Integer,
N::Integer) where {A <: Alphabet}
@boundscheck checkbounds(dst, doff:doff+N-1)
@boundscheck checkbounds(src, soff:soff+N-1)
for i in 0:N-1
dst[doff + i] = src[soff + i]
end
return dst
end | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2606 | ###
### Counting
###
### Counting operations on biological sequence types.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
###
### Naive counting
###
function count_naive(pred, seq::BioSequence)
n = 0
@inbounds for i in eachindex(seq)
n += pred(seq[i])::Bool
end
return n
end
function count_naive(pred, seqa::BioSequence, seqb::BioSequence)
n = 0
@inbounds for i in 1:min(length(seqa), length(seqb))
n += pred(seqa[i], seqb[i])::Bool
end
return n
end
"""
Count how many positions in a sequence satisfy a condition (i.e. f(seq[i]) -> true).
The first argument should be a function which accepts an element of the sequence
as its first parameter, additional arguments may be passed with `args...`.
"""
Base.count(pred, seq::BioSequence) = count_naive(pred, seq)
Base.count(pred, seqa::BioSequence, seqb::BioSequence) = count_naive(pred, seqa, seqb)
# These functions are BioSequences-specific because they take two arguments
isambiguous_or(x::T, y::T) where {T<:NucleicAcid} = isambiguous(x) | isambiguous(y)
isgap_or(x::T, y::T) where {T<:NucleicAcid} = isgap(x) | isgap(y)
iscertain_and(x::T, y::T) where {T<:NucleicAcid} = iscertain(x) & iscertain(y)
#BioSymbols.isambiguous(x::T, y::T) where {T<:NucleicAcid} = isambiguous(x) | isambiguous(y)
#BioSymbols.isgap(x::T, y::T) where {T<:NucleicAcid} = isgap(x) | isgap(y)
#BioSymbols.iscertain(x::T, y::T) where {T<:NucleicAcid} = iscertain(x) & iscertain(y)
Base.count(::typeof(isambiguous), seqa::S, seqb::S) where {S<:BioSequence{<:NucleicAcidAlphabet{2}}} = 0
Base.count(::typeof(isgap), seqa::S, seqb::S) where {S<:BioSequence{<:NucleicAcidAlphabet{2}}} = 0
Base.count(::typeof(iscertain), seqa::S, seqb::S) where {S<:BioSequence{<:NucleicAcidAlphabet{2}}} = min(length(seqa), length(seqb))
###
### Aliases for various uses of `count`.
###
"""
gc_content(seq::BioSequence)
Calculate GC content of `seq`.
"""
gc_content(seq::NucleotideSeq) = isempty(seq) ? 0.0 : count(isGC, seq) / length(seq)
n_ambiguous(seq) = count(isambiguous, seq)
n_ambiguous(seqa::BioSequence, seqb::BioSequence) = count(isambiguous_or, seqa, seqb)
n_certain(seq) = count(iscertain, seq)
n_certain(seqa::BioSequence, seqb::BioSequence) = count(iscertain_and, seqa, seqb)
n_gaps(seq::BioSequence) = count(isgap, seq)
n_gaps(seqa::BioSequence, seqb::BioSequence) = count(isgap_or, seqa, seqb)
mismatches(seqa::BioSequence, seqb::BioSequence) = count(!=, seqa, seqb)
matches(seqa::BioSequence, seqb::BioSequence) = count(==, seqa, seqb) | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2391 | ###
### Finders
###
###
### Finding positions meeting predicates in biological sequence types.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
function Base.findnext(f::Function, seq::BioSequence, start::Integer)
start > lastindex(seq) && return nothing
checkbounds(seq, start)
@inbounds for i in start:lastindex(seq)
if f(seq[i])
return i
end
end
return nothing
end
# No ambiguous sites can exist in a nucleic acid sequence using the two-bit alphabet.
Base.findnext(::typeof(isambiguous), seq::BioSequence{<:NucleicAcidAlphabet{2}}, from::Integer) = nothing
function Base.findprev(f::Function, seq::BioSequence, start::Integer)
start < firstindex(seq) && return nothing
checkbounds(seq, start)
for i in start:-1:firstindex(seq)
if f(seq[i])
return i
end
end
return nothing
end
Base.findfirst(f::Function, seq::BioSequence) = findnext(f, seq, firstindex(seq))
Base.findlast(f::Function, seq::BioSequence) = findprev(f, seq, lastindex(seq))
# Finding specific symbols
Base.findnext(x::DNA, seq::BioSequence{<:DNAAlphabet}, start::Integer) = Base.findnext(isequal(x), seq, start)
Base.findnext(x::RNA, seq::BioSequence{<:RNAAlphabet}, start::Integer) = Base.findnext(isequal(x), seq, start)
Base.findnext(x::AminoAcid, seq::BioSequence{AminoAcidAlphabet}, start::Integer) = Base.findnext(isequal(x), seq, start)
Base.findprev(x::DNA, seq::BioSequence{<:DNAAlphabet}, start::Integer) = Base.findprev(isequal(x), seq, start)
Base.findprev(x::RNA, seq::BioSequence{<:RNAAlphabet}, start::Integer) = Base.findprev(isequal(x), seq, start)
Base.findprev(x::AminoAcid, seq::BioSequence{AminoAcidAlphabet}, start::Integer) = Base.findprev(isequal(x), seq, start)
Base.findfirst(x::DNA, seq::BioSequence{<:DNAAlphabet}) = Base.findfirst(isequal(x), seq)
Base.findfirst(x::RNA, seq::BioSequence{<:RNAAlphabet}) = Base.findfirst(isequal(x), seq)
Base.findfirst(x::AminoAcid, seq::BioSequence{AminoAcidAlphabet}) = Base.findfirst(isequal(x), seq)
Base.findlast(x::DNA, seq::BioSequence{<:DNAAlphabet}) = Base.findlast(isequal(x), seq)
Base.findlast(x::RNA, seq::BioSequence{<:RNAAlphabet}) = Base.findlast(isequal(x), seq)
Base.findlast(x::AminoAcid, seq::BioSequence{AminoAcidAlphabet}) = Base.findlast(isequal(x), seq) | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 3103 | ###
### Indexing
###
###
### Indexing methods for mutable biological sequences.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
@inline function Base.iterate(seq::BioSequence, i::Int = firstindex(seq))
(i % UInt) - 1 < (lastindex(seq) % UInt) ? (@inbounds seq[i], i + 1) : nothing
end
## Bounds checking
function Base.checkbounds(x::BioSequence, i::Integer)
firstindex(x) ≤ i ≤ lastindex(x) || throw(BoundsError(x, i))
end
function Base.checkbounds(x::BioSequence, locs::AbstractVector{Bool})
length(x) == length(locs) || throw(BoundsError(x, lastindex(locs)))
end
@inline function Base.checkbounds(seq::BioSequence, locs::AbstractVector)
for i in locs
checkbounds(seq, i)
end
return true
end
@inline function Base.checkbounds(seq::BioSequence, range::UnitRange)
if !isempty(range) && (first(range) < 1 || last(range) > length(seq))
throw(BoundsError(seq, range))
end
end
## Getindex
Base.@propagate_inbounds function Base.getindex(x::BioSequence, i::Integer)
@boundscheck checkbounds(x, i)
data = extract_encoded_element(x, i)
return decode(Alphabet(x), data)
end
Base.@propagate_inbounds function Base.getindex(x::BioSequence, bools::AbstractVector{Bool})
@boundscheck checkbounds(x, bools)
res = typeof(x)(undef, count(bools))
ind = 0
@inbounds for i in eachindex(bools)
if bools[i]
ind += 1
res[ind] = x[i]
end
end
res
end
Base.@propagate_inbounds function Base.getindex(x::BioSequence, i::AbstractVector{<:Integer})
@boundscheck checkbounds(x, i)
isempty(i) && return empty(x)
res = typeof(x)(undef, length(i))
@inbounds for ind in eachindex(res)
res[ind] = x[i[ind]]
end
return res
end
Base.getindex(x::BioSequence, ::Colon) = copy(x)
## Setindex
Base.@propagate_inbounds function Base.setindex!(x::BioSequence, v, i::Integer)
@boundscheck checkbounds(x, i)
vT = convert(eltype(typeof(x)), v)
data = encode(Alphabet(x), vT)
encoded_setindex!(x, data, i)
end
Base.@propagate_inbounds function Base.setindex!(seq::BioSequence, x, locs::AbstractVector{<:Integer})
@boundscheck checkbounds(seq, locs)
@boundscheck if length(x) != length(locs)
throw(DimensionMismatch("Attempt to assign $(length(x)) values to $(length(locs)) destinations"))
end
for (i, xi) in zip(locs, x)
@boundscheck checkbounds(seq, i)
seq[i] = xi
end
return seq
end
Base.@propagate_inbounds function Base.setindex!(seq::BioSequence, x, locs::AbstractVector{Bool})
@boundscheck checkbounds(seq, locs)
n = count(locs)
@boundscheck if length(x) != n
throw(DimensionMismatch("Attempt to assign $(length(x)) values to $n destinations"))
end
j = 0
@inbounds for i in eachindex(locs)
if locs[i]
j += 1
seq[i] = x[j]
end
end
return seq
end
function Base.setindex!(seq::BioSequence, x, ::Colon)
return setindex!(seq, x, 1:lastindex(seq))
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2889 | ###
### Predicates & comparisons
###
### Generalised operations on biological sequence types.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
function Base.:(==)(seq1::BioSequence, seq2::BioSequence)
seq1 === seq2 && return true
length(seq1) == length(seq2) || return false
@inbounds for i in eachindex(seq1)
seq1[i] == seq2[i] || return false
end
return true
end
function Base.isless(seq1::BioSequence, seq2::BioSequence)
@inbounds for i in Base.OneTo(min(length(seq1), length(seq2)))
i1, i2 = seq1[i], seq2[i]
isless(i1, i2) && return true
isless(i2, i1) && return false
end
return isless(length(seq1), length(seq2))
end
"""
isrepetitive(seq::BioSequence, n::Integer = length(seq))
Return `true` if and only if `seq` contains a repetitive subsequence of length `≥ n`.
"""
function isrepetitive(seq::BioSequence, n::Integer = length(seq))
if n < 0
error("repetition must be non-negative")
elseif isempty(seq)
return n == 0
end
rep = 1
if rep ≥ n
return true
end
last = first(seq)
for i in 2:lastindex(seq)
x = seq[i]
if x == last
rep += 1
if rep ≥ n
return true
end
else
rep = 1
end
last = x
end
return false
end
"""
ispalindromic(seq::BioSequence)
Return `true` if `seq` is a palindromic sequence; otherwise return `false`.
"""
function ispalindromic(seq::BioSequence{<:NucleicAcidAlphabet})
for i in 1:cld(length(seq), 2)
if seq[i] != complement(seq[end - i + 1])
return false
end
end
return true
end
"""
hasambiguity(seq::BioSequence)
Returns `true` if `seq` has an ambiguous symbol; otherwise return `false`.
"""
function hasambiguity(seq::BioSequence)
for x in seq
if isambiguous(x)
return true
end
end
return false
end
# 2 Bit specialization:
@inline hasambiguity(seq::BioSequence{<:NucleicAcidAlphabet{2}}) = false
"""
iscanonical(seq::NucleotideSeq)
Returns `true` if `seq` is canonical.
For any sequence, there is a reverse complement, which is the same sequence, but
on the complimentary strand of DNA:
```
------->
ATCGATCG
CGATCGAT
<-------
```
!!! note
Using the [`reverse_complement`](@ref) of a DNA sequence will give give this
reverse complement.
Of the two sequences, the *canonical* of the two sequences is the lesser of the
two i.e. `canonical_seq < other_seq`.
"""
function iscanonical(seq::NucleotideSeq)
i = 1
j = lastindex(seq)
@inbounds while i <= j
f = seq[i]
r = complement(seq[j])
f < r && return true
r < f && return false
i += 1
j -= 1
end
return true
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 3998 | # Printing, show and parse
# ------------------------
Base.summary(seq::BioSequence{<:DNAAlphabet}) = string(length(seq), "nt ", "DNA Sequence")
Base.summary(seq::BioSequence{<:RNAAlphabet}) = string(length(seq), "nt ", "RNA Sequence")
Base.summary(seq::BioSequence{<:AminoAcidAlphabet}) = string(length(seq), "aa ", "Amino Acid Sequence")
# Buffer type. Not exposed to user, so code should be kept simple and performant.
# B is true if it is buffered and false if it is not
mutable struct SimpleBuffer{B, T} <: IO
len::UInt
arr::Vector{UInt8}
io::T
end
SimpleBuffer(io::IO) = SimpleBuffer{true, typeof(io)}(0, Vector{UInt8}(undef, 1024), io)
SimpleBuffer(io::IO, len) = SimpleBuffer{false, typeof(io)}(0, Vector{UInt8}(undef, len), io)
function Base.write(sb::SimpleBuffer{true}, byte::UInt8)
sb.len ≥ 1024 && flush(sb)
sb.len += 1
@inbounds sb.arr[sb.len] = byte
end
function Base.write(sb::SimpleBuffer{false}, byte::UInt8)
len = sb.len + 1
sb.len = len
@inbounds sb.arr[len] = byte
end
# Flush entire buffer to its io
@noinline function Base.flush(sb::SimpleBuffer{true})
arr = sb.arr
GC.@preserve arr unsafe_write(sb.io, pointer(arr), UInt(1024))
sb.len = 0
end
# Flush all unflushed bytes to its io. Does not close source or make buffer unwritable
function Base.close(sb::SimpleBuffer)
iszero(sb.len) && return 0
arr = sb.arr
GC.@preserve arr unsafe_write(sb.io, pointer(arr), sb.len)
sb.len = 0
end
function padded_length(len::Integer, width::Integer)
den = ifelse(width < 1, typemax(Int), width)
return len + div(len-1, den)
end
function Base.print(io::IO, seq::BioSequence{A}; width::Integer = 0) where {A<:Alphabet}
return _print(io, seq, width, codetype(A()))
end
# Generic method. The different name allows subtypes of BioSequence to
# selectively call the generic print despite being more specific type
function _print(io::IO, seq::BioSequence, width::Integer, ::UnicodeAlphabet)
col = 0
for x in seq
col += 1
if (width > 0) & (col > width)
write(io, '\n')
col = 1
end
print(io, x)
end
return nothing
end
# Specialized method for ASCII alphabet
function _print(io::IO, seq::BioSequence, width::Integer, ::AsciiAlphabet)
# If seq is large, always buffer for memory efficiency
if length(seq) ≥ 4096
return _print(SimpleBuffer(io), seq, width, AsciiAlphabet())
end
if (width < 1) | (length(seq) ≤ width)
# Fastest option
return print(io, String(seq))
else
# Second fastest option
buffer = SimpleBuffer(io, padded_length(length(seq), width))
return _print(buffer, seq, width, AsciiAlphabet())
end
end
function _print(buffer::SimpleBuffer, seq::BioSequence, width::Integer, ::AsciiAlphabet)
col = 0
@inbounds for i in eachindex(seq)
col += 1
if (width > 0) & (col > width)
write(buffer, UInt8('\n'))
col = 1
end
write(buffer, stringbyte(seq[i]))
end
close(buffer)
return nothing
end
Base.show(io::IO, seq::BioSequence) = showcompact(io, seq)
function Base.show(io::IO, ::MIME"text/plain", seq::BioSequence)
println(io, summary(seq), ':')
showcompact(io, seq)
end
function showcompact(io::IO, seq::BioSequence)
# don't show more than this many characters
# to avoid filling the screen with junk
if isempty(seq)
print(io, "< EMPTY SEQUENCE >")
else
width = displaysize()[2]
if length(seq) > width
half = div(width, 2)
for i in 1:half-1
print(io, seq[i])
end
print(io, '…')
for i in lastindex(seq)-half+2:lastindex(seq)
print(io, seq[i])
end
else
print(io, seq)
end
end
end
function string_compact(seq::BioSequence)
buf = IOBuffer()
showcompact(buf, seq)
return String(take!(buf))
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 5969 | # Transformations
# ===============
#
# Methods that manipulate and change a biological sequence.
#
# This file is a part of BioJulia.
# License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
"""
empty!(seq::BioSequence)
Completely empty a biological sequence `seq` of nucleotides.
"""
Base.empty!(seq::BioSequence) = resize!(seq, 0)
"""
push!(seq::BioSequence, x)
Append a biological symbol `x` to a biological sequence `seq`.
"""
function Base.push!(seq::BioSequence, x)
x_ = convert(eltype(seq), x)
resize!(seq, length(seq) + 1)
@inbounds seq[end] = x_
return seq
end
"""
pop!(seq::BioSequence)
Remove the symbol from the end of a biological sequence `seq` and return it.
Returns a variable of `eltype(seq)`.
"""
function Base.pop!(seq::BioSequence)
if isempty(seq)
throw(ArgumentError("sequence must be non-empty"))
end
@inbounds x = seq[end]
deleteat!(seq, lastindex(seq))
return x
end
"""
insert!(seq::BioSequence, i, x)
Insert a biological symbol `x` into a biological sequence `seq`, at the given
index `i`.
"""
function Base.insert!(seq::BioSequence, i::Integer, x)
checkbounds(seq, i)
resize!(seq, length(seq) + 1)
copyto!(seq, i + 1, seq, i, lastindex(seq) - i)
@inbounds seq[i] = x
return seq
end
"""
deleteat!(seq::BioSequence, range::UnitRange{<:Integer})
Deletes a defined `range` from a biological sequence `seq`.
Modifies the input sequence.
"""
function Base.deleteat!(seq::BioSequence, range::UnitRange{<:Integer})
checkbounds(seq, range)
copyto!(seq, range.start, seq, range.stop + 1, length(seq) - range.stop)
resize!(seq, length(seq) - length(range))
return seq
end
"""
deleteat!(seq::BioSequence, i::Integer)
Delete a biological symbol at a single position `i` in a biological sequence
`seq`.
Modifies the input sequence.
"""
function Base.deleteat!(seq::BioSequence, i::Integer)
checkbounds(seq, i)
copyto!(seq, i, seq, i + 1, length(seq) - i)
resize!(seq, length(seq) - 1)
return seq
end
"""
append!(seq, other)
Add a biological sequence `other` onto the end of biological sequence `seq`.
Modifies and returns `seq`.
"""
function Base.append!(seq::BioSequence, other::BioSequence)
resize!(seq, length(seq) + length(other))
copyto!(seq, lastindex(seq) - length(other) + 1, other, 1, length(other))
return seq
end
"""
popfirst!(seq)
Remove the symbol from the beginning of a biological sequence `seq` and return
it. Returns a variable of `eltype(seq)`.
"""
function Base.popfirst!(seq::BioSequence)
if isempty(seq)
throw(ArgumentError("sequence must be non-empty"))
end
@inbounds x = seq[1]
deleteat!(seq, 1)
return x
end
"""
pushfirst!(seq, x)
Insert a biological symbol `x` at the beginning of a biological sequence `seq`.
"""
function Base.pushfirst!(seq::BioSequence, x)
resize!(seq, length(seq) + 1)
copyto!(seq, 2, seq, 1, length(seq) - 1)
@inbounds seq[firstindex(seq)] = x
return seq
end
Base.filter(f, seq::BioSequence) = filter!(f, copy(seq))
function Base.filter!(f, seq::BioSequence)
ind = 0
@inbounds for i in eachindex(seq)
if f(seq[i])
ind += 1
else
break
end
end
@inbounds for i in ind+1:lastindex(seq)
v = seq[i]
if f(v)
ind += 1
seq[ind] = v
end
end
return resize!(seq, ind)
end
Base.map(f, seq::BioSequence) = map!(f, copy(seq))
function Base.map!(f, seq::BioSequence)
@inbounds for i in eachindex(seq)
seq[i] = f(seq[i])
end
seq
end
"""
reverse(seq::BioSequence)
Create reversed copy of a biological sequence.
"""
Base.reverse(seq::BioSequence) = reverse!(copy(seq))
function Base.reverse!(s::BioSequence)
i, j = 1, lastindex(s)
@inbounds while i < j
s[i], s[j] = s[j], s[i]
i, j = i + 1, j - 1
end
return s
end
"""
complement(seq)
Make a complement sequence of `seq`.
"""
function BioSymbols.complement(seq::NucleotideSeq)
return complement!(copy(seq))
end
complement!(seq::NucleotideSeq) = map!(complement, seq)
"""
reverse_complement!(seq)
Make a reversed complement sequence of `seq` in place.
"""
function reverse_complement!(seq::NucleotideSeq)
return complement!(reverse!(seq))
end
"""
reverse_complement(seq)
Make a reversed complement sequence of `seq`.
"""
function reverse_complement(seq::NucleotideSeq)
return complement!(reverse(seq))
end
"""
canonical!(seq::NucleotideSeq)
Transforms the `seq` into its canonical form, if it is not already canonical.
Modifies the input sequence inplace.
For any sequence, there is a reverse complement, which is the same sequence, but
on the complimentary strand of DNA:
```
------->
ATCGATCG
CGATCGAT
<-------
```
!!! note
Using the [`reverse_complement`](@ref) of a DNA sequence will give give this
reverse complement.
Of the two sequences, the *canonical* of the two sequences is the lesser of the
two i.e. `canonical_seq < other_seq`.
Using this function on a `seq` will ensure it is the canonical version.
"""
function canonical!(seq::NucleotideSeq)
if !iscanonical(seq)
reverse_complement!(seq)
end
return seq
end
"""
canonical(seq::NucleotideSeq)
Create the canonical sequence of `seq`.
"""
canonical(seq::NucleotideSeq) = iscanonical(seq) ? copy(seq) : reverse_complement(seq)
"Create a copy of a sequence with gap characters removed."
ungap(seq::BioSequence) = filter(!isgap, seq)
"Remove gap characters from an input sequence."
ungap!(seq::BioSequence) = filter!(!isgap, seq)
###
### Shuffle
###
function Random.shuffle!(seq::BioSequence)
# Fisher-Yates shuffle
@inbounds for i in 1:lastindex(seq) - 1
j = rand(i:lastindex(seq))
seq[i], seq[j] = seq[j], seq[i]
end
return seq
end
function Random.shuffle(seq::BioSequence)
return shuffle!(copy(seq))
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 3527 |
include("bitindex.jl")
include("bitpar-compiler.jl")
@inline function reversebits(x::T, ::BitsPerSymbol{2}) where T <: Base.BitUnsigned
mask = 0x33333333333333333333333333333333 % T
x = ((x >> 2) & mask) | ((x & mask) << 2)
return reversebits(x, BitsPerSymbol{4}())
end
@inline function reversebits(x::T, ::BitsPerSymbol{4}) where T <: Base.BitUnsigned
mask = 0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F % T
x = ((x >> 4) & mask) | ((x & mask) << 4)
return bswap(x)
end
reversebits(x::T, ::BitsPerSymbol{8}) where T <: Base.BitUnsigned = bswap(x)
@inline function complement_bitpar(x::Unsigned, ::T) where {T<:NucleicAcidAlphabet{2}}
return ~x
end
@inline function complement_bitpar(x::Unsigned, ::T) where {T<:NucleicAcidAlphabet{4}}
return (
((x & repeatpattern(typeof(x), 0x11)) << 3) | ((x & repeatpattern(typeof(x), 0x88)) >> 3) |
((x & repeatpattern(typeof(x), 0x22)) << 1) | ((x & repeatpattern(typeof(x), 0x44)) >> 1)
)
end
@inline function gc_bitcount(x::Unsigned, ::NucleicAcidAlphabet{2})
msk = repeatpattern(typeof(x), 0x55)
c = x & msk
g = (x >> 1) & msk
return count_ones(c ⊻ g)
end
@inline function gc_bitcount(x::Unsigned, ::NucleicAcidAlphabet{4})
a = x & repeatpattern(typeof(x), 0x11)
c = (x & repeatpattern(typeof(x), 0x22)) >> 1
g = (x & repeatpattern(typeof(x), 0x44)) >> 2
t = (x & repeatpattern(typeof(x), 0x88)) >> 3
return count_ones((c | g) & ~(a | t))
end
@inline a_bitcount(x::Unsigned, ::NucleicAcidAlphabet{2}) = count_00_bitpairs(x)
@inline c_bitcount(x::Unsigned, ::NucleicAcidAlphabet{2}) = count_01_bitpairs(x)
@inline g_bitcount(x::Unsigned, ::NucleicAcidAlphabet{2}) = count_10_bitpairs(x)
@inline t_bitcount(x::Unsigned, ::NucleicAcidAlphabet{2}) = count_11_bitpairs(x)
@inline function mismatch_bitcount(a::UInt64, b::UInt64, ::T) where {T<:NucleicAcidAlphabet{4}}
return count_nonzero_nibbles(a ⊻ b)
end
@inline function mismatch_bitcount(a::UInt64, b::UInt64, ::T) where {T<:NucleicAcidAlphabet{2}}
return count_nonzero_bitpairs(a ⊻ b)
end
@inline function match_bitcount(a::UInt64, b::UInt64, ::T) where {T<:NucleicAcidAlphabet{4}}
return count_0000_nibbles(a ⊻ b)
end
@inline function match_bitcount(a::UInt64, b::UInt64, ::T) where {T<:NucleicAcidAlphabet{2}}
return count_00_bitpairs(a ⊻ b)
end
@inline function ambiguous_bitcount(x::UInt64, ::T) where {T<:NucleicAcidAlphabet{4}}
return count_nonzero_nibbles(enumerate_nibbles(x) & 0xEEEEEEEEEEEEEEEE)
end
@inline function ambiguous_bitcount(a::UInt64, b::UInt64, ::T) where {T<:NucleicAcidAlphabet{4}}
return count_nonzero_nibbles((enumerate_nibbles(a) | enumerate_nibbles(b)) & 0xEEEEEEEEEEEEEEEE)
end
@inline function gap_bitcount(x::UInt64, ::T) where {T<:NucleicAcidAlphabet{4}}
return count_0000_nibbles(x)
end
@inline function gap_bitcount(a::UInt64, b::UInt64, ::T) where {T<:NucleicAcidAlphabet{4}}
# Count the gaps in a, count the gaps in b, subtract the number of shared gaps.
return count_0000_nibbles(a) + count_0000_nibbles(b) - count_0000_nibbles(a | b)
end
@inline function certain_bitcount(x::UInt64, ::T) where {T<:NucleicAcidAlphabet{4}}
x = enumerate_nibbles(x)
x = x ⊻ 0x1111111111111111
return count_0000_nibbles(x)
end
@inline function certain_bitcount(a::UInt64, b::UInt64, ::T) where {T<:NucleicAcidAlphabet{4}}
x = enumerate_nibbles(a) ⊻ 0x1111111111111111
y = enumerate_nibbles(b) ⊻ 0x1111111111111111
return count_0000_nibbles(x | y)
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 3027 | # BitIndex
# --------
#
# Utils for indexing bits in a vector of unsigned integers (internal use only).
#
# This file is a part of BioJulia.
# License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
#
# index(i)-1 index(i) index(i)+1
# ....|................|..X.............|................|....
# |<-offset(i)-|
# |<--- 64 bits -->|
"""
BitIndex
`BitIndex` is an internal type used in BioSequences.It contains
a bit offset. For biosequences with an internal array of coding units,
it can be used to obtain the array index and element bit offset.
Useful methods:
* bitindex(::BioSequence, ::Int)
* index(::BitIndex)
* offset(::BitIndex)
* nextposition / prevposition(::BitIndex)
* extract_encoded_element(::BitIndex, ::Union{Array, Tuple})
"""
struct BitIndex{N, W}
val::UInt64
end
BitsPerSymbol(::BitIndex{N, W}) where {N,W} = BitsPerSymbol{N}()
bits_per_symbol(::BitIndex{N, W}) where {N,W} = N
@inline function bitindex(::BitsPerSymbol{N}, ::Type{W}, i) where {N,W}
return BitIndex{N, W}((i - 1) << trailing_zeros(N))
end
bitwidth(::Type{W}) where W = 8*sizeof(W)
@inline index_shift(::BitIndex{N,W}) where {N,W} = trailing_zeros(bitwidth(W))
@inline offset_mask(::BitIndex{N,W}) where {N,W} = UInt8(bitwidth(W)) - 0x01
@inline index(i::BitIndex) = (i.val >> index_shift(i)) + 1
@inline offset(i::BitIndex) = i.val & offset_mask(i)
Base.:+(i::BitIndex{N,W}, n::Integer) where {N,W} = BitIndex{N,W}(i.val + n)
Base.:-(i::BitIndex{N,W}, n::Integer) where {N,W} = BitIndex{N,W}(i.val - n)
Base.:-(i1::BitIndex, i2::BitIndex) = i1.val - i2.val
Base.:(==)(i1::BitIndex, i2::BitIndex) = i1.val == i2.val
Base.isless(i1::BitIndex, i2::BitIndex) = isless(i1.val, i2.val)
@inline function nextposition(i::BitIndex{N,W}) where {N,W}
return i + N
end
@inline function prevposition(i::BitIndex{N,W}) where {N,W}
return i - N
end
function Base.iterate(i::BitIndex, s = 1)
if s == 1
return (index(i), 2)
elseif s == 2
return (offset(i), 3)
else
return nothing
end
end
Base.show(io::IO, i::BitIndex) = print(io, '(', index(i), ", ", offset(i), ')')
"Extract the element stored in a packed bitarray referred to by bidx."
@inline function extract_encoded_element(bidx::BitIndex{N,W}, data::Union{AbstractArray{W}, Tuple{Vararg{W}}}) where {N,W}
chunk = (@inbounds data[index(bidx)]) >> offset(bidx)
return chunk & bitmask(bidx)
end
# Create a bit mask that fills least significant `n` bits (`n` must be a
# non-negative integer).
"Create a bit mask covering the least significant `n` bits."
function bitmask(::Type{T}, n::Integer) where {T}
topshift = 8 * sizeof(T) - 1
return ifelse(n > topshift, typemax(T), one(T) << (n & topshift) - one(T))
end
# Create a bit mask filling least significant N bits.
# This is used in the extract_encoded_element function.
bitmask(::BitIndex{N,W}) where {N, W} = bitmask(W, N)
bitmask(n::Integer) = bitmask(UInt64, n)
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 8735 | ###
### Bitparallel
###
"""
A generator for efficient bitwise sequence operations.
"""
function compile_bitpar(funcname::Symbol;
arguments::Tuple = (),
init_code::Expr = :(),
head_code::Expr = :(),
body_code::Expr = :(),
tail_code::Expr = :(),
return_code::Expr = :())
functioncode = :(function $(funcname)() end)
for arg in arguments
push!(functioncode.args[1].args, arg)
end
functioncode.args[2] = quote
$(init_code)
ind = bitindex(seq, 1)
stop = bitindex(seq, lastindex(seq) + 1)
data = seq.data
@inbounds begin
if !iszero(offset(ind)) & (ind < stop)
# align the bit index to the beginning of a block boundary
o = offset(ind)
mask = bitmask(stop - ind)
n_bits_masked = ifelse(index(stop) == index(ind), count_zeros(mask), o)
chunk = (data[index(ind)] >> o) & mask
$(head_code)
ind += 64 - o
end
lastind = index(stop - bits_per_symbol(Alphabet(seq)))
lastind -= !iszero(offset(stop))
for i in index(ind):lastind
chunk = data[i]
$(body_code)
ind += 64
end
if ind < stop
n_bits_masked = 64 - offset(stop)
chunk = data[index(ind)] & bitmask(64 - n_bits_masked)
$(tail_code)
end
end
$(return_code)
end
return functioncode
end
function get_arg_name(arg)
if typeof(arg) === Expr
if arg.head === :(::)
return first(arg.args)
end
end
return arg
end
function check_arguments(args::Tuple)
# Check all arguments are symbols or expressions
for arg in args
if !(isa(arg, Symbol) || isa(arg, Expr))
error("Argument ", arg, " is not an expression or symbol")
end
end
a1 = first(args)
if isa(a1, Symbol)
@assert a1 == :seqa
elseif isa(a1, Expr)
@assert a1.head === :(::)
@assert first(a1.args) === :seqa
end
a2 = args[2]
if isa(a2, Symbol)
@assert a2 == :seqb
elseif isa(a2, Expr)
@assert a2.head === :(::)
@assert first(a2.args) === :seqb
end
end
function add_arguments!(exp, args)
check_arguments(args)
@assert exp.head === :function
if exp.args[1].head === :call
for arg in args
push!(exp.args[1].args, arg)
end
elseif exp.args[1].head === :where
@assert exp.args[1].args[1].head === :call
for arg in args
push!(exp.args[1].args[1].args, arg)
end
else
error("Expression in function is not a :call or :where!")
end
end
function compile_2seq_bitpar(funcname::Symbol;
arguments::Tuple = (),
parameters::Tuple = (),
init_code::Expr = :(),
head_code::Expr = :(),
body_code::Expr = :(),
tail_code::Expr = :(),
return_code::Expr = :())
# TODO: Check the parameters provided.
if isempty(parameters)
functioncode = :(function $(funcname)() end)
else
functioncode = :(function $(funcname)() where {$(parameters...)} end)
end
add_arguments!(functioncode, arguments)
argument_names = map(get_arg_name, arguments)
argument_names = tuple(argument_names[2], argument_names[1], argument_names[3:end]...)
functioncode.args[2] = quote
if length(seqa) > length(seqb)
return $funcname($(argument_names...))
end
@assert length(seqa) ≤ length(seqb)
nexta = bitindex(seqa, 1)
stopa = bitindex(seqa, lastindex(seqa) + 1)
nextb = bitindex(seqb, 1)
stopb = bitindex(seqb, lastindex(seqb) + 1)
adata = seqa.data
bdata = seqb.data
$(init_code)
# The first thing we need to sort out is to correctly align the head of
# sequence / subsequence `a`s data is aligned such that the offset of
# `nexta` is essentially reduced to 0.
# With sequence / subsequence `a` aligned, from there, we only need to
# worry about the alignment of sequence / subsequence `b` with respect
# to `a`.
if nexta < stopa && offset(nexta) != 0
# Here we shift the first data chunks to the right so as the first
# nucleotide of the seq/subseq is the first nibble / pair of bits.
x = adata[index(nexta)] >> offset(nexta)
y = bdata[index(nextb)] >> offset(nextb)
# Here it was assumed that there is something to go and get from
# the next chunk of `b`, yet that may not be true.
# We know that if this is not true of `b`, then it is certainly not
# true of `a`.
# We check if the end of the sequence is not contained in the same
# integer like so: `64 - offset(nextb) < stopb - nextb`.
#
# This edge case was found and accounted for by Ben J. Ward @BenJWard.
# Ask this maintainer for more information.
if offset(nextb) > offset(nexta) && 64 - offset(nextb) < stopb - nextb
y |= bdata[index(nextb) + 1] << (64 - offset(nextb))
end
# Here we need to check something, we need to check if the
# integer of `a` we are currently aligning contains the end of
# seq/subseq `a`. Because if so it's something we need to take into
# account of when we mask x and y.
#
# In other words if `64 - offset(nexta) > stopa - nexta, we know
# seq or subseq a's data ends before the end of this data chunk,
# and so the mask used needs to be defined to account for this:
# `mask(stopa - nexta)`, otherwise the mask simply needs to be
# `mask(64 - offset(nexta))`.
#
# This edge case was found and accounted for by Ben Ward @Ward9250.
# Ask this maintainer for more information.
offs = ifelse(64 - offset(nexta) > stopa - nexta, stopa - nexta, 64 - offset(nexta))
m = bitmask(offs)
x &= m
y &= m
$(head_code)
# Here we move our current position markers by k, meaning they move
# to either, A). The next integer, or B). The end of the sequence if
# it is in the current integer.
nexta += offs
nextb += offs
end
if offset(nextb) == 0 # data are aligned with each other
while stopa - nexta ≥ 64 # Iterate through body of data
x = adata[index(nexta)]
y = bdata[index(nextb)]
$(body_code)
nexta += 64
nextb += 64
end
if nexta < stopa
x = adata[index(nexta)]
y = bdata[index(nextb)]
offs = stopa - nexta
m = bitmask(offs)
x &= m
y &= m
$(tail_code)
end
elseif nexta < stopa # Data are unaligned
y = bdata[index(nextb)]
nextb += 64
# Note that here, updating `nextb` by 64, increases the chunk index,
# but the `offset(nextb)` will remain the same.
while stopa - nexta ≥ 64 # processing body of data
x = adata[index(nexta)]
z = bdata[index(nextb)]
y = y >> offset(nextb) | z << (64 - offset(nextb))
$(body_code)
y = z
nexta += 64
nextb += 64
end
if nexta < stopa # processing tail of data
x = adata[index(nexta)]
y = y >> offset(nextb)
if 64 - offset(nextb) < stopa - nexta
y |= bdata[index(nextb)] << (64 - offset(nextb))
end
offs = stopa - nexta
m = bitmask(offs)
x &= m
y &= m
$(tail_code)
end
end
$(return_code)
end
return functioncode
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2973 | ###
### Constructors
###
###
### Constructor methods for LongSequences.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
@inline seq_data_len(s::LongSequence{A}) where A = seq_data_len(A, length(s))
@inline function seq_data_len(::Type{A}, len::Integer) where A <: Alphabet
iszero(bits_per_symbol(A())) && return 0
return cld(len, div(64, bits_per_symbol(A())))
end
function LongSequence{A}(::UndefInitializer, len::Integer) where {A<:Alphabet}
if len < 0
throw(ArgumentError("len must be non-negative"))
end
return LongSequence{A}(Vector{UInt64}(undef, seq_data_len(A, len)), UInt(len))
end
# Generic constructor
function LongSequence{A}(it) where {A <: Alphabet}
len = length(it)
data = Vector{UInt64}(undef, seq_data_len(A, len))
bits = zero(UInt)
bitind = bitindex(BitsPerSymbol(A()), encoded_data_eltype(LongSequence{A}), 1)
@inbounds for x in it
xT = convert(eltype(A), x)
enc = encode(A(), xT)
bits |= enc << offset(bitind)
if iszero(offset(nextposition(bitind)))
data[index(bitind)] = bits
bits = zero(UInt64)
end
bitind = nextposition(bitind)
end
iszero(offset(bitind)) || (data[index(bitind)] = bits)
LongSequence{A}(data, len % UInt)
end
Base.empty(::Type{T}) where {T <: LongSequence} = T(UInt[], UInt(0))
(::Type{T})() where {T <: LongSequence} = empty(T)
# Constructors from other sequences
# TODO: Remove this method, since the user can just slice
LongSequence(s::LongSequence, xs::AbstractUnitRange{<:Integer}) = s[xs]
function LongSequence(seq::BioSequence{A}) where {A <: Alphabet}
return LongSequence{A}(seq)
end
LongSequence{A}(seq::LongSequence{A}) where {A <: Alphabet} = copy(seq)
function (::Type{T})(seq::LongSequence{<:NucleicAcidAlphabet{N}}) where
{N, T<:LongSequence{<:NucleicAcidAlphabet{N}}}
return T(copy(seq.data), seq.len)
end
# Constructors from strings
function LongSequence{A}(s::Union{String, SubString{String}}) where {A<:Alphabet}
return LongSequence{A}(s, codetype(A()))
end
# Generic method for String/Substring.
function LongSequence{A}(s::Union{String, SubString{String}}, ::AlphabetCode) where {A<:Alphabet}
len = length(s)
seq = LongSequence{A}(undef, len)
return copyto!(seq, 1, s, 1, len)
end
function LongSequence{A}(s::Union{String, SubString{String}}, ::AsciiAlphabet) where {A<:Alphabet}
seq = LongSequence{A}(undef, ncodeunits(s))
return encode_chunks!(seq, 1, codeunits(s), 1, ncodeunits(s))
end
function LongSequence{A}(
src::Union{AbstractString,AbstractVector{UInt8}},
part::AbstractUnitRange{<:Integer}=1:length(src)
) where {A<:Alphabet}
len = length(part)
seq = LongSequence{A}(undef, len)
return copyto!(seq, 1, src, first(part), len)
end
Base.parse(::Type{LongSequence{A}}, seq::AbstractString) where A = LongSequence{A}(seq) | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 773 | ###
### Conversion & Promotion
###
###
### Conversion methods for LongSequences.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
###
### Promotion
###
for alph in (DNAAlphabet, RNAAlphabet)
@eval function Base.promote_rule(::Type{LongSequence{A}}, ::Type{LongSequence{B}}) where {A<:$alph,B<:$alph}
return LongSequence{promote_rule(A, B)}
end
end
###
### Conversion
###
Base.convert(::Type{T}, seq::T) where {T <: LongSequence} = seq
Base.convert(::Type{T}, seq::T) where {T <: LongSequence{<:NucleicAcidAlphabet}} = seq
function Base.convert(::Type{T}, seq::LongSequence{<:NucleicAcidAlphabet}) where
{T<:LongSequence{<:NucleicAcidAlphabet}}
return T(seq)
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 9902 | ###
### Copying
###
###
### Copying methods for biological sequences.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
"""
copy!(dst::LongSequence, src::BioSequence)
In-place copy content of `src` to `dst`, resizing `dst` to fit.
The alphabets of `src` and `dst` must be compatible.
# Examples
```
julia> seq = copy!(dna"TAG", dna"AACGTM")
6nt DNA Sequence:
AACGTM
julia> copy!(seq, rna"UUAG")
4nt DNA Sequence:
TTAG
```
"""
function Base.copy!(dst::SeqOrView{A}, src::SeqOrView{A}) where {A <: Alphabet}
return _copy!(dst, src)
end
function Base.copy!(dst::SeqOrView{<:NucleicAcidAlphabet{N}},
src::SeqOrView{<:NucleicAcidAlphabet{N}}) where N
return _copy!(dst, src)
end
function _copy!(dst::LongSequence, src::LongSequence)
resize!(dst.data, length(src.data))
copyto!(dst.data, src.data)
dst.len = src.len
return dst
end
# This is specific to views because it might overwrite itself
function _copy!(dst::SeqOrView{A}, src::SeqOrView) where {A <: Alphabet}
# This intentionally throws an error for LongSubSeq
if length(dst) != length(src)
resize!(dst, length(src))
end
if dst.data === src.data
longseq = LongSequence{A}(src)
src_ = LongSubSeq{A}(longseq.data, 1:length(longseq))
else
src_ = src
end
return copyto!(dst, 1, src_, 1, length(src))
end
function Base.copyto!(dst::SeqOrView{A}, doff::Integer,
src::SeqOrView{A}, soff::Integer,
N::Integer) where {A <: Alphabet}
return _copyto!(dst, doff, src, soff, N)
end
function Base.copyto!(dst::SeqOrView{<:NucleicAcidAlphabet{B}}, doff::Integer,
src::SeqOrView{<:NucleicAcidAlphabet{B}}, soff::Integer,
N::Integer) where B
return _copyto!(dst, doff, src, soff, N)
end
function _copyto!(dst::SeqOrView{A}, doff::Integer,
src::SeqOrView, soff::Integer,
N::Integer) where {A <: Alphabet}
@boundscheck checkbounds(dst, doff:doff+N-1)
@boundscheck checkbounds(src, soff:soff+N-1)
# This prevents a sequence from destructively overwriting its own data
if (dst === src) & (doff > soff)
return _copyto!(dst, doff, src[soff:soff+N-1], 1, N)
end
id = bitindex(dst, doff)
is = bitindex(src, soff)
rest = N * bits_per_symbol(A())
dstdata = dst.data
srcdata = src.data
@inbounds while rest > 0
# move `k` bits from `src` to `dst`
x = dstdata[index(id)]
y = srcdata[index(is)]
if offset(id) < offset(is)
y >>= (offset(is) - offset(id)) & 63
k = min(64 - offset(is), rest)
else
y <<= (offset(id) - offset(is)) & 63
k = min(64 - offset(id), rest)
end
m = bitmask(k) << offset(id)
dstdata[index(id)] = y & m | x & ~m
id += k
is += k
rest -= k
end
return dst
end
#########
const SeqLike = Union{AbstractVector, AbstractString}
const ASCIILike = Union{String, SubString{String}}
"""
copy!(dst::LongSequence, src)
In-place copy content of sequence-like object `src` to `dst`, resizing `dst` to fit.
The content of `src` must be able to be encoded to the alphabet of `dst`.
# Examples
```
julia> seq = copy!(dna"TAG", "AACGTM")
6nt DNA Sequence:
AACGTM
julia> copy!(seq, [0x61, 0x43, 0x54])
3nt DNA Sequence:
ACT
```
"""
function Base.copy!(dst::SeqOrView{A}, src::SeqLike) where {A <: Alphabet}
return copy!(dst, src, codetype(A()))
end
function Base.copy!(dst::SeqOrView{<:Alphabet}, src::ASCIILike, C::AsciiAlphabet)
return copy!(dst, codeunits(src), C)
end
function Base.copy!(dst::SeqOrView{<:Alphabet}, src::AbstractVector{UInt8}, ::AsciiAlphabet)
resize!(dst, length(src))
return encode_chunks!(dst, 1, src, 1, length(src))
end
function Base.copy!(dst::SeqOrView{<:Alphabet}, src::SeqLike, ::AlphabetCode)
len = length(src) # calculate only once
resize!(dst, len)
return copyto!(dst, 1, src, 1, len)
end
########
# This is used to effectively scan an array of UInt8 for invalid bytes, when one is detected
@noinline function throw_encode_error(A::Alphabet, src::AbstractArray{UInt8}, soff::Integer)
for i in 1:div(64, bits_per_symbol(A))
index = soff + i - 1
sym = src[index]
if ascii_encode(A, sym) & 0x80 == 0x80
# If byte is a printable char, also display it
repr_char = if sym in UInt8('\a'):UInt8('\r') || sym in UInt8(' '):UInt8('~')
" (char '$(Char(sym))')"
else
""
end
error("Cannot encode byte $(repr(sym))$(repr_char) at index $(index) to $A")
end
end
@assert false "Expected error in encoding"
end
@inline function encode_chunk(A::Alphabet, src::AbstractArray{UInt8}, soff::Integer, N::Integer)
chunk = zero(UInt64)
check = 0x00
@inbounds for i in 1:N
enc = ascii_encode(A, src[soff+i-1])
check |= enc
chunk |= UInt64(enc) << (bits_per_symbol(A) * (i-1))
end
check & 0x80 == 0x00 || throw_encode_error(A, src, soff)
return chunk
end
# Use this for AsiiAlphabet alphabets only, internal use only, no boundschecks.
# This is preferential to `copyto!` if none of the sequence's original content
# needs to be kept, since this is faster.
function encode_chunks!(dst::SeqOrView{A}, startindex::Integer, src::AbstractVector{UInt8},
soff::Integer, N::Integer) where {A <: Alphabet}
chunks, rest = divrem(N, symbols_per_data_element(dst))
@inbounds for i in startindex:startindex+chunks-1
dst.data[i] = encode_chunk(A(), src, soff, symbols_per_data_element(dst))
soff += symbols_per_data_element(dst)
end
@inbounds if !iszero(rest)
dst.data[startindex+chunks] = encode_chunk(A(), src, soff, rest)
end
return dst
end
#########
# Two-argument method
"""
copyto!(dst::LongSequence, src)
Equivalent to `copyto!(dst, 1, src, 1, length(src))`.
"""
function Base.copyto!(dst::SeqOrView{A}, src::SeqLike) where {A <: Alphabet}
return copyto!(dst, src, codetype(A()))
end
# Specialized method to avoid O(N) length call for string-like src
function Base.copyto!(dst::SeqOrView{<:Alphabet}, src::ASCIILike, ::AsciiAlphabet)
len = ncodeunits(src)
@boundscheck checkbounds(dst, 1:len)
encode_chunks!(dst, 1, codeunits(src), 1, len)
return dst
end
function Base.copyto!(dst::SeqOrView{<:Alphabet}, src::SeqLike, C::AlphabetCode)
return copyto!(dst, 1, src, 1, length(src), C)
end
"""
copyto!(dst::LongSequence, soff, src, doff, N)
In-place encode `N` elements from `src` starting at `soff` to `dst`, starting at `doff`.
The length of `dst` must be greater than or equal to `N + doff - 1`.
The first N elements of `dst` are overwritten,
the other elements are left untouched. The content of `src` must be able to be encoded to
the alphabet of `dst`.
# Examples
```
julia> seq = copyto!(dna"AACGTM", 1, "TAG", 1, 3)
6nt DNA Sequence:
TAGGTM
julia> copyto!(seq, 2, rna"UUUU", 1, 4)
6nt DNA Sequence:
TTTTTM
```
"""
# Dispatch to codetype
function Base.copyto!(dst::SeqOrView{A}, doff::Integer,
src::SeqLike, soff::Integer, N::Integer) where {A <: Alphabet}
return copyto!(dst, doff, src, soff, N, codetype(A()))
end
# For ASCII seq and src, convert to byte vector and dispatch using that
function Base.copyto!(dst::SeqOrView{A}, doff::Integer,
src::ASCIILike, soff::Integer,
N::Integer, C::AsciiAlphabet) where {A <: Alphabet}
return Base.copyto!(dst, doff, codeunits(src), soff, N, C)
end
@noinline function throw_enc_indexerr(N::Integer, len::Integer, soff::Integer)
throw(ArgumentError("source of length $len does not contain $N elements from $soff"))
end
# Generic method for copyto!, i.e. NOT ASCII input
function Base.copyto!(dst::SeqOrView{A}, doff::Integer,
src::SeqLike, soff::Integer,
len::Integer, ::AlphabetCode) where {A <: Alphabet}
if soff != 1 && isa(src, AbstractString) && !isascii(src)
throw(ArgumentError("source offset ≠ 1 is not supported for non-ASCII string"))
end
checkbounds(dst, doff:doff+len-1)
length(src) < soff + len - 1 && throw_enc_indexerr(len, length(src), soff)
n = 0
i = soff
@inbounds while n < len
n += 1
dst[doff + n - 1] = src[i]
i = nextind(src, i)
end
return dst
end
# Special method possible for ASCII alphabet and UInt8 array
function Base.copyto!(dst::SeqOrView{A}, doff::Integer, src::AbstractVector{UInt8},
soff::Integer, N::Integer, ::AsciiAlphabet) where {A<:Alphabet}
checkbounds(dst, doff:doff+N-1)
length(src) < soff + N - 1 && throw_enc_indexerr(N, length(src), soff)
bitind = bitindex(dst, doff)
remaining = N
# Fill in first chunk. Since it may be only partially filled from both ends,
# bit-tricks are harder and we do it the old-fashined way.
# Maybe this can be optimized but eeehhh...
@inbounds while (!iszero(offset(bitind)) & !iszero(remaining))
dst[doff] = eltype(dst)(reinterpret(Char, (src[soff] % UInt32) << 24))
doff += 1
soff += 1
remaining -= 1
bitind += bits_per_symbol(A())
end
# Fill in middle
n = remaining - rem(remaining, symbols_per_data_element(dst))
encode_chunks!(dst, index(bitind), src, soff, n)
remaining -= n
soff += n
bitind += n * bits_per_symbol(A())
# Fill in last chunk
@inbounds if !iszero(remaining)
chunk = encode_chunk(A(), src, soff, remaining)
before = dst.data[index(bitind)] & (typemax(UInt) << (remaining * bits_per_symbol(A())))
dst.data[index(bitind)] = chunk | before
end
return dst
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 6756 | ###
### LongSequence specific specializations of src/biosequence/counting.jl
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
# Counting GC positions
let
counter = :(n += gc_bitcount(chunk, Alphabet(seq)))
compile_bitpar(
:count_gc_bitpar,
arguments = (:(seq::SeqOrView{<:NucleicAcidAlphabet}),),
init_code = :(n = 0),
head_code = counter,
body_code = counter,
tail_code = counter,
return_code = :(return n % Int)
) |> eval
end
Base.count(::typeof(isGC), seq::SeqOrView{<:NucleicAcidAlphabet}) = count_gc_bitpar(seq)
# Counting mismatches
let
counter = :(count += mismatch_bitcount(x, y, A()))
compile_2seq_bitpar(
:count_mismatches_bitpar,
arguments = (:(seqa::SeqOrView{A}), :(seqb::SeqOrView{A})),
parameters = (:(A<:NucleicAcidAlphabet),),
init_code = :(count = 0),
head_code = counter,
body_code = counter,
tail_code = counter,
return_code = :(return count % Int)
) |> eval
end
Base.count(::typeof(!=), seqa::SeqOrView{A}, seqb::SeqOrView{A}) where {A<:NucleicAcidAlphabet} = count_mismatches_bitpar(seqa, seqb)
Base.count(::typeof(!=), seqa::NucleicSeqOrView, seqb::NucleicSeqOrView) = count(!=, promote(seqa, seqb)...)
# Counting matches
let
counter = :(count += match_bitcount(x, y, A()))
count_empty = quote
count += match_bitcount(x, y, A())
nempty = div(64, bits_per_symbol(A())) - div(Int(offs), bits_per_symbol(A()))
count -= nempty
end
compile_2seq_bitpar(
:count_matches_bitpar,
arguments = (:(seqa::SeqOrView{A}), :(seqb::SeqOrView{A})),
parameters = (:(A<:NucleicAcidAlphabet),),
init_code = :(count = 0),
head_code = count_empty,
body_code = counter,
tail_code = count_empty,
return_code = :(return count % Int)
) |> eval
end
Base.count(::typeof(==), seqa::SeqOrView{A}, seqb::SeqOrView{A}) where {A<:NucleicAcidAlphabet} = count_matches_bitpar(seqa, seqb)
Base.count(::typeof(==), seqa::NucleicSeqOrView, seqb::NucleicSeqOrView) = count(==, promote(seqa, seqb)...)
# Counting ambiguous sites
# ------------------------
let
counter = :(count += ambiguous_bitcount(chunk, Alphabet(seq)))
compile_bitpar(
:count_ambiguous_bitpar,
arguments = (:(seq::SeqOrView{<:NucleicAcidAlphabet}),),
init_code = :(count = 0),
head_code = counter,
body_code = counter,
tail_code = counter,
return_code = :(return count % Int)
) |> eval
counter = :(count += ambiguous_bitcount(x, y, A()))
compile_2seq_bitpar(
:count_ambiguous_bitpar,
arguments = (:(seqa::SeqOrView{A}), :(seqb::SeqOrView{A})),
parameters = (:(A<:NucleicAcidAlphabet),),
init_code = :(count = 0),
head_code = counter,
body_code = counter,
tail_code = counter,
return_code = :(return count % Int)
) |> eval
end
## For a single sequence.
# You can never have ambiguous bases in a 2-bit encoded nucleotide sequence.
Base.count(::typeof(isambiguous), seq::SeqOrView{<:NucleicAcidAlphabet{2}}) = 0
Base.count(::typeof(isambiguous), seq::SeqOrView{<:NucleicAcidAlphabet{4}}) = count_ambiguous_bitpar(seq)
## For a pair of sequences.
# A pair of 2-bit encoded sequences will never have ambiguous bases.
Base.count(::typeof(isambiguous), seqa::SeqOrView{A}, seqb::SeqOrView{A}) where {A<:NucleicAcidAlphabet{2}} = 0
Base.count(::typeof(isambiguous), seqa::SeqOrView{A}, seqb::SeqOrView{A}) where {A<:NucleicAcidAlphabet{4}} = count_ambiguous_bitpar(seqa, seqb)
Base.count(::typeof(isambiguous), seqa::SeqOrView{<:NucleicAcidAlphabet{4}}, seqb::SeqOrView{<:NucleicAcidAlphabet{2}}) = count(isambiguous_or, promote(seqa, seqb)...)
Base.count(::typeof(isambiguous), seqa::SeqOrView{<:NucleicAcidAlphabet{2}}, seqb::SeqOrView{<:NucleicAcidAlphabet{4}}) = count(isambiguous_or, promote(seqa, seqb)...)
# Counting certain sites
let
counter = :(count += certain_bitcount(x, y, A()))
compile_2seq_bitpar(
:count_certain_bitpar,
arguments = (:(seqa::SeqOrView{A}), :(seqb::SeqOrView{A})),
parameters = (:(A<:NucleicAcidAlphabet),),
init_code = :(count = 0),
head_code = counter,
body_code = counter,
tail_code = counter,
return_code = :(return count % Int)
) |> eval
end
Base.count(::typeof(iscertain), seqa::SeqOrView{A}, seqb::SeqOrView{A}) where {A<:NucleicAcidAlphabet{4}} = count_certain_bitpar(seqa, seqb)
Base.count(::typeof(iscertain), seqa::SeqOrView{<:NucleicAcidAlphabet{4}}, seqb::SeqOrView{<:NucleicAcidAlphabet{2}}) = count(iscertain_and, promote(seqa, seqb)...)
Base.count(::typeof(iscertain), seqa::SeqOrView{<:NucleicAcidAlphabet{2}}, seqb::SeqOrView{<:NucleicAcidAlphabet{4}}) = count(iscertain_and, promote(seqa, seqb)...)
# Counting gap sites
let
count_empty = quote
Alph = Alphabet(seq)
count += gap_bitcount(chunk, Alph)
count -= div(n_bits_masked, bits_per_symbol(Alph))
end
counter = :(count += gap_bitcount(chunk, Alphabet(seq)))
compile_bitpar(
:count_gap_bitpar,
arguments = (:(seq::SeqOrView{<:NucleicAcidAlphabet{4}}),),
init_code = :(count = 0),
head_code = count_empty,
body_code = counter,
tail_code = count_empty,
return_code = :(return count % Int)
) |> eval
count_empty = quote
Alph = Alphabet(seqa)
count += gap_bitcount(x, y, Alph)
nempty = div(64, bits_per_symbol(Alph)) - div(offs, bits_per_symbol(Alph))
count -= nempty
end
counter = :(count += gap_bitcount(x, y, A()))
compile_2seq_bitpar(
:count_gap_bitpar,
arguments = (:(seqa::SeqOrView{A}), :(seqb::SeqOrView{A})),
parameters = (:(A<:NucleicAcidAlphabet),),
init_code = :(count = 0),
head_code = count_empty,
body_code = counter,
tail_code = count_empty,
return_code = :(return count % Int)
) |> eval
end
Base.count(::typeof(isgap), seqa::SeqOrView{A}, seqb::SeqOrView{A}) where {A<:NucleicAcidAlphabet{4}} = count_gap_bitpar(seqa, seqb)
Base.count(::typeof(isgap), seqa::SeqOrView{A}) where {A<:NucleicAcidAlphabet{4}} = count_gap_bitpar(seqa)
Base.count(::typeof(isgap), seqa::SeqOrView{<:NucleicAcidAlphabet{4}}, seqb::SeqOrView{<:NucleicAcidAlphabet{2}}) = count(isgap_or, promote(seqa, seqb)...)
Base.count(::typeof(isgap), seqa::SeqOrView{<:NucleicAcidAlphabet{2}}, seqb::SeqOrView{<:NucleicAcidAlphabet{4}}) = count(isgap_or, promote(seqa, seqb)...)
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 4577 | ###
### Hash
###
###
### MurmurHash3 function of BioSequence.
###
### The hash function defined here cares about the starting position of a
### character sequence in the underlying data. That means, even if the starting
### positions of two sequences (`s1` and `s2`) are different in their `data`
### field, their hash values are identical if `s1 == s1` is true. The
### implementation is based on the 128bit MurmurHash3 function, which was written
### by Austin Appleby, and the source code is distributed under the public domain:
### https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
# NB NOTE: This entire file is commented out until issue #243 is resolved
#=
const c1 = 0x87c37b91114253d5
const c2 = 0x4cf5ad432745937f
@inline function fmix64(k::UInt64)
k = k ⊻ k >> 33
k *= 0xff51afd7ed558ccd
k = k ⊻ k >> 33
k *= 0xc4ceb9fe1a85ec53
k = k ⊻ k >> 33
return k
end
@inline function murmur1(h1, k1)
k1 *= c1
k1 = bitrotate(k1, 31)
k1 *= c2
h1 = h1 ⊻ k1
return (h1, k1)
end
@inline function murmur2(h2, k2)
k2 *= c2
k2 = bitrotate(k2, 33)
k2 *= c1
h2 = h2 ⊻ k2
return (h2, k2)
end
@inline function murmur(h1, h2, k1, k2)
h1, k1 = murmur1(h1, k1)
h1 = bitrotate(h1, 27)
h1 += h2
h1 = h1 * 5 + 0x52dce729
h2, k2 = murmur2(h2, k2)
h2 = bitrotate(h2, 31)
h2 += h1
h2 = h2 * 5 + 0x38495ab5
return (h1, h2, k1, k2)
end
function finalize(h1, h2, len)
h1 = h1 ⊻ len
h2 = h2 ⊻ len
h1 += h2
h2 += h1
h1 = fmix64(h1)
h2 = fmix64(h2)
h1 += h2
h2 += h1
# Ref. implementation returns (h1, h2) for 128 bits, but we truncate to 64.
# last needless modification of h2 is optimised away by the compiler
return h1
end
function tail(::Type{<:LongSequence}, data, next, stop, h1, h2)
k1 = k2 = zero(UInt64)
# Use this to mask any noncoding bits in last chunk
mask = bitmask(offset(stop - bits_per_symbol(stop)) + bits_per_symbol(stop))
@inbounds if next < stop
k1 = data[index(next)]
next += 64
end
@inbounds if next < stop
k2 = data[index(next)] & mask
else
k1 &= mask
end
h1, k1 = murmur1(h1, k1)
h2, k2 = murmur2(h2, k2)
return (h1, h2)
end
@inline function body(::Type{<:LongSequence}, next, stop, data, h1, h2)
@inbounds while stop - next ≥ 128
j = index(next)
k1 = data[j]
k2 = data[j+1]
h1, h2, k1, k2 = murmur(h1, h2, k1, k2)
next += 128
end
return (h1, h2, next)
end
# This version of the body loop code must take a nonzero offset into account
function body(::Type{<:LongSubSeq}, next, stop, data, h1, h2)
off = offset(next)
next < stop || return (h1, h2, next)
# No offset, we can use the LongSequence one (more efficient)
iszero(off) && return body(LongSequence, next, stop, data, h1, h2)
@inbounds while stop - next ≥ 128
k1 = data[index(next)]
k2 = data[index(next) + 1]
k3 = data[index(next) + 2]
k1 = (k1 >>> off) | (k2 << ((64 - off) & 63))
k2 = (k2 >>> off) | (k3 << ((64 - off) & 63))
h1, h2, k1, k2 = murmur(h1, h2, k1, k2)
next += 128
end
return h1, h2, next
end
function tail(::Type{<:LongSubSeq}, data, next, stop, h1, h2)
next < stop || return (h1, h2)
# Load in first up to 3 data elements where the last 128 bits may be stored
firstindex = next
k1 = data[index(next)]
k2 = k3 = zero(UInt64)
off = offset(next)
next += 64 - off
if next < stop
k2 = @inbounds data[index(next)]
next += 64
end
if next < stop
k3 = @inbounds data[index(next)]
end
# Bitshift them to offset zero, only use k1 and k2
if !iszero(off)
k1 = (k1 >>> off) | (k2 << ((64 - off) & 63))
k2 = (k2 >>> off) | (k3 << ((64 - off) & 63))
end
# Mask any noncoding bits
mask = bitmask((stop-firstindex) & 63)
if stop - firstindex > 64
k2 &= mask
else
k1 &= mask
end
h1, k1 = murmur1(h1, k1)
h2, k2 = murmur2(h2, k2)
return (h1, h2)
end
function Base.hash(seq::SeqOrView, seed::UInt64)
h1, h2 = UInt64(0), seed
next = bitindex(seq, 1)
stop = bitindex(seq, (lastindex(seq) + 1) % UInt)
data = seq.data
h1, h2, next = body(typeof(seq), next, stop, data, h1, h2)
h1, h2 = tail(typeof(seq), data, next, stop, h1, h2)
h1 = finalize(h1, h2, length(seq))
return h1
end
=#
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2010 | ###
### LongSequence specific specializations of src/biosequence/indexing.jl
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
# Basic get/setindex methods
@inline function bitindex(x::LongSequence, i::Integer)
N = BitsPerSymbol(Alphabet(typeof(x)))
bitindex(N, encoded_data_eltype(typeof(x)), i)
end
firstbitindex(s::SeqOrView) = bitindex(s, firstindex(s))
lastbitindex(s::SeqOrView) = bitindex(s, lastindex(s))
@inline function extract_encoded_element(x::SeqOrView, i::Integer)
bi = bitindex(x, i % UInt)
extract_encoded_element(bi, x.data)
end
@inline function encoded_setindex!(s::SeqOrView, v::UInt64, i::BitIndex)
vi, off = i
data = s.data
bits = @inbounds data[vi]
@inbounds data[vi] = (UInt(v) << off) | (bits & ~(bitmask(i) << off))
return s
end
# More efficient due to copyto!
function Base.getindex(seq::LongSequence, part::AbstractUnitRange{<:Integer})
@boundscheck checkbounds(seq, part)
newseq = typeof(seq)(undef, length(part))
return copyto!(newseq, 1, seq, first(part), length(part))
end
# More efficient due to copyto!
function Base.setindex!(
seq::SeqOrView{A},
other::SeqOrView{A},
locs::AbstractUnitRange{<:Integer}
) where {A <: Alphabet}
@boundscheck checkbounds(seq, locs)
@boundscheck if length(other) != length(locs)
throw(DimensionMismatch("Attempt to assign $(length(locs)) values to $(length(seq)) destinations"))
end
return copyto!(seq, locs.start, other, 1, length(locs))
end
@inline function encoded_setindex!(
seq::SeqOrView{A},
bin::Unsigned,
i::Integer
) where {A <: Alphabet}
return encoded_setindex!(seq, bin, bitindex(seq, i))
end
@inline function encoded_setindex!(s::SeqOrView, v::Unsigned, i::BitIndex)
vi, off = i
data = s.data
bits = @inbounds data[vi]
v_ = v % encoded_data_eltype(typeof(s))
@inbounds data[vi] = (v_ << off) | (bits & ~(bitmask(i) << off))
return s
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 4849 | ###
### LongSequence
###
###
### A general purpose biological sequence representation.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
# About Internals
# ---------------
#
# The `data` field of a `LongSequence{A}` object contains binary representation
# of a biological character sequence. Each character is encoded with an encoder
# corresponding to the alphabet `A` and compactly packed into `data`. To extract
# a character from a sequence, you should decode this binary sequence with a
# decoder that is a pair of the encoder. The length of encoded binary bits is
# fixed, and hence a character at arbitrary position can be extracted in a
# constant time. To know the exact location of a character at a position, you
# can use the `bitindex(seq, i)` function, which returns a pair of element's index
# containing binary bits and bits' offset. As a whole, character extraction
# `seq[i]` can be written as:
#
# j = bitindex(seq, i)
# decode(A, (seq.data[index(j)] >> offset(j)) & mask(A))
#
# index : index(j) - 1 index(j) index(j) + 1
# data : |xxxxxxxxxxxxxxxx|xxXxxxxxxxxxxxxx|............xxxx|....
# offset : |<-offset(j)-|
# width : |<---- 64 ---->| |<---- 64 ---->| |<---- 64 ---->|
#
# * '.' : unused (4 bits/char)
# * 'x' : used
# * 'X' : used and pointed by index `i`
"""
LongSequence{A <: Alphabet}
General-purpose `BioSequence`. This type is mutable and variable-length, and should
be preferred for most use cases.
# Extended help
`LongSequence{A<:Alphabet} <: BioSequence{A}` is parameterized by a concrete
`Alphabet` type `A` that defines the domain (or set) of biological symbols
permitted.
As the [`BioSequence`](@ref) interface definition implies, `LongSequence`s store
the biological symbol elements that they contain in a succinct encoded form that
permits many operations to be done in an efficient bit-parallel manner. As per
the interface of [`BioSequence`](@ref), the [`Alphabet`](@ref) determines how
an element is encoded or decoded when it is inserted or extracted from the
sequence.
For example, [`AminoAcidAlphabet`](@ref) is associated with `AminoAcid` and hence
an object of the `LongSequence{AminoAcidAlphabet}` type represents a sequence of
amino acids.
Symbols from multiple alphabets can't be intermixed in one sequence type.
The following table summarizes common LongSequence types that have been given
aliases for convenience.
| Type | Symbol type | Type alias |
| :---------------------------------- | :---------- | :----------- |
| `LongSequence{DNAAlphabet{N}}` | `DNA` | `LongDNA{N}` |
| `LongSequence{RNAAlphabet{N}}` | `RNA` | `LongRNA{N}` |
| `LongSequence{AminoAcidAlphabet}` | `AminoAcid` | `LongAA` |
The `LongDNA` and `LongRNA` aliases use a DNAAlphabet{4}.
`DNAAlphabet{4}` permits ambiguous nucleotides, and a sequence must use at least
4 bits to internally store each element (and indeed `LongSequence` does).
If you are sure that you are working with sequences with no ambiguous nucleotides,
you can use `LongSequences` parameterised with `DNAAlphabet{2}` instead.
`DNAAlphabet{2}` is an alphabet that uses two bits per base and limits to only
unambiguous nucleotide symbols (A,C,G,T).
Changing this single parameter, is all you need to do in order to benefit from memory savings.
Some computations that use bitwise operations will also be dramatically faster.
The same applies with `LongSequence{RNAAlphabet{4}}`, simply replace the alphabet
parameter with `RNAAlphabet{2}` in order to benefit.
"""
mutable struct LongSequence{A <: Alphabet} <: BioSequence{A}
data::Vector{UInt64} # encoded character sequence data
len::UInt
function LongSequence{A}(data::Vector{UInt64}, len::UInt) where {A <: Alphabet}
new{A}(data, len)
end
end
"An alias for LongSequence{<:NucleicAcidAlpabet{N}}"
const LongNuc{N} = LongSequence{<:NucleicAcidAlphabet{N}}
"An alias for LongSequence{DNAAlphabet{N}}"
const LongDNA{N} = LongSequence{DNAAlphabet{N}}
"An alias for LongSequence{RNAAlphabet{N}}"
const LongRNA{N} = LongSequence{RNAAlphabet{N}}
"An alias for LongSequence{AminoAcidAlphabet}"
const LongAA = LongSequence{AminoAcidAlphabet}
# Basic attributes
Base.length(seq::LongSequence) = seq.len % Int
encoded_data_eltype(::Type{<:LongSequence}) = UInt64
Base.copy(x::LongSequence) = typeof(x)(copy(x.data), x.len)
# Derived basic attributes
symbols_per_data_element(x::LongSequence) = div(64, bits_per_symbol(Alphabet(x)))
include("seqview.jl")
include("indexing.jl")
include("constructors.jl")
include("conversion.jl")
include("copying.jl")
include("stringliterals.jl")
include("transformations.jl")
include("operators.jl")
include("counting.jl")
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 7313 |
# Sequences to Matrix
# -------------------
"""
seqmatrix(vseq::AbstractVector{BioSequence{A}}, major::Symbol) where {A<:Alphabet}
Construct a matrix of nucleotides or amino acids from a vector of `BioSequence`s.
If parameter `major` is set to `:site`, the matrix is created such that one
nucleotide from each sequence is placed in each column i.e. the matrix is laid
out in site-major order.
This means that iteration over one position of many sequences is efficient,
as julia arrays are laid out in column major order.
If the parameter `major` is set to `:seq`, the matrix is created such that each
sequence is placed in one column i.e. the matrix is laid out in sequence-major
order.
This means that iteration across each sequence in turn is efficient,
as julia arrays are laid out in column major order.
# Examples
```julia
julia> seqs = [dna"AAA", dna"TTT", dna"CCC", dna"GGG"]
4-element Array{BioSequences.BioSequence{BioSequences.DNAAlphabet{4}},1}:
3nt DNA Sequence:
AAA
3nt DNA Sequence:
TTT
3nt DNA Sequence:
CCC
3nt DNA Sequence:
GGG
julia> seqmatrix(seqs, :site)
4x3 Array{BioSequences.DNA,2}:
DNA_A DNA_A DNA_A
DNA_T DNA_T DNA_T
DNA_C DNA_C DNA_C
DNA_G DNA_G DNA_G
julia> seqmatrix(seqs, :seq)
3x4 Array{BioSequences.DNA,2}:
DNA_A DNA_T DNA_C DNA_G
DNA_A DNA_T DNA_C DNA_G
DNA_A DNA_T DNA_C DNA_G
```
"""
function seqmatrix(vseq::AbstractVector{LongSequence{A}}, major::Symbol) where {A<:Alphabet}
nseqs = length(vseq)
@assert nseqs > 0 throw(ArgumentError("Vector of BioSequence{$A} is empty."))
nsites = length(vseq[1])
@inbounds for i in 2:nseqs
length(vseq[i]) == nsites || throw(ArgumentError("Sequences in vseq must be of same length"))
end
if major == :site
mat = Matrix{eltype(A)}(undef, (nseqs, nsites))
@inbounds for seq in 1:nseqs, site in 1:nsites
mat[seq, site] = vseq[seq][site]
end
return mat
elseif major == :seq
mat = Matrix{eltype(A)}(undef, (nsites, nseqs))
@inbounds for seq in 1:nseqs, site in 1:nsites
mat[site, seq] = vseq[seq][site]
end
return mat
else
throw(ArgumentError("major must be :site or :seq"))
end
end
"""
seqmatrix(::Type{T}, vseq::AbstractVector{BioSequence{A}}, major::Symbol) where {T,A<:Alphabet}
Construct a matrix of `T` from a vector of `BioSequence`s.
If parameter `major` is set to `:site`, the matrix is created such that one
nucleotide from each sequence is placed in each column i.e. the matrix is laid
out in site-major order.
This means that iteration over one position of many sequences is efficient,
as julia arrays are laid out in column major order.
If the parameter `major` is set to `:seq`, the matrix is created such that each
sequence is placed in one column i.e. the matrix is laid out in sequence-major
order.
This means that iteration across each sequence in turn is efficient,
as julia arrays are laid out in column major order.
# Examples
```julia
julia> seqs = [dna"AAA", dna"TTT", dna"CCC", dna"GGG"]
4-element Array{BioSequences.BioSequence{BioSequences.DNAAlphabet{4}},1}:
3nt DNA Sequence:
AAA
3nt DNA Sequence:
TTT
3nt DNA Sequence:
CCC
3nt DNA Sequence:
GGG
julia> seqmatrix(seqs, :site, UInt8)
4×3 Array{UInt8,2}:
0x01 0x01 0x01
0x08 0x08 0x08
0x02 0x02 0x02
0x04 0x04 0x04
julia> seqmatrix(seqs, :seq, UInt8)
3×4 Array{UInt8,2}:
0x01 0x08 0x02 0x04
0x01 0x08 0x02 0x04
0x01 0x08 0x02 0x04
```
"""
function seqmatrix(::Type{T}, vseq::AbstractVector{LongSequence{A}}, major::Symbol) where {T,A<:Alphabet}
nseqs = length(vseq)
@assert nseqs > 0 throw(ArgumentError("Vector of BioSequence{$A} is empty."))
nsites = length(vseq[1])
@inbounds for i in 2:nseqs
length(vseq[i]) == nsites || throw(ArgumentError("Sequences in vseq must be of same length."))
end
if major == :site
mat = Matrix{T}(undef, (nseqs, nsites))
@inbounds for seq in 1:nseqs, site in 1:nsites
mat[seq, site] = convert(T, reinterpret(UInt8, vseq[seq][site]))
end
return mat
elseif major == :seq
mat = Matrix{T}(undef, (nsites, nseqs))
@inbounds for seq in 1:nseqs, site in 1:nsites
mat[site, seq] = convert(T, reinterpret(UInt8, vseq[seq][site]))
end
return mat
else
throw(ArgumentError("major must be :site or :seq"))
end
end
# Consensus
# ---------
"""
majorityvote(seqs::AbstractVector{LongSequence{A}}) where {A<:NucleicAcidAlphabet}
Construct a sequence that is a consensus of a vector of sequences.
The consensus is established by a simple majority vote rule, where ambiguous
nucleotides cast an equal vote for each of their possible states.
For each site a winner(s) out of A, T(U), C, or G is determined, in the cases
of ties the ambiguity symbol that unifies all the winners is returned.
E.g if A and T tie, then W is inserted in the consensus. If all A, T, C, and G
tie at a site, then N is inserted in the consensus. Note this means that if a
nucletide e.g. 'C' and a gap '-' draw, the nucleotide will always win over the
gap, even though they tied.
# Examples
```julia
julia> seqs = [dna"CTCGATCGATCC", dna"CTCGAAAAATCA", dna"ATCGAAAAATCG", dna"ATCGGGGGATCG"]
4-element Array{BioSequences.BioSequence{BioSequences.DNAAlphabet{4}},1}:
CTCGATCGATCC
CTCGAAAAATCA
ATCGAAAAATCG
ATCGGGGGATCG
julia> majorityvote(seqs)
12nt DNA Sequence:
MTCGAAARATCG
```
"""
function majorityvote(seqs::AbstractVector{LongSequence{A}}) where {A<:NucleicAcidAlphabet}
mat = seqmatrix(UInt8, seqs, :site)
nsites = size(mat, 2)
nseqs = size(mat, 1)
result = BioSequence{A}(nsites)
votes = Array{Int}(undef, 16)
@inbounds for site in 1:nsites
fill!(votes, 0)
for seq in 1:nseqs
nuc = mat[seq, site]
votes[1] += nuc == 0x00
votes[2] += (nuc & 0x01) != 0x00
votes[3] += (nuc & 0x02) != 0x00
votes[5] += (nuc & 0x04) != 0x00
votes[9] += (nuc & 0x08) != 0x00
end
m = maximum(votes)
merged = 0x00
for i in 0x01:0x10
merged |= ifelse(votes[i] == m, i - 0x01, 0x00)
end
result[site] = reinterpret(eltype(A), merged)
end
return result
end
### Comparisons
function Base.:(==)(seq1::SeqOrView{A}, seq2::SeqOrView{A}) where {A <: Alphabet}
length(seq1) == length(seq2) || false
# If they share the same data
if seq1.data === seq2.data && firstbitindex(seq1) == firstbitindex(seq2)
return true
end
# Fallback
for (i, j) in zip(seq1, seq2)
i == j || return false
end
return true
end
function Base.:(==)(seq1::LongSequence{A}, seq2::LongSequence{A}) where {A <: Alphabet}
length(seq1) == length(seq2) || return false
isempty(seq1) && return true
# Check all filled UInts
nextind = nextposition(lastbitindex(seq1))
@inbounds for i in 1:index(nextind) - 1
seq1.data[i] == seq2.data[i] || return false
end
# Check last coding UInt, if any
@inbounds if !iszero(offset(nextind))
mask = bitmask(offset(nextind))
i = index(nextind)
(seq1.data[i] & mask) == (seq2.data[i] & mask) || return false
end
return true
end | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 7437 | ###
### Random Sequence Generator
###
###
### Random LongSequence generator.
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
import Random: Sampler, rand!, default_rng
"""
SamplerUniform{T}
Uniform sampler of type T. Instantiate with a collection of eltype T containing
the elements to sample.
# Examples
```
julia> sp = SamplerUniform(rna"ACGU");
```
"""
struct SamplerUniform{T} <: Sampler{T}
elems::Vector{T}
function SamplerUniform{T}(elems) where {T}
elemsvector = convert(Vector{T}, vec(collect(elems)))
if length(elemsvector) < 1
throw(ArgumentError("elements collection must be non-empty"))
end
return new(elemsvector)
end
end
SamplerUniform(elems) = SamplerUniform{eltype(elems)}(elems)
Base.eltype(::Type{SamplerUniform{T}}) where {T} = T
Base.rand(rng::AbstractRNG, sp::SamplerUniform) = rand(rng, sp.elems)
Base.rand(sp::SamplerUniform) = rand(default_rng(), sp.elems)
const DefaultAASampler = SamplerUniform(aa"ACDEFGHIKLMNPQRSTVWY")
"""
SamplerWeighted{T}
Weighted sampler of type T. Instantiate with a collection of eltype T containing
the elements to sample, and an orderen collection of probabilities to sample
each element except the last. The last probability is the remaining probability
up to 1.
# Examples
```
julia> sp = SamplerWeighted(rna"ACGUN", fill(0.2475, 4));
```
"""
struct SamplerWeighted{T} <: Sampler{T}
elems::Vector{T}
probs::Vector{Float64}
function SamplerWeighted{T}(elems, probs) where {T}
elemsvector = convert(Vector{T}, vec(collect(elems)))
probsvector = convert(Vector{Float64}, vec(collect(probs)))
if !isempty(probsvector)
probsum = sum(probsvector)
if probsum > 1.0
throw(ArgumentError("sum of probabilties cannot exceed 1.0"))
elseif minimum(probsvector) < 0.0
throw(ArgumentError("probabilities must be non-negative"))
end
else
probsum = 0.0
end
if length(elemsvector) != length(probsvector) + 1
throw(ArgumentError("length of elems must be length of probs + 1"))
end
# Even with float weirdness, we can guarantee x + (1.0 - x) == 1.0,
# when 0 ≤ x ≤ 1, as there's no exponent, and it works like int addition
return new(elemsvector, push!(probsvector, 1.0 - probsum))
end
end
SamplerWeighted(elems, probs) = SamplerWeighted{eltype(elems)}(elems, probs)
Base.eltype(::Type{SamplerWeighted{T}}) where {T} = T
function Base.rand(rng::AbstractRNG, sp::SamplerWeighted)
r = rand(rng)
j = 1
probs = sp.probs
@inbounds cumulative_prob = probs[j]
while cumulative_prob < r
j += 1
@inbounds cumulative_prob += probs[j]
end
return @inbounds sp.elems[j]
end
Base.rand(sp::SamplerWeighted) = rand(default_rng(), sp)
###################### Generic longsequence methods ############################
# If no RNG is passed, use the global one
Random.rand!(seq::LongSequence) = rand!(default_rng(), seq)
Random.rand!(seq::LongSequence, sp::Sampler) = rand!(default_rng(), seq, sp)
randseq(A::Alphabet, len::Integer) = randseq(default_rng(), A, len)
randseq(A::Alphabet, sp::Sampler, len::Integer) = randseq(default_rng(), A, sp, len)
randdnaseq(len::Integer) = randdnaseq(default_rng(), len)
randrnaseq(len::Integer) = randrnaseq(default_rng(), len)
randaaseq(len::Integer) = randaaseq(default_rng(), len)
"""
randseq([rng::AbstractRNG], A::Alphabet, len::Integer)
Generate a LongSequence{A} of length `len` from the specified alphabet, drawn
from the default distribution. User-defined alphabets should implement this
method to implement random LongSequence generation.
For RNA and DNA alphabets, the default distribution is uniform across A, C, G,
and T/U.
For AminoAcidAlphabet, it is uniform across the 20 standard amino acids.
For a user-defined alphabet A, default is uniform across all elements of
`symbols(A)`.
# Example:
```
julia> seq = randseq(AminoAcidAlphabet(), 50)
50aa Amino Acid Sequence:
VFMHSIRMIRLMVHRSWKMHSARHVNFIRCQDKKWKSADGIYTDICKYSM
```
"""
function randseq(rng::AbstractRNG, A::Alphabet, len::Integer)
rand!(rng, LongSequence{typeof(A)}(undef, len))
end
"""
randseq([rng::AbstractRNG], A::Alphabet, sp::Sampler, len::Integer)
Generate a LongSequence{A} of length `len` with elements drawn from
the given sampler.
# Example:
```
# Generate 1000-length RNA with 4% chance of N, 24% for A, C, G, or U
julia> sp = SamplerWeighted(rna"ACGUN", fill(0.24, 4))
julia> seq = randseq(RNAAlphabet{4}(), sp, 50)
50nt RNA Sequence:
CUNGGGCCCGGGNAAACGUGGUACACCCUGUUAAUAUCAACNNGCGCUNU
```
"""
function randseq(rng::AbstractRNG, A::Alphabet, sp::Sampler, len::Integer)
rand!(rng, LongSequence{typeof(A)}(undef, len), sp)
end
# The generic method dispatches to `iscomplete`, since then we don't need
# to instantiate a sampler, and can use random bitpatterns
Random.rand!(rng::AbstractRNG, seq::LongSequence{A}) where A = rand!(rng, iscomplete(A()), seq)
####################### Implementations #######################################
# If given a sampler explicitly, just draw from that
function Random.rand!(rng::AbstractRNG, seq::LongSequence, sp::Sampler)
@inbounds for i in eachindex(seq)
letter = rand(rng, sp)
seq[i] = letter
end
return seq
end
# 4-bit nucleotides's default distribution are equal among
# the non-ambiguous ones
function Random.rand!(rng::AbstractRNG, seq::LongSequence{<:NucleicAcidAlphabet{4}})
data = seq.data
rand!(rng, data)
@inbounds for i in eachindex(data)
nuc = 0x1111111111111111
mask = data[i]
nuc = ((nuc & mask) << 1) | (nuc & ~mask)
mask >>>= 1
nuc = ((nuc & mask) << 2) | (nuc & ~mask)
data[i] = nuc
end
return seq
end
# Special AA implementation: Do not create the AA sampler, use the one
# that's already included.
Random.rand!(rng::AbstractRNG, seq::LongAA) = rand!(rng, seq, DefaultAASampler)
# All bitpatterns are valid - we use built-in RNG on the data vector.
function Random.rand!(rng::AbstractRNG, ::Val{true}, seq::LongSequence)
rand!(rng, seq.data)
seq
end
# Not all bitpatterns are valid - default to using a SamplerUniform
function Random.rand!(rng::AbstractRNG, ::Val{false}, seq::LongSequence)
A = Alphabet(seq)
letters = symbols(A)
sampler = SamplerUniform{eltype(A)}(letters)
rand!(rng, seq, sampler)
end
############################ Aliases for convenience ########################
"""
randdnaseq([rng::AbstractRNG], len::Integer)
Generate a random LongSequence{DNAAlphabet{4}} sequence of length `len`,
with bases sampled uniformly from [A, C, G, T]
"""
randdnaseq(rng::AbstractRNG, len::Integer) = randseq(rng, DNAAlphabet{4}(), len)
"""
randrnaseq([rng::AbstractRNG], len::Integer)
Generate a random LongSequence{RNAAlphabet{4}} sequence of length `len`,
with bases sampled uniformly from [A, C, G, U]
"""
randrnaseq(rng::AbstractRNG, len::Integer) = randseq(rng, RNAAlphabet{4}(), len)
"""
randaaseq([rng::AbstractRNG], len::Integer)
Generate a random LongSequence{AminoAcidAlphabet} sequence of length `len`,
with amino acids sampled uniformly from the 20 standard amino acids.
"""
randaaseq(rng::AbstractRNG, len::Integer) = randseq(rng, AminoAcidAlphabet(), len)
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 3527 | ################################### Construction etc
# Mention in docs no boundscheck is performed on instantiation
"""
LongSubSeq{A <: Alphabet}
A view into a `LongSequence`. This shares data buffer with the underlying
sequence, and is therefore much faster to instantiate than a `LongSequence`.
Modifying the view changes the sequence and vice versa.
# Examples
```jldoctest
julia> LongSubSeq(dna"TAGA", 2:3)
2nt DNA Sequence:
AG
julia> view(dna"TAGA", 2:3)
2nt DNA Sequence:
AG
```
"""
struct LongSubSeq{A<:Alphabet} <: BioSequence{A}
data::Vector{UInt64}
part::UnitRange{Int}
# Added to reduce method ambiguities
LongSubSeq{A}(data::Vector{UInt64}, part::UnitRange{Int}) where A = new{A}(data, part)
end
# These unions are significant because LongSubSeq and LongSequence have the same
# encoding underneath, so many methods can be shared.
const SeqOrView{A} = Union{LongSequence{A}, LongSubSeq{A}}
const NucleicSeqOrView = SeqOrView{<:NucleicAcidAlphabet}
Base.length(v::LongSubSeq) = last(v.part) - first(v.part) + 1
Base.copy(v::LongSubSeq{A}) where A = LongSequence{A}(v)
encoded_data_eltype(::Type{<:LongSubSeq}) = encoded_data_eltype(LongSequence)
symbols_per_data_element(x::LongSubSeq) = div(64, bits_per_symbol(Alphabet(x)))
@inline function bitindex(x::LongSubSeq, i::Integer)
N = BitsPerSymbol(Alphabet(typeof(x)))
bitindex(N, encoded_data_eltype(typeof(x)), i % UInt + first(x.part) - 1)
end
# Constructors
function LongSubSeq{A}(seq::LongSequence{A}) where A
return LongSubSeq{A}(seq.data, 1:length(seq))
end
function LongSubSeq{A}(seq::LongSubSeq{A}) where A
return LongSubSeq{A}(seq.data, seq.part)
end
function LongSubSeq{A}(seq::LongSequence{A}, part::AbstractUnitRange{<:Integer}) where A
@boundscheck checkbounds(seq, part)
return LongSubSeq{A}(seq.data, UnitRange{Int}(part))
end
function LongSubSeq{A}(seq::LongSubSeq{A}, part::AbstractUnitRange{<:Integer}) where A
@boundscheck checkbounds(seq, part)
newpart = first(part) + first(seq.part) - 1 : last(part) + first(seq.part) - 1
return LongSubSeq{A}(seq.data, newpart)
end
function LongSubSeq(seq::SeqOrView{A}, i) where A
return LongSubSeq{A}(seq, i)
end
LongSubSeq(seq::SeqOrView, ::Colon) = LongSubSeq(seq, 1:lastindex(seq))
LongSubSeq(seq::BioSequence{A}) where A = LongSubSeq{A}(seq)
Base.view(seq::SeqOrView, part::AbstractUnitRange) = LongSubSeq(seq, part)
# Conversion
function LongSequence(s::LongSubSeq{A}) where A
_copy_seqview(LongSequence{A}, s)
end
function LongSequence{A}(seq::LongSubSeq{A}) where {A<:NucleicAcidAlphabet}
_copy_seqview(LongSequence{A}, seq)
end
function _copy_seqview(T, s::LongSubSeq)
first = firstbitindex(s)
v = s.data[index(first):index(lastbitindex(s))]
res = T(v, length(s) % UInt)
return zero_offset!(res, offset(first) % UInt)
end
function (::Type{T})(seq::LongSequence{<:NucleicAcidAlphabet{N}}) where
{N, T<:LongSubSeq{<:NucleicAcidAlphabet{N}}}
T(seq.data, 1:length(seq))
end
function (::Type{T})(seq::LongSequence{<:NucleicAcidAlphabet{N}}, part::AbstractUnitRange{<:Integer}) where
{N, T<:LongSubSeq{<:NucleicAcidAlphabet{N}}}
@boundscheck checkbounds(seq, part)
T(seq.data, UnitRange{Int}(part))
end
function Base.convert(::Type{T1}, seq::T2) where
{T1 <: Union{LongSequence, LongSubSeq}, T2 <: Union{LongSequence, LongSubSeq}}
return T1(seq)
end
# Indexing
function Base.getindex(seq::LongSubSeq, part::AbstractUnitRange{<:Integer})
return LongSubSeq(seq, part)
end
Base.parentindices(seq::LongSubSeq) = (seq.part,)
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 1196 | ###
### String Decorators
###
###
### String literals for LongSequences
###
### This file is a part of BioJulia.
### License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
remove_newlines(s) = replace(s, r"\r|\n" => "")
macro dna_str(seq, flag)
if flag == "s"
return LongDNA{4}(remove_newlines(seq))
elseif flag == "d"
return quote
LongDNA{4}($(remove_newlines(seq)))
end
end
error("Invalid DNA flag: '$(flag)'")
end
macro dna_str(seq)
return LongDNA{4}(remove_newlines(seq))
end
macro rna_str(seq, flag)
if flag == "s"
return LongRNA{4}(remove_newlines(seq))
elseif flag == "d"
return quote
LongRNA{4}($(remove_newlines(seq)))
end
end
error("Invalid RNA flag: '$(flag)'")
end
macro rna_str(seq)
return LongRNA{4}(remove_newlines(seq))
end
macro aa_str(seq, flag)
if flag == "s"
return LongAA(remove_newlines(seq))
elseif flag == "d"
return quote
LongAA($(remove_newlines(seq)))
end
end
error("Invalid Amino Acid flag: '$(flag)'")
end
macro aa_str(seq)
return LongAA(remove_newlines(seq))
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 5479 | ###
### LongSequence specific specializations of src/biosequence/transformations.jl
###
"""
resize!(seq, size, [force::Bool])
Resize a biological sequence `seq`, to a given `size`. Does not resize the underlying data
array unless the new size does not fit. If `force`, always resize underlying data array.
"""
function Base.resize!(seq::LongSequence{A}, size::Integer, force::Bool=false) where {A}
if size < 0
throw(ArgumentError("size must be non-negative"))
else
if force | (seq_data_len(A, size) > seq_data_len(A, length(seq)))
resize!(seq.data, seq_data_len(A, size))
end
seq.len = size
return seq
end
end
"""
reverse!(seq::LongSequence)
Reverse a biological sequence `seq` in place.
"""
Base.reverse!(seq::LongSequence{<:Alphabet}) = _reverse!(seq, BitsPerSymbol(seq))
"""
reverse(seq::LongSequence)
Create reversed copy of a biological sequence.
"""
Base.reverse(seq::LongSequence{<:Alphabet}) = _reverse(seq, BitsPerSymbol(seq))
# Fast path for non-inplace reversion
@inline function _reverse(seq::LongSequence{A}, B::BT) where {A <: Alphabet,
BT <: Union{BitsPerSymbol{2}, BitsPerSymbol{4}, BitsPerSymbol{8}}}
cp = LongSequence{A}(undef, unsigned(length(seq)))
reverse_data_copy!(identity, cp.data, seq.data, seq_data_len(seq) % UInt, B)
return zero_offset!(cp)
end
_reverse(seq::LongSequence{<:Alphabet}, ::BitsPerSymbol) = reverse!(copy(seq))
# Generic fallback
function _reverse!(seq::LongSequence{<:Alphabet}, ::BitsPerSymbol)
i, j = 1, lastindex(seq)
@inbounds while i < j
seq[i], seq[j] = seq[j], seq[i]
i += 1
j -= 1
end
return seq
end
@inline function _reverse!(seq::LongSequence{<:Alphabet}, B::BT) where {
BT <: Union{BitsPerSymbol{2}, BitsPerSymbol{4}, BitsPerSymbol{8}}}
# We need to account for the fact that the seq may not use all its stored data
reverse_data!(identity, seq.data, seq_data_len(seq) % UInt, B)
return zero_offset!(seq)
end
# Reversion of chunk bits may have left-shifted data in chunks, this function right shifts
# all chunks by up to 63 bits.
# This is written so it SIMD parallelizes - careful with changes
@inline function zero_offset!(seq::LongSequence{A}) where A <: Alphabet
isempty(seq) && return seq
offs = (64 - offset(bitindex(seq, length(seq)) + bits_per_symbol(A()))) % UInt
zero_offset!(seq, offs)
end
@inline function zero_offset!(seq::LongSequence{A}, offs::UInt) where A <: Alphabet
isempty(seq) && return seq
iszero(offs) && return seq
rshift = offs
lshift = 64 - rshift
len = length(seq.data)
@inbounds if !iszero(lshift)
this = seq.data[1]
for i in 1:len-1
next = seq.data[i+1]
seq.data[i] = (this >>> (unsigned(rshift) & 63)) | (next << (unsigned(lshift) & 63))
this = next
end
seq.data[len] >>>= (unsigned(rshift) & 63)
end
return seq
end
# Reverse chunks in data vector and each symbol within a chunk. Chunks may have nonzero
# offset after use, so use zero_offset!
@inline function reverse_data!(pred, data::Vector{UInt64}, len::UInt, B::BT) where {
BT <: Union{BitsPerSymbol{2}, BitsPerSymbol{4}, BitsPerSymbol{8}}}
@inbounds @simd ivdep for i in 1:len >>> 1
data[i], data[len-i+1] = pred(reversebits(data[len-i+1], B)), pred(reversebits(data[i], B))
end
@inbounds if isodd(len)
data[len >>> 1 + 1] = pred(reversebits(data[len >>> 1 + 1], B))
end
end
@inline function reverse_data_copy!(pred, dst::Vector{UInt64}, src::Vector{UInt64}, len::UInt,
B::BT) where {BT <: Union{BitsPerSymbol{2}, BitsPerSymbol{4}, BitsPerSymbol{8}}}
@inbounds @simd for i in eachindex(dst)
dst[i] = pred(reversebits(src[len - i + 1], B))
end
end
"""
complement!(seq)
Make a complement sequence of `seq` in place.
"""
function complement!(seq::LongSequence{A}) where {A<:NucleicAcidAlphabet}
seqdata = seq.data
@inbounds for i in eachindex(seqdata)
seqdata[i] = complement_bitpar(seqdata[i], Alphabet(seq))
end
return seq
end
function complement!(s::LongSubSeq{A}) where {A <: NucleicAcidAlphabet}
bps = bits_per_symbol(A())
bi = firstbitindex(s)
i = 1
stop = lastbitindex(s) + bps
@inbounds while (!iszero(offset(bi)) & (bi < stop))
s[i] = complement(s[i])
bi += bps
i += 1
end
@inbounds for j in index(bi):index(stop)-1
s.data[j] = complement_bitpar(s.data[j], Alphabet(s))
bi += 64
i += symbols_per_data_element(s)
end
@inbounds while bi < stop
s[i] = complement(s[i])
bi += bps
i += 1
end
return s
end
function reverse_complement!(seq::LongSequence{<:NucleicAcidAlphabet})
pred = x -> complement_bitpar(x, Alphabet(seq))
reverse_data!(pred, seq.data, seq_data_len(seq) % UInt, BitsPerSymbol(seq))
return zero_offset!(seq)
end
function reverse_complement(seq::LongSequence{<:NucleicAcidAlphabet})
cp = typeof(seq)(undef, unsigned(length(seq)))
pred = x -> complement_bitpar(x, Alphabet(seq))
reverse_data_copy!(pred, cp.data, seq.data, seq_data_len(seq) % UInt, BitsPerSymbol(seq))
return zero_offset!(cp)
end
function Random.shuffle!(seq::LongSequence)
# Fisher-Yates shuffle
@inbounds for i in 1:lastindex(seq) - 1
j = rand(i:lastindex(seq))
seq[i], seq[j] = seq[j], seq[i]
end
return seq
end | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 7998 | # Approxiamte Search
# ==================
#
# Approximate sequence search tools.
#
# This file is a part of BioJulia.
# License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
"""
ApproximateSearchQuery{F<:Function,S<:BioSequence}
Query type for approximate sequence search.
These queries are used as a predicate for the `Base.findnext`, `Base.findprev`,
`Base.occursin`, `Base.findfirst`, and `Base.findlast` functions.
Using these functions with these queries allows you to search a given sequence
for a sub-sequence, whilst allowing a specific number of errors.
In other words they find a subsequence of the target sequence within a specific
[Levenshtein distance](https://en.wikipedia.org/wiki/Levenshtein_distance) of the
query sequence.
# Examples
```jldoctest
julia> seq = dna"ACAGCGTAGCT";
julia> query = ApproximateSearchQuery(dna"AGGG");
julia> findfirst(query, 0, seq) == nothing # nothing matches with no errors
true
julia> findfirst(query, 1, seq) # seq[3:6] matches with one error
3:6
julia> findfirst(query, 2, seq) # seq[1:4] matches with two errors
1:4
```
You can pass a comparator function such as `isequal` or `iscompatible` to its
constructor to modify the search behaviour.
The default is `isequal`, however, in biology, sometimes we want a more flexible
comparison to find subsequences of _compatible_ symbols.
```jldoctest
julia> query = ApproximateSearchQuery(dna"AGGG", iscompatible);
julia> occursin(query, 1, dna"AAGNGG") # 1 mismatch permitted (A vs G) & matched N
true
julia> findnext(query, 1, dna"AAGNGG", 1) # 1 mismatch permitted (A vs G) & matched N
1:4
```
!!! note
This method of searching for motifs was implemented with smaller query motifs
in mind.
If you are looking to search for imperfect matches of longer sequences in this
manner, you are likely better off using some kind of local-alignment algorithm
or one of the BLAST variants.
"""
struct ApproximateSearchQuery{F<:Function,S<:BioSequence}
comparator::F # comparator function
seq::S # query sequence
fPcom::Vector{UInt64} # compatibility vector for forward search
bPcom::Vector{UInt64} # compatibility vector for backward search
H::Vector{Int} # distance vector for alignback function
end
"""
ApproximateSearchQuery(pat::S, comparator::F = isequal) where {F<:Function,S<:BioSequence}
Construct an [`ApproximateSearchQuery`](@ref) predicate for use with Base find functions.
# Arguments
- `pat`: A concrete BioSequence that is the sub-sequence you want to search for.
- `comparator`: A function used to compare the symbols between sequences. `isequal` by default.
"""
function ApproximateSearchQuery(pat::S, comparator::F = isequal) where {F<:Function,S<:BioSequence}
m = length(pat)
if m > 64
throw(ArgumentError("query pattern sequence must have length of 64 or less"))
end
Σ = alphabet(eltype(pat))
fw = zeros(UInt64, length(Σ))
for i in 1:m
y = pat[i]
for x in Σ
if comparator(x, y)
fw[encoded_data(x) + 0x01] |= UInt(1) << (i - 1)
end
end
end
shift = 64 - m
bw = [bitreverse(i) >>> (shift & 63) for i in fw]
H = Vector{Int}(undef, length(pat) + 1)
return ApproximateSearchQuery{F,S}(comparator, copy(pat), fw, bw, H)
end
"""
findnext(query, k, seq, start)
Return the range of the first occurrence of `pat` in `seq[start:stop]` allowing
up to `k` errors.
Symbol comparison is done using the predicate supplied to the query.
By default, `ApproximateSearchQuery`'s predicate is `isequal`.
"""
function Base.findnext(query::ApproximateSearchQuery, k::Integer, seq::BioSequence, start::Integer)
return _approxsearch(query, k, seq, start, lastindex(seq), true)
end
"""
findprev(query, k, seq, start)
Return the range of the last occurrence of `query` in `seq[stop:start]` allowing
up to `k` errors.
Symbol comparison is done using the predicate supplied to the query.
By default, `ApproximateSearchQuery`'s predicate is `isequal`.
"""
function Base.findprev(query::ApproximateSearchQuery, k::Integer, seq::BioSequence, start::Integer)
return _approxsearch(query, k, seq, start, firstindex(seq), false)
end
Base.findfirst(query::ApproximateSearchQuery, k::Integer, seq::BioSequence) = findnext(query, k, seq, firstindex(seq))
Base.findlast(query::ApproximateSearchQuery, k::Integer, seq::BioSequence) = findprev(query, k, seq, lastindex(seq))
Base.occursin(query::ApproximateSearchQuery, k::Integer, seq::BioSequence) = !isnothing(_approxsearch(query, k, seq, 1, lastindex(seq), true))
function _approxsearch(query::ApproximateSearchQuery, k::Integer, seq::BioSequence, start::Integer, stop::Integer, forward::Bool)
checkeltype(query.seq, seq)
if k ≥ length(query.seq)
return start:start-1
end
# search the approximate suffix
matchstop, dist = search_approx_suffix(
forward ? query.fPcom : query.bPcom,
query.seq, seq, k, start, stop, forward)
if matchstop == 0 # No match
#return 0:-1
return nothing
end
# locate the starting position of the match
matchstart = alignback!(query, seq, dist, start, matchstop, forward)
if forward
return matchstart:matchstop
else
return matchstop:matchstart
end
end
# This returns the end index of a suffix sequence with up to `k` errors.
# More formally, when `forward = true`, it returns the minimum `j ∈ start:stop`
# such that `min_{g ∈ 1:j} δ(pat, seq[g:j]) ≤ k` where `δ(s, t)` is the edit
# distance between `s` and `t` sequences. See Myers' paper for details:
# Myers, Gene. "A fast bit-vector algorithm for approximate string matching
# based on dynamic programming." Journal of the ACM (JACM) 46.3 (1999): 395-415.
# NOTE: `Pcom` corresponds to `Peq` in the paper.
function search_approx_suffix(Pcom::Vector{UInt64}, pat::BioSequence, seq::BioSequence, k::Integer, start::Integer, stop::Integer, forward::Bool)
if k < 0
throw(ArgumentError("the number of errors must be non-negative"))
end
m = length(pat)
n = length(seq)
Pv::UInt64 = (one(UInt64) << m) - one(UInt64)
Mv::UInt64 = zero(UInt64)
dist = m
j = forward ? max(start, 1) : min(start, n)
if dist ≤ k
return j, dist
end
while (forward && j ≤ min(stop, n)) || (!forward && j ≥ max(stop, 1))
Eq = Pcom[reinterpret(UInt8, seq[j]) + 0x01]
Xv = Eq | Mv
Xh = (((Eq & Pv) + Pv) ⊻ Pv) | Eq
Ph = Mv | ~(Xh | Pv)
Mh = Pv & Xh
if (Ph >> (m - 1)) & 1 != 0
dist += 1
elseif (Mh >> (m - 1)) & 1 != 0
dist -= 1
end
if dist ≤ k
return j, dist # found
end
Ph <<= 1
Mh <<= 1
Pv = Mh | ~(Xv | Ph)
Mv = Ph & Xv
j += ifelse(forward, +1, -1)
end
return 0, -1 # not found
end
# run dynamic programming to get the starting position of the alignment
function alignback!(query::ApproximateSearchQuery{<:Function,<:BioSequence}, seq::BioSequence, dist::Int, start::Integer, matchstop::Integer, forward::Bool)
comparator = query.comparator
H = query.H
pat = query.seq
m = length(pat)
n = length(seq)
# initialize the cost column
for i in 0:m
H[i + 1] = i
end
j = ret = matchstop
found = false
while (forward && j ≥ max(start, 1)) || (!forward && j ≤ min(start, n))
y = seq[j]
h_diag = H[1]
for i in 1:m
x = forward ? pat[end - i + 1] : pat[i]
h = min(
H[i] + 1,
H[i + 1] + 1,
h_diag + ifelse(comparator(x, y), 0, 1))
h_diag = H[i + 1]
H[i + 1] = h
end
if H[m + 1] == dist
ret = j
found = true
end
j += ifelse(forward, -1, +1)
end
@assert found
return ret
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 7201 | """
ExactSearchQuery{F<:Function,S<:BioSequence}
Query type for exact sequence search.
An exact search, is one where are you are looking in some given sequence, for
exact instances of some given substring.
These queries are used as a predicate for the `Base.findnext`, `Base.findprev`,
`Base.occursin`, `Base.findfirst`, and `Base.findlast` functions.
# Examples
```jldoctest
julia> seq = dna"ACAGCGTAGCT";
julia> query = ExactSearchQuery(dna"AGC");
julia> findfirst(query, seq)
3:5
julia> findlast(query, seq)
8:10
julia> findnext(query, seq, 6)
8:10
julia> findprev(query, seq, 7)
3:5
julia> findall(query, seq)
2-element Vector{UnitRange{Int64}}:
3:5
8:10
julia> occursin(query, seq)
true
```
You can pass a comparator function such as `isequal` or `iscompatible` to its
constructor to modify the search behaviour.
The default is `isequal`, however, in biology, sometimes we want a more flexible
comparison to find subsequences of _compatible_ symbols.
```jldoctest
julia> query = ExactSearchQuery(dna"CGT", iscompatible);
julia> findfirst(query, dna"ACNT") # 'N' matches 'G'
2:4
julia> findfirst(query, dna"ACGT") # 'G' matches 'N'
2:4
julia> occursin(ExactSearchQuery(dna"CNT", iscompatible), dna"ACNT")
true
```
"""
struct ExactSearchQuery{F<:Function,S<:BioSequence}
comparator::F # comparator function
seq::S # query sequence
bloom_mask::UInt64 # compatibility bits / bloom mask
fshift::Int # shift length for forward search
bshift::Int # shift length for backward search
end
"""
ExactSearchQuery(pat::BioSequence, comparator::Function = isequal)
Construct an [`ExactSearchQuery`](@ref) predicate for use with Base find functions.
# Arguments
- `pat`: A concrete BioSequence that is the sub-sequence you want to search for.
- `comparator`: A function used to compare the symbols between sequences. `isequal` by default.
"""
function ExactSearchQuery(pat::BioSequence, comparator::Function = isequal)
T = ExactSearchQuery{typeof(comparator),typeof(pat)}
m = length(pat)
if m == 0
return T(comparator, pat, UInt64(0), 0, 0)
end
first = pat[1]
last = pat[end]
bloom_mask = zero(UInt64)
fshift = bshift = m
for i in 1:lastindex(pat)
x = pat[i]
bloom_mask |= _bloom_bits(typeof(comparator), x)
if comparator(x, last) && i < m
fshift = m - i
end
end
for i in lastindex(pat):-1:1
x = pat[i]
if comparator(x, first) && i > 1
bshift = i - 1
end
end
return T(comparator, pat, bloom_mask, fshift, bshift)
end
@inline _check_ambiguous(q::ExactSearchQuery{typeof(isequal),<:BioSequence}) = false
@inline _check_ambiguous(q::ExactSearchQuery{typeof(iscompatible),<:BioSequence}) = true
@inline function _bloom_bits(::Type{typeof(isequal)}, x::BioSymbol)
return (UInt64(1) << (encoded_data(x) & 63))
end
@inline function _bloom_bits(::Type{typeof(iscompatible)}, x::BioSymbol)
return compatbits(x)
end
@inline function checkeltype(seq1::BioSequence, seq2::BioSequence)
if eltype(seq1) != eltype(seq2)
throw(ArgumentError("the element type of two sequences must match"))
end
end
function quicksearch(query::ExactSearchQuery, seq::BioSequence, start::Integer, stop::Integer)
pat = query.seq
comparator = query.comparator
bloom_mask = query.bloom_mask
ambig_check = _check_ambiguous(query)
checkeltype(seq, pat)
m = length(pat)
n = length(seq)
stop′ = min(stop, n) - m
s::Int = max(start - 1, 0)
if m == 0 # empty query
if s ≤ stop′
return s + 1 # found
else
return 0 # not found
end
end
while s ≤ stop′
if comparator(pat[m], seq[s + m])
i = m - 1
while i > 0
if !comparator(pat[i], seq[s + i])
break
end
i -= 1
end
if i == 0
return s + 1 # found
elseif s < stop′ && (bloom_mask & _bloom_bits(typeof(comparator), seq[s + m + 1]) == 0)
s += m + 1
elseif ambig_check && isambiguous(seq[s + m])
s += 1
else
s += query.fshift
end
elseif s < stop′ && (bloom_mask & _bloom_bits(typeof(comparator), seq[s + m + 1]) == 0)
s += m + 1
else
s += 1
end
end
return 0 # not found
end
function quickrsearch(query::ExactSearchQuery, seq::BioSequence, start::Integer, stop::Integer)
pat = query.seq
comparator = query.comparator
bloom_mask = query.bloom_mask
ambig_check = _check_ambiguous(query)
checkeltype(seq, pat)
m = length(pat)
n = length(seq)
stop′ = max(stop - 1, 0)
s::Int = min(start, n) - m
if m == 0 # empty query
if s ≥ stop′
return s + 1 # found
else
return 0 # not found
end
end
while s ≥ stop′
if comparator(pat[1], seq[s + 1])
i = 2
while i < m + 1
if !comparator(pat[i], seq[s + i])
break
end
i += 1
end
if i == m + 1
return s + 1 # found
elseif s > stop′ && (bloom_mask & _bloom_bits(typeof(comparator), seq[s]) == 0)
s -= m + 1
elseif ambig_check && isambiguous(seq[s + 1])
s -= 1
else
s -= query.bshift
end
elseif s > stop′ && (bloom_mask & _bloom_bits(typeof(comparator), seq[s]) == 0)
s -= m + 1
else
s -= 1
end
end
return 0 # not found
end
"""
findnext(query::ExactSearchQuery, seq::BioSequence, start::Integer)
Return the index of the first occurrence of `query` in `seq`.
Symbol comparison is done using the predicate supplied to the query.
By default, `ExactSearchQuery`'s predicate is `isequal`.
"""
function Base.findnext(query::ExactSearchQuery, seq::BioSequence, start::Integer)
i = quicksearch(query, seq, start, lastindex(seq))
if i == 0
return nothing
else
return i:i+length(query.seq)-1
end
end
Base.findfirst(pat::ExactSearchQuery, seq::BioSequence) = findnext(pat, seq, firstindex(seq))
"""
findprev(query::ExactSearchQuery, seq::BioSequence, start::Integer)
Return the index of the last occurrence of `query` in `seq`.
Symbol comparison is done using the predicate supplied to the query.
By default, `ExactSearchQuery`'s predicate is `isequal`.
"""
function Base.findprev(query::ExactSearchQuery, seq::BioSequence, start::Integer)
i = quickrsearch(query, seq, start, 1)
if i == 0
return nothing
else
return i:i+length(query.seq)-1
end
end
Base.findlast(query::ExactSearchQuery, seq::BioSequence) = findprev(query, seq, lastindex(seq))
"""
occursin(x::ExactSearchQuery, y::BioSequence)
Return Bool indicating presence of exact match of x in y.
"""
Base.occursin(x::ExactSearchQuery, y::BioSequence) = quicksearch(x, y, 1, lastindex(y)) != 0
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 11578 | # Motif Search based on Position Weight Matrix
# ============================================
#
# This file defines two types of matrices: PFM and PWM. PFM is a thin wrapper
# of Matrix and stores non-negative frequency values for each symbol and
# position. PWM is a position weighted matrix and stores score values like PFM.
# PFMs are mutable like usual matrices but PWMs cache partial scores to each
# position and hence must be immutable so that updating operations won't cause
# inconsistency. PFM is created from a raw frequency matrix or a set of
# sequences. PWM is created from a raw score matrix or a PFM.
#
# The motif search algorithm implemented here uses PWM. It tries to find the
# nearest position from which the total score exceeds a specified threshold. The
# algorithm stops searching immediately when it finds that the total score will
# not exceeds the threshold even if the maximum partial score is achieved from
# that position. This uses the partial score cache stored in a PWM object.
"""
Position frequency matrix.
"""
struct PFM{S,T<:Real} <: AbstractMatrix{T}
# row: symbol, column: position
data::Matrix{T}
function PFM{S,T}(m::AbstractMatrix{T}) where {S<:Union{DNA,RNA},T}
if size(m, 1) != 4
throw(ArgumentError("PFM must have four rows"))
end
return new{S,T}(m)
end
end
function PFM{S}(m::AbstractMatrix{T}) where {S, T}
return PFM{S,T}(m)
end
Base.convert(::Type{PFM{S}}, m::AbstractMatrix{T}) where {S, T} = PFM{S}(m)
function Base.convert(::Type{Matrix{T}}, m::PFM) where T
return convert(Matrix{T}, m.data)
end
PFM(set) = PFM(collect(set))
function PFM(set::Vector)
if isempty(set)
throw(ArgumentError("sequence set must be non-empty"))
end
S = eltype(eltype(set))
if S ∉ (DNA, RNA)
throw(ArgumentError("sequence element must be DNA or RNA"))
end
len = length(set[1])
freq = zeros(Int, (4, len))
for i in 1:lastindex(set)
seq = set[i]
if eltype(seq) != S
throw(ArgumentError("sequence element must be $(S)"))
elseif length(seq) != len
throw(ArgumentError("all sequences must be of the same length"))
end
for j in 1:len
s = seq[j]
if iscertain(s) # ignore uncertain symbols
freq[index_nuc(s, j)] += 1
end
end
end
return PFM{S}(freq)
end
# Broadcasting
struct PFMBroadcastStyle{S} <: Broadcast.BroadcastStyle end
Base.BroadcastStyle(::Type{PFM{S,T}}) where {S,T} = PFMBroadcastStyle{S}()
Base.BroadcastStyle(s1::PFMBroadcastStyle, s2::Base.BroadcastStyle) = s1
function Base.similar(bc::Broadcast.Broadcasted{PFMBroadcastStyle{S}}, elt::Type{T}) where {S, T}
return PFM{S, T}(similar(Array{T}, axes(bc)))
end
function Base.IndexStyle(::Type{<:PFM})
return IndexLinear()
end
function Base.size(m::PFM)
return size(m.data)
end
function Base.getindex(m::PFM, i::Integer)
return m.data[i]
end
function Base.getindex(m::PFM{S}, s::S, j::Integer) where S<:Union{DNA,RNA}
return m.data[index_nuc(s, j)]
end
function Base.setindex!(m::PFM, val, i::Integer)
return setindex!(m.data, val, i)
end
function Base.setindex!(m::PFM, val, i::Integer, j::Integer)
return setindex!(m.data, val, i, j)
end
function Base.setindex!(m::PFM, val, s::S, j::Integer) where S<:Union{DNA,RNA}
return setindex!(m.data, val, index_nuc(s, j))
end
function Base.show(io::IO, m::PFM{<:Union{DNA,RNA}})
show_nuc_matrix(io, m)
end
function Base.show(io::IO, ::MIME"text/plain", m::PFM{<:Union{DNA,RNA}})
show_nuc_matrix(io, m)
end
"""
Position weight matrix.
"""
struct PWM{S,T<:Real} <: AbstractMatrix{T}
# symbol type
symtype::Type{S}
# score matrix (row: symbols, column: position)
data::Matrix{T}
# maxscore[i] == sum(maximum(data, 1)[i:end])
maxscore::Vector{T}
function PWM{S,T}(pwm::AbstractMatrix) where {S<:Union{DNA,RNA},T}
if size(pwm, 1) != 4
throw(ArgumentError("PWM must have four rows"))
end
# make a copy for safety
return new{S,T}(S, copy(pwm), make_maxscore(pwm))
end
end
"""
PWM(pfm::PFM{<:Union{DNA,RNA}}; prior=fill(1/4,4))
Create a position weight matrix from a position frequency matrix `pfm`.
The positive weight matrix will be `log2.((pfm ./ sum(pfm, 1)) ./ prior)`.
"""
function PWM(pfm::PFM{S}; prior = fill(1/4, 4)) where S <: Union{DNA,RNA}
if !all(x -> x > 0, prior)
throw(ArgumentError("prior must be positive"))
elseif sum(prior) ≉ 1
throw(ArgumentError("prior must be sum to 1"))
end
prob = pfm ./ sum(pfm, dims = 1)
return PWM{S,Float64}(log2.(prob ./ prior))
end
"""
PWM{T}(pwm::AbstractMatrix)
Create a PWM from a raw matrix `pwm` (rows are symbols and columns are
positions).
Examples
--------
```julia-repl
julia> pwm = [
0.065 -0.007 0.042 0.016 0.003 # A
0.025 -0.007 0.016 0.058 0.082 # C
0.066 0.085 0.070 0.054 0.010 # G
0.016 0.025 0.051 0.058 0.038 # T
]
4×5 Array{Float64,2}:
0.065 -0.007 0.042 0.016 0.003
0.025 -0.007 0.016 0.058 0.082
0.066 0.085 0.07 0.054 0.01
0.016 0.025 0.051 0.058 0.038
julia> PWM{DNA}(pwm)
BioSequences.PWM{BioSymbols.DNA,Float64}:
A 0.065 -0.007 0.042 0.016 0.003
C 0.025 -0.007 0.016 0.058 0.082
G 0.066 0.085 0.07 0.054 0.01
T 0.016 0.025 0.051 0.058 0.038
```
"""
function PWM{T}(pwm::AbstractMatrix) where T <: Union{DNA,RNA}
return PWM{T,eltype(pwm)}(pwm)
end
function Base.IndexStyle(::Type{<:PWM})
return IndexLinear()
end
function Base.size(pwm::PWM)
return size(pwm.data)
end
function Base.getindex(pwm::PWM, i::Integer)
return getindex(pwm.data, i)
end
function Base.getindex(m::PWM{S}, s::S, j::Integer) where S<:Union{DNA,RNA}
return m.data[index_nuc(s, j)]
end
function Base.show(io::IO, pwm::PWM{<:Union{DNA,RNA}})
show_nuc_matrix(io, pwm)
end
function Base.show(io::IO, ::MIME"text/plain", m::PWM{<:Union{DNA,RNA}})
show_nuc_matrix(io, m)
end
"""
maxscore(pwm::PWM)
Return the maximum achievable score of `pwm`.
"""
function maxscore(pwm::PWM)
if size(pwm, 2) == 0
return zero(eltype(pwm))
else
return pwm.maxscore[1]
end
end
# Make an accumulated maximum score vector.
function make_maxscore(pwm)
len = size(pwm, 2)
maxscore = Vector{eltype(pwm)}(undef, len)
for j in len:-1:1
s = pwm[1,j]
for i in 2:size(pwm, 1)
s = max(s, pwm[i,j])
end
if j == len
maxscore[j] = s
else
maxscore[j] = s + maxscore[j+1]
end
end
return maxscore
end
"""
scoreat(seq::BioSequence, pwm::PWM, start::Integer)
Calculate the PWM score starting from `seq[start]`.
"""
function scoreat(seq::BioSequence, pwm::PWM, start::Integer)
check_pwm(seq, pwm)
pwmlen = size(pwm, 2)
checkbounds(seq, start:start+pwmlen-1)
score = zero(eltype(pwm))
@inbounds for j in 0:pwmlen-1
x = seq[start + j]
score += iscertain(x) ? pwm[j << 2 + trailing_zeros(x) + 1] : zero(score)
end
return score
end
function check_pwm(seq, pwm::PWM{S}) where S <: Union{DNA,RNA}
if size(pwm, 1) != 4
throw(ArgumentError("matrix must have four rows"))
elseif eltype(seq) != S
throw(ArgumentError("sequence and PWM must have the same element type"))
end
end
# TODO: Have one version of search_nuc that searches backwards as well as forwards?
function search_nuc(seq::BioSequence, first::Int, last::Int, pwm::PWM{<:Union{DNA,RNA},S}, threshold::S) where S<:Real
check_pwm(seq, pwm)
checkbounds(seq, first:last)
pwmlen = size(pwm, 2)
for p in first:last-pwmlen+1
score = zero(eltype(pwm))
@inbounds for j in 0:pwmlen-1
if score + pwm.maxscore[j + 1] < threshold
break
end
x = seq[p + j]
score += iscertain(x) ? pwm[j << 2 + trailing_zeros(x) + 1] : zero(score)
end
if score ≥ threshold
return p
end
end
return nothing
end
function rsearch_nuc(seq::BioSequence, first::Int, last::Int, pwm::PWM{<:Union{DNA,RNA},S}, threshold::S) where S<:Real
check_pwm(seq, pwm)
checkbounds(seq, last:first)
pwmlen = size(pwm, 2)
for p in first-pwmlen+1:-1:last
score = zero(eltype(pwm))
@inbounds for j in 0:pwmlen-1
if score + pwm.maxscore[j + 1] < threshold
break
end
x = seq[p + j]
score += iscertain(x) ? pwm[j << 2 + trailing_zeros(x) + 1] : zero(score)
end
if score ≥ threshold
return p
end
end
return nothing
end
#= TODO: Replace forward and back function with this one?
function search_nuc2(seq::BioSequence, first::Integer, last::Integer, pwm::PWM{<:Union{DNA,RNA},S}, threshold::S) where S<:Real
check_pwm(seq, pwm)
rev = first > last
checkbounds(seq, ifelse(rev, last:first, first:last)
pwmlen = size(pwm, 2)
interval′ = range(
ifelse(rev, first - pwmlen + 1, first),
step = ifelse(rev, -1, 1),
ifelse(rev, last, last - pwmlen + 1)
)
for p in interval′
score = zero(eltype(pwm))
@inbounds for j in 0:pwmlen-1
if score + pwm.maxscore[j + 1] < threshold
break
end
x = seq[p + j]
score += iscertain(x) ? pwm[j << 2 + trailing_zeros(x) + 1] : zero(score)
end
if score ≥ threshold
return p
end
end
return nothing
end
=#
function index_nuc(s::Union{DNA,RNA}, j::Integer)
if !iscertain(s)
throw(ArgumentError(string("index symbol must be A, C, G or ", typeof(s) == DNA ? "T" : "U")))
end
return (j-1) << 2 + (trailing_zeros(s)) + 1
end
function show_nuc_matrix(io::IO, m::Union{PFM{S},PWM{S}}) where S<:Union{DNA,RNA}
compact(x) = string(x ≥ 0 ? " " : "", sprint(show, x, context=:compact=>true))
cells = hcat(['A', 'C', 'G', S == DNA ? 'T' : 'U'], compact.(m.data))
width = maximum(length.(cells), dims=1)
print(io, summary(m), ':')
for i in 1:size(cells, 1)
print(io, "\n ", rpad(cells[i,1], width[1]+1))
for j in 2:size(cells, 2)
print(io, rpad(cells[i,j], width[j]+1))
end
end
end
struct PWMSearchQuery{S,T,R<:Real}
pwm::PWM{S,T}
threshold::R
end
function PWMSearchQuery(sequences, threshold::Real, prior = fill(1 / 4, 4))
pfm = PFM(sequences)
pwm = PWM(pfm .+ 0.01, prior = prior)
return PWMSearchQuery(pwm, threshold)
end
function Base.findnext(query::PWMSearchQuery, seq::BioSequence, start)
if eltype(seq) == DNA || eltype(seq) == RNA
return search_nuc(seq, start, lastindex(seq), query.pwm, convert(eltype(query.pwm), query.threshold))
else
throw(ArgumentError("no search algorithm for '$(typeof(seq))'"))
end
end
function Base.findfirst(query::PWMSearchQuery, seq::BioSequence)
return findnext(query, seq, firstindex(seq))
end
function Base.findprev(query::PWMSearchQuery, seq::BioSequence, start)
if eltype(seq) == DNA || eltype(seq) == RNA
return rsearch_nuc(seq, start, firstindex(seq), query.pwm, convert(eltype(query.pwm), query.threshold))
else
throw(ArgumentError("no search algorithm for '$(typeof(seq))'"))
end
end
function Base.findlast(query::PWMSearchQuery, seq::BioSequence)
return findprev(query, seq, lastindex(seq))
end | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 24732 | # Regular Expression
# ==================
#
# Regular expression sequence search tools.
#
# This file is a part of BioJulia.
# License is MIT: https://github.com/BioJulia/BioSequences.jl/blob/master/LICENSE.md
# String Decorators
# -----------------
"""
biore"PAT"sym
Construct a PCRE `BioRegex` from pattern `PAT`. `sym` can be any of `d`/`dna`, `r`/`rna`,
or `a`/`aa`. BioRegex can also be constructed directly using e.g. `BioRegex{DNA}("[TA]G")`.
"""
macro biore_str(pat, opt...)
if isempty(opt)
error("symbol option is required: d(na), r(na), or a(a)")
end
@assert length(opt) == 1
opt = opt[1]
if opt ∈ ("d", "dna")
:($(RE.Regex{DNA}(pat, :pcre)))
elseif opt ∈ ("r", "rna")
:($(RE.Regex{RNA}(pat, :pcre)))
elseif opt ∈ ("a", "aa")
:($(RE.Regex{AminoAcid}(pat, :pcre)))
else
error("invalid symbol option: $(opt)")
end
end
"""
prosite"PAT"
Equivalent to `BioRegex{AminoAcid}("PAT", syntax=:prosite)`, but evaluated at parse-time.
"""
macro prosite_str(pat)
:($(RE.Regex{AminoAcid}(pat, :prosite)))
end
module RE
import BioSequences
# Syntax tree
# -----------
mutable struct SyntaxTree
head::Symbol
args::Vector{Any}
function SyntaxTree(head, args)
@assert head ∈ (
:|,
:*, :+, Symbol("?"), :range,
Symbol("*?"), Symbol("+?"), Symbol("??"), Symbol("range?"),
:set, :compset, :sym, :bits,
:capture, :nocapture, :concat, :head, :last)
return new(head, args)
end
end
expr(head, args) = SyntaxTree(head, args)
function charset(s)
set = Set{Char}()
union!(set, s)
union!(set, lowercase(s))
return set
end
# list of symbols available for each symbol type
const symbols = IdDict{Any, Set{Char}}(
BioSequences.DNA => charset("ACGTMRWSYKVHDBN"),
BioSequences.RNA => charset("ACGUMRWSYKVHDBN"),
BioSequences.AminoAcid => charset("ARNDCQEGHILKMFPSTWYVOUBJZX"))
macro check(ex, err)
esc(quote
if !$ex
throw($err)
end
end)
end
function parse(::Type{T}, pat::AbstractString) where {T}
parens = Char[] # stack of parens
ex, _ = parserec(T, pat, iterate(pat), parens)
@check isempty(parens) ArgumentError("'(' is not closed")
return ex
end
function parserec(::Type{T}, pat, s, parens) where {T}
args = []
while s !== nothing
c, state = s
s = iterate(pat, state)
if c == '*'
@check !isempty(args) ArgumentError("unexpected '*'")
arg = pop!(args)
push!(args, expr(:*, [arg]))
elseif c == '+'
@check !isempty(args) ArgumentError("unexpected '+'")
arg = pop!(args)
push!(args, expr(:+, [arg]))
elseif c == '?'
@check !isempty(args) ArgumentError("unexpected '?'")
arg = pop!(args)
if arg.head ∈ (:*, :+, Symbol("?"), :range)
# lazy quantifier
push!(args, expr(Symbol(arg.head, '?'), arg.args))
else
# zero-or-one quantifier
push!(args, expr(Symbol("?"), [arg]))
end
elseif c == '{'
@check !isempty(args) ArgumentError("unexpected '{'")
rng, s = parserange(pat , s)
arg = pop!(args)
push!(args, expr(:range, [rng, arg]))
elseif c == '|'
arg1 = expr(:concat, args)
arg2, s = parserec(T, pat, s, parens)
args = []
push!(args, expr(:|, [arg1, arg2]))
elseif c == '['
setexpr, s = parseset(T, pat, s)
push!(args, setexpr)
elseif c == '('
push!(parens, '(')
head = :capture
if peek(pat, s) == '?'
_, state = s
s = iterate(pat, state)
if peek(pat, s) == ':'
head = :nocapture
_, state = s
s = iterate(pat, state)
end
end
arg, s = parserec(T, pat, s, parens)
push!(args, expr(head, [arg]))
elseif c == ')'
@check !isempty(parens) && parens[end] == '(' ArgumentError("unexpected ')'")
pop!(parens)
return expr(:concat, args), s
elseif c == '^'
push!(args, expr(:head, []))
elseif c == '$'
push!(args, expr(:last, []))
elseif isspace(c)
# skip
elseif c ∈ symbols[T]
push!(args, expr(:sym, [convert(T, c)]))
else
throw(ArgumentError("unexpected input: '$c'"))
end
end
return expr(:concat, args), s
end
function parserange(pat, s)
lo = hi = -1
comma = false
while s !== nothing
c, state = s
s = iterate(pat, state)
if isdigit(c)
d = c - '0'
if comma
if hi < 0
hi = 0
end
hi = 10hi + d
else
if lo < 0
lo = 0
end
lo = 10lo + d
end
elseif c == ','
comma = true
elseif c == '}'
break
else
throw(ArgumentError("unexpected input: '$c'"))
end
end
if comma
if lo < 0 && hi < 0
throw(ArgumentError("invalid range"))
elseif lo ≥ 0 && hi < 0
return (lo,), s
elseif lo < 0 && hi ≥ 0
return (0, hi), s
else # lo ≥ 0 && hi ≥ 0
if lo > hi
throw(ArgumentError("invalid range"))
end
return (lo, hi), s
end
else
return lo, s
end
end
function peek(pat, s)
if s === nothing
throw(ArgumentError("unexpected end of pattern"))
end
return s[1]
end
function parseset(::Type{T}, pat, s) where {T}
if peek(pat, s) == '^'
head = :compset
_, state = s
s = iterate(pat, state)
else
head = :set
end
set = T[]
while s !== nothing
c, state = s
s = iterate(pat, state)
if c ∈ symbols[T]
push!(set, convert(T, c))
elseif c == ']'
break
else
throw(ArgumentError("unexpected input: '$c'"))
end
end
return expr(head, set), s
end
function parse_prosite(pat)
s = iterate(pat)
args = []
while s !== nothing
c, state = s
s = iterate(pat, state)
if c == '['
set, s = parseset_prosite(pat, s, ']')
push!(args, set)
elseif c == '{'
set, s = parseset_prosite(pat, s, '}')
push!(args, set)
elseif c == '('
@check !isempty(args) ArgumentError("unexpected '('")
rng, s = parserange_prosite(pat, s)
arg = pop!(args)
push!(args, expr(:range, [rng, arg]))
elseif c == '-'
# concat
continue
elseif c == 'x'
push!(args, expr(:sym, [BioSequences.AA_X]))
elseif c == '<'
push!(args, expr(:head, []))
elseif c == '>'
push!(args, expr(:last, []))
elseif c ∈ symbols[BioSequences.AminoAcid]
push!(args, expr(:sym, [convert(BioSequences.AminoAcid, c)]))
else
throw(ArgumentError("unexpected input: '$c'"))
end
end
return expr(:concat, args)
end
function parserange_prosite(pat, s)
lo = hi = -1
comma = false
while s !== nothing
c, state = s
s = iterate(pat, state)
if isdigit(c)
d = c - '0'
if comma
if hi < 0
hi = 0
end
hi = 10hi + d
else
if lo < 0
lo = 0
end
lo = 10lo + d
end
elseif c == ','
comma = true
elseif c == ')'
break
else
throw(ArgumentError("unexpected input: '$c'"))
end
end
if comma
if lo < 0 || hi < 0
throw(ArgumentError("invalid range"))
end
return (lo, hi), s
else
if lo < 0
throw(ArgumentError("invalid range"))
end
return lo, s
end
end
function parseset_prosite(pat, s, close)
set = BioSequences.AminoAcid[]
while s !== nothing
c, state = s
s = iterate(pat, state)
if c ∈ symbols[BioSequences.AminoAcid]
push!(set, convert(BioSequences.AminoAcid, c))
elseif c == close
if close == ']'
return expr(:set, set), s
elseif close == '}'
return expr(:compset, set), s
end
@assert false
else
throw(ArgumentError("unexpected input: '$c'"))
end
end
end
function bits2sym(::Type{T}, bits::UInt32) where {T}
for x in BioSequences.alphabet(T)
if BioSequences.compatbits(x) == bits
return x
end
end
error("bits are not found")
end
mask(::Type{T}) where {T<:BioSequences.NucleicAcid} = (UInt32(1) << 4) - one(UInt32)
@assert Int(reinterpret(UInt8, BioSequences.AA_U)) + 1 == 22 # check there are 22 unambiguous amino acids
mask(::Type{BioSequences.AminoAcid}) = (UInt32(1) << 22) - one(UInt32)
function desugar(::Type{T}, tree::SyntaxTree) where {T}
head = tree.head
args = tree.args
if head == :+
# e+ => ee*
head = :concat
args = [args[1], expr(:*, [args[1]])]
elseif head == Symbol("+?")
# e+? => ee*?
head = :concat
args = [args[1], expr(Symbol("*?"), [args[1]])]
elseif head == Symbol("?")
# e? => e|
head = :|
args = [args[1], expr(:concat, [])]
elseif head == Symbol("??")
# e?? => |e
head = :|
args = [expr(:concat, []), args[1]]
elseif head == :sym
head = :bits
args = [BioSequences.compatbits(args[1])]
elseif head == :set
bits = UInt32(0)
for arg in args
bits |= BioSequences.compatbits(arg)
end
head = :bits
args = [bits]
elseif head == :compset
bits = UInt32(0)
for arg in args
bits |= BioSequences.compatbits(arg)
end
head = :bits
args = [~bits & mask(T)]
elseif head == :nocapture
head = :concat
elseif head == :range || head == Symbol("range?")
rng = args[1]
pat = args[2]
greedy = head == :range
if isa(rng, Int)
# e{m} => eee...e
# |<-m->|
head = :concat
args = fill(pat, rng)
elseif isa(rng, Tuple{Int})
# e{m,} => eee...ee* (greedy)
# |<-m->|
# e{m,} => eee...ee*? (lazy)
# |<-m->|
head = :concat
args = fill(pat, rng[1])
if greedy
push!(args, expr(:*, [pat]))
else
push!(args, expr(Symbol("*?"), [pat]))
end
elseif isa(rng, Tuple{Int,Int})
# e{m,n} => eee...eee|eee...ee|...|eee...e (greedy)
# |<- n ->| |<-m->|
# e{m,n} => eee...e|eee...ee|...|eee...eee (lazy)
# |<-m->| |<- n ->|
m, n = rng
@assert m ≤ n
if m == n
head = :concat
args = fill(pat, m)
else
head = :|
f = (k, t) -> expr(:|, [expr(:concat, fill(pat, k)), t])
if greedy
args = foldr(f, n:-1:m+1, init=expr(:concat, fill(pat, m))).args
else
args = foldr(f, m:1:n-1, init=expr(:concat, fill(pat, n))).args
end
end
else
@assert false "invalid AST"
end
end
i = 1
for i in 1:lastindex(args)
args[i] = desugar(T, args[i])
end
return expr(head, args)
end
function desugar(::Type{T}, atom) where {T}
return atom
end
# Compiler
# --------
# tag | operation | meaning
# ------|-----------|----------------------------
# 0b000 | match | the pattern matches
# 0b001 | bits b | matches b in bit-wise way
# 0b010 | jump l | jump to l
# 0b011 | push l | push l and go to next
# 0b100 | save i | save string state to i
# 0b101 | head | matches the head of string
# 0b110 | last | matches the last of string
# 0b111 | fork l | push next and go to l
primitive type Op 32 end
const MatchTag = UInt32(0b000) << 29
const BitsTag = UInt32(0b001) << 29
const JumpTag = UInt32(0b010) << 29
const PushTag = UInt32(0b011) << 29
const SaveTag = UInt32(0b100) << 29
const HeadTag = UInt32(0b101) << 29
const LastTag = UInt32(0b110) << 29
const ForkTag = UInt32(0b111) << 29
# constructors
match() = reinterpret(Op, MatchTag)
bits(b::UInt32) = reinterpret(Op, BitsTag | b)
jump(l::Int) = reinterpret(Op, JumpTag | UInt32(l))
push(l::Int) = reinterpret(Op, PushTag | UInt32(l))
save(l::Int) = reinterpret(Op, SaveTag | UInt32(l))
head() = reinterpret(Op, HeadTag)
last() = reinterpret(Op, LastTag)
fork(l::Int) = reinterpret(Op, ForkTag | UInt32(l))
const operand_mask = (UInt32(1) << 29) - one(UInt32)
function tag(op::Op)
return reinterpret(UInt32, op) & ~operand_mask
end
function operand(op::Op)
return reinterpret(UInt32, op) & operand_mask
end
function Base.show(io::IO, op::Op)
t = tag(op)
x = operand(op)
if t == MatchTag
print(io, "match")
elseif t == BitsTag
print(io, "bits ", repr(x))
elseif t == JumpTag
print(io, "jump ", x)
elseif t == PushTag
print(io, "push ", x)
elseif t == SaveTag
print(io, "save ", x)
elseif t == HeadTag
print(io, "head")
elseif t == LastTag
print(io, "last")
elseif t == ForkTag
print(io, "fork ", x)
else
@assert false
end
end
function print_program(prog::Vector{Op})
L = lastindex(prog)
for l in 1:L
print(lpad(l, ndigits(L)), ": ", prog[l])
if l != lastindex(prog)
println()
end
end
end
function compile(tree::SyntaxTree)
code = Op[]
push!(code, save(1))
compilerec!(code, tree, 2)
push!(code, save(2))
push!(code, match())
return code
end
function compilerec!(code, tree::SyntaxTree, k)
h = tree.head
args = tree.args
if h == :bits
push!(code, bits(UInt32(args[1])))
elseif h == :concat
for arg in args
k = compilerec!(code, arg, k)
end
elseif h == :*
push!(code, push(0)) # placeholder
l = length(code)
k = compilerec!(code, args[1], k)
push!(code, jump(l))
code[l] = push(length(code) + 1)
elseif h == Symbol("*?")
push!(code, fork(0)) # placeholder
l = length(code)
k = compilerec!(code, args[1], k)
push!(code, jump(l))
code[l] = fork(length(code) + 1)
elseif h == :|
push!(code, push(0)) # placeholder
l = length(code)
k = compilerec!(code, args[1], k)
push!(code, jump(0)) # placeholder
code[l] = push(length(code) + 1)
l = length(code)
k = compilerec!(code, args[2], k)
code[l] = jump(length(code) + 1)
elseif h == :capture
k′ = k
push!(code, save(2k′-1))
k = compilerec!(code, args[1], k + 1)
push!(code, save(2k′))
elseif h == :head
push!(code, head())
elseif h == :last
push!(code, last())
else
@assert false "invalid tree"
end
return k
end
# Virtual machine
# ---------------
"""
Regex{T}(pattern::AbstractString, syntax=:pcre)
Biological regular expression to seatch for `pattern` in sequences of type `T`, where
`T` can be `DNA`, `RNA`, and `AminoAcid`. `syntax` can be `:pcre` or `:prosite` for AminoAcid
acids.
"""
struct Regex{T <: Union{BioSequences.DNA, BioSequences.RNA, BioSequences.AminoAcid}}
pat::String # regular expression pattern (for printing)
code::Vector{Op} # compiled code
nsaves::Int # the number of `save` operations in `code`
function Regex{T}(pat::AbstractString, syntax=:pcre) where T
if syntax == :pcre
ast = desugar(T, parse(T, pat))
elseif syntax == :prosite
if T != BioSequences.AminoAcid
throw(ArgumentError("alphabet must be AminoAcid for PROSITE syntax"))
end
ast = desugar(BioSequences.AminoAcid, parse_prosite(pat))
else
throw(ArgumentError("invalid syntax: $syntax"))
end
code = compile(ast)
nsaves = 0
for op in code
nsaves += tag(op) == SaveTag
end
@assert iseven(nsaves)
return new{T}(pat, code, nsaves)
end
end
function Base.show(io::IO, re::Regex{T}) where {T}
if T == BioSequences.DNA
opt = "dna"
elseif T == BioSequences.RNA
opt = "rna"
else T == BioSequences.AminoAcid
opt = "aa"
end
print(io, "biore\"", re.pat, "\"", opt)
end
# This is useful when testing
function Base.:(==)(x::Regex, y::Regex)
typeof(x) == typeof(y) && x.pat == y.pat && x.code == y.code && x.nsaves == y.nsaves
end
"""
RegexMatch
Result of matching by `Regex`.
julia> match(biore"A(C[TG])+N(CA)"d, dna"ACGACA")
RegexMatch("ACGACA", 1="CG", 2="", 3="CA")
"""
struct RegexMatch{S}
seq::S
captured::Vector{Int}
end
function Base.show(io::IO, m::RegexMatch)
print(io, "RegexMatch(")
for k in 1:div(length(m.captured), 2)
if k > 1
print(io, ", ", k - 1, '=')
end
print(io, '"', m.seq[m.captured[2k-1]:m.captured[2k]-1], '"')
end
print(io, ')')
end
"""
matched(match::BioRegexMatch)
Return the matched pattern as a `BioSequence`.
"""
function matched(m::RegexMatch{S}) where {S}
return m.seq[m.captured[1]:m.captured[2]-1]
end
"""
captured(match::BioRegexMatch)
Return a vector of the captured patterns, where a pattern not captured is `nothing`.
# Examples:
```
julia> captured(biore"A(C[TG])+N"d, dna"ACGAA"")
2-element Vector{Union{Nothing, LongDNA{4}, LongNuc{4, DNAAlphabet{4}}}}:
CG
nothing
```
"""
function captured(m::RegexMatch{S}) where {S}
return [m.captured[2k-1] != 0 && m.captured[2k] != 0 ?
m.seq[m.captured[2k-1]:m.captured[2k]-1] : nothing
for k in 2:div(length(m.captured), 2)]
end
function checkeltype(re::Regex{T}, seq::BioSequences.BioSequence) where {T}
if eltype(seq) != T
throw(ArgumentError("element type of sequence doesn't match with regex"))
end
end
function Base.match(re::Regex{T}, seq::BioSequences.BioSequence, start::Integer=1) where {T}
checkeltype(re, seq)
# use the first unambiguous symbol in the regular expression to find the
# next starting position of pattern matching; this improves the performance
if length(re.code) ≥ 2 && tag(re.code[2]) == BitsTag && count_ones(operand(re.code[2])) == 1
firstsym = bits2sym(T, operand(re.code[2]))
else
firstsym = BioSequences.gap(T)
end
# a thread is `(<program counter>, <sequence's iterator state>)`
threads = Stack{Tuple{Int,Int}}()
captured = Vector{Int}(undef, re.nsaves)
s = start
while true
if firstsym != BioSequences.gap(T)
s = findnext(isequal(firstsym), seq, s)
if s === nothing
break
end
end
empty!(threads)
push!(threads, (1, s))
fill!(captured, 0)
if runmatch!(threads, captured, re, seq)
return RegexMatch(seq, captured)
end
s += 1
if s > lastindex(seq)
break
end
end
return nothing
end
function Base.findfirst(re::Regex{T}, seq::BioSequences.BioSequence, start::Integer=1) where {T}
checkeltype(re, seq)
m = Base.match(re, seq, start)
if m === nothing
return nothing
else
return m.captured[1]:m.captured[2]-1
end
end
struct RegexMatchIterator{T,S}
re::Regex{T}
seq::S
overlap::Bool
function RegexMatchIterator{T,S}(re::Regex{T}, seq::S, overlap::Bool) where {T,S}
checkeltype(re, seq)
return new{T,S}(re, seq, overlap)
end
end
function Base.IteratorSize(::Type{RegexMatchIterator{T,S}}) where {T,S}
return Base.SizeUnknown()
end
function Base.eltype(::Type{RegexMatchIterator{T,S}}) where {T,S}
return RegexMatch{S}
end
function Base.iterate(iter::RegexMatchIterator)
threads = Stack{Tuple{Int,Int}}()
captured = Vector{Int}(undef, iter.re.nsaves)
s = 1
push!(threads, (1, s))
fill!(captured, 0)
state = advance!(threads, captured, s, iter.re, iter.seq, iter.overlap)
return iterate(iter, state)
end
function Base.iterate(iter::RegexMatchIterator, state)
item, threads, captured, s = state
if item === nothing
return nothing
else
item, advance!(threads, captured, s, iter.re, iter.seq, iter.overlap)
end
end
function advance!(threads, captured, s, re, seq, overlap)
while true
if runmatch!(threads, captured, re, seq)
if !overlap
empty!(threads)
s = captured[2]
if s <= lastindex(seq)
push!(threads, (1, s))
end
end
return RegexMatch(seq, copy(captured)), threads, captured, s
end
if !isempty(seq)
s += 1
end
if s > lastindex(seq)
break
end
push!(threads, (1, s))
fill!(captured, 0)
end
return nothing, threads, captured, s
end
function Base.eachmatch(re::Regex{T}, seq::BioSequences.BioSequence, overlap::Bool = true) where {T}
checkeltype(re, seq)
return RegexMatchIterator{T,typeof(seq)}(re, seq, overlap)
end
function Base.occursin(re::Regex{T}, seq::BioSequences.BioSequence) where {T}
return Base.match(re, seq) !== nothing
end
# simple stack
mutable struct Stack{T}
top::Int
data::Vector{T}
function Stack{T}(sz::Int=0) where T
return new{T}(0, Vector{T}(undef, sz))
end
end
function Base.isempty(stack::Stack)
return stack.top == 0
end
@inline function Base.push!(stack::Stack{T}, x::T) where {T}
if stack.top + 1 > length(stack.data)
push!(stack.data, x)
else
stack.data[stack.top+1] = x
end
stack.top += 1
return stack
end
@inline function Base.pop!(stack::Stack)
item = stack.data[stack.top]
stack.top -= 1
return item
end
@inline function Base.empty!(stack::Stack)
stack.top = 0
return stack
end
# run pattern maching using the current `threads` stack. Captured positions are
# stored in the preallocated `captured`. If match is found, this returns `true`
# immediately; otherwise returns `false`.
function runmatch!(threads::Stack{Tuple{Int,Int}},
captured::Vector{Int},
re::Regex, seq::BioSequences.BioSequence)
while !isempty(threads)
pc::Int, s = pop!(threads)
while true
op = re.code[pc]
t = tag(op)
if t == BitsTag
if s > lastindex(seq)
break
end
sym = seq[s]
s += 1
if BioSequences.compatbits(sym) & operand(op) != 0
pc += 1
else
break
end
elseif t == JumpTag
pc = operand(op)
elseif t == PushTag
push!(threads, (convert(Int, operand(op)), s))
pc += 1
elseif t == ForkTag
push!(threads, (pc + 1, s))
pc = operand(op)
elseif t == SaveTag
captured[operand(op)] = s
pc += 1
elseif t == HeadTag
if s == 1
pc += 1
else
break
end
elseif t == LastTag
if s == lastindex(seq) + 1
pc += 1
else
break
end
elseif t == MatchTag
return true
end
end
end
return false
end
end # module RE
# exported from BioSequences
const matched = RE.matched
const captured = RE.captured
const BioRegex = RE.Regex
const BioRegexMatch = RE.RegexMatch
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 6726 | # NOTE: Most tests related to biological symbols are located in BioSymbols.jl.
@testset "Symbols" begin
@testset "DNA" begin
@test DNA_A === BioSymbols.DNA_A
@test ACGT === BioSymbols.ACGT
@test ACGTN === BioSymbols.ACGTN
@test typeof(DNA_A) === BioSymbols.DNA
end
@testset "RNA" begin
@test RNA_A === BioSymbols.RNA_A
@test ACGU === BioSymbols.ACGU
@test ACGUN === BioSymbols.ACGUN
@test typeof(RNA_A) === BioSymbols.RNA
end
@testset "AminoAcid" begin
@test AA_A === BioSymbols.AA_A
@test typeof(AA_A) === BioSymbols.AminoAcid
end
@testset "Predicate functions" begin
@test iscompatible(DNA_A, DNA_N)
@test isambiguous(DNA_N)
@test iscertain(DNA_A)
@test isgap(DNA_Gap)
@test ispurine(DNA_A)
@test ispyrimidine(DNA_C)
@test isGC(DNA_G)
end
@testset "Misc. functions" begin
@test length(BioSymbols.alphabet(DNA)) == 16
@test BioSymbols.gap(DNA) === DNA_Gap
@test BioSymbols.complement(DNA_A) === DNA_T
end
end
@testset "Basic" begin
@test length(DNAAlphabet{4}()) == 16
@test length(RNAAlphabet{2}()) == 4
@test length(AminoAcidAlphabet()) == 28
@test BioSequences.symbols(RNAAlphabet{2}()) == (RNA_A, RNA_C, RNA_G, RNA_U)
end
encode = BioSequences.encode
EncodeError = BioSequences.EncodeError
decode = BioSequences.decode
# NOTE: See the docs for the interface of Alphabet
struct ReducedAAAlphabet <: Alphabet end
Base.eltype(::Type{ReducedAAAlphabet}) = AminoAcid
BioSequences.BitsPerSymbol(::ReducedAAAlphabet) = BioSequences.BitsPerSymbol{4}()
function BioSequences.symbols(::ReducedAAAlphabet)
(AA_L, AA_C, AA_A, AA_G, AA_S, AA_T, AA_P, AA_F,
AA_W, AA_E, AA_D, AA_N, AA_Q, AA_K, AA_H, AA_M)
end
(ENC_LUT, DEC_LUT) = let
enc_lut = fill(0xff, length(alphabet(AminoAcid)))
dec_lut = fill(AA_A, length(symbols(ReducedAAAlphabet())))
for (i, aa) in enumerate(symbols(ReducedAAAlphabet()))
enc_lut[reinterpret(UInt8, aa) + 0x01] = i - 1
dec_lut[i] = aa
end
(Tuple(enc_lut), Tuple(dec_lut))
end
function BioSequences.encode(::ReducedAAAlphabet, aa::AminoAcid)
i = reinterpret(UInt8, aa)
(i ≥ length(ENC_LUT) || ENC_LUT[i + 0x01] === 0xff) && throw(EncodeError(ReducedAAAlphabet(), aa))
ENC_LUT[i + 0x01] % UInt
end
function BioSequences.decode(::ReducedAAAlphabet, x::UInt)
DEC_LUT[x + UInt(1)]
end
@testset "Custom Alphabet" begin
@test BioSequences.has_interface(Alphabet, ReducedAAAlphabet())
@test length(symbols(ReducedAAAlphabet())) == 16
@test all(i isa AminoAcid for i in symbols(ReducedAAAlphabet()))
@test length(Set(symbols(ReducedAAAlphabet()))) == 16
for aa in [AA_P, AA_L, AA_H, AA_M]
data = UInt(findfirst(isequal(aa), symbols(ReducedAAAlphabet())) - 1)
@test encode(ReducedAAAlphabet(), aa) === data
@test decode(ReducedAAAlphabet(), data) === aa
end
str = "NSTPHML"
@test String(LongSequence{ReducedAAAlphabet}(str)) == str
@test_throws EncodeError encode(ReducedAAAlphabet(), AA_V)
@test_throws EncodeError encode(ReducedAAAlphabet(), AA_I)
@test_throws EncodeError encode(ReducedAAAlphabet(), AA_R)
@test_throws EncodeError encode(ReducedAAAlphabet(), AA_Gap)
@test_throws EncodeError encode(ReducedAAAlphabet(), reinterpret(AminoAcid, 0xff))
end
@testset "Encoding DNA/RNA/AminoAcid" begin
@testset "DNA" begin
# 2 bits
@test encode(DNAAlphabet{2}(), DNA_A) === UInt(0x00)
@test encode(DNAAlphabet{2}(), DNA_C) === UInt(0x01)
@test encode(DNAAlphabet{2}(), DNA_G) === UInt(0x02)
@test encode(DNAAlphabet{2}(), DNA_T) === UInt(0x03)
@test_throws EncodeError encode(DNAAlphabet{2}(), DNA_M)
@test_throws EncodeError encode(DNAAlphabet{2}(), DNA_N)
@test_throws EncodeError encode(DNAAlphabet{2}(), DNA_Gap)
# 4 bits
for nt in BioSymbols.alphabet(DNA)
@test encode(DNAAlphabet{4}(), nt) === UInt(reinterpret(UInt8, nt))
end
@test_throws EncodeError encode(DNAAlphabet{4}(), reinterpret(DNA, 0b10000))
end
@testset "RNA" begin
# 2 bits
@test encode(RNAAlphabet{2}(), RNA_A) === UInt(0x00)
@test encode(RNAAlphabet{2}(), RNA_C) === UInt(0x01)
@test encode(RNAAlphabet{2}(), RNA_G) === UInt(0x02)
@test encode(RNAAlphabet{2}(), RNA_U) === UInt(0x03)
@test_throws EncodeError encode(RNAAlphabet{2}(), RNA_M)
@test_throws EncodeError encode(RNAAlphabet{2}(), RNA_N)
@test_throws EncodeError encode(RNAAlphabet{2}(), RNA_Gap)
# 4 bits
for nt in BioSymbols.alphabet(RNA)
@test encode(RNAAlphabet{4}(), nt) === UInt(reinterpret(UInt8, nt))
end
@test_throws EncodeError encode(RNAAlphabet{4}(), reinterpret(RNA, 0b10000))
end
@testset "AminoAcid" begin
@test encode(AminoAcidAlphabet(), AA_A) === UInt(0x00)
for aa in BioSymbols.alphabet(AminoAcid)
@test encode(AminoAcidAlphabet(), aa) === convert(UInt, reinterpret(UInt8, aa))
end
@test_throws BioSequences.EncodeError encode(AminoAcidAlphabet(), BioSymbols.AA_INVALID)
end
end
@testset "Decoding DNA/RNA/AminoAcid" begin
@testset "DNA" begin
# 2 bits
@test decode(DNAAlphabet{2}(), 0x00) === DNA_A
@test decode(DNAAlphabet{2}(), 0x01) === DNA_C
@test decode(DNAAlphabet{2}(), 0x02) === DNA_G
@test decode(DNAAlphabet{2}(), 0x03) === DNA_T
# 4 bits
for x in 0b0000:0b1111
@test decode(DNAAlphabet{4}(), x) === reinterpret(DNA, x)
end
end
@testset "RNA" begin
# 2 bits
@test decode(RNAAlphabet{2}(), 0x00) === RNA_A
@test decode(RNAAlphabet{2}(), 0x01) === RNA_C
@test decode(RNAAlphabet{2}(), 0x02) === RNA_G
@test decode(RNAAlphabet{2}(), 0x03) === RNA_U
# 4 bits
for x in 0b0000:0b1111
@test decode(RNAAlphabet{4}(), x) === reinterpret(RNA, x)
end
end
@testset "AminoAcid" begin
@test decode(AminoAcidAlphabet(), 0x00) === AA_A
for x in 0x00:0x1b
@test decode(AminoAcidAlphabet(), x) === reinterpret(AminoAcid, x)
end
end
end
@testset "Interface" begin
@test BioSequences.has_interface(Alphabet, DNAAlphabet{2}())
@test BioSequences.has_interface(Alphabet, DNAAlphabet{4}())
@test BioSequences.has_interface(Alphabet, RNAAlphabet{2}())
@test BioSequences.has_interface(Alphabet, RNAAlphabet{4}())
@test BioSequences.has_interface(Alphabet, AminoAcidAlphabet())
end | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 5566 | @testset "Counting" begin
@testset "GC content" begin
@test gc_content(dna"") === 0.0
@test gc_content(dna"AATA") === 0.0
@test gc_content(dna"ACGT") === 0.5
@test gc_content(dna"CGGC") === 1.0
@test gc_content(dna"ACATTGTGTATAACAAAAGG") === 6 / 20
@test gc_content(dna"GAGGCGTTTATCATC"[2:end]) === 6 / 14
@test gc_content(rna"") === 0.0
@test gc_content(rna"AAUA") === 0.0
@test gc_content(rna"ACGU") === 0.5
@test gc_content(rna"CGGC") === 1.0
@test gc_content(rna"ACAUUGUGUAUAACAAAAGG") === 6 / 20
@test gc_content(rna"GAGGCGUUUAUCAUC"[2:end]) === 6 / 14
@test_throws Exception gc_content(aa"ARN")
Random.seed!(1234)
for _ in 1:200
s = randdnaseq(rand(1:100))
@test gc_content(s) === count(isGC, s) / length(s)
@test gc_content(LongSequence{DNAAlphabet{2}}(s)) === count(isGC, s) / length(s)
i = rand(1:lastindex(s))
j = rand(i-1:lastindex(s))
@test gc_content(s[i:j]) === (j < i ? 0.0 : count(isGC, s[i:j]) / (j - i + 1))
end
end
function testcounter(
pred::Function,
alias::Function,
seqa::BioSequence,
seqb::BioSequence,
singlearg::Bool,
multi_alias::Function
)
# Test that order does not matter.
@test count(pred, seqa, seqb) == count(pred, seqb, seqa)
@test BioSequences.count_naive(multi_alias, seqa, seqb) == BioSequences.count_naive(multi_alias, seqb, seqa)
@test alias(seqa, seqb) == alias(seqb, seqa)
# Test that result is the same as counting naively.
@test count(pred, seqa, seqb) == BioSequences.count_naive(multi_alias, seqa, seqb)
@test count(pred, seqb, seqa) == BioSequences.count_naive(multi_alias, seqb, seqa)
# Test that the alias function works.
@test count(pred, seqa, seqb) == alias(seqa, seqb)
@test count(pred, seqb, seqa) == alias(seqb, seqa)
if singlearg
@test count(pred, seqa) == count(pred, (i for i in seqa))
@test BioSequences.count_naive(pred, seqa) == BioSequences.count(pred, seqa)
end
end
function counter_random_tests(
pred::Function,
alias::Function,
alphx::Type{<:Alphabet},
alphy::Type{<:Alphabet},
subset::Bool,
singlearg::Bool,
multi_alias::Function
)
for _ in 1:10
seqA = random_seq(alphx, rand(10:100))
seqB = random_seq(alphy, rand(10:100))
sa = seqA
sb = seqB
if subset
intA = random_interval(1, length(seqA))
intB = random_interval(1, length(seqB))
subA = view(seqA, intA)
subB = view(seqB, intB)
sa = subA
sb = subB
end
testcounter(pred, alias, sa, sb, singlearg, multi_alias)
end
end
@testset "Mismatches" begin
for a in (DNAAlphabet, RNAAlphabet)
# Can't promote views
for sub in (true, false)
for n in (4, 2)
counter_random_tests(!=, mismatches, a{n}, a{n}, sub, false, !=)
end
end
counter_random_tests(!=, mismatches, a{4}, a{2}, false, false, !=)
counter_random_tests(!=, mismatches, a{2}, a{4}, false, false, !=)
end
end
@testset "Matches" begin
for a in (DNAAlphabet, RNAAlphabet)
for sub in (true, false)
for n in (4, 2)
counter_random_tests(==, matches, a{n}, a{n}, sub, false, ==)
end
end
counter_random_tests(==, matches, a{4}, a{2}, false, false, ==)
counter_random_tests(==, matches, a{2}, a{4}, false, false, ==)
end
end
@testset "Ambiguous" begin
for a in (DNAAlphabet, RNAAlphabet)
# Can't promote views
for n in (4, 2)
for sub in (true, false)
counter_random_tests(isambiguous, n_ambiguous, a{n}, a{n}, sub, false, BioSequences.isambiguous_or)
end
end
counter_random_tests(isambiguous, n_ambiguous, a{4}, a{2}, false, true, BioSequences.isambiguous_or)
counter_random_tests(isambiguous, n_ambiguous, a{2}, a{4}, false, true, BioSequences.isambiguous_or)
end
end
@testset "Certain" begin
for a in (DNAAlphabet, RNAAlphabet)
for n in (4, 2)
for sub in (true, false)
counter_random_tests(iscertain, n_certain, a{n}, a{n}, sub, true, BioSequences.iscertain_and)
end
end
counter_random_tests(iscertain, n_certain, a{4}, a{2}, false, true, BioSequences.iscertain_and)
counter_random_tests(iscertain, n_certain, a{2}, a{4}, false, true, BioSequences.iscertain_and)
end
end
@testset "Gap" begin
for a in (DNAAlphabet, RNAAlphabet)
for n in (4, 2)
for sub in (true, false)
counter_random_tests(isgap, n_gaps, a{n}, a{n}, sub, true, BioSequences.isgap_or)
end
end
counter_random_tests(isgap, n_gaps, a{4}, a{2}, false, true, BioSequences.isgap_or)
counter_random_tests(isgap, n_gaps, a{2}, a{4}, false, true, BioSequences.isgap_or)
end
end
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 1501 | module TestBioSequences
using Test
using Documenter
using Random
using StableRNGs
using LinearAlgebra: normalize
import BioSymbols
using BioSequences
using StatsBase
using YAML
# Test for the absence of ubound type parameters in the package
@test length(Test.detect_unbound_args(BioSequences, recursive=true)) == 0
# Test utils not dependent on BioSymbols
include("utils.jl")
@testset "Alphabet" begin
include("alphabet.jl")
end
@testset "BioSequences" begin
include("biosequences/biosequence.jl")
include("biosequences/indexing.jl")
include("biosequences/misc.jl")
end
@testset "LongSequences" begin
include("longsequences/basics.jl")
include("longsequences/conversion.jl")
include("longsequences/seqview.jl")
include("longsequences/hashing.jl")
include("longsequences/iteration.jl")
include("longsequences/mutability.jl")
include("longsequences/print.jl")
include("longsequences/transformations.jl")
include("longsequences/predicates.jl")
include("longsequences/find.jl")
include("longsequences/randseq.jl")
include("longsequences/shuffle.jl")
end
include("translation.jl")
include("counting.jl")
@testset "Search" begin
include("search/ExactSearchQuery.jl")
include("search/ApproximateSearchQuery.jl")
include("search/regex.jl")
include("search/pwm.jl")
end
# Include doctests.
DocMeta.setdocmeta!(BioSequences, :DocTestSetup, :(using BioSequences); recursive=true)
doctest(BioSequences; manual = false)
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 5427 | @testset "Translation" begin
# crummy string translation to test against
standard_genetic_code_dict = let
d_ = Dict{String,Char}(
"AAA" => 'K', "AAC" => 'N', "AAG" => 'K', "AAU" => 'N',
"ACA" => 'T', "ACC" => 'T', "ACG" => 'T', "ACU" => 'T',
"AGA" => 'R', "AGC" => 'S', "AGG" => 'R', "AGU" => 'S',
"AUA" => 'I', "AUC" => 'I', "AUG" => 'M', "AUU" => 'I',
"CAA" => 'Q', "CAC" => 'H', "CAG" => 'Q', "CAU" => 'H',
"CCA" => 'P', "CCC" => 'P', "CCG" => 'P', "CCU" => 'P',
"CGA" => 'R', "CGC" => 'R', "CGG" => 'R', "CGU" => 'R',
"CUA" => 'L', "CUC" => 'L', "CUG" => 'L', "CUU" => 'L',
"GAA" => 'E', "GAC" => 'D', "GAG" => 'E', "GAU" => 'D',
"GCA" => 'A', "GCC" => 'A', "GCG" => 'A', "GCU" => 'A',
"GGA" => 'G', "GGC" => 'G', "GGG" => 'G', "GGU" => 'G',
"GUA" => 'V', "GUC" => 'V', "GUG" => 'V', "GUU" => 'V',
"UAA" => '*', "UAC" => 'Y', "UAG" => '*', "UAU" => 'Y',
"UCA" => 'S', "UCC" => 'S', "UCG" => 'S', "UCU" => 'S',
"UGA" => '*', "UGC" => 'C', "UGG" => 'W', "UGU" => 'C',
"UUA" => 'L', "UUC" => 'F', "UUG" => 'L', "UUU" => 'F',
)
d = Dict{NTuple{3, RNA}, Char}(map(RNA, Tuple(k)) => v for (k, v) in d_)
for (a, b, c) in Iterators.product(ntuple(i -> alphabet(RNA), Val{3}())...)
(a == RNA_Gap || b == RNA_Gap || c == RNA_Gap) && continue
(a, b, c) ∈ keys(d) && continue
possible = ' '
for (x, y, z) in Iterators.product(map(BioSequences.UnambiguousRNAs, (a, b, c))...)
new_possible = d[(x, y, z)]
if possible == ' '
possible = new_possible
elseif possible == new_possible
nothing
elseif possible ∈ ('J', 'I', 'L') && new_possible ∈ ('I', 'L')
possible = 'J'
elseif possible ∈ ('B', 'D', 'N') && new_possible ∈ ('D', 'N')
possible = 'B'
elseif possible ∈ ('Z', 'Q', 'E') && new_possible ∈ ('Q', 'E')
possible = 'Z'
else
possible = 'X'
break
end
end
d[(a, b, c)] = possible
end
result = Dict(join(k) => v for (k, v) in d)
for (k, v) in result
if 'U' in k
result[replace(k, 'U'=>'T')] = v
end
end
result
end
function string_translate(seq::AbstractString)
@assert length(seq) % 3 == 0
aaseq = Vector{Char}(undef, div(length(seq), 3))
for i in 1:3:length(seq) - 3 + 1
aaseq[div(i, 3) + 1] = standard_genetic_code_dict[seq[i:i+2]]
end
return String(aaseq)
end
# Basics
@test length(BioSequences.standard_genetic_code) == 64
buf = IOBuffer()
show(buf, BioSequences.standard_genetic_code)
@test !iszero(length(take!(buf))) # just test it doesn't error
# TransTables
@test BioSequences.TransTables() isa BioSequences.TransTables
@test BioSequences.ncbi_trans_table[1] === BioSequences.standard_genetic_code
buf = IOBuffer()
show(buf, BioSequences.ncbi_trans_table)
@test !iszero(length(take!(buf)))
# Test translation values
sampler = SamplerWeighted(rna"ACGUMRSVWYHKDBN", [fill(0.2, 4); fill(0.018181818, 10)])
for len in [3, 9, 54, 102]
for A in [DNAAlphabet{4}(), RNAAlphabet{4}()]
for attempt in 1:25
seq = randseq(A, sampler, len)
@test string(translate(seq)) == string_translate(string(seq))
for window in [1:3, 5:13, 11:67]
checkbounds(Bool, eachindex(seq), window) || continue
v = view(seq, window)
@test string(translate(v)) == string_translate(string(v))
end
end
end
for A in [DNAAlphabet{2}(), RNAAlphabet{2}()]
seq = randseq(A, len)
@test string(translate(seq)) == string_translate(string(seq))
end
end
# ambiguous codons
@test translate(rna"YUGMGG") == aa"LR"
@test translate(rna"GAYGARGAM") == aa"DEX"
@test translate(rna"MUCGGG") == aa"JG"
@test translate(rna"AAASAAUUU") == aa"KZF"
# BioSequences{RNAAlphabet{2}}
@test translate(LongSequence{RNAAlphabet{2}}("AAAUUUGGGCCC")) == translate(rna"AAAUUUGGGCCC")
@test translate(LongSequence{DNAAlphabet{2}}("AAATTTGGGCCC")) == translate(dna"AAATTTGGGCCC")
# LongDNA{4}
@test translate(dna"ATGTAA") == aa"M*"
# Alternative start codons
@test translate(rna"GUGUAA", alternative_start = true) == aa"M*"
@test_throws Exception translate(rna"ACGUACGU") # can't translate non-multiples of three
# can't translate N
@test_throws Exception translate(rna"ACGUACGNU", allow_ambiguous_codons=false)
# Can't translate gaps
@test_throws Exception translate(dna"A-G")
@test_throws Exception translate(dna"---")
@test_throws Exception translate(dna"AACGAT-A-")
# issue #133
@test translate(rna"GAN") == aa"X"
# Test views
seq = dna"TAGTGCNTAGDACGGGWAAABCCGTAC"
@test translate(view(seq, 1:0)) == aa""
@test translate(LongSubSeq{RNAAlphabet{4}}(seq, 2:length(seq)-2)) == translate(seq[2:end-2])
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 3814 | # This file contains only utility functions that do NOT
# depend on BioSequences
const codons = [
"AAA", "AAC", "AAG", "AAU",
"ACA", "ACC", "ACG", "ACU",
"AGA", "AGC", "AGG", "AGU",
"AUA", "AUC", "AUG", "AUU",
"CAA", "CAC", "CAG", "CAU",
"CCA", "CCC", "CCG", "CCU",
"CGA", "CGC", "CGG", "CGU",
"CUA", "CUC", "CUG", "CUU",
"GAA", "GAC", "GAG", "GAU",
"GCA", "GCC", "GCG", "GCU",
"GGA", "GGC", "GGG", "GGU",
"GUA", "GUC", "GUG", "GUU",
"UAA", "UAC", "UAG", "UAU",
"UCA", "UCC", "UCG", "UCU",
"UGA", "UGC", "UGG", "UGU",
"UUA", "UUC", "UUG", "UUU",
# translatable ambiguities in the standard code
"CUN", "CCN", "CGN", "ACN",
"GUN", "GCN", "GGN", "UCN"
]
function random_translatable_rna(n)
probs = fill(1.0 / length(codons), length(codons))
cumprobs = cumsum(probs)
r = rand()
x = Vector{String}(undef, n)
for i in 1:n
x[i] = codons[searchsorted(cumprobs, rand()).start]
end
return string(x...)
end
function get_bio_fmt_specimens()
path = joinpath(dirname(@__FILE__), "BioFmtSpecimens")
if !isdir(path)
run(`git clone --depth 1 https://github.com/BioJulia/BioFmtSpecimens.git $(path)`)
end
end
# The generation of random test cases...
function random_array(n::Integer, elements, probs)
cumprobs = cumsum(probs)
x = Vector{eltype(elements)}(undef, n)
for i in 1:n
x[i] = elements[searchsorted(cumprobs, rand()).start]
end
return x
end
# Return a random DNA/RNA sequence of the given length.
function random_seq(n::Integer, nts, probs)
cumprobs = cumsum(probs)
x = Vector{Char}(undef, n)
for i in 1:n
x[i] = nts[searchsorted(cumprobs, rand()).start]
end
return String(x)
end
function random_seq(::Type{A}, n::Integer) where {A<:Alphabet}
# TODO: Resolve the use of symbols(A()).
nts = symbols(A())
probs = Vector{Float64}(undef, length(nts))
fill!(probs, 1 / length(nts))
return LongSequence{A}(random_seq(n, nts, probs))
end
function random_dna(n, probs=[0.24, 0.24, 0.24, 0.24, 0.04])
return random_seq(n, ['A', 'C', 'G', 'T', 'N'], probs)
end
function random_rna(n, probs=[0.24, 0.24, 0.24, 0.24, 0.04])
return random_seq(n, ['A', 'C', 'G', 'U', 'N'], probs)
end
function random_aa(len)
return random_seq(len,
['A', 'R', 'N', 'D', 'C', 'Q', 'E', 'G', 'H', 'I',
'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V', 'X' ],
push!(fill(0.049, 20), 0.02))
end
function intempdir(fn::Function, parent=tempdir())
dirname = mktempdir(parent)
try
cd(fn, dirname)
finally
rm(dirname, recursive=true)
end
end
function random_dna_kmer(len)
return random_dna(len, [0.25, 0.25, 0.25, 0.25])
end
function random_rna_kmer(len)
return random_rna(len, [0.25, 0.25, 0.25, 0.25])
end
function random_dna_kmer_nucleotides(len)
return random_array(len, [DNA_A, DNA_C, DNA_G, DNA_T],
[0.25, 0.25, 0.25, 0.25])
end
function random_rna_kmer_nucleotides(len)
return random_array(len, [RNA_A, RNA_C, RNA_G, RNA_U],
[0.25, 0.25, 0.25, 0.25])
end
function dna_complement(seq::AbstractString)
seqc = Vector{Char}(undef, length(seq))
complementer = Dict(zip("-ACGTSWYRKMDVHBN", "-TGCASWRYMKHBDVN"))
for (i, c) in enumerate(seq)
seqc[i] = complementer[c]
end
return String(seqc)
end
function rna_complement(seq::AbstractString)
seqc = Vector{Char}(undef, length(seq))
complementer = Dict(zip("-ACGUSWYRKMDVHBN", "-UGCASWRYMKHBDVN"))
for (i, c) in enumerate(seq)
seqc[i] = complementer[c]
end
return String(seqc)
end
function random_interval(minstart, maxstop)
start = rand(minstart:maxstop)
return start:rand(start:maxstop)
end | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2774 | struct Unsafe end
# Create new biosequence for testing
struct SimpleSeq <: BioSequence{RNAAlphabet{2}}
x::Vector{UInt}
SimpleSeq(::Unsafe, x::Vector{UInt}) = new(x)
end
function SimpleSeq(it)
SimpleSeq(Unsafe(), [BioSequences.encode(Alphabet(SimpleSeq), convert(RNA, i)) for i in it])
end
Base.copy(x::SimpleSeq) = SimpleSeq(Unsafe(), copy(x.x))
Base.length(x::SimpleSeq) = length(x.x)
BioSequences.encoded_data_eltype(::Type{SimpleSeq}) = UInt
BioSequences.extract_encoded_element(x::SimpleSeq, i::Integer) = x.x[i]
BioSequences.encoded_setindex!(x::SimpleSeq, e::UInt, i::Integer) = x.x[i] = e
SimpleSeq(::UndefInitializer, x::Integer) = SimpleSeq(Unsafe(), zeros(UInt, x))
Base.resize!(x::SimpleSeq, len::Int) = (resize!(x.x, len); x)
# Not part of the API, just used for testing purposes
random_simple(len::Integer) = SimpleSeq(rand([RNA_A, RNA_C, RNA_G, RNA_U], len))
@testset "Basics" begin
@test BioSequences.has_interface(BioSequence, SimpleSeq, [RNA_C], true)
seq = SimpleSeq([RNA_C, RNA_G, RNA_U])
@test seq isa BioSequence{RNAAlphabet{2}}
@test Alphabet(seq) === RNAAlphabet{2}()
@test empty(seq) isa BioSequence
@test eltype(typeof(seq)) == RNA
@test eltype(seq) == RNA
@test copy(seq) == seq
@test copy(seq) !== seq
@test length(seq) == 3
@test size(seq) == (3,)
@test length(empty(seq)) == 0
@test isempty(empty(seq))
@test isempty(empty(seq))
@test firstindex(seq) == 1
@test lastindex(seq) == 3
@test collect(eachindex(seq)) == [1, 2, 3]
@test collect(keys(seq)) == [1, 2, 3]
@test nextind(seq, firstindex(seq)) == 2
@test prevind(seq, lastindex(seq)) == 2
@test prevind(seq, 2) == 1
seq2 = SimpleSeq([RNA_U, RNA_C, RNA_U])
gen = (i for i in [seq, seq2])
newseq = SimpleSeq([])
join!(newseq, [seq, seq2])
@test newseq == SimpleSeq([RNA(i) for i in "CGUUCU"])
join!(newseq, gen)
@test newseq == SimpleSeq([RNA(i) for i in "CGUUCU"])
join!(newseq, [RNA_U, RNA_C, SimpleSeq([RNA_G, RNA_C])])
@test newseq == SimpleSeq([RNA(i) for i in "UCGC"])
@test join(SimpleSeq, [seq, seq2]) == join!(SimpleSeq([]), [seq, seq2])
@test join(SimpleSeq, gen) == join!(SimpleSeq([]), gen)
@test join(SimpleSeq, [RNA_U, RNA_G, seq, RNA_U]) == SimpleSeq([RNA(i) for i in "UGCGUU"])
@test copy!(SimpleSeq([]), seq) == seq
seq3 = copy(seq2)
@test copyto!(seq3, seq) == seq
seq3 = copy(seq2)
@test copyto!(seq3, 2, seq, 3, 1) == SimpleSeq([RNA(i) for i in "UUU"])
@test_throws EncodeError SimpleSeq([RNA_C, RNA_G, RNA_M])
@test_throws EncodeError SimpleSeq([RNA_Gap])
@test_throws MethodError SimpleSeq(1:3)
@test_throws MethodError SimpleSeq([DNA_C, "foo", DNA_C])
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 5817 |
@testset "Getindex" begin
@testset "Scalar getindex" begin
seq = SimpleSeq([RNA_C, RNA_G, RNA_C, RNA_A])
@test_throws BoundsError seq[0]
@test_throws BoundsError seq[5]
@test first(seq) == RNA_C
@test last(seq) == RNA_A
@test seq[2] == RNA_G
@test seq[3] == RNA_C
end
@testset "Getindex w. bool array" begin
char_arr = map(RNA, collect("ACGUAGCUAUUAUACCC"))
seq = SimpleSeq(char_arr) # len = 17
@test_throws BoundsError seq[fill(true, length(char_arr) - 1)]
@test_throws BoundsError seq[fill(true, length(char_arr) + 1)]
for i in 1:3
arr = rand(Bool, length(seq))
seq2 = seq[arr]
@test length(seq2) == count(arr)
@test seq2 == SimpleSeq(char_arr[arr])
end
end
@testset "Getindex w. unit range" begin
char_arr = map(RNA, collect("ACGUAGAUUAUUUCUCCAA")) # len = 19
seq = SimpleSeq(char_arr)
@test seq[1:0] == empty(seq)
@test seq[5:4] == empty(seq)
@test_throws BoundsError seq[-1:2]
@test_throws BoundsError seq[5:22]
@test_throws BoundsError seq[0:19]
@test seq[2:5] == SimpleSeq(map(RNA, collect("CGUA")))
@test seq[1:9] == SimpleSeq(map(RNA, collect("ACGUAGAUU")))
@test seq[1:18] == SimpleSeq(map(RNA, collect("ACGUAGAUUAUUUCUCCA")))
@test seq[1:19] == seq
end
@testset "Getindex w. colon" begin
char_arr = map(RNA, collect("ACGUAGAUUAUUUCUCCAA")) # len = 19
seq = SimpleSeq(char_arr)
seq[:] == seq
seq[:] !== seq
seq = SimpleSeq([RNA_A, RNA_C])
seq[:] == SimpleSeq([RNA_A, RNA_C])
seq[:] !== seq
seq = empty(seq)
seq[:] == empty(seq)
seq[:] !== empty(seq)
end
@testset "Getindex w. integer array" begin
char_arr = map(RNA, collect("AGCGUAUAGCGA")) # len = 12
seq = SimpleSeq(char_arr)
seq[Int[]] == empty(seq)
@test_throws BoundsError seq[[-1, 2, 4]]
@test_throws BoundsError seq[[3, 7, 9, 0]]
@test_throws BoundsError seq[[5, 3, 13]]
seq[[5, 2, 1]] == SimpleSeq([RNA_U, RNA_C, RNA_A])
seq[1:2:11] == SimpleSeq(collect(seq)[1:2:11])
end
end
@testset "Setindex!" begin
@testset "Scalar setindex!" begin
seq = SimpleSeq([RNA_U, RNA_U, RNA_A])
@test_throws BoundsError seq[0] = RNA_A
@test_throws BoundsError seq[-3] = RNA_A
@test_throws BoundsError seq[4] = RNA_U
@test_throws MethodError seq[1] = AA_A
@test_throws MethodError seq[1] = UInt8(1)
seq[2] = RNA_U
@test seq == SimpleSeq([RNA_U, RNA_U, RNA_A])
seq[1] = RNA_G
@test seq == SimpleSeq([RNA_G, RNA_U, RNA_A])
# RNA/DNA can be converted freely
seq[3] = DNA_T
@test seq == SimpleSeq([RNA_G, RNA_U, RNA_U])
end
@testset "Setindex w. bool array" begin
function test_bool_arr(s::SimpleSeq, mask::AbstractArray{Bool})
n = count(mask)
seq2 = random_simple(n)
cp = copy(s)
@test s[mask] == SimpleSeq(collect(cp)[mask])
end
random_simple(len::Integer) = SimpleSeq(rand([RNA_A, RNA_C, RNA_G, RNA_U], len))
seq = random_simple(19)
@test_throws DimensionMismatch seq[trues(19)] = random_simple(18)
@test_throws BoundsError seq[trues(18)] = random_simple(19)
mask = vcat(falses(2), trues(5), falses(12))
@test_throws DimensionMismatch seq[mask] = random_simple(4)
@test_throws DimensionMismatch seq[mask] = random_simple(6)
test_bool_arr(seq, mask)
for i in 1:5
seq = random_simple(20)
mask = rand(Bool, 20)
test_bool_arr(seq, mask)
end
end
@testset "Setindex with colon" begin
seq1 = SimpleSeq(map(RNA, collect("AGAUGCUCUUAGAC")))
seq2 = SimpleSeq(map(RNA, collect("AGUCGUAUAUAGGC")))
seq3 = copy(seq1)
seq3[:] = seq2
@test seq3 == seq2
seq3 = copy(seq2)
seq3[:] = seq1
@test seq3 == seq1
seq3 = copy(seq2)
seq3[:] = collect("AGAUGCUCUUAGAC")
@test seq3 == seq1
seq3 = empty(seq1)[:]
seq3[:] = RNA[]
@test isempty(seq3)
end
@testset "Setindex with unit range" begin
seq = SimpleSeq(map(RNA, collect("AUGCUGUAUUCGGAAA"))) # 16 bp
@test_throws BoundsError seq[15:17] = [RNA_A, RNA_C, RNA_U]
@test_throws BoundsError seq[5:25] = ""
@test_throws DimensionMismatch seq[5:7] = "AUCG"
seq2 = copy(seq)
seq2[5:4] = ""
@test seq2 == seq
seq[4:6] = "CAU"
@test seq == SimpleSeq(map(RNA, collect("AUGCAUUAUUCGGAAA")))
end
@testset "Setindex with integer array" begin
seq = SimpleSeq(map(RNA, collect("AUGCUGCGUAUGUUCUU"))) # 17 bp
@test_throws BoundsError seq[[0, 1, 2]] = "UUU"
@test_throws BoundsError seq[[6, 1, 18]] = "UUU"
@test_throws DimensionMismatch seq[[4,5,6]] = "UU"
@test_throws DimensionMismatch seq[[4,5,6]] = "ACGU"
seq[[2,6,8]] = "ACU"
@test seq == SimpleSeq(map(RNA, collect("AAGCUCCUUAUGUUCUU")))
seq[1:2:17] = "ACG"^3
@test seq == SimpleSeq(map(RNA, collect("AACCGCAUCAGGAUCUG")))
end
end
@testset "BitIndex" begin
ind = BioSequences.BitIndex{4, UInt64}(16)
@test BioSequences.BitsPerSymbol(ind) == BioSequences.BitsPerSymbol{4}()
@test BioSequences.bitwidth(UInt64) == 64
@test BioSequences.bitwidth(UInt16) == 16
@test BioSequences.prevposition(ind) == BioSequences.BitIndex{4, UInt64}(12)
@test BioSequences.nextposition(ind) == BioSequences.BitIndex{4, UInt64}(20)
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 6507 | @testset "Convert to String or Vector" begin
seq = SimpleSeq("ACGUAAUUUCA")
@test String(seq) == "ACGUAAUUUCA"
seq = SimpleSeq(RNA[])
@test isempty(seq)
end
@testset "Counting" begin
for i in 1:3
seq = random_simple(100)
str = String(seq)
@test count(isequal(RNA_A), seq) == count(isequal('A'), str)
@test count(isambiguous, seq) == 0
@test count(iscertain, seq) == length(seq)
@test count(x -> x in (RNA_A, RNA_C), seq) == count(x -> x in "AC", str)
@test isapprox(gc_content(seq), count(x -> x in "GC", str) / length(seq))
@test n_ambiguous(seq) == 0
@test n_certain(seq) == length(seq)
@test n_gaps(seq) == 0
end
end
@testset "Matches/mismatches" begin
seq1 = random_simple(1000)
seq2 = random_simple(1000)
n_matches = sum(i == j for (i, j) in zip(seq1, seq2))
@test mismatches(seq1, seq2) == length(seq1) - n_matches
@test matches(seq1, seq2) == n_matches
end
@testset "Finding" begin
@testset "Findfirst" begin
seq = SimpleSeq("AUGCUGAUGAC")
seq2 = SimpleSeq("AUGAUGAUGAUGUACA")
@test findfirst(isequal(RNA_U), seq) == 2
@test findfirst(isequal(missing), seq) === nothing
@test findfirst(x -> true, empty(seq)) === nothing
@test findfirst(x -> x == RNA_C, seq2) == 15
end
@testset "Findlast" begin
seq = SimpleSeq("AUGCUGAUGAC")
seq2 = SimpleSeq("AUGAUGAUGAUGUACA")
@test findlast(isequal(RNA_U), seq) == 8
@test findlast(isequal(missing), seq) === nothing
@test findlast(x -> true, empty(seq)) === nothing
@test findlast(x -> x == RNA_C, seq2) == 15
end
@testset "Findnext / prev" begin
seq = SimpleSeq("AUGAUGAUGAUGUACA") # 16 nt
@test findnext(x -> true, seq, 17) === nothing
@test findprev(x -> true, seq, 0) === nothing
@test_throws BoundsError findnext(x -> true, seq, 0)
@test_throws BoundsError findprev(x -> true, seq, 17)
@test findnext(isequal(RNA_U), seq, 6) == 8
@test findprev(isequal(RNA_U), seq, 6) == 5
end
end
@testset "Equality" begin
@test SimpleSeq("AUGC") == SimpleSeq("AUGC")
@test SimpleSeq("AUGC") != SimpleSeq("AUG")
@test SimpleSeq("AUGC") != SimpleSeq("AUGCA")
@test SimpleSeq("A") != SimpleSeq("U")
@test !isless(SimpleSeq("GAC"), SimpleSeq("CAC"))
@test isless(SimpleSeq("UG"), SimpleSeq("UGA"))
@test isless(SimpleSeq("AGCUUA"), SimpleSeq("AGCUUU"))
# This is particular for the RNA alphabet of SimpleSeq, not generic
for i in 1:5
seq1, seq2 = random_simple(20), random_simple(20)
@test isless(seq1, seq2) == isless(String(seq1), String(seq2))
end
end
@testset "Repetitive" begin
@test isrepetitive(SimpleSeq("CCCCCCCCC"))
@test !isrepetitive(SimpleSeq("CCCCCCCCA"))
@test isrepetitive(SimpleSeq(RNA[]))
@test isrepetitive(SimpleSeq("GAUGUCGAAAC"), 3)
@test !isrepetitive(SimpleSeq("GAUGUCGAAAC"), 4)
@test isrepetitive(SimpleSeq(""))
@test !isrepetitive(SimpleSeq(""), 1)
@test isrepetitive(SimpleSeq("A"))
@test isrepetitive(SimpleSeq("A"), 1)
@test isrepetitive(SimpleSeq("AAA"))
@test !isrepetitive(SimpleSeq("ACGU"), 2)
@test isrepetitive(SimpleSeq("AAGU"), 2)
@test isrepetitive(SimpleSeq("ACCG"), 2)
@test isrepetitive(SimpleSeq("ACGG"), 2)
@test !isrepetitive(SimpleSeq("ACGUCCGU"), 3)
@test isrepetitive(SimpleSeq("ACGCCCGU"), 3)
@test isrepetitive(SimpleSeq(""))
@test !isrepetitive(SimpleSeq(""), 1)
@test isrepetitive(SimpleSeq("A"))
@test isrepetitive(SimpleSeq("A"), 1)
@test isrepetitive(SimpleSeq("AAA"))
@test !isrepetitive(SimpleSeq("ACGU"), 2)
@test isrepetitive(SimpleSeq("AAGU"), 2)
@test isrepetitive(SimpleSeq("ACCG"), 2)
@test isrepetitive(SimpleSeq("ACGG"), 2)
@test !isrepetitive(SimpleSeq("ACGUCCGU"), 3)
@test isrepetitive(SimpleSeq("ACGCCCGU"), 3)
end
@testset "Canonical" begin
@test iscanonical(SimpleSeq("ACCG"))
@test iscanonical(SimpleSeq("GCAC"))
@test iscanonical(SimpleSeq("AAUU"))
@test !iscanonical(SimpleSeq("UGGA"))
@test !iscanonical(SimpleSeq("CGAU"))
@test canonical(SimpleSeq("UGGA")) == SimpleSeq("UCCA")
@test canonical(SimpleSeq("GCAC")) == SimpleSeq("GCAC")
seq = SimpleSeq("CGAU")
canonical!(seq)
@test seq == SimpleSeq("AUCG")
@test iscanonical(SimpleSeq("UCA"))
@test !iscanonical(SimpleSeq("UGA"))
end
@testset "Ispalindromic" begin
@test ispalindromic(SimpleSeq(""))
@test !ispalindromic(SimpleSeq("A"))
@test !ispalindromic(SimpleSeq("C"))
@test ispalindromic(SimpleSeq("AU"))
@test ispalindromic(SimpleSeq("CG"))
@test !ispalindromic(SimpleSeq("AC"))
@test !ispalindromic(SimpleSeq("UU"))
@test ispalindromic(SimpleSeq("ACGU"))
@test ispalindromic(SimpleSeq(""))
@test !ispalindromic(SimpleSeq("A"))
@test !ispalindromic(SimpleSeq("C"))
@test ispalindromic(SimpleSeq("AU"))
@test ispalindromic(SimpleSeq("CG"))
@test !ispalindromic(SimpleSeq("AC"))
@test !ispalindromic(SimpleSeq("UU"))
@test ispalindromic(SimpleSeq("ACGU"))
end
@testset "Has ambiguity" begin
@test !hasambiguity(SimpleSeq("UAGUCGUGAG"))
@test !hasambiguity(SimpleSeq(""))
@test !hasambiguity(SimpleSeq("A"))
@test !hasambiguity(SimpleSeq("ACGU"))
@test !hasambiguity(SimpleSeq(""))
@test !hasambiguity(SimpleSeq("A"))
@test !hasambiguity(SimpleSeq("ACGU"))
end
@testset "Shuffle" begin
function test_same(a, b)
@test all(symbols(Alphabet(a))) do i
count(isequal(i), a) == count(isequal(i), b)
end
end
seq = SimpleSeq([RNA(i) for i in "AGCGUUAUGCUGAUUAGGAC"])
seq2 = Random.shuffle(seq)
test_same(seq, seq2)
Random.shuffle!(seq)
test_same(seq, seq2)
end
@testset "Reverse-complement" begin
seq = SimpleSeq([RNA(i) for i in "UAGUUC"])
@test reverse(seq) == SimpleSeq([RNA(i) for i in "CUUGAU"])
@test complement(seq) == SimpleSeq([RNA(i) for i in "AUCAAG"])
@test reverse_complement(seq) == reverse(complement(seq))
reverse!(seq)
@test seq == SimpleSeq([RNA(i) for i in "CUUGAU"])
complement!(seq)
@test seq == SimpleSeq([RNA(i) for i in "GAACUA"])
end
@testset "Ungap" begin
seq = SimpleSeq([RNA(i) for i in "UAGUUC"])
@test ungap(seq) == seq
cp = copy(seq)
@test ungap!(seq) == cp
end | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 13286 | @testset "Basics" begin
@test BioSequences.has_interface(BioSequence, LongDNA{2}, [DNA_G], true)
@test BioSequences.has_interface(BioSequence, LongDNA{4}, [DNA_G], true)
@test BioSequences.has_interface(BioSequence, LongRNA{2}, [RNA_G], true)
@test BioSequences.has_interface(BioSequence, LongRNA{4}, [RNA_G], true)
@test BioSequences.has_interface(BioSequence, LongAA, [AA_G], true)
seq = LongSequence{DNAAlphabet{2}}()
@test isempty(seq)
@test similar(seq) == seq
seq = LongSequence{DNAAlphabet{2}}([DNA(i) for i in "TAGCA"])
@test seq isa LongSequence
@test seq isa LongSequence{DNAAlphabet{2}}
sim = similar(seq)
@test typeof(sim) == typeof(seq)
@test length(sim) == length(seq)
# Construct from other sequences
seq = LongAA("AGCTVMN")
@test LongSequence(seq) == LongAA("AGCTVMN")
@test LongSequence(seq, 2:5) == LongAA("GCTV")
@test LongSequence(SimpleSeq("AUCGU")) isa LongRNA{2}
@test LongSequence(SimpleSeq("AUCGU")) == LongRNA{2}("AUCGU")
LongDNA{4}(LongRNA{4}("AUCGUA")) == LongDNA{4}("ATCGTA")
# Displays a nice error when constructed from strings substrings
# and bytearrays on encoding error
@static if VERSION >= v"1.8"
malformed = "ACWpNS"
@test_throws "Cannot encode byte $(repr(UInt8('p'))) (char 'p') at index 4 to BioSequences.DNAAlphabet{4}" LongDNA{4}(malformed)
malformed = "AGCUGUAGUCGGUAUAUAGGCGCGCUCGAUGAUGAUGCGUGCUGCUATDNANCUG"
@test_throws "Cannot encode byte $(repr(UInt8('T'))) (char 'T') at index $(length(malformed) - 7) to BioSequences.RNAAlphabet{2}" LongRNA{2}(malformed)
end
end
@testset "Copy sequence" begin
# Test copy from sequence to sequence
function test_copy(A, str)
seq = LongSequence{A}(str)
str2 = String(copy(seq))
@test (str == str2 == String(seq))
end
for len in [0, 1, 15, 33]
test_copy(DNAAlphabet{4}, random_dna(len))
test_copy(RNAAlphabet{2}, random_rna(len, [0.25, 0.25, 0.25, 0.25]))
test_copy(AminoAcidAlphabet, random_aa(len))
end
end # testset
@testset "Copy! sequence" begin
function test_copy!(A, srctxt)
src = LongSequence{A}(srctxt)
dst = LongSequence{A}(undef, 0)
for len in [max(0, length(src) - 3), length(src), length(src) + 4]
resize!(dst, len)
copy!(dst, src)
@test String(dst) == String(src)
end
end
test_copy!(DNAAlphabet{4}, random_dna(14))
test_copy!(RNAAlphabet{2}, random_rna(55, [0.25, 0.25, 0.25, 0.25]))
test_copy!(AminoAcidAlphabet, random_aa(18))
# Also works across nucleotide types!
for N in (2,4)
src = LongDNA{N}(random_dna(33, [0.25, 0.25, 0.25, 0.25]))
dst = LongRNA{N}(random_rna(31, [0.25, 0.25, 0.25, 0.25]))
copy!(dst, src)
@test String(typeof(dst)(src)) == String(dst)
resize!(dst, 16)
copy!(src, dst)
@test String(typeof(dst)(src)) == String(dst)
end
# Doesn't work for wrong types
@test_throws Exception copy!(LongDNA{4}("TAG"), LongAA("WGM"))
@test_throws Exception copy!(LongDNA{2}("TAG"), LongRNA{4}("UGM"))
end
@testset "Copyto! sequence" begin
function test_copyto!1(A1, dst, A2, src)
dst_ = LongSequence{A1}(dst)
src_ = LongSequence{A2}(src)
copyto!(dst_, src_)
@test String(src_) == String(dst_[1:length(src_)])
end
test_copyto!1(DNAAlphabet{4}, random_dna(19), DNAAlphabet{4}, random_dna(17))
test_copyto!1(RNAAlphabet{2}, random_rna(31, [0.25, 0.25, 0.25, 0.25]),
RNAAlphabet{2}, random_rna(11, [0.25, 0.25, 0.25, 0.25]))
test_copyto!1(AminoAcidAlphabet, random_aa(61), AminoAcidAlphabet, random_aa(61))
function test_copyto2!(A, F)
for len in [10, 17, 51]
start = rand(1:3)
N = len - rand(1:4) - start
src = LongSequence{A}(F(len))
dst = LongSequence{A}(F(len))
copyto!(dst, start, src, start + 1, N)
@test String(dst[start:start+N-1]) == String(src[start+1:start+N])
end
end
test_copyto2!(DNAAlphabet{2}, len -> random_dna(len, [0.25, 0.25, 0.25, 0.25]))
test_copyto2!(RNAAlphabet{4}, random_rna)
test_copyto2!(AminoAcidAlphabet, random_aa)
# Test bug when copying to self
src = LongDNA{4}("A"^16 * "C"^16 * "A"^16)
copyto!(src, 17, src, 1, 32)
@test String(src) == "A"^32 * "C"^16
# Can't copy over edge
dst = LongDNA{4}("TAGCA")
@test_throws Exception copyto!(dst, 1, fill(0x61, 2), 2, 3)
end
@testset "Copy! data" begin
function test_copy!(seq, src)
@test String(src) == String(copy!(seq, src))
end
# Needed because conversion to String truncates vector.
function test_copy!(seq, src::Vector)
@test String(copy(src)) == String(copy!(copy(seq), src))
end
probs = [0.25, 0.25, 0.25, 0.25, 0.00]
dna2 = LongDNA{2}(undef, 6)
dna4 = LongDNA{4}(undef, 6)
rna2 = LongRNA{2}(undef, 6)
rna4 = LongRNA{4}(undef, 6)
aa = LongAA(undef, 6)
for dtype in [Vector{UInt8}, Vector{Char}, String, Test.GenericString]
for len in [0, 1, 5, 16, 32, 100]
test_copy!(dna2, dtype(random_dna(len, probs)))
test_copy!(dna4, dtype(random_dna(len)))
test_copy!(rna2, dtype(random_rna(len, probs)))
test_copy!(rna4, dtype(random_rna(len)))
test_copy!(aa, dtype(random_aa(len)))
end
end
end
@testset "Copyto! data" begin
function test_twoarg_copyto!(seq, src)
copyto!(seq, src)
@test String(src[1:length(src)]) == String(src)
end
# Needed because conversion to String truncates vector.
function test_twoarg_copyto!(seq, src::Vector)
copyto!(seq, src)
@test String(src[1:length(src)]) == String(copy(src))
end
probs = [0.25, 0.25, 0.25, 0.25, 0.00]
dna2 = LongDNA{2}(undef, 50)
dna4 = LongDNA{4}(undef, 50)
rna2 = LongRNA{2}(undef, 50)
rna4 = LongRNA{4}(undef, 50)
aa = LongAA(undef, 50)
for dtype in [Vector{UInt8}, Vector{Char}, String, Test.GenericString]
for len in [0, 1, 10, 16, 32, 5]
test_twoarg_copyto!(dna2, dtype(random_dna(len, probs)))
test_twoarg_copyto!(dna4, dtype(random_dna(len)))
test_twoarg_copyto!(rna2, dtype(random_rna(len, probs)))
test_twoarg_copyto!(rna4, dtype(random_rna(len)))
test_twoarg_copyto!(aa, dtype(random_aa(len)))
end
end
# Five-arg copyto!
function test_fivearg_copyto!(seq, src)
for soff in (1, 3)
for doff in (1, 5)
for N in (0, 5, 18, 30)
copyto!(seq, doff, src, soff, N)
@test String(seq[doff:doff+N-1]) == String(src[soff:soff+N-1])
end
end
end
end
for dtype in [Vector{UInt8}, Vector{Char}, String, Test.GenericString]
test_fivearg_copyto!(dna2, dtype(random_dna(60, probs)))
test_fivearg_copyto!(dna4, dtype(random_dna(60)))
test_fivearg_copyto!(rna2, dtype(random_rna(60, probs)))
test_fivearg_copyto!(rna4, dtype(random_rna(60)))
test_fivearg_copyto!(aa, dtype(random_aa(60)))
end
end
################
@testset "Concatenation" begin
function test_concatenation(A, chunks)
parts = UnitRange{Int}[]
for i in 1:lastindex(chunks)
start = rand(1:length(chunks[i]))
stop = rand(start:length(chunks[i]))
push!(parts, start:stop)
end
str = string([chunk[parts[i]] for (i, chunk) in enumerate(chunks)]...)
seq = *([LongSequence{A}(chunk)[parts[i]] for (i, chunk) in enumerate(chunks)]...)
@test String(seq) == uppercase(str)
end
for _ in [1, 2, 5, 10, 18, 32, 55, 64, 70]
n = rand(1:10)
chunks = [random_dna(rand(1:100)) for _ in 1:n]
test_concatenation(DNAAlphabet{4}, chunks)
chunks = [random_rna(rand(1:100)) for _ in 1:n]
test_concatenation(RNAAlphabet{4}, chunks)
chunks = [random_aa(rand(1:100)) for _ in 1:n]
test_concatenation(AminoAcidAlphabet, chunks)
probs = [0.25, 0.25, 0.25, 0.25, 0.00]
chunks = [random_dna(rand(1:100), probs) for _ in 1:n]
test_concatenation(DNAAlphabet{2}, chunks)
chunks = [random_rna(rand(1:100), probs) for _ in 1:n]
test_concatenation(RNAAlphabet{2}, chunks)
end
end
@testset "Repetition" begin
function test_repetition(A, chunk)
start = rand(1:length(chunk))
stop = rand(start:length(chunk))
n = rand(1:10)
str = chunk[start:stop] ^ n
seq = LongSequence{A}(chunk)[start:stop] ^ n
@test String(seq) == uppercase(str)
end
for _ in 1:10
chunk = random_dna(rand(1:100))
test_repetition(DNAAlphabet{4}, chunk)
chunk = random_rna(rand(1:100))
test_repetition(RNAAlphabet{4}, chunk)
chunk = random_aa(rand(1:100))
test_repetition(AminoAcidAlphabet, chunk)
probs = [0.25, 0.25, 0.25, 0.25, 0.00]
chunk = random_dna(rand(1:100), probs)
test_repetition(DNAAlphabet{2}, chunk)
chunk = random_rna(rand(1:100), probs)
test_repetition(RNAAlphabet{2}, chunk)
end
end
@testset "Join" begin
function test_join(::Type{T}, seqs, result) where T
@test join(T, seqs) == result
@test join!(T(), seqs) == result
long_seq = T(undef, 1000)
@test join!(long_seq, seqs) == result
end
base_seq = dna"TGATGCTAVWMMKACGAS" # used for seqviews in testing
test_join(LongDNA{4}, [dna"TACG", dna"ACCTGT", @view(base_seq[16:18])], dna"TACGACCTGTGAS")
test_join(LongRNA{4}, Set([]), LongRNA{4}())
base_aa_seq = aa"KMAEEHPAIYWLMN"
test_join(LongAA, (aa"KMVLE", aa"", (@view base_aa_seq[3:6])), aa"KMVLEAEEH")
# Joining seqs and symbols
test_join(LongAA, [AA_G, AA_P, AA_L, aa"MNVWEED", AA_K], aa"GPLMNVWEEDK")
test_join(LongRNA{4}, [RNA_M, RNA_U, RNA_S, rna"AGCGSK"], rna"MUSAGCGSK")
test_join(LongDNA{2}, [dna"ATGCTTA", DNA_G, DNA_G, DNA_A, DNA_A, DNA_A], dna"ATGCTTAGGAAA")
end
@testset "Length" begin
for len in [0, 1, 2, 10, 16, 32, 1000]
seq = LongDNA{4}(random_dna(len))
@test length(seq) === lastindex(seq) === len
seq = LongRNA{4}(random_rna(len))
@test length(seq) === lastindex(seq) === len
seq = LongAA(random_aa(len))
@test length(seq) === lastindex(seq) === len
end
end
@testset "Access" begin
dna_seq = dna"ACTG"
@test dna_seq[1] === DNA_A
@test dna_seq[2] === DNA_C
@test dna_seq[3] === DNA_T
@test dna_seq[4] === DNA_G
# Access indexes out of bounds
@test_throws BoundsError dna_seq[-1]
@test_throws BoundsError dna_seq[0]
@test_throws BoundsError dna_seq[5]
@test dna"ACTGNACTGN"[1:5] == dna"ACTGN"
@test dna"ACTGNACTGN"[5:1] == dna""
rna_seq = rna"ACUG"
@test rna_seq[1] === RNA_A
@test rna_seq[2] === RNA_C
@test rna_seq[3] === RNA_U
@test rna_seq[4] === RNA_G
# Access indexes out of bounds
@test_throws BoundsError rna_seq[-1]
@test_throws BoundsError rna_seq[0]
@test_throws BoundsError rna_seq[5]
@test rna"ACUGNACUGN"[1:5] == rna"ACUGN"
@test rna"ACUGNACUGN"[5:1] == rna""
@test aa"KSAAV"[3] == AA_A
end
@testset "Equality" begin
@testset "DNA" begin
a = dna"ACTGN"
b = dna"ACTGN"
@test a == b
@test dna"ACTGN" == dna"ACTGN"
@test dna"ACTGN" != dna"ACTGA"
@test dna"ACTGN" != dna"ACTG"
@test dna"ACTG" != dna"ACTGN"
a = dna"ACGTNACGTN"
b = dna"""
ACGTN
ACGTN
"""
@test a == b
end
@testset "RNA" begin
a = rna"ACUGN"
b = rna"ACUGN"
@test a == b
@test rna"ACUGN" == rna"ACUGN"
@test rna"ACUGN" != rna"ACUGA"
@test rna"ACUGN" != rna"ACUG"
@test rna"ACUG" != rna"ACUGN"
a = rna"ACUGNACUGN"
b = rna"""
ACUGN
ACUGN
"""
@test a == b
end
@testset "AminoAcid" begin
a = aa"ARNDCQEGHILKMFPSTWYVX"
b = aa"ARNDCQEGHILKMFPSTWYVX"
@test a == b
@test a != aa"ARNDCQEGHILKMFPSTWYXV"
@test a != aa"ARNDCQEGHLKMFPSTWYVX"
b = aa"""
ARNDCQEGHI
LKMFPSTWYV
X
"""
@test a == b
end
end
@testset "Custom ASCII alphabet" begin
@test string(LongSequence{ReducedAAAlphabet}("FSPMKH")) == "FSPMKH"
buf = IOBuffer()
print(buf, LongSequence{ReducedAAAlphabet}("AGTDNWLE"))
@test String(take!(buf)) == "AGTDNWLE"
#### Now add AsciiAlphabet capacity
BioSequences.codetype(::ReducedAAAlphabet) = BioSequences.AsciiAlphabet()
function BioSequences.ascii_encode(::ReducedAAAlphabet, x::UInt8)
for sym in symbols(ReducedAAAlphabet())
if UInt8(Char(sym)) == x
return UInt8(encode(ReducedAAAlphabet(), sym))
end
end
end
@test string(LongSequence{ReducedAAAlphabet}("FSPMKH")) == "FSPMKH"
buf = IOBuffer()
print(buf, LongSequence{ReducedAAAlphabet}("AGTDNWLE"))
@test String(take!(buf)) == "AGTDNWLE"
end | BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 11194 | @testset "Constructing empty sequences" begin
@test isempty(LongDNA{4}())
@test isempty(LongRNA{4}())
@test isempty(LongAA())
end
@testset "Constructing uninitialized sequences" begin
@test isa(LongSequence{DNAAlphabet{2}}(undef, 0), LongSequence)
@test isa(LongSequence{DNAAlphabet{4}}(undef, 10), LongSequence)
@test isa(LongSequence{RNAAlphabet{2}}(undef, 0), LongSequence)
@test isa(LongSequence{RNAAlphabet{4}}(undef, 10), LongSequence)
@test isa(LongSequence{AminoAcidAlphabet}(undef, 10), LongSequence)
@test_throws ArgumentError LongSequence{DNAAlphabet{2}}(undef, -1)
@test_throws ArgumentError LongSequence{DNAAlphabet{4}}(undef, -1)
@test_throws ArgumentError LongSequence{RNAAlphabet{2}}(undef, -1)
@test_throws ArgumentError LongSequence{RNAAlphabet{4}}(undef, -1)
@test_throws ArgumentError LongSequence{AminoAcidAlphabet}(undef, -1)
end
@testset "Conversion from/to strings" begin
# Check that sequences in strings survive round trip conversion:
# String → LongSequence → String
function test_string_construction(A::Type, seq::AbstractString)
@test String(LongSequence{A}(seq)) == uppercase(seq)
end
function test_string_parse(A::Type, seq::AbstractString)
@test parse(LongSequence{A}, seq) == LongSequence{A}(seq)
end
for len in [0, 1, 3, 10, 32, 100]
test_string_construction(DNAAlphabet{4}, random_dna(len))
test_string_construction(DNAAlphabet{4}, SubString(random_dna(len), 1:len))
test_string_construction(DNAAlphabet{4}, lowercase(random_dna(len)))
test_string_construction(RNAAlphabet{4}, lowercase(random_rna(len)))
test_string_construction(RNAAlphabet{4}, random_rna(len))
test_string_construction(AminoAcidAlphabet, random_aa(len))
test_string_construction(AminoAcidAlphabet, lowercase(random_aa(len)))
test_string_parse(DNAAlphabet{4}, random_dna(len))
test_string_parse(DNAAlphabet{4}, SubString(random_dna(len), 1:len))
test_string_parse(DNAAlphabet{4}, lowercase(random_dna(len)))
test_string_parse(RNAAlphabet{4}, lowercase(random_rna(len)))
test_string_parse(RNAAlphabet{4}, random_rna(len))
test_string_parse(AminoAcidAlphabet, random_aa(len))
test_string_parse(AminoAcidAlphabet, lowercase(random_aa(len)))
probs = [0.25, 0.25, 0.25, 0.25, 0.00]
test_string_construction(DNAAlphabet{2}, random_dna(len, probs))
test_string_construction(DNAAlphabet{2}, lowercase(random_dna(len, probs)))
test_string_construction(RNAAlphabet{2}, random_rna(len, probs))
test_string_construction(RNAAlphabet{2}, lowercase(random_rna(len, probs)))
test_string_parse(DNAAlphabet{2}, random_dna(len, probs))
test_string_parse(DNAAlphabet{2}, lowercase(random_dna(len, probs)))
test_string_parse(RNAAlphabet{2}, random_rna(len, probs))
test_string_parse(RNAAlphabet{2}, lowercase(random_rna(len, probs)))
end
# non-standard string literal
@test isa(dna"ACGTMRWSYKVHDBN-", LongDNA{4})
@test isa(rna"ACGUMRWSYKVHDBN-", LongRNA{4})
@test isa(aa"ARNDCQEGHILKMFPSTWYVBJZXOU*-", LongAA)
# Non-nucleotide characters should throw
@test_throws Exception LongDNA{4}("ACCNNCATTTTTTAGATXATAG")
@test_throws Exception LongRNA{4}("ACCNNCATTTTTTAGATXATAG")
@test_throws Exception LongAA("ATGHLMY@ZACAGNM")
# LazyString from BioSequence
@static if VERSION >= v"1.8"
@test string(LazyString(aa"MQLLCP")) == "MQLLCP"
end
end
@testset "Construction from vectors" begin
function test_vector_construction(A, seq::AbstractString)
T = eltype(A)
xs = T[convert(T, c) for c in seq]
@test LongSequence{A}(xs) == LongSequence{A}(seq)
end
# Construct from abstract vector
LongDNA{4}(0x61:0x64) == LongDNA{4}("ABCD")
LongDNA{4}(0x61:0x64, 3:4) == LongDNA{4}("CD")
LongRNA{2}(0x61:0x61) == LongRNA{2}("A")
LongDNA{4}(Test.GenericString("AGCTMYWK")) == LongDNA{4}("AGCTMYWK")
LongAA(Test.GenericString("KMSPIYT")) == LongAA("KMSPIYT")
for len in [0, 1, 10, 32, 1000]
test_vector_construction(DNAAlphabet{4}, random_dna(len))
test_vector_construction(RNAAlphabet{4}, random_rna(len))
test_vector_construction(AminoAcidAlphabet, random_aa(len))
probs = [0.25, 0.25, 0.25, 0.25, 0.00]
test_vector_construction(DNAAlphabet{2}, random_dna(len, probs))
test_vector_construction(RNAAlphabet{2}, random_rna(len, probs))
end
end
@testset "Encode_copy!" begin
# Note: Other packages use this function, so we need to test it
# Even though this is NOT exported or part of the API in a normal sense
function test_copyto!(dst::LongSequence, doff, src, soff, N)
BioSequences.copyto!(dst, doff, src, soff, N)
@test String(dst[doff:doff+N-1]) == String(src[soff:soff+N-1])
end
probs = [0.25, 0.25, 0.25, 0.25]
for len in [0, 1, 10, 100]
for f in [identity, Vector{Char}, Vector{UInt8}]
test_copyto!(LongSequence{DNAAlphabet{2}}(undef, len), 1, f(random_dna(len, probs)), 1, len)
test_copyto!(LongSequence{RNAAlphabet{2}}(undef, len), 1, f(random_rna(len, probs)), 1, len)
test_copyto!(LongSequence{DNAAlphabet{4}}(undef, len), 1, f(random_dna(len)), 1, len)
test_copyto!(LongSequence{RNAAlphabet{4}}(undef, len), 1, f(random_rna(len)), 1, len)
test_copyto!(LongSequence{AminoAcidAlphabet}(undef, len), 1, f(random_aa(len)), 1, len)
end
end
for len in [10, 32, 100]
for f in [identity, Vector{Char}, Vector{UInt8}]
test_copyto!(LongSequence{DNAAlphabet{2}}(undef, len+7), 5, f(random_dna(len+11, probs)), 3, len)
test_copyto!(LongSequence{RNAAlphabet{2}}(undef, len+7), 5, f(random_rna(len+11, probs)), 3, len)
test_copyto!(LongSequence{DNAAlphabet{4}}(undef, len+7), 5, f(random_dna(len+11)), 3, len)
test_copyto!(LongSequence{RNAAlphabet{4}}(undef, len+7), 5, f(random_rna(len+11)), 3, len)
test_copyto!(LongSequence{AminoAcidAlphabet}(undef, len+7), 5, f(random_aa(len+11)), 3, len)
end
end
end
@testset "Convert to same type" begin
function test_same_conversion(seq)
@test convert(typeof(seq), seq) === seq
end
test_same_conversion(random_dna(20))
test_same_conversion(random_rna(20))
test_same_conversion(random_aa(20))
end
@testset "Conversion between 2-bit and 4-bit encodings" begin
function test_conversion(A1, A2, seq)
@test convert(LongSequence{A1}, LongSequence{A2}(seq)) == LongSequence{A1}(seq)
end
test_conversion(DNAAlphabet{2}, DNAAlphabet{4}, "")
test_conversion(DNAAlphabet{4}, DNAAlphabet{2}, "")
test_conversion(RNAAlphabet{4}, RNAAlphabet{2}, "")
test_conversion(RNAAlphabet{2}, RNAAlphabet{4}, "")
test_conversion(DNAAlphabet{2}, DNAAlphabet{4}, "ACGT")
test_conversion(DNAAlphabet{4}, DNAAlphabet{2}, "ACGT")
test_conversion(RNAAlphabet{4}, RNAAlphabet{2}, "ACGU")
test_conversion(RNAAlphabet{2}, RNAAlphabet{4}, "ACGU")
test_conversion(DNAAlphabet{2}, DNAAlphabet{4}, "ACGT"^100)
test_conversion(DNAAlphabet{4}, DNAAlphabet{2}, "ACGT"^100)
test_conversion(RNAAlphabet{4}, RNAAlphabet{2}, "ACGU"^100)
test_conversion(RNAAlphabet{2}, RNAAlphabet{4}, "ACGU"^100)
# ambiguous nucleotides cannot be stored in 2-bit encoding
EncodeError = BioSequences.EncodeError
@test_throws EncodeError convert(LongSequence{DNAAlphabet{2}}, dna"AN")
@test_throws EncodeError convert(LongSequence{RNAAlphabet{2}}, rna"AN")
# test promotion
a = LongSequence{DNAAlphabet{2}}("ATCG")
b = LongSequence{DNAAlphabet{4}}("ATCG")
c = LongSequence{RNAAlphabet{2}}("AUCG")
d = LongSequence{RNAAlphabet{4}}("AUCG")
@test typeof(promote(a, b)) == Tuple{LongSequence{DNAAlphabet{4}},LongSequence{DNAAlphabet{4}}}
@test typeof(promote(c, d)) == Tuple{LongSequence{RNAAlphabet{4}},LongSequence{RNAAlphabet{4}}}
@test_throws ErrorException typeof(promote(a, d))
@test_throws ErrorException typeof(promote(a, b, d))
end
@testset "Conversion between RNA and DNA" begin
@test convert(LongRNA{4}, LongDNA{4}("ACGTN")) == rna"ACGUN"
@test convert(LongDNA{4}, LongRNA{4}("ACGUN")) == dna"ACGTN"
end
@testset "Conversion to Matrices" begin
dna = [dna"AAA", dna"TTT", dna"CCC", dna"GGG"]
dnathrow = [dna"AAA", dna"TTTAAA", dna"CCC", dna"GGG"]
rna = [rna"AAA", rna"UUU", rna"CCC", rna"GGG"]
rnathrow = [rna"AAA", rna"UUU", rna"CCCUUU", rna"GGG"]
prot = [aa"AMG", aa"AMG", aa"AMG", aa"AMG"]
sitemajdna = [
DNA_A DNA_A DNA_A
DNA_T DNA_T DNA_T
DNA_C DNA_C DNA_C
DNA_G DNA_G DNA_G
]
seqmajdna = [
DNA_A DNA_T DNA_C DNA_G
DNA_A DNA_T DNA_C DNA_G
DNA_A DNA_T DNA_C DNA_G
]
sitemajrna = [
RNA_A RNA_A RNA_A
RNA_U RNA_U RNA_U
RNA_C RNA_C RNA_C
RNA_G RNA_G RNA_G
]
seqmajrna = [
RNA_A RNA_U RNA_C RNA_G
RNA_A RNA_U RNA_C RNA_G
RNA_A RNA_U RNA_C RNA_G
]
sitemajnucint = [
0x01 0x01 0x01
0x08 0x08 0x08
0x02 0x02 0x02
0x04 0x04 0x04
]
seqmajnucint = [
0x01 0x08 0x02 0x04
0x01 0x08 0x02 0x04
0x01 0x08 0x02 0x04
]
sitemajaa = [
AA_A AA_M AA_G
AA_A AA_M AA_G
AA_A AA_M AA_G
AA_A AA_M AA_G
]
seqmajaa = [
AA_A AA_A AA_A AA_A
AA_M AA_M AA_M AA_M
AA_G AA_G AA_G AA_G
]
@test seqmatrix(dna, :site) == sitemajdna
@test seqmatrix(rna, :site) == sitemajrna
@test seqmatrix(prot, :site) == sitemajaa
@test seqmatrix(UInt8, dna, :site) == sitemajnucint
@test seqmatrix(UInt8, rna, :site) == sitemajnucint
@test seqmatrix(dna, :seq) == seqmajdna
@test seqmatrix(rna, :seq) == seqmajrna
@test seqmatrix(prot, :seq) == seqmajaa
@test seqmatrix(UInt8, dna, :seq) == seqmajnucint
@test seqmatrix(UInt8, rna, :seq) == seqmajnucint
@test seqmatrix([dna"", dna"", dna""], :site) == Matrix{DNA}(undef, (3, 0))
@test seqmatrix([dna"", dna"", dna""], :seq) == Matrix{DNA}(undef, (0, 3))
@test seqmatrix([rna"", rna"", rna""], :site) == Matrix{RNA}(undef, (3, 0))
@test seqmatrix([rna"", rna"", rna""], :seq) == Matrix{RNA}(undef, (0, 3))
@test seqmatrix(UInt8, [dna"", dna"", dna""], :site) == Matrix{UInt8}(undef, (3, 0))
@test seqmatrix(UInt8, [dna"", dna"", dna""], :seq) == Matrix{UInt8}(undef, (0, 3))
@test seqmatrix(UInt8, [rna"", rna"", rna""], :site) == Matrix{UInt8}(undef, (3, 0))
@test seqmatrix(UInt8, [rna"", rna"", rna""], :seq) == Matrix{UInt8}(undef, (0, 3))
@test_throws ArgumentError seqmatrix(dnathrow, :site)
@test_throws ArgumentError seqmatrix(rnathrow, :seq)
@test_throws ArgumentError seqmatrix(dna, :lol)
@test_throws MethodError seqmatrix(AminoAcid, dna, :site)
@test_throws ArgumentError seqmatrix(LongDNA{4}[], :site)
@test_throws ArgumentError seqmatrix(LongDNA{4}[], :seq)
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2208 | @testset "Find" begin
seq = dna"ACGNA"
@test findnext(isequal(DNA_A), seq, 1) == 1
@test findnext(isequal(DNA_C), seq, 1) == 2
@test findnext(isequal(DNA_G), seq, 1) == 3
@test findnext(isequal(DNA_N), seq, 1) == 4
@test findnext(isequal(DNA_T), seq, 1) === nothing
@test findnext(isequal(DNA_A), seq, 2) == 5
@test_throws BoundsError findnext(isequal(DNA_A), seq, 0)
@test findnext(isequal(DNA_A), seq, 6) === nothing
@test findprev(isequal(DNA_A), seq, 4) == 1
@test findprev(isequal(DNA_C), seq, 4) == 2
@test findprev(isequal(DNA_G), seq, 4) == 3
@test findprev(isequal(DNA_N), seq, 4) == 4
@test findprev(isequal(DNA_T), seq, 4) === nothing
@test findprev(isequal(DNA_G), seq, 2) === nothing
@test findprev(isequal(DNA_A), seq, 0) === nothing
@test_throws BoundsError findprev(isequal(DNA_A), seq, 6)
seq = dna"ACGNAN"
@test findfirst(isequal(DNA_A), seq) == 1
@test findfirst(isequal(DNA_N), seq) == 4
@test findfirst(isequal(DNA_T), seq) === nothing
@test findlast(isequal(DNA_A), seq) == 5
@test findlast(isequal(DNA_N), seq) == 6
@test findlast(isequal(DNA_T), seq) === nothing
# 0000000001111
# 1234567890123
seq = dna"NNNNNGATCGATC"
# Check default search.
@test findall(DNA_A, seq) == [7, 11]
@test findall(ExactSearchQuery(dna"A"), seq) == [7:7, 11:11]
# Check overlap key argument.
@test findall(ExactSearchQuery(dna"GATC", iscompatible), seq; overlap = false) == [1:4, 6:9, 10:13]
@test findall(ExactSearchQuery(dna"GATC", iscompatible), seq; overlap = true) == [1:4, 2:5, 6:9, 10:13]
# Check mapping of indices.
@test findall(DNA_A, seq, 7:11) == [7, 11]
@test findall(ExactSearchQuery(dna"A"), seq, 7:11) == [7:7, 11:11]
# Check empty return type.
@test findall(DNA_A, dna"GGGG") |> typeof == Vector{Int}
@test findall(ExactSearchQuery(dna"A"), dna"GGGG") |> typeof == Vector{UnitRange{Int}}
@test findall(isequal(DNA_A), dna"ACGTAC") == [1, 5]
@test findall(i -> true, aa"ACGTA") == collect(1:5)
@test findall(i -> true, aa"") == Int[]
@test findall(i -> i == AA_A, rna"AGCA") == Int[]
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2124 | @testset "Hash" begin
s = dna"ACGTACGT"
v = view(s, 1:lastindex(s))
for seq in [s, v]
@test isa(hash(seq), UInt64)
@test hash(seq) === hash(dna"ACGTACGT")
@test hash(seq) !== hash(seq[1:6])
@test hash(seq) !== hash(seq[1:7])
@test hash(seq) === hash(seq[1:8])
@test hash(seq[1:4]) === hash(dna"ACGT")
@test hash(seq[2:4]) === hash(dna"CGT")
@test hash(seq[3:4]) === hash(dna"GT")
@test hash(seq[4:4]) === hash(dna"T")
@test hash(seq[5:8]) === hash(dna"ACGT")
end
@test hash(s) == hash(v)
@test hash(s[2:4]) == hash(v[2:4])
for i in 1:4
s1 = LongDNA{4}("A"^(i-1))
s2 = LongDNA{4}("A"^i)
@test hash(s1) != hash(s2)
v1 = view(s2, 1:lastindex(s2) - 1)
v2 = view(s2, 1:lastindex(s2))
@test hash(v1) != hash(v2)
end
for n in [1, 2, 3, 6, 8, 9, 11, 15, 16, 20], seq in [dna"A", dna"AC", dna"ACG", dna"ACGT", dna"ACGTN"]
@test hash(seq^n) === hash((dna"" * seq^n)[1:end])
@test hash(seq^n) === hash((dna"T" * seq^n)[2:end])
@test hash(seq^n) === hash((dna"TT" * seq^n)[3:end])
@test hash(seq^n) === hash((dna"TTT" * seq^n)[4:end])
@test hash(seq^n) === hash((dna"TTTT" * seq^n)[5:end])
@test hash(seq^n) === hash((seq^n * dna"" )[1:end ])
@test hash(seq^n) === hash((seq^n * dna"T" )[1:end-1])
@test hash(seq^n) === hash((seq^n * dna"TT" )[1:end-2])
@test hash(seq^n) === hash((seq^n * dna"TTT" )[1:end-3])
@test hash(seq^n) === hash((seq^n * dna"TTTT")[1:end-4])
end
@test hash(rna"AAUU") === hash(rna"AAUU")
@test hash(rna"AAUUAA"[3:5]) === hash(rna"UUA")
@test hash(aa"MTTQAPMFTQPLQ") === hash(aa"MTTQAPMFTQPLQ")
@test hash(aa"MTTQAPMFTQPLQ"[5:10]) === hash(aa"APMFTQ")
# Test hash of longer view to engange some inner loops
seq = randdnaseq(250)
@test hash(seq[33:201]) == hash(view(seq, 33:201))
@test hash(seq[23:201]) == hash(view(seq, 23:201))
@test hash(seq[37:249]) == hash(view(seq, 37:249))
@test hash(seq[50:250]) == hash(view(seq, 50:250))
@test hash(seq[10:232]) == hash(view(seq, 10:232))
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 768 | @testset "Iteration" begin
dna_seq = dna"ACTG"
dna_vec = [DNA_A, DNA_C, DNA_T, DNA_G]
@test all([nt === dna_vec[i] for (i, nt) in enumerate(dna_seq)])
rna_seq = rna"ACUG"
rna_vec = [RNA_A, RNA_C, RNA_U, RNA_G]
@test all([nt === rna_vec[i] for (i, nt) in enumerate(rna_seq)])
aa_seq = aa"ARNPS"
aa_vec = [AA_A, AA_R, AA_N, AA_P, AA_S]
@test all([aa == aa_vec[i] for (i, aa) in enumerate(aa_seq)])
@test iterate(dna_seq) == iterate(dna_seq, 1) == (DNA_A, 2)
@test iterate(dna_seq, 2) == (DNA_C, 3)
@test iterate(dna_seq, 3) == (DNA_T, 4)
@test iterate(dna_seq, 4) == (DNA_G, 5)
@test iterate(dna_seq, -1) == nothing
@test iterate(dna_seq, 0) == nothing
@test iterate(dna_seq, 5) == nothing
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 4724 | @testset "Mutability" begin
@testset "setindex!" begin
s = dna"ACGT"
s[1] = DNA_A
@test s == dna"ACGT"
s[1] = DNA_C
@test s == dna"CCGT"
s[2] = DNA_T
@test s == dna"CTGT"
s[4] = DNA_A
@test s == dna"CTGA"
@test_throws BoundsError s[0]
@test_throws BoundsError s[5]
s = dna"ACGTACGT"
s[3:5] = dna"AAA"
@test s == dna"ACAAACGT"
s[3:5] = dna"TTT"
@test s == dna"ACTTTCGT"
s[1:8] = dna"CCCCCCCC"
@test s == dna"CCCCCCCC"
s[:] = repeat([DNA_G], length(s))
@test s == dna"GGGGGGGG"
@test_throws BoundsError s[0:3]
@test_throws BoundsError s[5:10]
s = dna"ACGTACGT"
s[[1,2,3]] = dna"TTT"
@test s == dna"TTTTACGT"
s[[1,5,8]] = dna"CCC"
@test s == dna"CTTTCCGC"
@test_throws BoundsError s[[3,9]] = DNA_A
s = dna"ACGT"
s[[true, false, false, true]] = [DNA_G, DNA_G]
@test s == dna"GCGG"
s[trues(4)] = repeat([DNA_A], 4)
@test s == dna"AAAA"
@test_throws BoundsError s[[true, false, false]] = dna"G"
@test_throws BoundsError s[[true, false, false, false, true]] = dna"GG"
s = dna"ACGTACGT"
s[2:3] = dna"AA"
@test s == dna"AAATACGT"
s[7:8] = dna"CC"
@test s == dna"AAATACCC"
s[:] = dna"AACCGGTT"
@test s == dna"AACCGGTT"
@test_throws BoundsError s[0:1] = dna"AA"
@test_throws DimensionMismatch s[3:4] = dna"A"
s = dna"ACGTACGT"
s[[1,4]] = dna"TA"
@test s == dna"TCGAACGT"
s[[2,3,5]] = dna"CAT"
@test s == dna"TCAATCGT"
@test_throws BoundsError s[[1,2,9]] = dna"AAA"
@test_throws DimensionMismatch s[[1,2,8]] = dna"AA"
s = dna"ACGT"
s[[true,false,true,false]] = dna"TT"
@test s == dna"TCTT"
s[trues(4)] = dna"AAAA"
@test s == dna"AAAA"
@test_throws BoundsError s[[true,false,true]] = dna"TT"
@test_throws DimensionMismatch s[[true,false,true,true]] = dna"TT"
end
@testset "resize!" begin
seq = dna""
resize!(seq, 100)
@test length(seq) == 100
resize!(seq, 200)
@test length(seq) == 200
seq1 = seq[3:198]
resize!(seq1, 55)
@test length(seq1) == 55
resize!(seq, 10)
@test length(seq) == 10
@test_throws ArgumentError resize!(seq, -1)
end
@testset "empty!" begin
seq = dna"ACG"
@test empty!(seq) == dna""
@test length(seq) == 0
end
@testset "push!" begin
seq = dna""
@test push!(seq, DNA_A) == dna"A"
@test push!(seq, DNA_C) == dna"AC"
@test seq == dna"AC"
end
@testset "pushfirst!" begin
seq = dna""
@test pushfirst!(seq, DNA_A) == dna"A"
@test pushfirst!(seq, DNA_C) == dna"CA"
@test seq == dna"CA"
end
@testset "pop!" begin
seq = dna"ACGT"
@test pop!(seq) === DNA_T
@test seq == dna"ACG"
@test pop!(seq) === DNA_G
@test seq == dna"AC"
@test_throws ArgumentError pop!(dna"")
end
@testset "popfirst!" begin
seq = dna"ACGT"
@test popfirst!(seq) === DNA_A
@test seq == dna"CGT"
@test popfirst!(seq) === DNA_C
@test seq == dna"GT"
@test_throws ArgumentError popfirst!(dna"")
end
@testset "insert!" begin
seq = dna"ACGT"
@test insert!(seq, 2, DNA_G) == dna"AGCGT"
@test insert!(seq, 5, DNA_A) == dna"AGCGAT"
@test_throws BoundsError insert!(seq, 10, DNA_T)
end
@testset "deleteat!" begin
seq = dna"ACGT"
@test deleteat!(seq, 1) == dna"CGT"
@test deleteat!(seq, 2) == dna"CT"
@test_throws BoundsError deleteat!(seq, 10)
seq = dna"ACGTACGT"
@test deleteat!(seq, 3:5) == dna"ACCGT"
@test_throws BoundsError deleteat!(seq, 10:12)
end
@testset "append!" begin
seq = dna""
@test append!(seq, dna"A") == dna"A"
@test append!(seq, dna"ACG") == dna"AACG"
end
@testset "copyto!" begin
seq = dna"GGG"
@test copyto!(seq, dna"ACG") == dna"ACG"
@test copyto!(seq, dna"TTA") == dna"TTA"
seq = dna"TCCC"
@test copyto!(seq, 2, dna"TT", 1, 2) == dna"TTTC"
seq = dna"TCCC"
@test copyto!(seq, 2, dna"TT", 1, 1) == dna"TTCC"
seq = dna"ACGT"
@test copyto!(seq, seq) == dna"ACGT"
@test copyto!(seq, 1, seq, 3, 2) == dna"GTGT"
seq = dna"ACGT"
@test copyto!(seq, 3, seq, 1, 2) == dna"ACAC"
end
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 2481 | @testset "Predicates" begin
# ispalindromic
@test ispalindromic(dna"")
@test !ispalindromic(dna"A")
@test !ispalindromic(dna"C")
@test ispalindromic(dna"AT")
@test ispalindromic(dna"CG")
@test !ispalindromic(dna"AC")
@test !ispalindromic(dna"TT")
@test ispalindromic(dna"ANT")
@test ispalindromic(dna"ACGT")
@test !ispalindromic(dna"ACNT")
@test ispalindromic(rna"")
@test !ispalindromic(rna"A")
@test !ispalindromic(rna"C")
@test ispalindromic(rna"AU")
@test ispalindromic(rna"CG")
@test !ispalindromic(rna"AC")
@test !ispalindromic(rna"UU")
@test ispalindromic(rna"ANU")
@test ispalindromic(rna"ACGU")
@test !ispalindromic(rna"ACNU")
@test_throws Exception ispalindromic(aa"PQ")
# hasambiguity
@test !hasambiguity(dna"")
@test !hasambiguity(dna"A")
@test hasambiguity(dna"N")
@test !hasambiguity(dna"ACGT")
@test hasambiguity(dna"ANGT")
@test !hasambiguity(rna"")
@test !hasambiguity(rna"A")
@test hasambiguity(rna"N")
@test !hasambiguity(rna"ACGU")
@test hasambiguity(rna"ANGU")
@test !hasambiguity(aa"")
@test !hasambiguity(aa"A")
@test !hasambiguity(aa"P")
@test hasambiguity(aa"B")
@test hasambiguity(aa"X")
@test !hasambiguity(aa"ARNDCQEGHILKMFPSTWYVOU")
@test hasambiguity(aa"ARXDCQEGHILKMFPSTWYVOU")
# isrepetitive
@test isrepetitive(dna"")
@test !isrepetitive(dna"", 1)
@test isrepetitive(dna"A")
@test isrepetitive(dna"A", 1)
@test isrepetitive(dna"AAA")
@test !isrepetitive(dna"ACGT", 2)
@test isrepetitive(dna"AAGT", 2)
@test isrepetitive(dna"ACCG", 2)
@test isrepetitive(dna"ACGG", 2)
@test !isrepetitive(dna"ACGTCCGT", 3)
@test isrepetitive(dna"ACGCCCGT", 3)
@test isrepetitive(rna"")
@test !isrepetitive(rna"", 1)
@test isrepetitive(rna"A")
@test isrepetitive(rna"A", 1)
@test isrepetitive(rna"AAA")
@test !isrepetitive(rna"ACGU", 2)
@test isrepetitive(rna"AAGU", 2)
@test isrepetitive(rna"ACCG", 2)
@test isrepetitive(rna"ACGG", 2)
@test !isrepetitive(rna"ACGUCCGU", 3)
@test isrepetitive(rna"ACGCCCGU", 3)
@test isrepetitive(aa"")
@test !isrepetitive(aa"PGQQ")
@test isrepetitive(aa"PGQQ", 2)
@test !isrepetitive(aa"PPQQ", 3)
@test isrepetitive(aa"PPPQQ", 3)
# iscanonical
@test iscanonical(dna"TCA")
@test !iscanonical(dna"TGA")
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 956 | @testset "Print" begin
buf = IOBuffer()
print(buf, dna"")
@test String(take!(buf)) == ""
print(buf, dna"ACGTN")
@test String(take!(buf)) == "ACGTN"
print(buf, rna"ACGUN")
@test String(take!(buf)) == "ACGUN"
print(buf, dna"A"^100)
@test String(take!(buf)) == "A"^100
print(buf, dna"G"^60, width=0)
@test String(take!(buf)) == "G"^60
print(buf, dna"A"^60, width=-5)
@test String(take!(buf)) == "A"^60
print(buf, dna"A"^100, width=70)
@test String(take!(buf)) == string("A"^70, '\n', "A"^30)
print(buf, dna"A"^100, width=50)
@test String(take!(buf)) == string("A"^50, '\n', "A"^50)
print(buf, dna"A"^4100, width=100)
@test String(take!(buf)) == repeat("A"^100 * '\n', 40) * "A"^100
end
@testset "Show" begin
buf = IOBuffer()
show(buf, dna"")
@test String(take!(buf)) == "< EMPTY SEQUENCE >"
show(buf, dna"ATCG")
@test String(take!(buf)) == "ATCG"
end
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
|
[
"MIT"
] | 3.1.6 | 6fdba8b4279460fef5674e9aa2dac7ef5be361d5 | code | 8756 | # Note: This test suite has many hard coded values in it.
# While that is normally a bad idea, we need to guarantee reproducible results
# when using the same seed.
global SEED = 0 # Do not change this
struct MyAlphabet <: Alphabet end
@testset "Random LongSequences" begin
function test_sampler(sampler, seed, elements, firstten, T)
rng = StableRNG(seed)
sampled1 = [rand(rng, sampler) for i in 1:1000]
sampled2 = rand(StableRNG(seed), sampler, 1000)
@test sampled1 == sampled2
@test Set(sampled1) == Set(T[convert(T, i) for i in elements])
@test eltype(sampler) == T
@test eltype(firstten) == T
@test rand(StableRNG(seed), sampler, 10) == firstten
end
function test_isseq(seq, alphabettype, len)
@test seq isa LongSequence{alphabettype}
@test length(seq) == len
end
@testset "SamplerUniform" begin
# Cannot instantiate with empty collection
@test_throws ArgumentError sampler = SamplerUniform{DNA}(DNA[])
# DNA sampler with DNA array
sampler = SamplerUniform{DNA}([DNA_A, DNA_C, DNA_G, DNA_W])
firstten = DNA[DNA_C, DNA_W, DNA_G, DNA_C, DNA_C, DNA_C, DNA_C, DNA_A, DNA_A, DNA_A]
test_sampler(sampler, SEED, sampler.elems, firstten, DNA)
# Now RNA sampler from DNA array
sampler = SamplerUniform{RNA}([DNA_A, DNA_C, DNA_G, DNA_W])
firstten = RNA[RNA_C, RNA_W, RNA_G, RNA_C, RNA_C, RNA_C, RNA_C, RNA_A, RNA_A, RNA_A]
test_sampler(sampler, SEED, sampler.elems, firstten, RNA)
# Cannot make AA sampler from DNA
@test_throws MethodError s = SamplerUniform{AminoAcid}([DNA_A, DNA_C, DNA_G, DNA_W])
# Automatically infer eltype
sampler1 = SamplerUniform{DNA}([DNA_A, DNA_C])
sampler2 = SamplerUniform([DNA_A, DNA_C])
@test typeof(sampler2) == SamplerUniform{DNA}
@test eltype(sampler1) == eltype(sampler2)
# Can also infer abstract eltype
sampler3 = SamplerUniform([DNA_A, RNA_A])
@test eltype(sampler3) == typejoin(DNA, RNA)
sampler = SamplerUniform{RNA}([DNA_A, DNA_C, DNA_G, DNA_W])
@test typeof(rand(sampler)) == RNA
end # SamplerUniform
@testset "SamplerWeighted" begin
# Must have one less weight than elements
@test_throws ArgumentError SamplerWeighted{DNA}([DNA_A], [0.5])
@test_throws ArgumentError SamplerWeighted{DNA}([DNA_A, DNA_C], [0.5, 0.5])
@test_throws ArgumentError SamplerWeighted{DNA}([DNA_A], [0.5, 0.5])
# Weights cannot exceed one
@test_throws ArgumentError SamplerWeighted{DNA}([DNA_A, DNA_C], [1.1])
@test_throws ArgumentError SamplerWeighted{DNA}([DNA_A, DNA_C, DNA_G], [1.00001, 0.0])
# Weights cannot be negative
@test_throws ArgumentError SamplerWeighted{DNA}([DNA_A, DNA_C, DNA_G], [0.5, -0.001])
@test_throws ArgumentError SamplerWeighted{DNA}([DNA_A, DNA_C, DNA_A], [1.1, -0.2])
# Weights always sum to one after instantiation
s = SamplerWeighted{DNA}([DNA_A, DNA_C, DNA_G, DNA_W], [0.03, 0.2, 0.7])
@test sum(s.probs) == 1.0
s = SamplerWeighted{DNA}([DNA_A], [])
@test sum(s.probs) == 1.0
s = SamplerWeighted{DNA}([DNA_A, DNA_C], [1.0])
@test sum(s.probs) == 1.0
s = SamplerWeighted{DNA}([DNA_A, DNA_C, DNA_G], [0.03, 0.20000001])
@test sum(s.probs) == 1.0
sampler = SamplerWeighted{DNA}([DNA_N, DNA_C, DNA_W, DNA_T], [0.1, 0.2, 0.3])
firstten = DNA[DNA_C, DNA_N, DNA_T, DNA_T, DNA_T, DNA_N, DNA_W, DNA_C, DNA_W, DNA_N]
test_sampler(sampler, 0, sampler.elems, firstten, DNA)
sampler = SamplerWeighted{RNA}([DNA_N, DNA_C, DNA_W, DNA_T], [0.15, 0.5, 0.2])
firstten = RNA[RNA_C, RNA_N, RNA_U, RNA_W, RNA_U, RNA_N, RNA_C, RNA_C, RNA_C, RNA_N]
test_sampler(sampler, 0, sampler.elems, firstten, RNA)
@test_throws MethodError s = SamplerWeighted{AminoAcid}([DNA_A, DNA_C], [0.1])
# Casual test to see that it can use the global RNG automatically
sampler = SamplerWeighted{RNA}([DNA_N, DNA_C, DNA_W, DNA_T], [0.15, 0.5, 0.2])
@test typeof(rand(sampler)) == RNA
end # SamplerWeighted
@testset "randseq Sampler" begin
# Cannot instantiate < 0-length seq
@test_throws ArgumentError randseq(DNAAlphabet{2}(), SamplerUniform(dna"ACG"), -1)
@test_throws ArgumentError randseq(AminoAcidAlphabet(), SamplerUniform(aa"VTW"), -1)
@test_throws ArgumentError randseq(RNAAlphabet{4}(), SamplerWeighted(dna"ACG", ones(2)/3), -1)
# CAN make empty sequence with mismatching alphabets
# Or with matching alphabets
@test randseq(DNAAlphabet{2}(), SamplerUniform(aa"AV"), 0) == LongSequence{DNAAlphabet{2}}()
@test randseq(DNAAlphabet{2}(), SamplerUniform(rna"U"), 2) == LongSequence{DNAAlphabet{2}}(dna"TT")
# Cannot make nonzero sequence with mismatching alphabets
@test_throws MethodError randseq(RNAAlphabet{4}(), SamplerUniform(aa"AV", 1))
@test_throws MethodError randseq(AminoAcidAlphabet(), SamplerUniform(dna"ACG", 10))
# A few samplings
sampler = SamplerUniform(aa"TVVWYAEDK")
@test randseq(StableRNG(SEED), AminoAcidAlphabet(), sampler, 10) == aa"VEVTKTTADY"
sampler = SamplerUniform(dna"TGAWYKN")
@test randseq(StableRNG(SEED), DNAAlphabet{4}(), sampler, 10) == dna"GWNGGGKTTT"
sampler = SamplerWeighted(rna"UGCMKYN", [0.1, 0.05, 0.2, 0.15, 0.15, 0.2])
@test randseq(StableRNG(SEED), DNAAlphabet{4}(), sampler, 10) == dna"CTNYNTKCMT"
# Casual tests to see that it can use the global RNG automatically
sampler = SamplerUniform(aa"TVVWYAEDK")
seq = randseq(AminoAcidAlphabet(), sampler, 25)
test_isseq(seq, AminoAcidAlphabet, 25)
sampler = SamplerWeighted(rna"UGCMKYN", [0.1, 0.05, 0.2, 0.15, 0.15, 0.2])
seq = randseq(RNAAlphabet{4}(), sampler, 25)
test_isseq(seq, RNAAlphabet{4}, 25)
sampler = SamplerUniform(dna"AGC")
seq = randseq(DNAAlphabet{2}(), sampler, 25)
test_isseq(seq, DNAAlphabet{2}, 25)
# Test that rand! correctly works
seq = LongDNA{4}("ATGCTAMWKSSWKHHNNNATVVCGATADGCTTWWSYKMMNKATCGACTAYSWTACCCGATC")
Random.rand!(seq)
@test Set(seq) == Set(symbols(DNAAlphabet{2}()))
Random.rand!(seq, sampler)
@test Set(seq) == Set([DNA_A, DNA_G, DNA_C])
end # randseq Sampler
@testset "randseq" begin
sampler = SamplerUniform(aa"ACDEFGHIKLMNPQRSTVWY")
automatic = randseq(StableRNG(SEED), AminoAcidAlphabet(), 1000)
manual = randseq(StableRNG(SEED), AminoAcidAlphabet(), sampler, 1000)
@test automatic == manual
@test Set(automatic) == Set(aa"ACDEFGHIKLMNPQRSTVWY")
@test randseq(StableRNG(SEED), DNAAlphabet{4}(), 20) == dna"CTCTTCGTATGCCGTACCGT"
@test randseq(StableRNG(SEED), DNAAlphabet{2}(), 20) == dna"CATCCGCTCCTAGGCCATTT"
@test randseq(StableRNG(SEED), RNAAlphabet{4}(), 20) == rna"CUCUUCGUAUGCCGUACCGU"
@test randseq(StableRNG(SEED), RNAAlphabet{2}(), 20) == rna"CAUCCGCUCCUAGGCCAUUU"
# Casual tests to see that it can use the global RNG automatically
seq = randseq(DNAAlphabet{2}(), 100)
test_isseq(seq, DNAAlphabet{2}, 100)
seq = randseq(RNAAlphabet{4}(), 100)
test_isseq(seq, RNAAlphabet{4}, 100)
seq = randseq(AminoAcidAlphabet(), 100)
test_isseq(seq, AminoAcidAlphabet, 100)
end # randseq
@testset "Simple constructors" begin
manual = randseq(StableRNG(SEED), AminoAcidAlphabet(), 100)
automatic = randaaseq(StableRNG(SEED), 100)
@test automatic == manual
manual = randseq(StableRNG(SEED), DNAAlphabet{4}(), 100)
automatic = randdnaseq(StableRNG(SEED), 100)
@test automatic == manual
manual = randseq(StableRNG(SEED), RNAAlphabet{4}(), 100)
automatic = randrnaseq(StableRNG(SEED), 100)
@test automatic == manual
# Casual tests to see that it can use the global RNG automatically
seq = randdnaseq(10)
test_isseq(seq, DNAAlphabet{4}, 10)
seq = randrnaseq(10)
test_isseq(seq, RNAAlphabet{4}, 10)
seq = randaaseq(10)
test_isseq(seq, AminoAcidAlphabet, 10)
end # simple constructors
@testset "Custom alphabet" begin
Base.length(A::MyAlphabet) = 6
BioSequences.symbols(A::MyAlphabet) = (DNA_A, DNA_C, DNA_G, DNA_T, RNA_U, DNA_N)
BioSequences.BitsPerSymbol(A::MyAlphabet) = BioSequences.BitsPerSymbol{8}()
BioSequences.encode(A::MyAlphabet, x::DNA) = reinterpret(UInt8, x)
BioSequences.encode(A::MyAlphabet, x::RNA) = reinterpret(UInt8, x) | 0x10
Base.eltype(A::MyAlphabet) = NucleicAcid
function BioSequences.decode(A::MyAlphabet, x::UInt64)
uint = UInt8(x)
if uint & 0x10 == 0x10
return reinterpret(RNA, uint & 0x0f)
else
return reinterpret(DNA, uint)
end
end
seq = randseq(MyAlphabet(), 1000)
@test typeof(seq) == LongSequence{MyAlphabet}
@test length(seq) == 1000
@test Set(seq) == Set(symbols(MyAlphabet()))
end # Custom Alphabet
end # Entire Random LongSequences testset
| BioSequences | https://github.com/BioJulia/BioSequences.jl.git |
Subsets and Splits