StatGeochem

TC = Ayers_tsphene(SiO2, TiO2, Al2O3, FeOT, MnO, MgO, CaO, Na2O, K2O, P2O5)

Calculate sphene saturation temperature in degrees Celsius Following the sphene saturation calibration of Ayers et al., 2018 (doi: 10.1130/abs/2018AM-320568)

TiO2Sat = Ayers_tspheneTiO2(SiO2, TiO2, Al2O3, FeOT, MnO, MgO, CaO, Na2O, K2O, P2O5, T)

Calculate sphene saturation TiO2 concentration (in wt. %) for a given temperature (in C) following the sphene saturation calibration of Ayers et al., 2018 (doi: 10.1130/abs/2018AM-320568)

T = Boehnke_tzirc(SiO2, TiO2, Al2O3, FeOT, MnO, MgO, CaO, Na2O, K2O, P2O5, Zr)

Calculate zircon saturation temperature in degrees Celsius Following the zircon saturation calibration of Boehnke, Watson, et al., 2013 (doi: 10.1016/j.chemgeo.2013.05.028)

M = Boehnke_tzircM(SiO2, TiO2, Al2O3, FeOT, MnO, MgO, CaO, Na2O, K2O, P2O5)

Calculate zircon saturation M-value based on major element concentrations Following the zircon saturation calibration of Boehnke, Watson, et al., 2013 (doi: 10.1016/j.chemgeo.2013.05.028)

ZrSat = Boehnke_tzircZr(SiO2, TiO2, Al2O3, FeOT, MnO, MgO, CaO, Na2O, K2O, P2O5, T)

Calculate zircon saturation Zr concentration for a given temperature (in C) Following the zircon saturation calibration of Boehnke, Watson, et al., 2013 (doi: 10.1016/j.chemgeo.2013.05.028)

TC = Harrison_tapatite(SiO2, P2O5)

Calculate apatite saturation temperature in degrees Celcius following the apatite saturation model of Harrison and Watson 1984 (doi: 10.1016/0016-7037(84)90403-4)

As Harrison_tapatiteP2O5, but returns saturation phosphorus concentration in PPM P

P2O5 = Harrison_tapatiteP2O5(SiO2, Al2O3, CaO, Na2O, K2O, T)

Calculate P2O5 concentration (in wt.%) required for apatite saturation at a given T (in C) following the apatite saturation model of Harrison and Watson 1984 (doi: 10.1016/0016-7037(84)90403-4) with the correction of Bea et al. 1992 (doi: 10.1016/0024-4937(92)90033-U) where applicable

LREEmolwt(La, Ce, Pr, Nd, Sm, Gd)

Returns the average molecular weight of the LREE considered in the REEt value from the monazite saturation model of Montel 1993 (doi: 10.1016/0009-2541(93)90250-M)

LREEt(La, Ce, Pr, Nd, Sm, Gd)

Returns the sum of the LREE concentrations divided by their respective molar masses. If REE are input in parts per million by weight (ppmw), the result is in units of moles per megagram. This is equivalent to the REEt value from the monazite saturation model of Montel 1993 (doi: 10.1016/0009-2541(93)90250-M)

TC = Montel_tmonazite(SiO2, TiO2, Al2O3, FeOT, MgO, CaO, Na2O, K2O, Li2O, H2O, La, Ce, Pr, Nd, Sm, Gd)

Calculate monazite saturation temperature in degrees Celcius following the monazite saturation model of Montel 1993 (doi: 10.1016/0009-2541(93)90250-M)

REEt = Montel_tmonaziteREE(SiO2, TiO2, Al2O3, FeOT, MgO, CaO, Na2O, K2O, Li2O, H2O, T)

Calculate monazite saturation REEt value (in [ppm/mol.wt.]) for a given temperature (in C) following the monazite saturation model of Montel 1993 (doi: 10.1016/0009-2541(93)90250-M), where:

