NeuroAnalyzer.jl documentation

na_info()

Show NeuroAnalyzer and imported packages versions.

Arguments

Nothing

Returns

Nothing

na_set_colors(value)

Change colors preference.

Arguments

• value::Bool: value

Returns

Nothing

na_set_exclude_bads(value)

Change exclude_bads preference.

Arguments

• value::Bool: value

Returns

Nothing

na_set_prefs(; use_gpu, progress_bar, verbose, exclude_bads, colors)

Set and save NeuroAnalyzer preferences.

Arguments

• use_gpu::Bool
• progress_bar::Bool
• verbose::Bool
• exclude_bads::Bool
• colors::Bool

Returns

Nothing

na_set_progress_bar(value)

Change progress_bar preference.

Arguments

• value::Bool: value

Returns

Nothing

na_set_use_gpu(value)

Change use_gpu preference.

Arguments

• value::Bool: value

Returns

Nothing

na_set_verbose(value)

Change verbose preference.

Arguments

• value::Bool: value

Returns

Nothing

na_version()

Convert NeuroAnalyzer version to string.

Arguments

Nothing

Returns

• VER::String

na_plugins_install(plugin)

Install NeuroAnalyzer plugin from remote Git repository or from local .TAR.GZ/.ZIP archive (requires unzip or tar command to be available).

Arguments

• plugin::String: plugin Git repository URL or file name (with full path)

Returns

Nothing

na_plugins_list()

List NeuroAnalyzer plugins.

Arguments

Nothing

Returns

Nothing

na_plugins_reload()

Reload NeuroAnalyzer plugins.

Arguments

Nothing

Returns

Nothing

na_plugins_remove(plugin)

Remove NeuroAnalyzer plugin.

Arguments

• plugin::String: plugin name

Returns

Nothing

na_plugins_update(plugin)

Update NeuroAnalyzer plugin(s).

Arguments

• plugin::String: plugin to update; if empty, update all

Returns

Nothing

size(obj)

Return size of the object data.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• s::Tuple{Int64, Int64, Int64}

size(obj, n)

Return size of the object data.

Arguments

• obj::NeuroAnalyzer.NEURO
• d::Int64: compute size along dimension d

Returns

• s::Int64

add_component(obj; <keyword arguments>)

Add component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name
• v::Any: component value

Returns

• obj_new::NeuroAnalyzer.NEURO

add_component!(obj; <keyword arguments>)

Add component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name
• v::Any: component value

Returns

Nothing

add_note(obj; <keyword arguments>)

Add recording note to the object header.

Arguments

• obj::NeuroAnalyzer.NEURO
• note::String

Returns

• obj_new::NeuroAnalyzer.NEURO

add_note!(obj; <keyword arguments>)

Add recording note to the object header.

Arguments

• obj::NeuroAnalyzer.NEURO
• note::String

Returns

Nothing

aff_mni2tal(pts)

Convert MNI coordinates to Talairach coordinates: redo the affine transform of Talairach coordinates.

Arguments

• pts::Vector{<:Number}: MNI X, Y, Z coordinates

Returns

• t::Vector{Float64}: Talairach X, Y, Z coordinates

Source

https://www.brainmap.org/training/BrettTransform.html

aff_tal2mni(pts)

Convert Talairach coordinates to MNI coordinates: do the affine transform of MNI coordinates.

Arguments

• pts::Vector{<:Number}: Talairach X, Y, Z coordinates

Returns

• t::Vector{Float64}: MNI X, Y, Z coordinates

Source

https://www.brainmap.org/training/BrettTransform.html

apply(obj; <keyword arguments>)

Apply custom function.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Union{String, Vector{String}, Regex}: channel name or list of channel names
• f::String: function to be applied, e.g. f="mean(obj, dims=3)"; OBJ signal is given using variable obj here.

Returns

• out::Array{Float64, 3}

areduce(a, f; <keyword arguments>)

Reduce an array at indices of a vector being multiplications of a constant. Useful e.g. for simplifying values across frequencies, when the number of frequencies (and thus values) is high.

Arguments

• a::AbstractArray: e.g. signal data
• f::AbstractVector: e.g. frequencies
• n::Float64=0.5: reduce at multiplications of this value

Returns

• a_new::Array{eltype(a), ndims(a)}
• f_new::Vector{eltype(f)}

arr2mat(x)

Reshape array into matrix.

Arguments

• x::AbstractArray

Returns

• m::AbstractMatrix

band_frq(obj, band)

Return band frequency limits.

Arguments

• obj::NeuroAnalyzer.NEURO
• band::Symbol: band range name:
  • :list
  • :total
  • :delta: 0.1 - 4.0 Hz
  • :theta: 4.0 - 8.0 Hz
  • :alpha: 8.0 - 13.0 Hz
  • :alpha_lower: 8.0 - 10.5 Hz
  • :alpha_higher: 10.5 - 13.0 Hz
  • :beta: 14.0 - 30.0 Hz
  • :beta_lower: 14.0 - 25.0 Hz
  • :beta_higher: 25.0 - 30.0 Hz
  • :gamma: 30.0 - 150.0 Hz
  • :gamma_1: 30.0 - 40.0 Hz
  • :gamma_2: 40.0 - 50.0 Hz
  • :gamma_lower: 30.0 - 80.0 Hz
  • :gamma_higher: 80.0 - 150.0 Hz

Returns

• bf::Tuple{Float64, Float64}

band_frq(fs, band)

Return band frequency limits.

Arguments

• fs::Int64: sampling rate
• band::Symbol: band range name:
  • :list
  • :total
  • :delta: 0.1 - 4.0 Hz
  • :theta: 4.0 - 8.0 Hz
  • :alpha: 8.0 - 13.0 Hz
  • :alpha_lower: 8.0 - 10.5 Hz
  • :alpha_higher: 10.5 - 13.0 Hz
  • :beta: 14.0 - 30.0 Hz
  • :beta_lower: 14.0 - 25.0 Hz
  • :beta_higher: 25.0 - 30.0 Hz
  • :gamma: 30.0 - 150.0 Hz
  • :gamma_1: 30.0 - 40.0 Hz
  • :gamma_2: 40.0 - 50.0 Hz
  • :gamma_lower: 30.0 - 80.0 Hz
  • :gamma_higher: 80.0 - 150.0 Hz

Returns

• bf::Tuple{Float64, Float64}

cextrema(x)

Return extreme values of the complex vector.

Arguments

• x::Vector{ComplexF64}

Returns

Tuple containing:

• cmax::ComplexF64
• cmin::ComplexF64

channels_cluster(obj; <keyword arguments>)

Return channels belonging to a cluster of channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• cluster::Symbol: available clusters are:
  • :f1: left frontal (F1, F3, F5, F7, AF3, AF7)
  • :f2: right frontal (F2, F4, F6, F8, AF4, AF8)
  • :t1: left temporal (C3, C5, T7, FC3, FC5, FT7)
  • :t2: right temporal (C4, C6, T8, FC4, FC6, FT8)
  • :c1: anterior central (Cz, C1, C2, FC1, FC2, FCz)
  • :c2: posterior central (Pz, P1, P2, CP1, CP2, CPz)
  • :p1: left parietal (P3, P5, P7, CP3, CP5, TP7)
  • :p2: right parietal (P4, P6, P8, CP4, CP6, TP8)
  • :o: occipital (Oz, O1, O2, POz, PO3, PO4)

Returns

• ch::Vector{Int64}: channel numbers

channel_info(obj; <keyword arguments>)

Show channel info.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::Int64

Returns

Nothing

channel_order(obj)

Return channel order of the object.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• co::Vector{Int64}

channel_pick(obj; <keyword arguments>)

Return set of channel indices corresponding to a set of electrodes ("pick", e.g. left or frontal electrodes).

Arguments

• obj::NeuroAnalyzer.NEURO
• p::Vector{Symbol}: pick of electrodes; picks may be combined, e.g. [:left, :frontal]
  • :central (or :c)
  • :left (or :l)
  • :right (or :r)
  • :frontal (or :f)
  • :temporal (or :t)
  • :parietal (or :p)
  • :occipital (or :o)

Returns

• channels::Vector{Int64}: channel numbers

chtypes(obj)

Return channel types.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• cht::Vector{String}

cmax(x)

Return maximum value of the complex vector.

Arguments

• x::Vector{ComplexF64}

Returns

• cmax::ComplexF64

cmin(x)

Return minimum value of the complex vector.

Arguments

• x::Vector{ComplexF64}

Returns

• cmin::ComplexF64

component_type(obj, c)

Return component data type.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name

Return

• c_type::DataType

cums(signal)

Calculate cumulative sum of a 3-dimensional array.

Arguments

• signal::Array{<:Real, 3}

Returns

• signal_cs::Array{Float64, 3}

cwtfrq(s; <keyword arguments>)

Return mean frequencies of a collection of analytic or real wavelets for a given signal.

Arguments

• s::AbstractVector
• fs::Int64: sampling rate
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=2), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• f::Vector{Float64}: frequencies

cwtfrq(s; <keyword arguments>)

Return mean frequencies of a collection of analytic or real wavelets for a given signal.

Arguments

• s::AbstractArray
• fs::Int64: sampling rate
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=2), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• f::Vector{Float64}: frequencies

cwtfrq(obj; <keyword arguments>)

Return mean frequencies of a collection of analytic or real wavelets for a given signal.

Arguments

• obj::NeuroAnalyzer.NEURO
• wt::T where {T <: CWT}=wavelet(Morlet(2π), β=2), see ContinuousWavelets.jl documentation for the list of available wavelets

Returns

• f::Vector{Float64}: frequencies

datatype(obj)

Return data type of the object.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• dt::String

delete_component(obj; <keyword arguments>)

Delete component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name

Returns

• obj_new::NeuroAnalyzer.NEURO

delete_component!(obj; <keyword arguments>)

Delete component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name

Returns

Nothing

delete_note(obj)

Delete recording note from the object header.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• obj_new::NeuroAnalyzer.NEURO

delete_note!(obj)

Delete recording note from the object header.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

delmean(s)

Demean signal.

Arguments

• s::AbstractArray

Returns

• s_new::AbstractArray

describe(obj; <keyword arguments>)

Return basic descriptive statistics of the object data.

Arguments

• obj::NeuroAnalyzer.NEURO
• df::Bool=false: if true, return statistics as a DataFrame

Returns

• Union{Nothing, DataFrame}

detector_labels(obj)

Return NIRS detector labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• l::Vector{String}

epoch_duration(obj)

