kalmarek

using Revise
using Arblib
import MutableArithmetics
const MA = MutableArithmetics
using LinearAlgebra

MA.mutability(::Type{Arb}) = MA.IsMutable()

MA.mutable_copy(x::Arb) = set!(Arb(prec=precision(x)), x)

kalmarek

Fast paced github setting up guide

Situation

You have your own repository on github.com/username/MyPackage.jl with a julia package and would like to write and deploy documentation for it using Documenter.jl.

Step 0 - Prerequisites

Install DocumenterTools.jl:

kalmarek

Fast paced github setting up guide

Situation

You have your own repository on github.com/username/MyPackage.jl with a julia package and would like to write and deploy documentation for it using Documenter.jl.

Step 0 - Prerequisites

Install DocumenterTools.jl:

kalmarek

struct BacktrackSearch{V<:AbstractVector, VI<:AbstractVector, VS<:AbstractVector, O, A}
    nodes::V
    iterators::VI
    states::VS
    oracle_descend::O
    node_accept::A
end

"""
BacktrackSearch(iterators; oracle_descend, node_accept)

kalmarek

import Arblib: arb_struct, arf_struct, @libarb, ArbLike

struct arf_interval
    lo::arf_struct
    hi::arf_struct

    # function arf_interval()
    #     v = new()
    #     init!(v)
    #     finalizer(clear!, v)

kalmarek

module Monoids

using KnuthBendix
import KnuthBendix: Alphabet, AbstractWord, LenLex, alphabet

export Alphabet, FreeMonoid, gens

# this should go to KnuthBendix.jl
Base.convert(::Type{Word{I}}, v::AbstractVector{<:Integer}) where I = Word{I}(v)

kalmarek

struct Order{I} <: Integer
    val::I

    Order{I}(n::Integer) where I<:Integer = (n > 0 ? new{I}(n) : throw(DomainError(0, "invalid order")))
    Order{I}(::Val{Inf}) where I<:Integer = new{I}(0)
end

Order(n::I) where I<:Integer = Order{I}(n)
Order(v::Val{Inf}) = Order{Int}(v)

kalmarek

using Statistics
using Random
using LinearAlgebra

function Wstatistic(X, sw_coeffs)
    @boundscheck @assert length(X) == length(sw_coeffs)
    @assert issorted(X)
    @assert last(X) - first(X) > length(X) * eps(eltype(X)) "Data seems to be constant!"

    µ = mean(X)

kalmarek

using Groups
using KnuthBendix

import Groups: ϱ, λ

KnuthBendix.Word(A::Alphabet{T}, v::AbstractVector{T}) where {T} = Word([A[s] for s in v])
invof(A::Alphabet{T}, a::T) where {T} = A[-A[a]]
comm(A::Alphabet, x::S, y::S) where {S<:Groups.GSymbol} =
    Word([A[x], A[y], A[invof(A, x)], A[invof(A, y)]])

kalmarek

# using Pkg
# Pkg.activate(joinpath(@__DIR__, ".."))

using PropertyT
using PropertyT.GroupRings
using PropertyT.Groups
using PropertyT.AbstractAlgebra
using PropertyT.JuMP

using PropertyT.IntervalArithmetic