D = (Na + K + Li + 2Ca) / Al * 1/(Al + Si)) # all as molar cation fractions (not at. %!) ln(REEt) = 9.50 + 2.34D + 0.3879√H2O - 13318/T # H2O as wt.% REEt = Σ REEᵢ(ppm) / at. weight (g/mol)

LREEt = Rusiecka_tmonaziteREE(P_ppm, TC)

Calculate the LREEt (mol/Megagram) value required for monazite saturation at a temperature of TC degrees celcius and P ppmw phosphorous present, following the solubility model of Rusiecka & Baker, 2019 (doi: 10.2138/am-2019-6931)

LREEt = Rusiecka_txenotimeY(P_ppm, TC)

Calculate the Y (ppmw) concentration required for xenotime saturation at a temperature of TC degrees celcius and P ppmw phosphorous present, following the solubility model of Rusiecka & Baker, 2019 (doi: 10.2138/am-2019-6931)

TC = Tollari_tapatite(SiO2, TiO2, Al2O3, FeOT, MgO, CaO, Na2O, K2O, P2O5)

Calculate apatite saturation temperature in degrees Celcius following the apatite saturation model of Tollari et al. 2006 (doi: 10.1016/j.gca.2005.11.024)

P2O5 = Tollari_tapatiteP2O5(SiO2, CaO, T)

Calculate P2O5 concentration (in wt.%) required for apatite saturation at a given T (in C) following the apatite saturation model of Tollari et al. 2006 (doi: 10.1016/j.gca.2005.11.024)

bin_bsr([f!::Function], x::Vector, y::VecOrMat, xmin, xmax, nbins, [w];
    	x_sigma = zeros(size(x)),
    	y_sigma = zeros(size(y)),
    	nresamplings = 1000,
    	sem = :sigma,
    	p = 0.2
)

Returns the bincenters c, means or medians m, and uncertainties of the mean or median for a variable y binned by independent variable x into nbins equal bins between xmin and xmax, after nresamplings boostrap resamplings with acceptance probability p.

If a 2-d array (matrix) of y values is provided, each column will be treated as a separate variable, means and uncertainties will be returned column-wise.

Optional keyword arguments and defaults:

x_sigma = zeros(size(x))

A vector representing the uncertainty (standard deviation) of each x value

y_sigma = zeros(size(y))

A vector representing the uncertainty (standard deviation) of each y value

nresamplings = 1000

The number of resamplings to conduct

sem = :sigma

Format of the uncertainty estimate of the distribution of the mean. If :sigma is chosen, a tuple of three vectors (c, m, e) will be returned, where e is the standard error of the mean. If :CI or :pctile is chosen, a tuple of four vectors (c, m, el, eu) will be returned, where el and eu are the lower and upper bounds of the 95% confidence interval.

p = 0.2

Resampling probabilities, either as a scalar or a vector of the same length as x

Examples:

(c,m,e) = bin_bsr(nanbinmedian!, x, y, 0, 4000, 40, x_sigma=0.05x, p=probability, sem=:sigma)

(c,m,el,eu) = bin_bsr(nanbinmean!, x, y, 0, 4000, 40, x_sigma=0.05x, p=probability, sem=:pctile)

(c, m, el, eu) = bin_bsr_ratios([f!::Function], x::Vector, num::Vector, denom::Vector, xmin, xmax, nbins, [w];
    	x_sigma = zeros(size(x)),
    	num_sigma = zeros(size(num)),
    	denom_sigma = zeros(size(denom)),
    	nresamplings = 1000,
    	p::Union{Number,Vector} = 0.2
)

Returns the bincenters c, means m, as well as upper (el) and lower (eu) 95% CIs of the mean for a ratio num/den binned by x into nbins equal bins between xmin and xmax, after nresamplings boostrap resamplings with acceptance probability p.

(bincenters, N) = bincounts(x::AbstractArray, xmin::Number, xmax::Number, nbins::Integer)

Tally the number of samples that fall into each of nbins equally spaced x bins between xmin and xmax, aligned with bin edges as xmin:(xmax-xmin)/nbins:xmax

(c,m,e) = binmeans(x, y, xmin, xmax, nbins, [weight]; resamplingratio::Number=1)