Return epoch length.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• ed::Float64

epoch_len(obj)

Return epoch length.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• len::Int64

extract_component(obj, c)

Extract component values.

Arguments

• obj::NeuroAnalyzer.NEURO
• c::Symbol: component name

Returns

• c::Any

f2t(f)

Convert frequency in Hz to cycle length in ms.

Arguments

• f::Real: frequency in Hz

Returns

• f::Float64: cycle length in ms

fft0(x, n)

Perform zeros-padded FFT.

Arguments

• x::AbstractVector
• n::Int64: number of zeros to add

Returns

• fft0::Vector{ComplexF64}

fft2(x)

Perform zeros-padded FFT, so the length of padded vector is a power of 2.

Arguments

• x::AbstractVector

Returns

• fft2::Vector{ComplexF64}

findpeaks(signal; <keyword arguments>)

Find peaks.

Arguments

• signal::AbstractVector
• d::Int64=32: distance between peeks in samples

Returns

• p_idx::Vector{Int64}

fir_order_bw(; <keyword arguments>)

Calculate order of FIR filter using Harris formula.

Arguments

• bw::Real: transition band width
• a::Real: attenuation in dB
• fs::Int64: sampling rate

Returns

• n::Int64

fir_order_bw(obj; <keyword arguments>)

Calculate order of FIR filter using Harris formula.

Arguments

• obj::NeuroAnalyzer.NEURO
• bw::Real: transition band width
• a::Real: attenuation in dB

Returns

• n::Int64

fir_order_f(obj; <keyword arguments>)

Calculate order of FIR filter using lower frequency bound.

Arguments

• obj::NeuroAnalyzer.NEURO
• f::Real: lower frequency bound for analyzed range

Returns

• n::Tuple{Int64, Int64}: recommended order range

fir_order_f(; <keyword arguments>)

Calculate order of FIR filter using lower frequency bound.

Arguments

• f::Real: lower frequency bound for analyzed range
• fs::Int64: sampling rate

Returns

• n::Tuple{Int64, Int64}: recommended order range

f_nearest(m, pos)

Find nearest position tuple in a matrix of positions.

Arguments

• m::Matrix{Tuple{Float64, Float64}}: matrix of positions
• p::Tuple{Float64, Float64}: position tuple

Returns

• pos::Tuple{Int64, Int64}: row and column in m

freqs(t; nf)

Return vector of frequencies and Nyquist frequency for time vector.

Arguments

• t::AbstractVector, AbstractRange}: time vector
• nf::Bool=false: if true, return negative and positive frequencies, otherwise return positive frequencies only

Returns

• hz::Vector{Float64}
• nqf::Float64

freqs(s, fs; nf)

Return vector of frequencies and Nyquist frequency for signal.

Arguments

• s::AbstractVector
• fs::Int64
• nf::Bool=false: if true, return negative and positive frequencies, otherwise return positive frequencies only

Returns