The means (ignoring NaNs) of y values binned by x, into each of nbins equally spaced x bins between xmin and xmax, returning bincenters, means, and standard errors of the mean.

To calculate binned medians only (without uncertainties), see nanmean

Examples

(c,m,e) = binmeans(x, y, 0, 4000, 40)

binmedians(x::AbstractArray, y::AbstractArray, min::Number, max::Number, nbins::Integer;
    	resamplingratio::Number=1
)

The medians (ignoring NaNs) of y values binned by x, into each of nbins equally spaced x bins between xmin and xmax, returning bincenters, medians, and equivalent standard errors of the mean (1.4828 * median abolute deviation)

To calculate binned medians only (without uncertainties), see nanmedian

Examples

(c,m,e) = binmedians(x, y, 0, 4000, 40)

bsr!([f::Function], resampled::Array, index::Vector{Int}, data, sigma, p;
    	rng::AbstractRNG=MersenneTwister()
)

Fill resampled with data boostrap resampled from a (sample-per-row / element-per-column) dataset data with uncertainties sigma and resampling probabilities p, optionally using random numbers generated by f where f is a function of the form f(rng, data[i], sigma[i])

resampled = bsresample(data::AbstractArray, sigma, nrows, [p];
    	 kernel = gaussian,
    	 rng = MersenneTwister(),
    	 return_index = false
)

Bootstrap resample a (sample-per-row / element-per-column) array of data with uncertainties sigma and resampling probabilities p

resampled = bsresample(dataset::Dict, nrows, [elements], [p];
    	 kernel = gaussian,
    	 rng = MersenneTwister()
)

Bootstrap resample a dictionary-based dataset with uncertainties stored either in dataset["err"] or dataset["[variable]_sigma"]

changepoint(data, [sigma], nsteps; np, npmin, npmax)

Given an ordered array of data points, optionally with uncertainties sigma, use a Markov chain Monte Carlo approach based on that of Gallagher et al., 2010 (10.1016/j.epsl.2011.09.015) to estimate the position (by index) and optionally number of changepoints that best explain the data. Will return the results for nsteps steps of the Markov chain.

Optionally, you may also specify as keyword arguments either np or npmin and npmax to constrain the number of allowed changepoints.

Currently prints results to the terminal (stdout), one line per step of the Markov chain, but a more efficent output format is probably desirable in a future version of this function.

concatenatedatasets(d1::AbstractDict, d2::AbstractDict)

Vertically concatenate two Dict-based datasets, variable-by-variable