• hz::Vector{Float64: signal vector
• nqf::Float64

freqs(n, fs; nf)

Return vector of frequencies and Nyquist frequency for signal.

Arguments

• n::Int64: number of samples
• fs::Int64
• nf::Bool=false: if true, return negative and positive frequencies, otherwise return positive frequencies only

Returns

• hz::Vector{Float64: signal vector
• nqf::Float64

freqs(obj; nf)

Return vector of frequencies and Nyquist frequency.

Arguments

• obj::NeuroAnalyzer.NEURO
• nf::Bool=false: if true, return negative and positive frequencies, otherwise return positive frequencies only

Returns

Named tuple containing:

• hz::Vector{Float64}
• nqf::Float64

fwhm(s)

Calculate indices of full-width half-maximum points of a Gaussian-like distribution.

Arguments

• s::AbstractVector

Returns

• p1_idx::Int64: pre-peak half-maximum point
• p_idx::Int64: peak
• p2_idx::Int64: post-peak half-maximum point

generate_cosine(f, t, a, p)

Generate cosine wave.

Arguments

• f::Real: frequency [Hz]
• t::AbstractVector: time vector
• a::Real: amplitude, sine amplitude will be in [-amp, +amp]
• p::Real: phase shift [degrees]

Returns

• s::Vector{Float64}`

generate_csine(f, t, a)

Generate complex sine wave.

Arguments

• f::Real: frequency [Hz]
• t::AbstractVector: time vector
• a::Real: amplitude, sine amplitude will be in [-amp, +amp]

Returns

• cs::Vector{ComplexF64}`

generate_gaussian(fs, f, t; <keyword arguments>)

Generate Gaussian wave.

Arguments

• fs::Int64: sampling rate
• f::Real: frequency
• t::Real=1: length = -t:1/fs:t
• ncyc::Int64: : number of cycles, width, SD of the Gaussian
• a::Real=1: peak amp

Returns

• g::Vector{Float64}

generate_morlet(fs, f, t; <keyword arguments>)

Generate Morlet wavelet.

Arguments

• fs::Int64: sampling rate
• f::Real: frequency
• t::Real=1: wavelet length is -t:1/fs:t
• ncyc::Int64=5: number of cycles
• complex::Bool=false: generate complex Morlet

Returns

• morlet::Union{Vector{Float64}, Vector{ComplexF64}}

generate_morlet_fwhm(fs, f, t; <keyword arguments>)

Generate Morlet wavelet using FWHM (full width at half maximum) formula.

Arguments

• fs::Int64: sampling rate
• f::Real: frequency
• t::Real=1: length = -t:1/fs:t
• h::Float64=0.25: full width at half-maximum in seconds (FWHM)

Returns

• mw::Vector{ComplexF64}

Source

Cohen MX. A better way to define and describe Morlet wavelets for time-frequency analysis. NeuroImage. 2019 Oct;199:81–6.

generate_noise(n, a; <keyword arguments>)

Generate noise.

Arguments

• n::Int64: length (in samples)
• a::Real=1.0: amplitude, signal amplitude will be in [-amp, +amp]
• type::Symbol=:whiten: noise type:
  • :whiten: normally distributed
  • :whiteu: uniformly distributed
  • :pink

Returns

• s::Vector{Float64}

generate_signal(n, amp)

Generate signal based on normally distributed random noise.

Arguments

• n::Int64: length (in samples)
• a::Real=1.0: amplitude, signal amplitude will be in [-amp, +amp]

Returns

• s::Vector{Float64}

generate_sinc(t, f, peak, norm)

Generate sinc function.

Arguments

• t::AbstractVector=-2:0.01:2: time
• `f::Real=1.0: frequency
• peak::Real=0: sinc peak time
• norm::Bool=true: generate normalized function

Returns

• s::Vector{Float64}

generate_sine(f, t, a, p)

Generate sine wave.

Arguments

• f::Real: frequency [Hz]
• t::AbstractVector: time vector
• a::Real: amplitude, sine amplitude will be in [-amp, +amp]
• p::Real: phase shift [degrees]

Returns

• s::Vector{Float64}`

generate_square(t, a, p, w, offset)

Generate square wave.

Arguments

• t::AbstractVector: time vector
• a::Real: amplitude
• p::Real: duty cycle
• w::Real: width
• offset::Real: amplitude offset

Returns

• s::Vector{Float64}

generate_triangle(t, a)

Generate triangle wave.

Arguments

• t::AbstractVector: time vector
• a::Real: amplitude

Returns

• s::Vector{Float64}

generate_window(type, n; <keyword arguments>)

Return the n-point long symmetric window type.

Arguments

• type::Symbol: window type:
  • :hann: Hann
  • :bh: Blackman-Harris
  • :bohman: Bohman
  • :flat: Flat-top window
  • :bn: Blackman-Nuttall
  • :nutall: Nuttall
  • :triangle: symmetric triangle (left half ↑, right half ↓)
  • :exp: symmetric exponential (left half ↑, right half ↓)
• n::Int64: window length
• even::Bool=false: if true, make the window of even length (increase length by 1 for odd value of n)

Returns

• w::Vector{Float64}:: generated window

gradient(x; <keyword arguments>)

Calculate gradient of a 1-dimensional scalar field.

Arguments

• x::AbstractVector
• rev::Bool=false: by default the direction of the gradient vector field is towards maximum value, if rev=true, the direction is towards the minimum value

Returns

Named tuple containing:

• g::Vector{Vector{Float64}}: vector field of gradients
• g_len::Vector{Float64}: scalar field of gradient lengths

gradient(x; <keyword arguments>)

Calculate gradient of a 2-dimensional scalar field.

Arguments

• x::AbstractMatrix
• rev::Bool=false: by default the direction of the gradient vector field is towards maximum value, if rev=true, the direction is towards the minimum value

Returns

Named tuple containing:

• g::Matrix{Vector{Float64}}: vector field of gradients
• g_len::Matrix{Float64}: scalar field of gradient lengths

gradient(x; <keyword arguments>)

Calculate gradient of a ≥3-dimensional scalar field.

Arguments

• x::AbstractArray
• rev::Bool=false: by default the direction of the gradient vector field is towards maximum value, if rev=true, the direction is towards the minimum value

Returns

Named tuple containing:

• g::Array{Vector{Float64}, 3}: vector field of gradients
• g_len::Array{Float64, 3}: scalar field of gradient lengths

header(obj; <keyword arguments>)

Show object header.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

history(obj)

Show processing history.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• h::Vector{String}

hz2rads(f)

Convert frequency in Hz to rad/s.

Arguments

• f::Real

Returns

• f_rads::Float64

ifft0(x, n)

Perform IFFT of zero-padded vector.

Arguments

• x::AbstractVector
• n::Int64: number of zeros added to x

Returns

• ifft0::Vector{ComplexF64}: reconstructed signal trimmed to original length

iir_order(; <keyword arguments>)

Calculate order of IIR filter.

Arguments

• fprototype::Symbol: filter prototype:
  • :butterworth
  • :chebyshev1
  • :chebyshev2
  • :elliptic
• ftype::Symbol: filter type:
  • :lp: low pass
  • :hp: high pass
  • :bp: band pass
  • :bs: band stop
• cutoff::Union{Real, Tuple{Real, Real}}: filter cutoff in Hz (a pair of frequencies for band pass and band stop filters)
• bw::Real: transition band width
• rp::Union{Nothing, Real}=nothing: ripple amplitude in dB in the pass band; default: 0.0025 dB for :elliptic, 2 dB for others
• rs::Union{Nothing, Real}=nothing: ripple amplitude in dB in the stop band; default: 40 dB for :elliptic, 20 dB for others
• fs::Int64: sampling rate

Returns

• n::Int64

iir_order(obj; <keyword arguments>)

Calculate order of FIR filter using harris' formula.

Arguments

• obj::NeuroAnalyzer.NEURO
• fprototype::Symbol: filter prototype:
  • :butterworth
  • :chebyshev1
  • :chebyshev2
  • :elliptic
• ftype::Symbol: filter type:
  • :lp: low pass
  • :hp: high pass
  • :bp: band pass
  • :bs: band stop
• cutoff::Union{Real, Tuple{Real, Real}}: filter cutoff in Hz (a pair of frequencies for band pass and band stop filters)
• bw::Real: transition band width
• rp::Union{Nothing, Real}=nothing: ripple amplitude in dB in the pass band; default: 0.0025 dB for :elliptic, 2 dB for others
• rs::Union{Nothing, Real}=nothing: ripple amplitude in dB in the stop band; default: 40 dB for :elliptic, 20 dB for others

Returns

• n::Int64

info(obj; <keyword arguments>)

Show info.

Arguments

• obj::NeuroAnalyzer.NEURO
• df::Bool=false: if true, return object data as a DataFrame containing time points and channels

Returns

• Union{Nothing, DataFrame}

l1(a1, a2)

Compare two arrays (e.g. two spectrograms), using L1 (Manhattan) distance.

Arguments

• a1::AbstractArray: first array
• a2::AbstractArray: second array

Returns

• l1::Float64

l2(a1, a2)

Compare two arrays (e.g. two spectrograms), using L2 (Euclidean) distance.

Arguments

• a1::AbstractArray: first array
• a2::AbstractArray: second array

Returns

• l2::Float64

labels(obj)

Return channel labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• l::Vector{String}

linspace(start, stop, length)

Generates a sequence of evenly spaced numbers between start and stop.

Arguments

• start::Number
• stop::Number
• n::Int64: sequence length

Returns

• range::Vector{Float64}

list_component(obj)

List component names.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• components::Union{Vector{Symbol}, Nothing}

log10space(start, stop, n)

Generates a sequence of log10-spaced numbers between start and stop.

Arguments

• start::Number
• stop::Number
• n::Int64: sequence length

Returns

• range::Vector{Float64}

log2space(start, stop, n)

Generates a sequence of log2-spaced numbers between start and stop.

Arguments

• start::Number
• stop::Number
• n::Int64: sequence length

Returns

• range::Vector{Float64}

markers_s2t(m; <keyword arguments>)

Convert markers start and length from samples to seconds.

Arguments

• m::DataFrame: markers
• fs::Int64: sampling rate

Returns

• m_new::DataFrame

markers_s2t(obj; <keyword arguments>)

Convert markers start and length from samples to seconds.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• m_new::DataFrame

markers_s2t!(m; <keyword arguments>)

Convert markers start and length from samples to seconds.

Arguments

• m::DataFrame: markers
• fs::Int64: sampling rate

Returns

Nothing

markers_s2t!(obj; <keyword arguments>)

Convert markers start and length from samples to seconds.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

maxat(x, y)

Find maximum value of one vector and return value at its index from another vector.

Argument

• x::AbstractVector
• y::AbstractVector

Returns

• value::Real
• idx::Int64

meshgrid(x)

Create mesh grid (pair of x and y coordinates) from two vectors.

Arguments

• x::Vector{Float64}
• y::Vector{Float64}

Returns

• m::Tuple{Vector{Vector{Float64}}, Vector{Vector{Float64}}}

minat(x, y)

Find minimum value of one vector and return value at its index from another vector.

Argument

• x::AbstractVector
• y::AbstractVector

Returns

• value::Real
• idx::Int64

mni2tal(pts)

Convert MNI coordinates to Talairach coordinates: a non-linear transform of MNI to Talairach coordinates.

Arguments

• pts::Vector{<:Number}: MNI X, Y, Z coordinates

Returns

• t::Vector{Float64}: Talairach X, Y, Z coordinates

Source

https://www.brainmap.org/training/BrettTransform.html

m_norm(m)

Normalize matrix.

Arguments

• m::AbstractArray

Returns

• m_norm::AbstractArray

m_pad0(m)

Pad matrix with zeros to make it square.

Arguments

• m::AbstractMatrix

Returns

• m::AbstractMatrix

m_pad0(m, r, c)

Pad matrix with zeros to make its size r × c.

Arguments

• m::AbstractMatrix
• r::Int64: number of rows
• c::Int64: number of columns

Returns

• m::AbstractMatrix

m_sort(m, m_idx; <keyword arguments>)

Sorts matrix using sorting index.

Arguments

• m::AbstractMatrix
• m_idx::Vector{Int64}: sorting index
• rev::Bool=false: reverse sort
• dims::Int64=1: sort by columns (dims=1) or by rows (dims=2)

Returns

• m_sorted::AbstractMatrix

m_sortperm(m; <keyword arguments>)

Generates matrix sorting index.

Arguments

• m::AbstractMatrix
• rev::Bool: reverse sort
• dims::Int64=1: sort by columns (dims=1) or by rows (dims=2)

Returns

• idx::Matrix{Int64}

nchannels(obj; <keyword arguments>)

Return number type channels.

Arguments

• obj::NeuroAnalyzer.NEURO
• type::String="all": channel type (stored in the global channel_types constant variable)

Returns

• ch_n::Int64

nepochs(obj)

Return number of epochs.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• ep_n::Int64

nextpow2(x)

Return the next power of 2 for a given number.

Argument

• x::Int64

Returns

• nextpow2::Int64

ntapers(obj; df)

Return recommended number of Slepian tapers for multi-taper power spectrum analysis.

Arguments

• obj::NeuroAnalyzer.NEURO
• df::Real: frequency resolution (bandwidth); smallest distance between frequency peaks that we want to observe (e.g. 1 Hz)

Returns

• nt::Int64

optode_labels(obj)

Return optode labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• l::Vector{String}

pad0(x, n)

Pad row(s) with zeros. Works with 1-, 2- and 3-dimensional arrays.

Arguments

• x::Union{AbstractVector, AbstractArray}
• n::Int64: padding length (number of zeros to add)

Returns

• pad0::Union{AbstractVector, AbstractArray}

pad2(x)

Pad row(s) with zeros to the nearest power of 2 length. Works with 1-, 2- and 3-dimensional arrays.

Arguments

• x::Union{AbstractVector, AbstractArray}

Returns

• pad2::Union{AbstractVector, AbstractArray}

padm(x, n)

Pad row(s) with mean value(s). Works with 1-, 2- and 3-dimensional arrays.

Arguments

• x::Union{AbstractVector, AbstractArray}
• n::Int64: padding length (number of values to add)
• mode::Symbol=:row: how the mean is calculated:
  • :all: mean of all rows
  • :row: separate mean per each row

Returns

• padm::Union{AbstractVector, AbstractArray}

paired_labels(l; <keyword arguments>)

Return paired labels.

Arguments

• l::Vector{String}
• unq::Bool=true: if true, do not add pairs of the same labels, e.g. "label1-label1"

Returns

• l_paired::Vector{String}: paired labels

paired_labels(l1, l2)

Return paired labels.

Arguments

• l1::Vector{String}
• l2::Vector{String}

Returns

• l_paired::Vector{String}: paired labels

perm_cmp(a1, a2; <keyword arguments>)

Compare two 3-dimensional arrays (e.g. two spectrograms), using permutation based statistic.

Arguments

• a1::Array{<:Real, 3}: first array
• a2::Array{<:Real, 3}: second array
• p::Float64=0.05: p-value
• perm_n::Int64=1000: number of permutations

Returns

Named tuple containing:

• zmap::Matrix{Float64}: array of Z-values
• bm::BitMatrix: binarized mask of statistically significant positions

phases(s)

Calculate phases.

Arguments

• s::AbstractVector

Returns

• phases::Vector{Float64}

play(obj; <keyword arguments>)

Play channel signal as audio.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• seg::Tuple{Real, Real}: time segment to play
• ep::Int64: epoch number

Returns

Nothing

rads2hz(f)

Convert frequency in rad/s to Hz.

Arguments

• f::Real

Returns

• f_rads::Float64

rename_component(obj, c_old, c_new)

Rename component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c_old::Symbol: old component name
• c_new::Symbol: new component name

Return

• obj_new::NeuroAnalyzer.NEURO

rename_component!(obj, c_old, c_new)

Rename component.

Arguments

• obj::NeuroAnalyzer.NEURO
• c_old::Symbol: old component name
• c_new::Symbol: new component name

Returns

Nothing

reset_components(obj)

Remove all components.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• obj_new::NeuroAnalyzer.NEURO

reset_components!(obj)

Remove all components.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

rfft0(x, n)

Perform zeros-padded single-sided FFT.

Arguments

• x::AbstractVector
• n::Int64: number of zeros to add

Returns

• rfft0::Vector{ComplexF64}

rfft2(x)

Perform zeros-padded single-sided FFT, so the length of padded vector is a power of 2.

Arguments

• x::AbstractVector

Returns

• rfft2::Vector{ComplexF64}

s2t(s, fs)

Convert sample number to time in seconds.

Arguments

• s::Real: sample number
• fs::Int64: sampling rate

Returns

• s2t::Float64: time in s

s2t(obj; <keyword arguments>)

Convert time in samples to seconds.

Arguments

• obj::NeuroAnalyzer.NEURO
• s::Int64: time in samples

Returns

• s2t::Float64: time in seconds

signal_duration(obj)

Return signal duration.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• sd::Float64

signal_len(obj)

Return signal length.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• sl::Int64

source_labels(obj)

Return NIRS source labels.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• l::Vector{String}

sr(obj)

Return sampling rate.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• fs::Int64

t2f(t)

Convert cycle length in ms to frequency.

Arguments

• t::Real: cycle length in ms

Returns

• f::Float64: frequency in Hz

t2s(t, fs)

Convert time in seconds to sample number.

Arguments

• t::Real: time in s
• fs::Int64: sampling rate

Returns

• t2s::Int64: sample number

t2s(obj; <keyword arguments>)

Convert time in seconds to sample number.

Arguments

• obj::NeuroAnalyzer.NEURO
• t::Real: time in seconds

Returns

• t2s::Int64: sample number

Convert Talairach coordinates to MNI coordinates: a non-linear transform of MNI to Talairach coordinates.

Arguments

• pts::Vector{<:Number}: Talairach X, Y, Z coordinates

Returns

• m::Vector{Float64}: MNI X, Y, Z coordinates

Source

https://www.brainmap.org/training/BrettTransform.html

tavg(s)

Average signal across trials.

Arguments

• s::AbstractArray

Returns

• s_new::AbstractArray

to_df(obj)

Export object data as DataFrames.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• df::DataFrame: DataFrame containing time points and channels

trtm(obj; <keyword arguments>)

Return signal channel in the form trials × time.

Arguments

• obj::NeuroAnalyzer.NEURO
• ch::String: channel name
• ep::Union{Int64, Vector{Int64}, AbstractRange}=_c(nepochs(obj)): epoch numbers; default use all epochs

Returns

• s::Matrix{Float64}

tuple_order(t, rev)

Order tuple elements in ascending or descending (rev=true) order.

Arguments

• t::Tuple{Real, Real}
• rev::Bool=false

Returns

• t::Tuple{Real, Real}

vec2mat(x; <keyword arguments>)

Reshape vector into matrix using fixed segment length and overlapping.

Arguments

• x::AbstractVector
• wlen::Int64: window length (in samples)
• woverlap::Int64: overlap with the previous window (in samples)

Returns

• m::AbstractMatrix

header(obj)

Show keys and values of the object header.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

Nothing

view_note(obj)

Return the object recording note.

Arguments

• obj::NeuroAnalyzer.NEURO

Returns

• note::String

vreduce(x, f; <keyword arguments>)

Reduce two vectors at indices of the second vector being multiplications of a constant. Useful e.g. for simplifying values across frequencies, when the number of frequencies (and thus values) is high.

Arguments

• x::AbstractVector: e.g. signal data
• f::AbstractVector: e.g. frequencies
• n::Float64=0.5: reduce at multiplications of this value

Returns

• x_new::AbstractVector
• f_new::AbstractVector

vsearch(y, x)

Return the positions of the string in the vector of strings.

Arguments

• y::String: value of interest
• x::Vector{String}: vector to search within

Returns

• idx::Union{Int64, Nothing}

vsearch(y, x; <keyword arguments>)

Return the positions of the value in the vector.

Arguments

• y::Real: value of interest
• x::AbstractVector: vector to search within
• acc::Bool=false: if true, return the difference between y and x[idx]

Returns

• idx::Int64
• d::Real: the difference between y and x[idx]

vsearch(y, x; <keyword arguments>)

Return the positions of the value in the vector.

Arguments

• y::AbstractVector: vector of interest
• x::AbstractVector: vector to search within
• acc::Bool=false: if true, return the difference between y and x[idx:idx + length(y)]

Returns

• idx::Int64
• d::Real: the difference between y and x[idx:idx + length(y)]

vsplit(x, n)

Splits vector into pieces.

Argument

• x::AbstractVector
• n::Int64: length of one piece

Returns

• x::Vector{AbstractVector}

angle(x)

Return the phase angles (in radians) of a vector with complex elements.

Arguments

• x::Vector{ComplexF64}

Returns

• angle::Vector{Float64}

arf(df, var)

Calculate absolute and relative frequencies.

Arguments

• df::DataFrame
• var::Union{Symbol, String}: variable name

Returns

• m::Matrix{Float64}: first row: absolute frequencies, second row: relative frequencies (proportion), third row: second row: relative frequencies (percentage); last column: totals

ba(x, y; <keyword arguments>)

Calculate Bland-Altman comparison between two clinical measurements.

Arguments

• x::AbstractVector
• y::AbstractVector
• la::FLoat64=0.95: 95% limits of agreement for each comparison (average difference ± 1.96 standard deviation of the difference)

Returns

Named tuple containing:

• m::Float64: mean of the difference
• s_u::Float64: +1.96 (for default la) × standard deviation of the difference
• s_d::Float64: -1.96 (for default la) × standard deviation of the difference

Notes

To plot the Bland-Altman plot: p = hline([0, m]); hline!([0, s_u]); hline!([0, s-d])

binom_prob(p, r, n)

Calculate probability of exactly r successes in n trials.

Arguments

• p::Float64: proportion of successes
• r::Int64: number of successes
• n::Int64: number of trials

Returns

• bp::Float64: probability

binom_test(p, n; verbose)

Test proportion against 0.5.

Arguments

• p::Float64: proportion of level 1 observations
• n::Int64: number of observations
• verbose::Bool=true: print detailed output

Returns

Named tuple containing:

• x0::Int64: level 0 counts
• x1::Int64: level 1 counts
• p0::Float64: level 0 proportion
• p1::Float64: level 1 proportion
• ci0::Tuple{Float64, Float64}: level 1 proportion 95%CI
• ci1::Tuple{Float64, Float64}: level 1 proportion 95%CI
• p::Float64: Binomial test p value

binom_test(x; verbose)

Test proportion against 0.5.

Arguments

• x::Vector{Bool}: vector of level 0 and 1 categories
• verbose::Bool=true: print detailed output

Returns

Named tuple containing:

• x0::Int64: level 0 counts
• x1::Int64: level 1 counts
• p0::Float64: level 0 proportion
• p1::Float64: level 1 proportion
• ci0::Tuple{Float64, Float64}: level 1 proportion 95%CI
• ci1::Tuple{Float64, Float64}: level 1 proportion 95%CI
• p::Float64: Binomial test p value

binom_test(x, n; verbose)

Test proportion against 0.5.

Arguments

• x::Int64: number of level 1 observations
• n::Int64: number of observations
• verbose::Bool=true: print detailed output

Returns

Named tuple containing:

• x0::Int64: level 0 counts
• x1::Int64: level 1 counts
• p0::Float64: level 0 proportion
• p1::Float64: level 1 proportion
• ci0::Tuple{Float64, Float64}: level 1 proportion 95%CI
• ci1::Tuple{Float64, Float64}: level 1 proportion 95%CI
• p::Float64: Binomial test p value

biplot(df, vars; <keyword arguments>)

Plot PCA biplot.

Arguments

• df::DataFrame
• vars::Union{Vector{String}, Vector{Symbol}}: variable names
• n::Int64: number of PCs
• zstd::Bool=true: perform z score standardization before performing PCA

Returns

• p::Plots.Plot{Plots.GRBackend}

bootstrap_ci(s; <keyword arguments>)

Calculate Confidence Interval using bootstrapping.

Arguments

• s::AbstractMatrix: signal (time points × epochs)
• n1::Int64=3000: number of stage 1 resamplings - number of samples in the resampled signal
• n2::Int64=1000: number of stage 2 resamplings - number of samples sampled from the signal
• cl::Float64=0.95: confidence level

Returns

Named tuple containing:

• s_avg::Vector{Float64}: averaged signal
• s_ci_l::Vector{Float64}: lower bound of the confidence interval
• s_ci_h::Vector{Float64}: upper bound of the confidence interval

bootstrap_stat(s; <keyword arguments>)

Calculate signal statistic using bootstrapping.

Arguments

• s::AbstractMatrix: signal (time points × epochs)
• n1::Int64=3000: number of stage 1 resamplings - number of samples in the resampled signal
• n2::Int64=1000: number of stage 2 resamplings - number of samples sampled from the signal
• f::String: statistic function to be applied, e.g. f="abs(maximum(obj))"; signal is given using variableobj` here.

Returns

• out::AbstractVector

center(x)

Center values by subtracting mean.

Arguments

• x::AbstractVector

Returns

• x::Vector{Float64}

chi2p(chi; <keyword arguments>)

Convert Χ² score to right-tailed (P(Chi > chi)) p value.

Arguments

• chi::Real: Χ² score
• df::Real: degrees of freedom

Returns

• p::Float64

Notes

To calculate P(Chi < chi) (left-tailed) use 1 - chi2p(chi, df=df).

cim(x; <keyword arguments>)

Calculate confidence interval for the mean.

Arguments

• x::AbstractVector
• cl::Float64=0.95: confidence level
• d::Symbol=:t: distribution used for critical value calculation (:z or :t)
• twotailed::Bool=true: interval type, use twotailed=false to calculate lower and upper bound separately (both will be returned)

Returns

• cim::Tuple{Float64, Float64}: lower and upper bound

cimd(x; <keyword arguments>)

Calculate confidence interval for the median.

Arguments

• x::AbstractVector
• cl::Float64=0.95: confidence level

Returns

• cimd::Tuple{Float64, Float64}

cimd(x; <keyword arguments>)

Calculate confidence interval for the median.

Arguments

• x::AbstractArray
• cl::Float64=0.95: confidence level

Returns

• cimd::Tuple{Float64, Float64}

cip(p, n; <keyword arguments>)

Calculate confidence interval for the proportion.

Arguments

• p::Float64: proportion
• n::Int64: sample size
• cl::Float64=0.95: confidence level

Returns

• cip::Tuple{Float64, Float64}

cir(x, y; <keyword arguments>)

Calculate confidence interval for the correlation coefficient.

Arguments

• x::AbstractVector
• y::AbstractVector
• cl::Float64=0.95: confidence level

Returns

• cir::Tuple{Float64, Float64}

cir(; <keyword arguments>)

Calculate confidence interval for the correlation coefficient.

Arguments

• r::Float64: correlation coefficient
• n::Int64: number of observations
• cl::Float64=0.95: confidence level

Returns

• cir::Tuple{Float64, Float64}

cis(x; <keyword arguments>)

Calculate confidence interval for the standard deviation.

Arguments

• x::AbstractVector
• cl::Float64=0.95: confidence level

Returns

• cis::Tuple{Float64, Float64}: lower and upper bound

civ(x; <keyword arguments>)

Calculate confidence interval for the variance.

Arguments

• x::AbstractVector
• cl::Float64=0.95: confidence level

Returns

• civ::Tuple{Float64, Float64}: lower and upper bound

cl2z(ci; <keyword arguments>)

Convert confidence level to z score.

Arguments

• cl::Float64: confidence level
• twotailed::Bool=true: one- or two-tailed probability

Returns

• z::Float64

Notes

The confidence interval is (-z, +z) if twotailed=true; otherwise it is (-∞, -z) on the left and (z, +∞) on the right.

cmp_stat(stat_dist, v)

Calculate proportion of elements below or above a given statistic value.

Arguments

• stat_dist::AbstractVector: statistic values distribution
• v::Real: statistic value
• type::Symbol=:g: calculation proportion of elements greater (:g) or lesser (:l) than v

Returns

• p::Float64

cmp_test(seg1, seg2; <keyword arguments>)

Compare two vectors. Jarque–Bera is used first to test normality of distribution, next variances are tested using F-test. Finally, paired or non-paired t-test or non-parametric test (Wilcoxon signed rank for paired data; Mann-Whitney U test for non-paired data) is applied. Permutation-based testing is also

Arguments

• s1::AbstractVector
• s2::AbstractVector
• paired::Bool
• alpha::Float64=0.05: confidence level
• type::Symbol=:auto
  • :auto: choose test automatically
  • :perm: permutation-based
  • :p: parametric
  • :np: non-parametric
• exact::Bool=false: if true, use exact Wilcoxon test
• nperm::Int64=1000: number of permutation for :perm method
• verbose::Bool=true: print detailed output

Returns

For permutation-based test, named tuple containing:

• t::Tuple{perm_diff::Vector{Float64}, obs_diff::Float64}: test result (permutation difference, observed difference)
• p1::Float64: one-tiled p value
• p2::Float64: two-tiled p value

Otherwise, named tuple containing:

• t::Union{OneSampleTTest, EqualVarianceTTest, UnequalVarianceTTest, ExactSignedRankTest, ApproximateSignedRankTest, ExactMannWhitneyUTest, ApproximateMannWhitneyUTest}: statistical test
• ts::Tuple{Float64, String}: test statistic value and name
• tc::Tuple{Float64, Float64}: test statistic confidence interval
• df::Float64: degrees of freedom
• p::Float64: p value

cor_test(seg1, seg2)

Calculate correlation between two vectors.

Arguments

• s1::AbstractVector
• s2::AbstractVector

Returns

Named tuple containing:

• t::CorrelationTest{Float64}
• r::Float64: correlation coefficient
• rc::Tuple{Float64, Float64}: correlation coefficient confidence interval
• ts::Tuple{Float64, String}: t-statistics
• df::Int64: degrees of freedom
• p::Float64: p value

count_thresh(x; <keyword arguments>)

Collect thresholded elements, e.g. in a topographical map.

Arguments

• x::AbstractMatrix
• t::Real: threshold value
• t_type::Symbol=:g: rule for thresholding:
  • :eq: =
  • :geq: ≥
  • :leq: ≤
  • :g: >
  • :l: <

Returns

Named tuple containing:

• x_t::Matrix{Bool}: thresholded matrix
• n::Int64: number of elements

crit_chi(df, alpha)

Calculate critical Χ² score.

Arguments

• df::Real: degrees of freedom (usually df = n - 1)
• alpha::Float64=0.05: alpha value

Returns

• chi::Float64

crit_t(df, alpha; <keyword arguments>)

Calculate critical t value.

Arguments

• df::Real: degrees of freedom (usually df = n - 1)
• alpha::Float64=0.05: alpha value
• twotailed::Bool=true: one- or two-tailed probability

Returns

• t::Float64

Notes

Critical region for one- tailed probability:

• left: (-∞ , -t]
• right: [t , ∞)

Critical region for two-tailed probability: (-∞ , -t] ∪ [t, ∞)

crit_z(alpha; <keyword arguments>)

Calculate critical z score.

Arguments

• alpha::Float64=0.05: alpha value
• twotailed::Bool=true: one- or two-tailed probability

Returns

• z::Float64

Notes

Critical region for one- tailed probability:

• left: (-∞ , -z]
• right: [z , ∞)

Critical region for two-tailed probability: (-∞ , -z] ∪ [z, ∞)

cvm(x)

Calculate coefficient of variation for a mean.

Arguments

• x::AbstractVector

Returns

• cvm::Float64

cvmd(x)

Calculate coefficient of variation for a median.

Arguments

• x::AbstractVector

Returns

• cvmd::Float64

dap(x)

Calculate D'Agostino-Pearson Omnibus Test for normality.

Arguments

• x::AbstractVector

Returns

Named tuple containing:

• zs::Float64: skewness test
• zk::Float64: kurtosis test
• d::Float64: test statistic
• p::Float64: p value

df(x)

Calculate degrees of freedom.

Arguments

• x::AbstractVector

Returns

• df::Int64

distance(p1, p2)

Calculate distance between two points.

Arguments

• p1::Tuple{Real, Real}
• p2::Tuple{Real, Real}

Returns

• d::Float64: distance

dprime(p1::Real, p2::Real)

Calculate d' and response bias for two proportions.

Arguments

• p1::Real
• p2::Real

Returns

Named tuple containing:

• dp::Float64
• rb::Float64: response bias

dranks(x, nbins)

Calculate ranks scaled in 0..nbins.

Arguments

• x::AbstractArray: some continuous variable, such as reaction time (the time it takes to indicate the response)
• nbins::Int64: number of bins, default is Sturges' formula (nbins = 1 + log2(length(x))))

Returns

• sr::Array{Int64}

efs(x1, x2)

Calculate effect sizes.

Arguments

• x1::AbstractVector
• x2::AbstractVector

Returns

Named tuple containing:

• d::Float64: Cohen's d
• g::Float64: Hedges g, uses maximum likelihood estimator by Hedges and Olkin
• Δ::Float64: Glass' Δ

efs_p1g(p)

Calculate Cohen's h effect size for one proportion.

Arguments

• p::Float64: proportion

Returns

• h::Float64

efs_p2g(p1, p2; nd)

Calculate Cohen's h effect size for two proportions p1 and p2.

Arguments

• p1::Float64: 1st proportion, e.g. 0.7
• p2::Float64: 2nd proportion, e.g. 0.3
• nd::Bool=false: if true, calculate non-directional h value

Returns

• h::Float64

f1(; <keyword arguments>)

Assess performance of the classification model using F1-score. F1-score value ranges from 0 to 1.

Arguments

• tp::Int64: number of true positives
• tn::Int64: number of true negatives
• fp::Int64: number of false positives
• fn::Int64: number of false negatives

Returns

Named tuple containing:

• f1::Float64: F1-score
• p::Float64: precision
• r::Float64: recall

Source

https://www.statology.org/what-is-a-good-f1-score/

f2p(t; <keyword arguments>)

Convert F score to right-tailed (P(F > f)) p value.

Arguments

• f::Real: F score (F = var(x) / var(y))
• df1::Real: numerator degrees of freedom (DF1)
• df2::Real: denominator degrees of freedom (DF2)

Returns

• p::Float64

Notes

To calculate P(F < f) (left-tailed) use 1 - f2p(f, df1=df1, df2=df2).

fano(x)

Calculate Fano factor.

Arguments

• x::AbstractVector

Returns

• fano::Float64

friedman(m)

Estimate Friedman's nonparametric two-way analysis of variance (and Kendall's coefficient of concordance, normalized Friedman's Q statistics).

Arguments

• m::AbstractArray: values × groups

Returns

Named tuple containing:

• q::Float64: Friedman's Q statistics
• w::Float64: Kendall's coefficient of concordance
• p::Float64: p value

Notes

• H0 (Friedman) is that the treatments are equal
• H0 (Kendall) is that there is agreement between rankings or test results
• Kendall's coefficient of concordance ranges from 0 to 1, with 0 meaning no agreement across raters (judges)

grubbs(x; <keyword arguments>)

Perform Grubbs test for outlier.

Arguments

• x::AbstractVector
• alpha::Float64=0.95
• t::Int64=0: test type:
  • -1: test whether the minimum value is an outlier
  • 0: two-tiled test
  • 1: test whether the maximum value is an outlier

Returns

• g::Bool: true: outlier exists, false: there is no outlier

hildebrand_rule(x; verbose)

Calculate Hildebrand rule for vector x.

If H < 0.2 then the vector x is symmetric.

Arguments

• x::AbstractVector
• verbose::Bool=true: print detailed output

Returns

• h::Float64

infcrit(m)

Calculate R², R² adjusted, Akaike’s Information Criterion (AIC) and Bayesian Information Criterion (BIC) for a linear regression model m.

Arguments

• m::StatsModels.TableRegressionModel: linear regression model

Returns

Named tuple containing:

• R2::Float64
• R2adj::Float64
• bic::Float64
• bic::Float64

jaccsim(x, y)

Calculate Jaccard similarity between two vectors.

Arguments

• x::AbstractVector
• y::AbstractVector

Returns

• j::Float64

Notes

To compute Jaccard distance, use 1 - jaccard(x, y)

k_categories(n)

Calculate number of categories for a given sample size n.

Arguments

• n::Int64: sample size

Returns

Named tuple containing:

• k1::Float64: sqrt(n)
• k2::Float64: 1 + 3.222 * log10(n)

linreg(x, y)

Linear regression between two vectors.

Arguments

• x::AbstractVector
• y::AbstractVector

Notes

To predict, use: `newx = DataFrame(x = [3.5, 7]); predict(lr, newx)

Returns

Named tuple containing:

• lr::StatsModels.TableRegressionModel: model
• c::Vector{Float64}: coefficients
• se::Vector{Float64}: standard error for coefficients
• R2::Float64: R²
• R2adj::Float64: R² adjusted
• aic::Float64:: Akaike’s Information Criterion (AIC)
• bic::Float64:: Bayesian Information Criterion (BIC)
• lf::Vector{Float64}: linear fit (plot(x, lf))

logit(p)

Convert proportion to logit.

Arguments

• p::Float64: proportion

Returns

• l::Float64

make_table(; <keyword arguments>)

Display data as a table.

Arguments

• header::Matrix{String}: table header, e.g. header = ["Group" "A" "B"]
• data::Matrix{Any}: table data, e.g. data = ["var1" 1.0 2.0; "var2" 3.0 4.0]

Returns

Nothing

mcc(; <keyword arguments>)

Assess performance of the classification model using Matthews correlation coefficient (MCC).

MCC’s value ranges from -1 to 1, depending on:

• a score of -1 denotes a complete discrepancy between expected and actual classes
• 0 is equivalent to making an entirely arbitrary guess
• total agreement between expected and actual classes is indicated by a score of 1

Arguments

• tp::Int64: number of true positives
• tn::Int64: number of true negatives
• fp::Int64: number of false positives
• fn::Int64: number of false negatives

Returns

• mcc::Float64

Source

https://finnstats.com/index.php/2022/09/06/assess-performance-of-the-classification-model/

mde(; <keyword arguments>)

Calculate minimum detectable difference (MDE).

Arguments

• n::Int64: number of subject per group
• s::Real: standard deviation
• alpha::Float64=0.05: the probability of type I error
• beta::Float64=0.20: the probability of type II error
• verbose::Bool=true: print detailed output

Returns

• mde::Float64

meanc(g, x)

Calculate mean of categorical data.

Arguments

• g::Vector{Int64}: group (e.g. [0, 1, 2, 3])
• x::Vector{Int64}: amount of subject per group (e.g. [2, 8, 27, 45])

Returns

• m::Float64

meancirc(x; <keyword arguments>)

Calculate circular mean.

Arguments

• x::AbstractVector: angles
• rad::Bool=false: angles are provided in radians (rad=true) or degrees (rad=false)

Returns

• m::Float64

meang(x)

Calculate geometric mean.

Arguments

• x::AbstractVector

Returns

• m::Float64

meanh(x)

Calculate harmonic mean.

Arguments

• x::AbstractVector

Returns

• m::Float64

meanp(p, n)

Calculate mean of the proportion.

Arguments

• p::Float64: proportion

• n::Int64: number of observations

• m::Float64

meant(x; <keyword arguments>)

Calculate trimmed mean.

Arguments

• x::AbstractVector
• n::Float64=0.1: percentage of extreme values to trim from both ends

Returns

• m::Float64

meanw(x, w)

Calculate weighted mean.

Arguments

• x::AbstractVector
• w::AbstractVector: weights

Returns

• m::Float64

moe(n)

Calculate margin of error for given sample size n.

Arguments

• n::Int64

Returns

• m::Float64

moe(x)

Calculate margin of error.

Arguments

• x::AbstractArray

Returns

• m::Float64

mrng(x)

Calculate midrange.

Arguments

• x::AbstractArray

Returns

• mr::Float64

mscr(; <keyword arguments>)

Assess performance of the classification model using misclassification rate.

Arguments

• tp::Int64: number of true positives
• tn::Int64: number of true negatives
• fp::Int64: number of false positives
• fn::Int64: number of false negatives

Returns

Named tuple containing:

• mr::Float64: misclassification rate
• acc::Float64: accuracy

Source

https://www.statology.org/misclassification-rate/

na(x)

Return values of x ignoring NaNs and Missing values.

Arguments

• x::AbstractVector

Returns

• x::Vector{Float64}

norminv(x::Real)

Convert probability to a normal distribution with a peak at 0.5.

Arguments

• x::Real

Returns

• n::Float64

npca(m; <keyword arguments>)

Calculate recommended number of Primary Components (PCs).

Arguments

• m::Matrix{Float64}: observations × variables
• zstd::Bool=true: perform z score standardization before performing PCA
• type::Symbol
  • :var: use total variation
  • :eig: use eigenvalue
• value::Real: minimum % of total variation or threshold for eigenvalues (keep the components with eigenvalues greater than the threshold)

Returns

• n::Int64: recommended number of PCs

o2p(o::Float64)

Convert probability to odds.

Arguments

• o::Float64

Returns

• p::Float64

op(x, y)

Calculate outer product of two vectors.

Arguments

• x::AbstractVector
• y::AbstractVector

Returns

• op::AbstractMatrix

outlier_detect(x; <keyword arguments>)

Detect outliers.

Arguments

• x::AbstractVector
• method::Symbol=iqr: detecting methods:
  • :iqr: interquartile range
  • :z: z-score
  • :g: Grubbs test

Returns

• o::Vector{Bool}: index of outliers

p2o(p::Float64)

Convert probability to odds.

Arguments

• p::Float64

Returns

• o::Float64

p2z(p; <keyword arguments>)

Convert p value to z score.

Arguments

• p::Float64=0.05: p value
• twotailed::Bool=false: one- or two-tailed probability

Returns

• z::Float64

pcacomp(m; <keyword arguments>)

Calculate n first Primary Components (PCs).

Arguments

• m::Matrix{Float64}: observations × variables
• n=size(m, 2)::Int64: number of PCs
• zstd::Bool=true: perform z score standardization before performing PCA

Returns

Named tuple containing:

• pc::DataFrame: PC(1)..PC(n)
• pcv::Vector{Float64}: PC variances (fraction of total variance explained)
• pcm::Vector{Float64}: PC means
• pcp::Matrix{Float64}: PC projections
• pc_model::MultivariateStats.PCA{Float64}: PC model

pcacomp(df, vars; <keyword arguments>)

Calculate n first Primary Components (PCs).

Arguments

• df::DataFrame
• vars::Union{Vector{String}, Vector{Symbol}}: variable names
• n::Int64: number of PCs
• zstd::Bool=true: perform z score standardization before performing PCA

Returns

Named tuple containing:

• pc::DataFrame: PC(1)..PC(n)
• pcv::Vector{Float64}: PC variances (fraction of total variance explained)
• pcm::Vector{Float64}: PC means
• pcp::Matrix{Float64}: PC projections
• pc_model::MultivariateStats.PCA{Float64}: PC model

permute(s, n)

Permute signal data.

Arguments

• s::AbstractVector
• n::Int64: number of permutations

Returns

• s_new::Matrix{Float64}

permute(s, n)

Permute signal data.

Arguments

• s::AbstractArray
• n::Int64: number of permutations

Returns

• s_new::Union{Array{Float64, 3}, Array{Float64, 4}}

power_c1g(; <keyword arguments>)

Calculate study power for a continuous variable (group 1 vs population).

Arguments

• m::Real: population mean
• s::Real: population standard deviation
• xbar::Real: study group mean
• n::Int64: group sample size
• alpha::Float64=0.05: the probability of type I error

Returns

• p::Float64: study power

power_c2g(; <keyword arguments>)

Calculate study power for a continuous variable (group 1 vs group 2).

Arguments

• m1::Real: study group 1 mean
• s1::Real: study group 1 standard deviation
• n1::Int64: study group 1 sample size
• m2::Real: study group 2 mean
• s2::Real: study group 2 standard deviation
• n2::Int64: study group 2 sample size
• alpha::Float64=0.05: the probability of type I error

Returns

• p::Float64: study power

power_p1g(; <keyword arguments>)

Calculate study power for one proportion.

Arguments

• p1::Float64: study group proportion
• p2::Float64: population proportion
• n1::Int64: study group sample size
• alpha::Float64=0.05: the probability of type I error

Returns

• p::Float64: study power

power_p2g(; <keyword arguments>)

Calculate study power for two proportions.

Arguments

• p1::Float64: study group 1 proportion
• p2::Float64: study group 2 proportion
• n1::Int64: study group 1 sample size
• n2::Int64: study group 2 sample size
• alpha::Float64=0.05: the probability of type I error

Returns

• p::Float64: study power

prank(x)

Calculate percentile ranks.

Arguments

• x::AbstractVector: the vector to analyze

Returns

• p::Vector{Float64}: percentile ranks

pred_int(n)

Calculate the prediction interval (95% CI adjusted for sample size)

Arguments

• n::Int64: sample size

Returns

• pi::Float64

r1r2_zscore(; <keyword arguments>)

Calculate z score for the difference of two correlation coefficients.

Arguments

• r1::Float64: correlation coefficient, group 1
• r2::Float64: correlation coefficient, group 2
• n1::Int64: number of observations, group 1
• n2::Int64: number of observations, group 2

Returns

• z::Float64: z score

res_norm(x, g)

Test normal distribution of residuals.

Arguments

• x::AbstractVector: data values
• g::Vector{Int64}: group(s) to which each data value belongs

Returns

Named tuple containing:

• adt_p::Vector{Float64}: p values for k-sample Anderson–Darling test vs normal distribution
• ks_p::Vector{Float64}: p values for one-sample exact Kolmogorov–Smirnov test vs normal distribution

Notes

p values are reported for each group and for the whole sample. If there is only one group, p values are returned only for the whole sample p values are reported.

rfz(r)

Calculate Fischer's z transformations of correlation coefficient.

Arguments

• r::Float64: correlation coefficient

Returns

• z::Float64: z score

Notes

Formula: z = atanh(r), gives ∞ for r = 1.0 and -∞ for r = -1.0. This functions returns 18.36840028483855 (atanh(1 - eps())) for r = 1.0 and -18.36840028483855 (atanh(1 - eps())) for r = -1.0.

rng(x)

Calculate range.

Arguments

• x::AbstractArray

Returns

• r::Float64

screeplot(df, vars; <keyword arguments>)

Plot PCA scree plot.

Arguments

• df::DataFrame
• vars::Union{Vector{String}, Vector{Symbol}}: variable names
• n::Int64: number of PCs
• zstd::Bool=true: perform z score standardization before performing PCA

Returns

• p::Plots.Plot{Plots.GRBackend}

sdi(x, y)

Calculate Sorensen-Dice similarity index between two vectors.

Arguments

• x::AbstractVector
• y::AbstractVector

Returns

• sdi::Float64

Notes

Sorensen-Dice Index values range from 0 to 1:

• 0.80-1.00: very high similarity
• 0.60-0.79: high similarity
• 0.40-0.59: moderate similarity
• 0.20-0.39: low similarity
• 0.00-0.19: very low similarity

sek(x)

Calculate standard error of the kurtosis.

Arguments

• x::AbstractVector

Returns

• s::Float64

ses(n)

Calculate standard error of the skewness.

Arguments

• n::Int64: number of observations

Returns

• s::Float64

sem(x)

Calculate standard error of the mean.

Arguments

• x::AbstractVector

Returns

• s::Float64

semd(x)

Calculate standard error of the median.

Arguments

• x::AbstractVector

Returns

• s::Float64

sem_diff(x, y)

Calculate SEM (standard error of the mean) of difference between two means.

Arguments

• x::AbstractVector
• y::AbstractVector

Returns

• sd::Float64

sen(n)

Calculate standard error of the number.

Arguments

• n::Int64: number of observations

Returns

• s::Float64

sen_diff(n1, n2)

Calculate standard error of the difference between two numbers.

Arguments

• n1::Int64: number of observations in group 1
• n2::Int64: number of observations in group 2

Returns

• s::Float64

sep(p, n)

Calculate standard error of the proportion.

Arguments

• p::Float64: proportion
• n::Int64: number of observations

Returns

• s::Float64

sep_diff(p1, p2, n1, n2)

Calculate standard error of the difference of two proportions.

Arguments

• p1::Float64: proportion 1
• p2::Float64: proportion 1
• n1::Int64: number of observations in group 1
• n2::Int64: number of observations in group 2

Returns

• s::Float64

ses(x)

Calculate standard error of the skewness.

Arguments

• x::AbstractVector

Returns

• s::Float64

ses(n)

Calculate standard error of the skewness.

Arguments

• n::Int64: number of observations

Returns

• s::Float64

size_c1diff(; <keyword arguments>)

Calculate required sample size for detecting a difference in a continuous variable (group 1 vs population).

Arguments

• s1::Real: study study standard deviation that we want to detect
• s2::Real: population standard deviation
• twotailed::Bool=true: if true, the estimation is for two-tiled difference
• power::Float64=0.8: the ability to detect a difference between groups (power = 1 - beta, where beta is the probability of type II error)

Returns

• n::Int64: study sample size

size_c1g(; <keyword arguments>)

Calculate required sample size for a continuous variable (group 1 vs population).

Arguments

• m::Real: population mean
• s::Real: population standard deviation
• xbar::Real: study group mean
• alpha::Float64=0.05: the probability of type I error
• power::Float64=0.8: the ability to detect a difference between groups (power = 1 - beta, where beta is the probability of type II error)
• iter::Bool=false: use iterative method

Returns

• n::Int64: group sample size

size_c2g(; <keyword arguments>)

Calculate required sample size for a continuous variable (group 1 vs group 2).

Arguments

• m1::Real: study group 1 mean
• s1::Real: study group 1 standard deviation
• m2::Real: study group 2 mean (expected)
• r::Int64=1: enrollment ratio - the ratio of group 2 to group 1 enrollment
• alpha::Float64=0.05: the probability of type I error
• power::Float64=0.8: the ability to detect a difference between groups (power = 1 - beta, where beta is the probability of type II error)

Returns

Named tuple containing:

• n1::Int64: group 1 sample size
• n2::Int64: group 2 sample size

size_m(; <keyword arguments>)

Calculate required sample size for estimating sample mean.

Arguments

• sigma::Real: population standard deviation
• alpha::Float64=0.05: the probability of type I error
• E::Real: margin of error (error of sample mean estimation)

Returns

• n::Int64: sample size

size_p(; <keyword arguments>)

Calculate required sample size for estimating proportion.

Arguments

• p::Union{Float64, Nothing}: study group proportion, omit if unknown
• alpha::Float64=0.05: the probability of type I error
• E::Float64: margin of error (error of sample proportion estimation)

Returns

• n::Int64: sample size

size_p1diff(; <keyword arguments>)

Calculate required sample size for detecting a difference in a proportion (group 1 vs population).

Arguments

• p1::Float64: study group proportion that we want to detect
• p2::Float64: population proportion
• power::Float64=0.8: the ability to detect a difference between groups (power = 1 - beta, where beta is the probability of type II error)

Returns

• n::Int64: study sample size (for both study groups)

size_p1g(; <keyword arguments>)

Calculate required sample size for a proportion (group 1 vs population).

Arguments

• p1::Float64: population proportion
• p2::Float64: study group proportion
• alpha::Float64=0.05: the probability of type I error
• power::Float64=0.8: the ability to detect a difference between groups (power = 1 - beta, where beta is the probability of type II error)

Returns

• n::Int64: group 1 sample size

size_p2g(; <keyword arguments>)

Calculate required sample size for a proportion (group 1 vs group 2).

Arguments

• p1::Float64: study group 1 proportion
• p2::Float64: study group 2 proportion
• r::Int64=1: enrollment ratio - the ratio of group 2 to group 1 enrollment
• alpha::Float64=0.05: the probability of type I error
• power::Float64=0.8: the ability to detect a difference between groups (power = 1 - beta, where beta is the probability of type II error)

Returns

Named tuple containing:

• n1::Int64: group 1 sample size
• n2::Int64: group 2 sample size

slope(p1, p2)

Calculate slope of the line crossing two points.

Arguments

• p1::Tuple{Real, Real}
• p2::Tuple{Real, Real}

Returns

• s::Float64: slope

stdc(g, x)

Calculate standard deviation of categorical data.

Arguments

• g::Vector{Int64}: group (e.g. [0, 1, 2, 3])
• x::Vector{Int64}: amount of subject per group (e.g. [2, 8, 27, 45])

Returns

• σ::Float64

stdp(p, n)

Calculate standard deviation of the proportion.

Arguments

• p::Float64: proportion
• n::Int64: number of observations

Returns

• σ::Float64

stdp(x1, x2; <keyword arguments>)

Calculate pooled standard deviation.

Arguments

• x1::AbstractVector
• x2::AbstractVector
• type::Symbol=:cohen: use Cohen's equation (:cohen) or maximum likelihood estimator by Hedges and Olkin (:hedges)

Returns

• sp::Float64

stdp(s1, s2, n1, n2; <keyword arguments>)

Calculate pooled standard deviation when number of subjects in groups are different.

Arguments

• s1::Real
• s2::Real
• n1::Int64
• n2::Int64
• type::Symbol=:cohen: use Cohen's equation (:cohen) or maximum likelihood estimator by Hedges and Olkin (:hedges)

Returns

• ps::Float64

stdp(s1, s2)

Calculate pooled standard deviation when number of subjects in groups are equal.

Arguments

• s1::Real
• s2::Real

Returns

• ps::Float64

summary(x; g)

Return summary statistics.

Arguments

• x::AbstractVector
• g::String="": group name

Returns

Named tuple containing:

• n::Int64: number of observations
• ms::Int64: missings
• mm::Float64: mean
• v::Float64: variance
• s::Float64: standard deviation
• min::Float64: minimum
• q1::Float64: 1st quartile
• md::Float64: median
• q3::Float64: 3rd quartile
• max::Float64: maximum
• mo::Float64: mode

summary(x; g, d)

Return summary statistics.

Arguments

• x::AbstractMatrix
• g::Vector{String}: group names
• d::Int64: round to d digits

Returns

- df::DataFrame containing: - :group: group name - :n: number of observations - :missing: missings - :m: mean - :v: variance - :s: standard deviation - :min: minimum - :Q1: 1st quartile - :median: median - :Q3: 3rd quartile - :max: maximum - :mode: mode

summary(x; g, d)

Return summary statistics.

Arguments

• x::AbstractMatrix
• g::Vector{String}: group names
• d::Int64: round to d digits

Returns

- df::DataFrame containing: - :group: group name - :n: number of observations - :missing: missings - :m: mean - :v: variance - :s: standard deviation - :min: minimum - :Q1: 1st quartile - :median: median - :Q3: 3rd quartile - :max: maximum - :mode: mode

sumsq(x)

Calculate sum of squares.

Arguments

• x::AbstractVector

Returns

• s::Float64

t2p(t; <keyword arguments>)

Convert t score to p value.

Arguments

• t::Real: t score
• df::Real: degrees of freedom
• twotailed::Bool=false: one- (P(Z > t)) or two-tailed (P(T < -t or T > t)) probability

Returns

• p::Float64

Notes

To calculate:

• P(T < t) (left-tailed) use 1 - t2p(t, df=df, twotailed=false)
• P(-t < T < t) use 1 - t2p(t, df=df, twotailed=true)
• P(0 < T < t) use (1 - t2p(t, df=df, twotailed=true))/2

varc(g, x)

Calculate variance of categorical data.

Arguments

• g::Vector{Int64}: group (e.g. [0, 1, 2, 3])
• x::Vector{Int64}: amount of subject per group (e.g. [2, 8, 27, 45])

Returns

• σ2::Float64

varp(p, n)

Calculate variance of the proportion.

Arguments

• p::Float64: proportion
• n::Int64: number of observations

Returns

• σ2::Float64

z2p(z; <keyword arguments>)

Convert z score to p value.

Arguments

• z::Real: z value
• twotailed::Bool=false: one- (P(Z > z)) or two-tailed (P(Z < -z or Z > z)) probability

Returns

• p::Float64

Notes

To calculate:

• P(Z < z) (left-tailed) use 1 - z2p(z, twotailed=false)
• P(-z < Z < z) use 1 - z2p(z, twotailed=true)
• P(0 < Z < z) use (1 - z2p(z, twotailed=true))/2

zscore(x)

Calculate z-scores for each value of the vector x.

Arguments

• x::AbstractVector

Returns

• z::Vector{Float64}

zscore(x, m, sd)

Calculate z-score for x.

Arguments

• x::Real
• m::Real: mean
• sd::Real: standard deviation

Returns

• z::Float64

export_csv(obj; <keyword arguments>)

Export NeuroAnalyzer.NEURO object to CSV.

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String
• names::Bool=true: export channel names
• header::Bool=false: export header
• epoch_time::Bool=false: export epoch time points
• components::Bool=false: export components
• markers::Bool=false: export event markers
• locs::Bool=false: export channel locations
• history::Bool=false: export history
• overwrite::Bool=false

Returns

Nothing

export_locs(obj; <keyword arguments>)

Export channel locations data, format is based on file_name extension (.csv, .ced, .locs or .tsv)

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String
• overwrite::Bool=false

Returns

Nothing

export_locs(locs; <keyword arguments>)

Export channel locations, format is based on file_name extension (.ced, .locs, .tsv)

Arguments

• locs::DataFrame
• file_name::String
• overwrite::Bool=false

Returns

Nothing

export_markers(obj; <keyword arguments>)

Export NeuroAnalyzer.NEURO object markers to CSV.

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String
• overwrite::Bool=false

Returns

Nothing

import_alice4(file_name; <keyword arguments>)

Load EDF exported from Alice 4 Polysomnography System and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

EDF files exported from Alice 4 have incorrect value of data_records (-1) and multiple sampling rate; channels are upsampled to the highest rate.

import_bdf(file_name; <keyword arguments>)

Load BDF/BDF+ file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on channel label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

• sampling_rate = n.samples ÷ data.record.duration
• gain = (physical maximum - physical minimum) ÷ (digital maximum - digital minimum)
• value = (value - digital minimum ) × gain + physical minimum

Source

1. https://www.biosemi.com/faq/file_format.htm

import_bv(file_name; <keyword arguments>)

Load BrainVision BVCDF file and return NeuroAnalyzer.NEURO object. At least two files are required: .vhdr (header) and .eeg (signal data). If available, markers are loaded from .vmrk file.

Arguments

• file_name::String: name of the file to load, should point to .vhdr file.
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

import_cnt(file_name; <keyword arguments>)

Load Neuroscan continuous signal file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label
• data_format::Symbol=:i32: Neuroscan stores data either in 16-bit (:i16) or 32-bit (:i32) representation, but does not say so in the file format

Returns

• obj::NeuroAnalyzer.NEURO

Notes

Based on loadcnt.m by Sean Fitzgibbon and Arnaud Delorme (https://cnl.salk.edu/~arno/cntload/index.html)

import_csv(file_name; <keyword arguments>)

Load CSV file (e.g. exported from EEGLAB) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

CSV first row or first column must contain channel names. Shape of data array will be detected automatically. Sampling rate will be detected. If file is gzip-ed, it will be uncompressed automatically while reading.

import_dat(file_name)

Load Neuroscan DAT file.

Arguments

• file_name::String: name of the file to load

Returns

• dat::DataFrame

import_digitrack(file_name; <keyword arguments>)

Load Digitrack ASCII file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

import_duomag(file_name)

Load DuoMAG TMS MEP recording file (.ascii or .m) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load

Returns

• obj::NeuroAnalyzer.NEURO

import_edf(file_name; <keyword arguments>)

Load EDF/EDF+ file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

• sampling_rate = n.samples ÷ data.record.duration
• gain = (physical maximum - physical minimum) ÷ (digital maximum - digital minimum)
• value = (value - digital minimum ) × gain + physical minimum

Source

1. Kemp B, Varri A, Rosa AC, Nielsen KD, Gade J. A simple format for exchange of digitized polygraphic recordings. Electroencephalography and Clinical Neurophysiology. 1992; 82(5): 391–3
2. Kemp B, Olivan J. European data format ‘plus’(EDF+), an EDF alike standard format for the exchange of physiological data. Clinical Neurophysiology 2003; 114: 1755–61
3. https://www.edfplus.info/specs/

import_edf_annotations(file_name; <keyword arguments>)

Load annotations from EDF+ file and return markers DataFrame. This function is used for EDF+ files containing annotations only.

Arguments

• file_name::String: name of the file to load

Returns

• markers::DataFrame

import_fiff(file_name)

Load Elekta-Neuromag 306 FIFF (Functional Image File Format) file (MEG, EEG) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load

Returns

• obj::NeuroAnalyzer.NEURO

import_ft(file_name; <keyword arguments>)

Load FieldTrip file (.mat) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• type::Symbol: type of imported data
  • :eeg: EEG
  • :meg: MEG
  • :nirs: fNIRS
  • :events: events
• detect_type::Bool=false: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO - for EEG, MEG, fNIRS data
• markers::DataFrame - for events

import_gdf(file_name; <keyword arguments>)

Load GDF file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Notes

• sampling_rate = n.samples ÷ data.record.duration
• gain = (physical maximum - physical minimum) ÷ (digital maximum - digital minimum)
• value = (value - digital minimum ) × gain + physical minimum

Source

1. Schlögl A, Filz O, Ramoser H, Pfurtscheller G. GDF - A General Dataformat for Biosignals Version 1.25. 1998
2. Schlögl, A. GDF - A General Dataformat for Biosignals Version 2.12. 2009
3. Schlögl, A. GDF - A General Dataformat for Biosignals Version 2.51. 2013

import_locs(file_name)

Load channel locations. Supported formats:

• CED
• ELC
• LOCS
• TSV
• SFP
• CSD
• GEO
• MAT
• TXT
• DAT
• ASC
• CSV

This is a meta-function that triggers appropriate import_locs_*() function. File format is detected based on file extension.

Arguments

• file_name::String: name of the file to load

Returns

• locs::DataFrame

import_locs_asc(file_name)

Load channel locations from ASC file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_ced(file_name)

Load channel locations from CED file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_csd(file_name)

Load channel locations from CSD file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_csv(file_name)

Load channel locations from CSV file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_dat(file_name)

Load channel locations from DAT file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_elc(file_name)

Load channel locations from ELC file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_geo(file_name)

Load channel locations from GEO file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_locs(file_name)

Load channel locations from LOCS file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_mat(file_name)

Load channel locations from MAT file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_sfp(file_name)

Load channel locations from SFP file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_tsv(file_name)

Load channel locations from TSV file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_locs_txt(file_name)

Load channel locations from TXT file.

Arguments

• file_name::String

Returns

• locs::DataFrame

import_montage(file_name)

Load montage from a text file. Example montage files are located in the montages/ folder. The structure of the file is:

• first line: name of the montage, e.g. longitudinal-BIP
• next lines: channel pairs or individual channels, e.g. Fz-Cz or Fp1

Each channel/channel pair must be in a separate line

Arguments

• file_name::String: name of the file to load

Returns

Named tuple containing:

• ref_list::Vector{String}: list of channel pairs
• ref_name::String: name of the montage

import_ncs(file_name)

Load Neuralinx Continuously Sampled Channels (CSC) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load

Returns

• obj::NeuroAnalyzer.NEURO

import_nirs(file_name)

Load NIRS file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load

Returns

• obj::NeuroAnalyzer.NEURO

Source

1. https://github.com/BUNPC/Homer3/wiki/HOMER3-file-formats

import_nirx(file_name)

Load NIRX file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load, should point to .hdr file.

Returns

• obj::NeuroAnalyzer.NEURO

Source

1. https://nirx.net/file-formats

import_npy(file_name; <keyword arguments>)

Load NPY file (exported from MNE) and return NeuroAnalyzer.NEURO object. Data type and channel types are set as is EEG.

Arguments

• file_name::String: name of the file to load
• sampling_rate::Int64: NPY file contains only signal data, therefore its sampling rate must be provided upon importing

Returns

• obj::NeuroAnalyzer.NEURO

import_nwb(file_name; <keyword arguments>)

Load EEG data from Neurodata Without Borders (NWB) file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Source

1. https://www.biorxiv.org/content/10.1101/523035v1

import_recording(file_name; <keyword arguments>)

Load recording file and return NeuroAnalyzer.NEURO object. Supported formats:

• EDF/EDF+
• BDF/BDF+
• GDF
• BrainVision
• CSV or CSV.GZ
• VHDR or AHDR (BrainVision)
• SET (EEGLAB dataset)
• NPY (MNE)
• XDF (Extensible Data Format)
• NWB (Neurodata Without Borders)
• NCS (Neuralinx Continuously Sampled Channels (CSC))
• FIFF (Neuromag)
• MAT (FieldTrip)
• SNIRF
• NIRS
• ASCII or M (DuoMAG TMS MEP)

This is a meta-function that triggers appropriate import_*() function. File format is detected based on file extension (.edf|.bdf|.gdf|.vhdr|.ahdr|.csv|.csv.gz|.set|.npy|.xdf|.nwb|.ncs|.fif|.fiff|.mat|.snirf|.nirs|.ascii|.m). Signal data type (e.g. EEG or MEG is auto-detected, if possible) and stored in the obj.header.recording[:data_type] field.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on channel label
• type::Union{Nothing, Symbol}=nothing: type of imported data (required for FieldTrip files)
  • :eeg: EEG
  • :meg: MEG
  • :nirs: fNIRS
  • :events: events
• n::Int64=0: subject number to extract in case of multi-subject file (required for SNIRF files)
• sampling_rate::Union{Nothing, Int64}=nothing: NPY file contains only signal data, therefore its sampling rate must be provided upon importing

Returns

• obj::NeuroAnalyzer.NEURO - for EEG, MEG, fNIRS data
• markers::DataFrame - for events

import_set(file_name; <keyword arguments>)

Load SET file (exported from EEGLAB) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• detect_type::Bool=true: detect channel type based on its label

Returns

• obj::NeuroAnalyzer.NEURO

Source

1. https://eeglab.org/tutorials/ConceptsGuide/Data_Structures.html

import_snirf(file_name; <keyword arguments>)

Load Shared Near Infrared Spectroscopy Format (SNIRF) file and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load
• n::Int64=0: subject number to extract in case of multi-subject file

Returns

• obj::NeuroAnalyzer.NEURO

Source

1. https://github.com/fNIRS/snirf/blob/v1.1/snirf_specification.md

import_thymatron(file_name)

Import scanned images of EEG printed by Thymatron ECT equipment and return NeuroAnalyzer.NEURO object.

Usually there are three images: baseline, during seizure activity and after seizure activity. If more then one image is provided, images are added as consecutive channels in the same object.

Image properties:

• 100 DPI
• 490 x 100 px
• height 2.5 cm
• width 12.5 cm

Arguments

• file_name::Union{String, Vector{String}}: name(s) of the file(s) to load
• dpi::Int64=100: DPI of the scanned images

Returns

• obj::NeuroAnalyzer.NEURO

Source

1. Wysokiński A. EEG_ADC: Digitizer and Analyzer of Electroconvulsive Therapy Paper Electroencephalogram Recordings. JECT 2022; 4: 255-256

import_xdf(file_name)

Load Extensible Data Format (XDF) and return NeuroAnalyzer.NEURO object.

Arguments

• file_name::String: name of the file to load

Returns

• obj::NeuroAnalyzer.NEURO

load(file_name)

Load NeuroAnalyzer.NEURO object from file_name file (HDF5-based).

Arguments

• file_name::String: name of the file to load

Returns

• obj::NeuroAnalyzer.NEURO

load_fiff(file_name)

Load Elekta-Neuromag 306 FIFF (Functional Image File Format) file (MEG, EEG) and return FIFF object.

Arguments

• file_name::String: name of the file to load

Returns

• fiff::Dict{Symbol, Dict{Any, Any}}
• fiff_object::Vector{Any}
• fiff_blocks::Matrix{Int64}

Source

1. Elekta Neuromag: Functional Image File Format Description. FIFF version 1.3. March 2011

load_locs(obj; <keyword arguments>)

Load channel locations from file_name and return NeuroAnalyzer.NEURO object with locs data frame.

Accepted formats:

• CED
• LOCS
• ELC
• TSV
• SFP
• CSD
• GEO
• MAT
• TXT
• DAT
• ASC
• CSV

Channel locations:

• loc_theta: polar angle
• loc_radius: polar radius
• loc_x: spherical Cartesian x
• loc_y: spherical Cartesian y
• loc_z: spherical Cartesian z
• loc_radius_sph: spherical radius
• loc_theta_sph: spherical horizontal angle
• loc_phi_sph: spherical azimuth angle

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String: name of the file to load

Returns

• obj_new::NeuroAnalyzer.NEURO

load_locs!(obj; <keyword arguments>)

Load channel locations from file_name and return NeuroAnalyzer.NEURO object with locs data frame.

Accepted formats:

• CED
• LOCS
• ELC
• TSV
• SFP
• CSD
• GEO
• MAT
• TXT
• DAT
• ASC

Channel locations:

• loc_theta: polar angle
• loc_radius: polar radius
• loc_x: spherical Cartesian x
• loc_y: spherical Cartesian y
• loc_z: spherical Cartesian z
• loc_radius_sph: spherical radius
• loc_theta_sph: spherical horizontal angle
• loc_phi_sph: spherical azimuth angle

Arguments

• obj::NeuroAnalyzer.NEURO
• file_name::String

Return

Nothing