delim_string_function(f, str, delim, T;
    	merge::Bool=false,

Parse a delimited string str with delimiter delim into substrings that will then be operated upon by function f. The results of f will be returned in an array with eltype T.

delim_string_parse(str, delim, T;
    	merge::Bool=false,
    	undefval=NaN)

Parse a delimited string str with delimiter delim into values of type T and return the answers as an array with eltype T

delim_string_parse!(result, str, delim, [T];
    	offset::Integer=0,
    	merge::Bool=false,
    	undefval=NaN)

Parse a delimited string str with delimiter delim into values of type T and return the answers in a pre-allocated result array provided as input.

If T is not specified, it the eltype of the result array will be used by default.

(x,y) = digitize_plotline(img, line_color, xlims, ylims; atol=0.16)

Calculate approximate x and y positions for a colored line in an image

(x,dx,y,dy) = digitize_plotmarkers(img, marker_color, xlims, ylims; atol=0.16)

Calculate approximate x and y positions and uncertainties for colored markers in an image

elementify(data::Array, elements::Array=data[1,:];
    	importas=:Dict,
    	standardize::Bool=true,
    	floattype=Float64,
    	skipstart::Integer=1,
    	skipnameless::Bool=true
)

Convert a flat array data into a dictionary (importas=:Dict) or named tuple (importas=:Tuple) with each column as a variable. Tuples are substantially more efficient, so should be favored where possible.

eustar(Nd::Number, Sm::Number, Gd::Number, Tb::Number)

Calculate expected europium concentration, Eu*, based on abundance of adjacent rare earths. Full four-element log-linear interpolation, using ionic radii

eustar(Sm::Number, Gd::Number)

Calculate expected europium concentration, Eu*, based on abundance of adjacent rare earths. Simple geometric mean interpolation from Sm and Gd alone

exportdataset(dataset, [elements], filepath, delim;
    	floatout::Bool=false,
    	findnumeric::Bool=false,
    	skipnan::Bool=true,
    	digits::Integer,
    	sigdigits::Integer
    	rows=:
)

Convert a dict or named tuple of vectors into a 2-D array with variables as columns Export a dataset (in the form of either a Dict or a NamedTuple), optionally specifying which elements to export, as a delimited ASCII text file with the name specified by filepath and delimiter delim.

Possible keyword arguments include:

	digits
	sigdigits

Specify a number of absolute or significant digits to which to round the printed output. Default is no rounding.

	skipnan

Leave NaNs as empty cells in the delimited output file. Boolean; true by default.

	floatout

Force all output to be represented as a floating-point number, or else NaN. Boolean; false by default.

	findnumeric

Export only numeric columns. Boolean; false by default.

	rows

specify which rows of the dataset to export. Default : exports all rows.

feoconversion(FeO::Number=NaN, Fe2O3::Number=NaN, FeOT::Number=NaN, Fe2O3T::Number=NaN)

Compiles data from FeO, Fe2O3, FeOT, and Fe2O3T into a single FeOT value.

find_tc1_age(lat::Number,lon::Number)

Return a tuple (age, age_min, age_max) containing the nominal, upper, and lower tc1 age bounds for the 1x1 arc degree grid cell containing lat and lon

find_tc1_age(lat::AbstractArray,lon::AbstractArray)

Return a tuple (age, age_min, age_max) where age, age_min, and age_max are arrays containing the nominal, upper and lower tc1 age bounds for each location pair lat[i], lon[i]

find_tc1_crust(lat::Number,lon::Number)

Find the depth to the 550C isotherm for the 1x1 arc degree grid cell containing lat and lon

find_tc1_crust(lat::AbstractArray,lon::AbstractArray)

For each pair of latitudes and longitudes given by lat and lon, find the depth to the 550C isotherm for the 1x1 arc degree grid cell containing lat[i] and lon[i]

find_tc1_lith(lat::Number,lon::Number)

Find the depth to the 1300C isotherm for the 1x1 arc degree grid cell containing lat and lon

find_tc1_lith(lat::AbstractArray,lon::AbstractArray)

For each pair of latitudes and longitudes given by lat and lon, find the depth to the 1300C isotherm for the 1x1 arc degree grid cell containing lat[i] and lon[i]

floatify(x, T::Type=Float64)

Convert x to a floating-point number (default Float64) by any means necessary

function importdataset(filepath, delim;
    	importas=:Dict,
    	standardize::Bool=true,
    	floattype=Float64,
    	skipstart::Integer=0,
    	skipnameless::Bool=true,
    	mindefinedcolumns::Integer=0
)

Import a delimited file specified by filepath with delimiter delim as a dataset in the form of either a Dict or a NamedTuple.

Possible keyword arguments include:

	importas

Specify the format of the imported dataset. Options include :Dict and :Tuple

	standardize

Convert columns to uniform type wherever possible. Boolean; true by default.

	floattype

Preferred floating-point type for numerical data. Float64 by default.

	skipstart

Ignore this many rows at the start of the input file (useful if input file has a header or other text before the column names). 0 by default.

	skipnameless

Skip columns with no column name. Boolean; true by default

	mindefinedcolumns

Skip rows with fewer than this number of delimiters. 0 by default.

k = invweight(lat::AbstractArray, lon::AbstractArray, age::AbstractArray;
    	lp::Number=2,
    	spatialscale=1.8,
    	agescale=38.0
)

Find the inverse weights k (proportional to spatiotemporal sample density) for a set of geological samples with specified latitude (lat), logitude (lon), and age (of crystallization, deposition, etc.).

The default spatialscale and agescale are taken from Keller and Schoene 2012. However, alternative scalings can be supplied. If an array is supplied for either spatialscale, agescale, or both, a 3-d matrix of k values will be returned, with dimensions length(spatialscale)length(agescale)nrows.

k = invweight(nums::AbstractArray, scale::Number; lp=2)

Find the inverse weights for a single array nums for a given scale, and exponent lp (default lp = 2).

Returns an array k where k[i] is the "inverse weight" for element i of the input array.

k = invweight_age(age::AbstractArray; lp::Number=2, agescale::Number=38.0)

Find the inverse weights k (proportional to temporal sample density) for a set of geological samples with specified age (of crystallization, deposition, etc.).

k = invweight_location(lat::AbstractArray, lon::AbstractArray;
    	lp::Number=2,
    	spatialscale::Number=1.8
)

Find the inverse weights k (proportional to spatial sample density) for a set of geological samples with specified latitude (lat), and logitude (lon).

melts_clean_modes(scratchdir::String; index=1)

Read and parse / clean-up modal phase proportions from specified MELTS run directory Returns an elementified dictionary

melts_configure(meltspath::String, scratchdir::String, composition::Array{Float64},
    	elements::Array,
    	T_range::Array=[1400, 600],
    	P_range::Array=[10000,10000];)

Configure and run a MELTS simulation using alphaMELTS. Optional keyword arguments and defaults:

batchstring::String="1 sc.melts 10 1 3 1 liquid 1 1.0 0 10 0 4 0 "

dT = -10

dP = 0

index = 1

version = "pMELTS"

mode = "isobaric"

fo2path = "FMQ" Oxygen fugacity buffer to follow, e.g., FMQ or NNO+1

fractionatesolids::Bool = false Fractionate all solids

suppress::Array{String} = [] Supress individual phases (specify as strings in array, i.e. ["leucite"])

verbose::Bool = true Print verbose MELTS output to terminal (else, write it to melts.log)

melts_query_modes(scratchdir::String; index=1)

Read all phase proportions from Phase_main_tbl.txt in specified MELTS run directory Returns an elementified dictionary

melts_query_liquid(scratchdir::String; index=1)

Read liquid composition from Liquid_comp_tbl.txt in specified MELTS run directory Returns an elementified dictionary

melts_query_modes(scratchdir::String; index=1)

Read modal phase proportions from Phase_mass_tbl.txt in specified MELTS run Returns an elementified dictionary

melts_query_solid(scratchdir::String; index=1)

Read solid composition from Solid_comp_tbl.txt in specified MELTS run directory Returns an elementified dictionary

nonnumeric(x)

Return true for if x is not missing but cannot be parsed as a number

dataset = oxideconversion!(dataset::Dict; unitratio::Number=10000)

Convert major elements (Ti, Al, etc.) into corresponding oxides (TiO2, Al2O3, ...) in place.

If metals are as PPM, set unitratio=10000 (default); if metals are as wt%, set unitratio = 1

dataset = oxideconversion(dataset::Dict; unitratio::Number=10000)

Convert major elements (Ti, Al, etc.) into corresponding oxides (TiO2, Al2O3, ...).

If metals are as PPM, set unitratio=10000 (default); if metals are as wt%, set unitratio = 1

parsedlm(str::AbstractString, delimiter::Char, T::Type=Float64; rowdelimiter::Char='\n')

Parse a string delimited by both row and column into a single (2-D) matrix. Default column delimiter is newline. Similar to readdlm, but operating on a string instead of a file.

perplex_configure_geotherm(perplexdir::String, scratchdir::String, composition::Array{<:Number},
    	elements::String=["SIO2","TIO2","AL2O3","FEO","MGO","CAO","NA2O","K2O","H2O"],
    	P_range::Array{<:Number}=[280,28000], T_surf::Number=273.15, geotherm::Number=0.1;
    	dataset::String="hp02ver.dat",
    	index::Integer=1,
    	npoints::Integer=100,
    	solution_phases::String="O(HP)\nOpx(HP)\nOmph(GHP)\nGt(HP)\noAmph(DP)\ncAmph(DP)\nT\nB\nChl(HP)\nBio(TCC)\nMica(CF)\nCtd(HP)\nIlHm(A)\nSp(HP)\nSapp(HP)\nSt(HP)\nfeldspar_B\nDo(HP)\nF\n",
    	excludes::String="ts\nparg\ngl\nged\nfanth\ng\n",
    	mode_basis::String="vol",  #["vol", "wt", "mol"]
    	composition_basis::String="wt",  #["vol", "wt", "mol"]
    	fluid_eos::Integer=5)

Set up a PerpleX calculation for a single bulk composition along a specified geothermal gradient and pressure (depth) range. P specified in bar and T_surf in Kelvin, with geothermal gradient in units of Kelvin/bar

perplex_configure_isobar(perplexdir::String, scratchdir::String, composition::Array{<:Number},
    	elements::String=["SIO2","TIO2","AL2O3","FEO","MGO","CAO","NA2O","K2O","H2O"]
    	P::Number=10000, T::Array{<:Number}=[500+273.15, 1500+273.15];
    	dataset::String="hp11ver.dat",
    	index::Integer=1,
    	npoints::Integer=100,
    	solution_phases::String="O(HP)\nOpx(HP)\nOmph(GHP)\nGt(HP)\noAmph(DP)\ncAmph(DP)\nT\nB\nChl(HP)\nBio(TCC)\nMica(CF)\nCtd(HP)\nIlHm(A)\nSp(HP)\nSapp(HP)\nSt(HP)\nfeldspar_B\nDo(HP)\nF\n",
    	excludes::String="ts\nparg\ngl\nged\nfanth\ng\n",
    	mode_basis::String="vol",  #["vol", "wt", "mol"]
    	composition_basis::String="wt",  #["vol", "wt", "mol"]
    	fluid_eos::Integer=5)

Set up a PerpleX calculation for a single bulk composition along a specified isobaric temperature gradient. P specified in bar and T_range in Kelvin

perplex_configure_pseudosection(perplexdir::String, scratchdir::String, composition::Array{<:Number},
    	elements::Array{String}=["SIO2","TIO2","AL2O3","FEO","MGO","CAO","NA2O","K2O","H2O"],
    	P::Array{<:Number}=[280, 28000], T::Array{<:Number}=[273.15, 1500+273.15];
    	dataset::String="hp11ver.dat",
    	index::Integer=1,
    	xnodes::Integer=42,
    	ynodes::Integer=42,
    	solution_phases::String="O(HP)\nOpx(HP)\nOmph(GHP)\nGt(HP)\noAmph(DP)\ncAmph(DP)\nT\nB\nChl(HP)\nBio(TCC)\nMica(CF)\nCtd(HP)\nIlHm(A)\nSp(HP)\nSapp(HP)\nSt(HP)\nfeldspar_B\nDo(HP)\nF\n",
    	excludes::String="ts\nparg\ngl\nged\nfanth\ng\n",
    	mode_basis::String="vol", #["vol", "wt", "mol"]
    	composition_basis::String="wt", #["wt", "mol"]
    	fluid_eos::Number=5)

Set up a PerpleX calculation for a single bulk composition across an entire 2d P-T space. P specified in bar and T in Kelvin.

perplex_query_modes(perplexdir::String, scratchdir::String, P::Array{<:Number}, T::Array{<:Number};
    	index::Integer=1, npoints::Integer=200, include_fluid="y")

Query modal mineralogy (mass proportions) along a specified P-T path using a pre-computed pseudosection. Results are returned as a dictionary.

perplex_query_modes(perplexdir::String, scratchdir::String;
    	dof::Integer=1, index::Integer=1, include_fluid="y")

Query modal mineralogy (mass proportions) along a previously configured 1-d path (dof=1, isobar or geotherm) or 2-d grid / pseudosection (dof=2). Results are returned as a dictionary.

Currently returns vol %

perplex_query_phase(perplexdir::String, scratchdir::String, phase::String, P::Array{<:Number}, T::Array{<:Number};
    	index::Integer=1, npoints::Integer=200, include_fluid="y", clean_units::Bool=true)

Query all perplex-calculated properties for a specified phase (e.g. "Melt(G)") along a specified P-T path using a pre-computed pseudosection. Results are returned as a dictionary.

perplex_query_phase(perplexdir::String, scratchdir::String, phase::String;
    	dof::Integer=1, index::Integer=1, include_fluid="y", clean_units::Bool=true)

Query all perplex-calculated properties for a specified phase (e.g. "Melt(G)") along a previously configured 1-d path (dof=1, isobar or geotherm) or 2-d grid / pseudosection (dof=2). Results are returned as a dictionary.

perplex_query_point(perplexdir::String, scratchdir::String, P::Number, T::Number; index::Integer=1)

Query perplex results at a single P,T point in a pseudosection. Results are returned as a string.

perplex_query_point(perplexdir::String, scratchdir::String, indvar::Number; index::Integer=1)

Query perplex results at a single temperature on an isobar or single pressure on a geotherm. Results are returned as a string.

perplex_query_seismic(perplexdir::String, scratchdir::String, P::Array{<:Number}, T::Array{<:Number};
    	index::Integer=1, npoints::Integer=200, include_fluid="n")

Query perplex seismic results along a specified P-T path using a pre-computed pseudosection. Results are returned as a dictionary.

perplex_query_seismic(perplexdir::String, scratchdir::String;
    	dof::Integer=1, index::Integer=1, include_fluid="n")

Query perplex seismic results along a previously configured 1-d path (dof=1, isobar or geotherm) or 2-d grid / pseudosection (dof=2). Results are returned as a dictionary.

function perplex_query_system(perplexdir::String, scratchdir::String, P::Array{<:Number}, T::Array{<:Number};
    	index::Integer=1, npoints::Integer=200, include_fluid="y",clean_units::Bool=true)

Query all perplex-calculated properties for the system (with or without fluid) along a specified P-T path using a pre-computed pseudosection. Results are returned as a dictionary. Set include_fluid="n" to return solid+melt only.

perplex_query_system(perplexdir::String, scratchdir::String;
    	index::Integer=1, include_fluid="y", clean_units::Bool=true)

?

Query all perplex-calculated properties for the system (with or without fluid) along a previously configured 1-d path (dof=1, isobar or geotherm) or 2-d grid / pseudosection (dof=2). Results are returned as a dictionary. Set include_fluid="n" to return solid+melt only.

plausiblynumeric(x)

Return true if x can be parsed as a number, else false

randsample(data::Array, nrows, [p])

Bootstrap resample (without uncertainty) a data array to length nrows. Optionally provide weights p either as a vector (one-weight-per-sample) or scalar.

randsample(dataset::Dict, nrows, [elements], [p])

Bootstrap resample (without uncertainty) a dataset dict to length nrows. Optionally provide weights p either as a vector (one-weight-per-sample) or scalar.

renormalize!(dataset, [elements]; total=1.0)

Normalize in-place a (i.e., compositional) dataset defined by a Dict or NamedTuple of one-dimensional numerical arrays, such that all the elements (i.e., variables – by default all keys in the datset) sum to a given total (by default, 1.0).

Note that the arrays representing each element or variable are assumed to be of uniform length

renormalize!(A::AbstractArray; dim, total=1.0)

Normalize an array A in place such that it sums to total. Optionally may specify a dimension dim along which to normalize.

system(cmdstr::AbstractString)

Direct access to the command line through C's system function – without stripping/sanitizing special characters, in contrast to Julia's safer run() function. This allows pipelining, etc. in shell commands. Returns 0 on success.

unelementify(dataset, elements;
    	floatout::Bool=false,
    	floattype=Float64,
    	findnumeric::Bool=false,
    	skipnan::Bool=false,
    	rows=:
)

Convert a dict or named tuple of vectors into a 2-D array with variables as columns