text:
# mcmc sampler¶

This is the Markov Chain Monte Carlo Metropolis sampler used by CosmoMC, and described in Lewis, “Efficient sampling of fast and slow cosmological parameters” (arXiv:1304.4473). It works well on simple uni-modal (or only weakly multi-modal) distributions.

The proposal pdf is a gaussian mixed with an exponential pdf in random directions, which is more robust to misestimation of the width of the proposal than a pure gaussian. The scale width of the proposal can be specified per parameter with the property proposal (it defaults to the standard deviation of the reference pdf, if defined, or the prior’s one, if not). However, initial performance will be much better if you provide a covariance matrix, which overrides the default proposal scale width set for each parameter.

Note

The proposal width for a parameter should be close to its conditional posterior, not its marginalized width. For strong degeneracies the latter can be much wider than the former, and hence it could cause the chain to get stuck. Underestimating a good proposal width is usually better than overestimating it: an underestimate can be rapidly corrected by the adaptive covariance learning, but if the proposal width is too large the chain may never move at all.

If the distribution being sampled is known have tight strongly non-linear parameter degeneracies, re-define the sampled parameters to remove the degeneracy before sampling (linear degeneracies are not a problem, esp. if you provide an approximate initial covariance matrix).

## Initial point for the chains¶

The initial points for the chains are sampled from the reference pdf (see Parameters and priors). If the reference pdf is a fixed point, chains will always start from that point. If there is no reference pdf defined for a parameter, the initial sample is drawn from the prior instead.

Example of parameters block:

params:
a:
prior:
min: -2
max:  2
ref:
min: -1
max:  1
proposal: 0.5
latex: \alpha

b:
prior:
min: -1
max:  4
ref: 2
proposal: 0.25
latex: \beta
c:
prior:
min: -1
max:  1
ref:
dist: norm
loc: 0
scale: 0.2
latex: \gamma

• a – the initial point of the chain is drawn from an uniform pdf between -1 and 1.
• b – the initial point of the chain is always at b=2.
• c – the initial point of the chain is drawn from a gaussian centred at 0 with standard deviation 0.2.

Fixing the initial point is not usually recommended, since to assess convergence it is useful to run multiple chains (which you can do in parallel using MPI), and use the difference between the chains to assess convergence: if the chains all start in exactly the same point, they could appear to have converged just because they started at the same place. On the other hand if your initial points are spread much more widely than the posterior it could take longer for chains to converge.

## Covariance matrix of the proposal pdf¶

An accurate, or even approximate guess for the proposal pdf will normally lead to significantly faster convergence.

In Cobaya, the covariance matrix of the proposal pdf is optionally indicated through mcmc’s property covmat, either as a file name (including path, absolute or relative to the invocation folder), or as an actual matrix. If a file name is given, the first line of the covmat file must start with #, followed by a list of parameter names, separated by a space. The rest of the file must contain the covariance matrix, one row per line.

An example for the case above:

# a     b
0.1   0.01
0.01  0.2

Instead, if given as a matrix, you must also include the covmat_params property, listing the parameters in the matrix in the order in which they appear. Finally, covmat admits the special value auto that searches for an appropriate covariance matrix in a database (see Basic cosmology runs).

If you do not know anything about the parameters’ correlations in the posterior, instead of specifying the covariance matrix via MCMC’s covmat field, you may simply add a proposal field to the sampled parameters, containing the expected standard deviation of the proposal. In the absence of a parameter in the covmat which also lacks its own proposal property, the standard deviation of the reference pdf (of prior if not given) will be used instead (though you would normally like to avoid that possibility by providing at least a proposal property, since guessing it from the prior usually leads to a very small initial acceptance rate, and will tend to get your chains stuck).

Note

A covariance matrix given via covmat does not need to contain the all the sampled parameters, and may contain additional ones unused in your run. For the missing parameters the specified input proposal (or reference, or prior) is used, assuming no correlations.

If the covariance matrix shown above is used for the previous example, the final covariance matrix of the proposal will be:

# a     b     c
0.1   0.01  0
0.01  0.2   0
0     0     0.04

If the option learn_proposal is set to True, the covariance matrix will be updated regularly. This means that a high accuracy of the initial covariance is not critical (just make sure your proposal widths are sufficiently small that chains can move and hence explore the local shape; if your widths are too wide the parameter may just get stuck).

If you are not sure that your posterior has one single mode, or if its shape is very irregular, you may want to set learn_proposal: False; however the MCMC sampler is not likely to work well in this case and other samplers designed for multi-modal distributions (e.g. PolyChord) may be a better choice.

If you do not know how good your initial guess for the starting point and covariance is, a number of initial burn in samples can be ignored from the start of the chains (e.g. 10 per dimension). This can be specified with the parameter burn_in. These samples will be ignored for all purposes (output, convergence, proposal learning…). Of course there may well also be more burn in after these points are discarded, as the chain points converge (and, using learn_proposal, the proposal estimates also converge). Often removing the first 30% the entire final chains gives good results (using ignore_rows=0.3 when analysing with getdist).

## Taking advantage of a speed hierarchy¶

In Cobaya, the proposal pdf is blocked by speeds, i.e. it allows for efficient sampling of a mixture of fast and slow parameters, such that we can avoid recomputing the slowest parts of the likelihood calculation when sampling along the fast directions only. This is often very useful when the likelihoods have large numbers of nuisance parameters, but recomputing the likelihood for different sets of nuisance parameters is fast.

Two different sampling schemes are available in the mcmc sampler to take additional advantage of a speed hierarchy:

• Oversampling the fast parameters: consists simply of taking more steps in the faster directions, useful when exploring their conditional distributions is cheap. Enable it by setting oversample_power to any value larger than 0 (1 means spending the same amount of time in all parameter blocks; you will rarely want to go over that value).
• Dragging the fast parameters: consists of taking a number of intermediate fast steps when jumping between positions in the slow parameter space, such that (for large numbers of dragging steps) the fast parameters are dragged along the direction of any degeneracy with the slow parameters. Enable it by setting drag: True. You can control the relative amount of fast vs slow samples with the same oversample_power parameter.

In general, the dragging method is the recommended one if there are non-trivial degeneracies between fast and slow parameters that are not well captured by a covariance matrix, and you have a fairly large speed hierarchy. Oversampling can potentially produce very large output files (less so if the oversample_thin option is left to its default True value); dragging outputs smaller chain files since fast parameters are effectively partially marginalized over internally. For a thorough description of both methods and references, see A. Lewis, “Efficient sampling of fast and slow cosmological parameters” (arXiv:1304.4473).

The relative speeds can be specified per likelihood/theory, with the option speed, preferably in evaluations per second (approximately). The speeds can also be measured automatically when you run a chain (with mcmc, measure_speeds: True), allowing for variations with the number of threads used and machine differences. This option only tests the speed on one point (per MPI instance) by default, so if your speed varies significantly with where you are in parameter space it may be better to either turn the automatic selection off and keep to manually specified average speeds, or to pass a large number instead of True as the value of measure_speeds (it will evaluate the posterior that many times, so the chains will take longer to initialise).

To manually measure the average speeds, set measure_speeds in the mcmc block to a high value and run your input file with the --test option; alternatively, add timing: True at the highest level of your input (i.e. not inside any of the blocks), set the mcmc options burn_in: 0 and max_samples to a reasonably large number (so that it will be done in a few minutes), and check the output: it should have printed, towards the end, computation times for the likelihood and theory codes in seconds, the inverse of which are the speeds.

If the speed has not been specified for a component, it is assigned the slowest one in the set. If two or more components with different speeds share a parameter, said parameter is assigned to a separate block with a speed that takes into account the computation time of all the codes that depends on it.

For example:

theory:
theory_code:
speed: 2

likelihood:
like_a:
like_b:
speed: 4

Here, evaluating the theory code is the slowest step, while the like_b is faster. Likelihood like_a is assumed to be as slow as the theory code.

### Manual specification of speed blocking¶

Automatic speed blocking takes advantage of differences in speed per likelihood (or theory). If the parameters of your likelihood or theory have some internal speed hierarchy that you would like to exploit (e.g. if your likelihood internally caches the result of a computation depending only on a subset of the likelihood parameters), you can specify a fine-grained list of parameter blocks and their oversampling factors, using the mcmc option blocking.

E.g. if a likelihood depends of parameters a, b and c and the cost of varying a is twice as big as the other two, your mcmc block should look like

mcmc:
blocking:
- [1, [a]]
- [2, [b,c]]
# drag: True  # if desired; 2 different oversampling factors only!

Warning

When choosing an oversampling factor, one should take into account the total cost of varying one parameter in the block, i.e. the time needed to re-compute every part of the code that depends (directly or indirectly) on it.

For example, if varying parameter a in the example above would also force a re-computation of the part of the code associated to parameters b and c, then the relative cost of varying the parameters in each block would not be 2-to-1, but (2+1)-to-1, meaning oversampling factors of 1 and 3 may be more appropriate.

Note

If blocking is specified, it must contain all the sampled parameters.

Note

If automatic learning of the proposal covariance is enabled, after some checkpoint the proposed steps will mix parameters from different blocks, but always towards faster ones. Thus, it is important to specify your blocking in ascending order of speed, when not prevented by the architecture of your likelihood (e.g. due to internal caching of intermediate results that require some particular order of parameter variation).

## Convergence checks¶

Convergence of an MCMC run is assessed in terms a generalized version of the $$R-1$$ Gelman-Rubin statistic, implemented as described in arXiv:1304.4473.

In particular, given a small number of chains from the same run, the $$R-1$$ statistic measures (from the last half of each chain) the variance between the means of the different chains in units of the covariance of the chains (in other words, that all chains are centered around the same point, not deviating from it a significant fraction of the standard deviation of the posterior). When that number becomes smaller than Rminus1_stop twice in a row, a second $$R-1$$ check is also performed on the bounds of the Rminus1_cl_level % confidence level interval, which, if smaller than Rminus1_cl_stop, stops the run.

The default settings have Rminus1_stop = 0.01, Rminus1_cl_level = 0.95 and Rminus1_cl_level = 0.2; the stop values can be decreased for better convergence.

Note

For single-chain runs, the chain is split into a number Rminus1_single_split of segments, the first segment is discarded, and the $$R-1$$ checks are performed on the rest as if they were independent chains.

Warning

The $$R-1$$ diagnostics is a necessary but not sufficient condition for convergence. Most realistic cases should have converged when $$R-1$$ is small enough, but harder ones, such as multimodal posteriors with modes farther apart than their individual sizes, may mistakenly report convergence if all chains are stuck in the same mode (or never report it if stuck in different ones). Using a smaller value of Rminus1_cl_stop can ensure better exploration of the tails of the distribution, which may be important if you want to place robust limits on parameters or make 2D constraint plots.

## Progress monitoring¶

When writing to the hard drive, the MCMC sampler produces an additional [output_prefix].progress file containing the acceptance rate and the Gelman $$R-1$$ diagnostics (for means and confidence level contours) per checkpoint, so that the user can monitor the convergence of the chain. In interactive mode (when running inside a Python script of in the Jupyter notebook), an equivalent progress table in a pandas.DataFrame is returned among the products.

The mcmc module provides a plotting tool to produce a graphical representation of convergence, see plot_progress(). An example plot can be seen below:

from cobaya.samplers.mcmc import plot_progress
# Assuming chain saved at chains/gaussian
plot_progress("chains/gaussian", fig_args={"figsize": (6,4)})
import matplotlib.pyplot as plt
plt.tight_layout()
plt.show()

When writing to the hard drive (i.e. when an [output_prefix].progress file exists), one can produce these plots even if the sampler is still running.

## Callback functions¶

A callback function can be specified through the callback_function option. It must be a function of a single argument, which at runtime is the current instance of the mcmc sampler. You can access its attributes and methods inside your function, including the SampleCollection of chain points and the model (of which prior and likelihood are attributes). For example, the following callback function would print the points added to the chain since the last callback:

def my_callback(sampler):
print(sampler.collection[sampler.last_point_callback:])

The callback function is called every callback_every points have been added to the chain, or at every checkpoint if that option has not been defined.

## Interaction with MPI when using MCMC inside your own script¶

When integrating Cobaya in your pipeline inside a Python script (as opposed to calling it with cobaya-run), you need to be careful when using MPI: exceptions will not me caught properly unless some wrapping is used:

from mpi4py import MPI

comm = MPI.COMM_WORLD
rank = comm.Get_rank()

from cobaya.run import run
from cobaya.log import LoggedError

success = False
try:
upd_info, mcmc = run(info)
success = True
except LoggedError as err:
pass

# Did it work? (e.g. did not get stuck)
success = all(comm.allgather(success))

if not success and rank == 0:
print("Sampling failed!")

In this case, if one of the chains fails, the rest will learn about it and raise an exception too as soon as they arrive at the next checkpoint (in order for them to be able to learn about the failing process earlier, we would need to have used much more aggressive MPI polling in Cobaya, that would have introduced a lot of communication overhead).

As sampler products, every MPI process receives its own chain via the products() method. To gather all of them in the root process and combine them, skipping the first third of each, do:

all_chains = comm.gather(mcmc.products()["sample"], root=0)

# Pass all of them to GetDist in rank = 0

if rank == 0:
from getdist.mcsamples import MCSamplesFromCobaya
gd_sample = MCSamplesFromCobaya(upd_info, all_chains)

# Manually concatenate them in rank = 0 for some custom manipulation,
# skipping 1st 3rd of each chain

copy_and_skip_1st_3rd = lambda chain: chain[int(len(chain) / 3):]
if rank == 0:
full_chain = copy_and_skip_1st_3rd(all_chains[0])
for chain in all_chains[1:]:
full_chain.append(copy_and_skip_1st_3rd(chain))
# The combined chain is now full_chain

## Options and defaults¶

Simply copy this block in your input yaml file and modify whatever options you want (you can delete the rest).

# Default arguments for the Markov Chain Monte Carlo sampler
# ('Xd' means 'X steps per dimension', or full parameter cycle
#  when adjusting for oversampling / dragging)

# Number of discarded burn-in samples per dimension (d notation means times dimension)
burn_in: 0
# Error criterion: max attempts (= weight-1) before deciding that the chain
# is stuck and failing. Set to .inf to ignore these kind of errors.
max_tries: 40d
# File (including path) or matrix defining a covariance matrix for the proposal:
# - null (default): will be generated from params info (prior and proposal)
# - matrix: remember to set covmat_params to the parameters in the matrix
# - "auto" (cosmology runs only): will be looked up in a library
covmat:
covmat_params:
# Overall scale of the proposal pdf (increase for longer steps)
proposal_scale: 2.4
# Update output file(s) and print some info
# every X seconds (if ends in 's') or X accepted samples (if just a number)
output_every: 60s
# Number of distinct accepted points between proposal learn & convergence checks
learn_every: 40d
# Proposal covariance matrix learning
# -----------------------------------
learn_proposal: True
# Don't learn if convergence is worse than...
learn_proposal_Rminus1_max: 2.
# (even earlier if a param is not in the given covariance matrix)
learn_proposal_Rminus1_max_early: 30.
# ... or if it is better than... (no need to learn, already good!)
learn_proposal_Rminus1_min: 0.
# Convergence and stopping
# ------------------------
# Maximum number of accepted steps
max_samples: .inf
# Gelman-Rubin R-1 on means
Rminus1_stop: 0.01
# Gelman-Rubin R-1 on std deviations
Rminus1_cl_stop: 0.2
Rminus1_cl_level: 0.95
# When no MPI used, number of fractions of the chain to compare
Rminus1_single_split: 4
# Exploiting speed hierarchy
# --------------------------
# Whether to measure actual speeds for your machine/threading at starting rather
# than using stored values
measure_speeds: True
# Amount of oversampling of each parameter block, relative to their speeds
# Value from 0 (no oversampling) to 1 (spend the same amount of time in all blocks)
# Can be larger than 1 if extra oversampling of fast blocks required.
oversample_power: 0.4
# Thin chain by total oversampling factor (ignored if drag: True)
# NB: disabling it with a non-zero oversample_power may produce a VERY LARGE chains
oversample_thin: True
# Dragging: simulates jumps on slow params when varying fast ones
drag: False
# Manual blocking
# ---------------
# Specify parameter blocks and their correspondent oversampling factors
# (may be useful e.g. if your likelihood has some internal caching).
# If used in combination with dragging, assign 1 to all slow parameters,
# and a common oversampling factor to the fast ones.
blocking:
#  - [oversampling_factor_1, [param_1, param_2, ...]]
#  - etc.
# Callback function
# -----------------
callback_function:
callback_every:  # default: every checkpoint
# Seeding runs
# ------------
seed:  # integer between 0 and 2**32 - 1
# To be deprecated
# ----------------
check_every:  # now it is learn_every
oversample: # now controlled by oversample_power > 0
drag_limits:  # use oversample_power instead

## Module documentation¶

Synopsis: Blocked fast-slow Metropolis sampler (Lewis 1304.4473) Antony Lewis (for the CosmoMC sampler, wrapped for cobaya by Jesus Torrado)

### MCMC sampler class¶

class samplers.mcmc.MCMC(info_sampler: Dict[str, Any], model: cobaya.model.Model, output=typing.Union[cobaya.output.Output, NoneType], packages_path: Optional[str] = None, name: Optional[str] = None)

Adaptive, speed-hierarchy-aware MCMC sampler (adapted from CosmoMC) cite{Lewis:2002ah,Lewis:2013hha}.

set_instance_defaults()

Can use this to define any default instance attributes before setting to the input dictionary (from inputs or defaults)

initialize()

Initializes the sampler: creates the proposal distribution and draws the initial sample.

run()

Runs the sampler.

n(burn_in=False)

Returns the total number of accepted steps taken, including or not burn-in steps depending on the value of the burn_in keyword.

get_new_sample_metropolis()

Draws a new trial point from the proposal pdf and checks whether it is accepted: if it is accepted, it saves the old one into the collection and sets the new one as the current state; if it is rejected increases the weight of the current state by 1.

Returns: True for an accepted step, False for a rejected one.
get_new_sample_dragging()

Draws a new trial point in the slow subspace, and gets the corresponding trial in the fast subspace by “dragging” the fast parameters. Finally, checks the acceptance of the total step using the “dragging” pdf: if it is accepted, it saves the old one into the collection and sets the new one as the current state; if it is rejected increases the weight of the current state by 1.

Returns: True for an accepted step, False for a rejected one.
metropolis_accept(logp_trial, logp_current)

Symmetric-proposal Metropolis-Hastings test.

Returns: True or False.
process_accept_or_reject(accept_state, trial, trial_results)

Processes the acceptance/rejection of the new point.

check_ready()

Checks if the chain(s) is(/are) ready to check convergence and, if requested, learn a new covariance matrix for the proposal distribution.

check_convergence_and_learn_proposal()

Checks the convergence of the sampling process, and, if requested, learns a new covariance matrix for the proposal distribution from the covariance of the last samples.

products()

Auxiliary function to define what should be returned in a scripted call.

Returns: The sample SampleCollection containing the accepted steps.
classmethod output_files_regexps(output, info=None, minimal=False)

Returns a list of tuples (regexp, root) of output files potentially produced. If root in the tuple is None, output.folder is used.

If minimal=True, returns regexp’s for the files that should really not be there when we are not resuming.

classmethod get_version()

Get version information for this component.

Returns: string or dict of values or None

### Progress monitoring¶

samplers.mcmc.plot_progress(progress, ax=None, index=None, figure_kwargs=mappingproxy({}), legend_kwargs=mappingproxy({}))

Plots progress of one or more MCMC runs: evolution of R-1 (for means and c.l. intervals) and acceptance rate.

Takes a progress instance (actually a pandas.DataFrame, returned as part of the sampler products), a chain output prefix, or a list of any of those for plotting progress of several chains at once.

You can use figure_kwargs and legend_kwargs to pass arguments to matplotlib.pyplot.figure and matplotlib.pyplot.legend respectively.

Return a subplots axes array. Display with matplotlib.pyplot.show().

### Proposal¶

Synopsis: proposal distributions Antony Lewis and Jesus Torrado

Using the covariance matrix to give the proposal directions typically significantly increases the acceptance rate and gives faster movement around parameter space.

We generate a random basis in the eigenvectors, then cycle through them proposing changes to each, then generate a new random basis. The distance proposal in the random direction is given by a two-D Gaussian radial function mixed with an exponential, which is quite robust to wrong width estimates

class samplers.mcmc.proposal.CyclicIndexRandomizer(n, random_state)
next()

Get the next random index, or alternate for two or less.

Returns: index
class samplers.mcmc.proposal.RandDirectionProposer(n, random_state)
propose_vec(scale: float = 1)

propose a random n-dimension vector for n>1

Parameters: scale – units for the distance array with vector
propose_r()

Radial proposal. By default a mixture of an exponential and 2D Gaussian radial proposal (to make wider tails and more mass near zero, so more robust to scale misestimation)

Returns: random distance (unit scale)
class samplers.mcmc.proposal.BlockedProposer(parameter_blocks, random_state, oversampling_factors=None, i_last_slow_block=None, proposal_scale=2.4)
set_covariance(propose_matrix)

Take covariance of sampled parameters (propose_matrix), and construct orthonormal parameters where orthonormal parameters are grouped in blocks by speed, so changes in slowest block changes slow and fast parameters, but changes in the fastest block only changes fast parameters

Parameters: propose_matrix – covariance matrix for the sampled parameters.


text:
3D Graphic Statics: Geometric Construction of Global Equilibrium

Akbarzadeh M., Van Mele T. and Block P.
Proceedings of the International Association for Shell and Spatial Structures (IASS) Symposium
Amsterdam
2015

Graphic Statics provides a collection of procedures for the design and analysis of two-dimensional structural systems, involving only geometric operations on two-dimensional form and force diagrams. Unfortunately, the applicability of Graphic Statics to three-dimensional problems is limited. Only three-dimensional problems that can be replaced by an equivalent series of two-dimensional problems, can be addressed.

Revious research has shown how the equilibrium of three-dimensional systems of forces can be described using polyhedral form and force diagrams. However, procedures for solving specific design and analysis problems with these polyhedral diagrams have not yet been developed. One of the fundamental procedures in traditional (2D) Graphic Statics is to establish global equilibrium for given boundary conditions, and to use this information to construct different funicular solutions for the specified loads and supports. Therefore, in this paper, as a first step in the development of truly 3D Graphic Statics, we describe an equivalent procedure for given, three-dimensional boundary conditions. The procedure involves only geometric operations on polyhedral form and force diagrams.

The method, as it is presented here, is only applicable to statically determined systems of forces in which the applied loads do not generate a resultant couple. We give an overview of the well known procedure in 2D Graphic Statics to identify its key concepts and constructive elements, and describe the different steps of the three-dimensional version in detail.

BibTeX

@inproceedings{Akbarzadeh2015,
author    = "Akbarzadeh, M. and Van Mele, T. and Block, P. ",
title     = "3D Graphic Statics: Geometric Construction of Global Equilibrium",
booktitle = "Proceedings of the  International Association for Shell and Spatial Structures (IASS) Symposium",
year      = "2015",
editor    = "",
volume    = "",
number    = "",
pages     = "",
publisher = "",
month     = "August",
doi       = "",
note      = "",
}

Related publications

Computer-Aided Design,63: 118-128,2015.
Proceedings of the International Association for Shell and Spatial Structures (IASS) Symposium 2013,Wroclaw, Poland,2013 (September).

ETH Zurich
Institute of Technology in Architecture
Block Research Group
Stefano-Franscini-Platz 1, HIB E 45
8093 Zurich, Switzerland
paulson@arch.ethz.ch
block.arch.ethz.ch

+41 44 633 38 35  phone
+41 44 633 10 53  fax

format: plain


text:
## omnomnom Group Title An object falls for 2 seconds after being dropped from rest. Its speed is approximately: Select one: a. 2 m/sec. Incorrect b. 4.9 m/sec. c. 9.8 m/sec. d. 19.6 m/sec. one year ago one year ago

1. slorraine Group Title

It's 19.6m/sec

2. omnomnom Group Title

thank yiuuuu

3. JamesWolf Group Title

Slorraine is totally right, $v = g \times t$ v = velocity/meters per second, g = acceleration due to gravity on earth (9.8)meters per second per second, t = time/seconds

4. omnomnom Group Title

I know shes right :D


text:
AAS Meeting #194 - Chicago, Illinois, May/June 1999
Session 71. Between the Stars II: The ISM, Galactic and Extragalactic
Display, Wednesday, June 2, 1999, 10:00am-6:30pm, Southwest Exhibit Hall

## [71.09] Further Evidence for Chemical Fractionation from Ultraviolet Observations of Interstellar Carbon Monoxide

S.R. Federman (UToledo), David L. Lambert, Yaron Sheffer (UTexas), Jason A. Cardelli (Villanova), B-G Andersson (JHU/JPL), Ewine F. van Dishoeck (Leiden), J. Zsarg\'{o} (UToledo)

Ultraviolet absorption from interstellar 12CO and 13CO was detected toward \rho Oph A and \chi Oph. The measurements were obtained at medium resolution with the Goddard High Resolution Spectrograph on the Hubble Space Telescope. Equivalent widths were converted into column densities through the use of f-values from Chan et al. (1993, Chem. Phys., 170, 123). Column density ratios, N(12CO)/N(13CO), of 125 ± 23 and 117 ± 35 were derived for the sight lines toward \rho Oph A and \chi Oph, respectively. A value of 1000 ± 500 for the ratio N(12C16O)/N(12C18O) toward \rho Oph A was also obtained.

These ratios are larger than the isotopic ratios for carbon and oxygen appropriate for the ambient material. Since for both carbon and oxygen the more abundant isotopic variant is enhanced, selective isotope photodissociation plays the key role in the fractionation process. The enhancement arises because the more abundant variant has lines that are more optically thick, resulting in more self shielding from dissociating radiation. A simple argument involving the amount of self shielding (from N(12CO)) and the strength of the UV field permeating the gas (from the amount of vibrationally excited H2 seen in our spectra) shows that selective isotope photodissociation does control the fractionation seen in these two sight lines, as well as the sight line to \zeta Oph.

If the author provided an email address or URL for general inquiries, it is a s follows:


text:
# When are homotopy colimits in $\mathrm{Cat}$ colimits in $\mathcal{C}\mathrm{at}_\infty$?

Letting $\mathrm{Cat}$ denote the category of (small) categories and $\mathrm{Set}_\Delta$ the category of simplicial sets, it is well known that the nerve $N:\mathrm{Cat} \to \mathrm{Set}_\Delta$ admits a left adjoint which we can denote by $\mathrm{Ho}:\mathrm{Set}_\Delta \to \mathrm{Cat}$.

Endowing $\mathrm{Cat}$ with the unique (proper) model structure $[1]$ having as weak equivalences the usual equivalences of categories and $\mathrm{Set}_\Delta$ with the Joyal model structure one can readily check that $(\mathrm{Ho}, N)$ is a Quillen pair.

By work of Aaron Mazel-Gee $[2]$ this induces an adjunction $$i:\mathcal{C}\mathrm{at} \leftrightarrows\mathcal{C}\mathrm{at}_\infty:\mathrm{Ho},$$ between the $\infty$-categories underlying, respectively, the model categories $\mathrm{Cat}$ and $\mathrm{Set}_\Delta$ above. We can therefore conclude that $i: \mathcal{C}\mathrm{at} \to \mathcal{C}\mathrm{at}_\infty$ preserves limits (5.2.3.5 Higher Topos Theory).

However, I do not believe that $i$ preserves colimits. My argument goes as follows:

One can also present $\mathcal{C}\mathrm{at}_\infty$ as the $\infty$-category underlying the cartesian model structure on $\mathrm{Set}_\Delta^+$, the category of marked simplical sets. As this is combinatorial (3.1.3.7 HTT) and simplicial (3.1.4.4 HTT) $\mathcal{C}\mathrm{at}_\infty$ is presentable (A.3.7.6 HTT).

Similarly, in a note by Rezk $[3]$ it is shown that canonical model structure on $\mathrm{Cat}$ is cofibrantly generated and simplicial. I assume that $\mathrm{Cat}$ is locally presentable, though I do not know of a reference. Assuming that this is the case, $\mathcal{C}\mathrm{at}$ is also presentable.

By the adjoint functor theorem (5.5.2.9 HTT) $i$ preserves colimits if and only if $i$ admits a right adjoint. Let's denote such a candidate right adjoint by $R: \mathcal{C}\mathrm{at}_\infty \to \mathcal{C}\mathrm{at}$. Then in particular it must be that case that for each ordinary category $\mathrm{C}$ and each $\infty$-category $\mathcal{C}$, $$\mathrm{Map}( \mathrm{C}, \mathcal{C}) \simeq \mathrm{Map}(\mathrm{C}, R(\mathcal{C}).$$ Consider the case when $\mathrm{C} = [0]$ and $\mathcal{C}$ is an $\infty$-groupoid $X$. Then the above adjunction would require an equivalence of spaces $$X \simeq \iota R(X).$$ Since $R(X)$ is an ordinary category, $\iota R(X)$ is $1$-truncated and so such an equivalence cannot hold for general $X$.

What colimits are preserved by $i:\mathcal{C}\mathrm{at} \to \mathcal{C}\mathrm{at}_\infty$? In particular, which pushouts are preserved by $i$?

$[2]$: Aaron Mazel-Gee, Quillen adjunctions induce adjunctions of quasicategories

$[3]$: Charles Rezk, A model category for categories

• $\infty$-categories are generated by simplices under colimits, so $Cat$ cannot be closed under colimits – Denis Nardin Aug 15 '16 at 22:40
• Welcome to MO Mark :-) (PS: did you have slides/notes for your recent talk at Leicester?) – David Roberts Aug 15 '16 at 23:26
• @DenisNardin Thanks for the comment. I realised shortly after submitting that the answer to the question was in the negative, though for a different reason. I've edited the question to reflect this. Do you have a reference for the statement that $\mathcal{C}at_{oo}$ is generated by simplices? – Mark Penney Aug 15 '16 at 23:26
• @DavidRoberts Thanks for the welcome David! I have slides that I would be happy to send you. – Mark Penney Aug 15 '16 at 23:30
• Cat is locally presentable. Check out the examples in Adamek and Rosicky, right after the definition. – David White Aug 16 '16 at 1:15


text:
# Help with single slit diffraction (fraunhoffer)

1. Dec 2, 2007

### j-lee00

urgent Help with single slit diffraction (fraunhoffer)

why is it a minimum at a*sin ($$\theta$$) = m*$$\lambda$$,

a = slit separation

I would have thought if the path difference is equal to a whole wavelength then there would be constructive interference??

See http://hyperphysics.phy-astr.gsu.edu/hbase/hframe.html

Last edited: Dec 2, 2007
2. Dec 2, 2007

### Staff: Mentor

Don't confuse the double slit interference condition (http://hyperphysics.phy-astr.gsu.edu/hbase/phyopt/slits.html#c1").

In the single slit condition, when the light from opposite ends of the slit have a full wavelength phase difference, that means that half the light from the slit is exactly one half wavelength out of phase with the other half. Which mean destructive interference.

Last edited by a moderator: Apr 23, 2017


text:
Skip to main content

# ‘exocrine’

#### The Role of HNF6 on Pancreatic Cancer

The effects of the acinar-specific inactivation of the Hnf6 transcription factor in pancreatic cancer as well as the correlation between PanIN progression to pancreatic cancer and HNF6 expression were studied here. Authors:

Posted by Printess Berry on Tuesday, September 15th, 2015 in May 2011, , , , ,


text:
×

# How to do this geometry problem?

I can't make sense of this problem. I can find AEO=30 and OAE=30 so AOE=120. But I can't go further. The diagram is so complicated.

Note by Ajala Singh
3 years, 9 months ago

Sort by:

Okay,so my solution is like this: Let $$\angle BAC = x$$,therefore $$\angle EAO = 45-x.$$(Diameter subtend $$90^{\circ}$$ at the circumcircle) Also,$$\angle AEB = 30^{\circ}$$,and $$OE=OA$$,so $$45-x=30 \Rightarrow x=15^{\circ}.$$ Notice that $$\angle CBE=\angle CAE \Rightarrow \angle CBE =75^{\circ}.$$ Also observe that quadrilateral $$BCDE$$ is cyclic, therefore $$\angle EDC=105^{\circ} \Rightarrow \angle DEB=75^{\circ}.$$

Hence $$\angle AEF = 180^{\circ} - \angle DEB - \angle AEB = 75^{\circ}$$and by above angle chasing,it is obvious that $$\bigtriangleup AEF \sim \bigtriangleup CAE$$ by $$AAA$$ similarity criteria.I hope this may help. · 3 years, 9 months ago


text:
Definitions

# Interval arithmetic

Interval arithmetic, also called interval mathematics, interval analysis, and interval computation, is a method in mathematics. It has been developed by mathematicians since the 1950s and 1960s as an approach to putting bounds on rounding errors in mathematical computation and thus developing numerical methods that yield very reliable results.

Where classical arithmetic defines operations on individual numbers, interval arithmetic defines a set of operations on intervals:

T · S = { x | there is some y in T, and some z in S, such that x = y · z }.

The basic operations of interval arithmetic are, for two intervals [a, b] and [c, d] that are subsets of the real line (-∞,∞),

• [a,b] + [c,d] = [a + c, b + d]
• [a,b] − [c, d] = [ad, bc]
• [a,b] × [c,d] = [min (ac, ad, bc, bd), max (ac, ad, bc, bd)]
• [a,b] / [c,d] = [min (a/c, a/d, b/c, b/d), max (a/c, a/d, b/c, b/d)]

Division by an interval containing zero is not defined under the basic interval arithmetic. The addition and multiplication operations are commutative, associative and sub-distributive: the set X (Y + Z ) is a subset of XY + XZ.

Instead of working with an uncertain real $x$ we work with the two ends of the interval $\left[a,b\right]$ which contains $x$: $x$ lies between $a$ and $b$, or could be one of them. Similarly a function $f$ when applied to $x$ is also uncertain. Instead, in interval arithmetic $f$ produces an interval $\left[c,d\right]$ which is all the possible values for $f\left(x\right)$ for all $x in \left[a,b\right]$.

This concept is suitable, inter alia, for the treatment of rounding errors directly during the calculation and of uncertainties in the knowledge of the exact values of physical and technical parameters. The latter often arise from measurement errors and tolerances for components. Interval arithmetic also helps find reliable and guaranteed solutions to equations and optimization problems.

Take as an example the calculation of body mass index (BMI). The BMI is the body weight in kilograms divided by the square of height in metres. Measuring the mass with bathroom scales may have an accuracy of one kilogram. We will not know intermediate values - about 79.6 kg or 80.3 kg - but information rounded to the nearest whole number. It is unlikely that you really weigh 80.0 kg exactly when it appears. In normal rounding to the nearest value, the scales showing 80 kg indicates a weight between 79.5 kg and 80.5 kg. The relevant range is that of all real numbers that are greater than or equal to 79.5, while less than or equal to 80.5, or in other words the interval [79.5,80.5].

For a man who weighs 80 kg and is 1.80 m tall, the BMI is about 24.7. With a weight of 79.5 kg and the same height the value is 24.5, while 80.5 kilograms gives almost 24.9. So the actual BMI is in the range [24.5,24.9]. The error in this case does not affect the conclusion (normal weight), but this is not always the position. For example, weight fluctuates in the course of a day so that the BMI can vary between 24 (normal weight) and 25 (overweight). Without detailed analysis it is no possible to always exclude questions as to whether an error ultimately is large enough to have significant influence.

Interval arithmetic states the range of possible outcomes explicitly. Simply put, results are no longer stated as numbers, but as intervals which represent imprecise values. The size of the intervals are similar to error bars to a metric in expressing the extent of uncertainty. Simple arithmetic operations, such as basic arithmetic and trigonometric functions, enable the calculation of outer limits of intervals.

## Introduction

The main focus in the interval arithmetic is on the simplest way to calculate upper and lower endpoints for the the range of values of a function in one or more variables. These barriers need be not necessarily the supremum or infimum, since the precise calculation of those values are often too difficult; it can be shown that that task is in general NP-hard.

Treatment is typically limited to real intervals, so quantities of form

$\left[a,b\right] = \left\{x in mathbb\left\{R\right\} ,|, a le x le b\right\}$,
where $a = \left\{-infty\right\}$ and $b = \left\{infty\right\}$ are allowed; with one of then infinite we would have an unbounded interval, while with both infinite we would have the whole real number line.

As with traditional calculations with real numbers, simple arithmetic operations and functions on elementary intervals must first be defined (Lit.: Kulisch, 1989). More complicated functions can be calculated from these basic elements (Lit.: Kulish, 1989).

### Simple arithmetic

Returning to the earlier BMI example, in determining the body mass index, height and body weight both affect the result. For height, measurements are usually in round centimetres: a recorded measurement of 1.80 metres actually means a height somewhere between 1.795 m and 1.805 m. This uncertainty must be combined with the fluctuation range in weight between 79.5 kg and 80.5 kg. The BMI is defined as the weight in kilograms divided by the square of height in metre. Using either 79.5 kg and 1.795 m or 80.5 kg and 1.805 m gives approximately 24.7. But the person in question may only be 1.795 m tall, with a weight of 80.5 kilograms - or 1.805 m and 79.5 kilograms: all combinations of all possible intermediate values must be considered. Using the interval arithmetic methods described below, the BMI lies in the interval

$\left[79\left\{.\right\}5; 80\left\{.\right\}5\right]/\left(\left[1\left\{.\right\}795; 1\left\{.\right\}805\right]\right)^2 = \left[24\left\{.\right\}4; 25\left\{.\right\}0\right].$

An operation $\left\{langle!mathrm\left\{op\right\}!rangle\right\}$ on two intervals , with $\left\{langle!mathrm\left\{op\right\}!rangle\right\}$ for example being addition or multiplication, is defined by

$\left[x_1, x_2\right] \left\{,langle!mathrm\left\{op\right\}!rangle,\right\} \left[y_1, y_2\right] = \left\{ x \left\{,langle!mathrm\left\{op\right\}!rangle,\right\} y , | , x in \left[x_1, x_2\right] ,mbox\left\{and\right\}, y in \left[y_1, y_2\right] \right\}$.
For the four basic arithmetic operations this can become
$begin\left\{matrix\right\}\left[x_1, x_2\right]\left\{,langle!mathrm\left\{op\right\}!rangle,\right\} \left[y_1, y_2\right] & = & \left\{left\left[min\left(x_1 \left\{langle!mathrm\left\{op\right\}!rangle\right\} y_1, x_1\left\{langle!mathrm\left\{op\right\}!rangle\right\} y_2, x_2 \left\{langle!mathrm\left\{op\right\}!rangle\right\} y_1, x_2 \left\{langle!mathrm\left\{op\right\}!rangle\right\} y_2\right),$
right.} && {left. ;max(x_1 {langle!mathrm{op}!rangle}y_1, x_1 {langle!mathrm{op}!rangle} y_2, x_2 {langle!mathrm{op}!rangle} y_1, x_2 {langle!mathrm{op}!rangle} y_2) right]} ,mathrm{,} end{matrix}

provided that $x \left\{,langle!mathrm\left\{op\right\}!rangle,\right\} y$ is allowed for all $xin \left[x_1, x_2\right]$ and $y in \left[y_1, y_2\right]$.

For practical applications this can be simplified further:

• Addition: $\left[x_1, x_2\right] + \left[y_1, y_2\right] = \left[x_1+y_1, x_2+y_2\right]$
• Subtraction: $\left[x_1, x_2\right] - \left[y_1, y_2\right] = \left[x_1-y_2, x_2-y_1\right]$
• Multiplication: $\left[x_1, x_2\right] cdot \left[y_1, y_2\right] = \left[min\left(x_1 y_1,x_1 y_2,x_2 y_1,x_2 y_2\right), max\left(x_1 y_1,x_1 y_2,x_2 y_1,x_2 y_2\right)\right]$
• Division: $\left[x_1, x_2\right] / \left[y_1, y_2\right] =$

[x_1, x_2] cdot (1/[y_1, y_2]), where $1/\left[y_1, y_2\right] = \left[1/y_2, 1/y_1\right]$ if $0 notin \left[y_1, y_2\right]$. For division by an interval including zero, first define

$1/\left[y_1, 0\right] = \left[-infty, 1/y_1\right]$ and $1/\left[0, y_2\right] = \left[1/y_2, infty\right]$.
For $y_1 < 0 < y2$, we get $1/\left[y_1, y_2\right] = \left[-infty, 1/y_1\right] cup \left[1/y_2, infty\right]$ which as a single interval gives $1/\left[y_1, y_2\right] = \left[-infty, infty\right]$; this loses useful information about $\left(1/y_1, 1/y_2\right)$. So typically it is common to work with $\left[-infty, 1/y_1\right]$ and $\left[1/y_2, infty\right]$ as separate intervals.

Because several such divisions may occur in an interval arithmetic calculation, it is sometimes useful to do the calculation with so-called multi-intervals of the form $textstyle bigcup_\left\{i=1\right\}^l \left[x_\left\{i1\right\},x_\left\{i2\right\}\right]$. The corresponding multi-interval arithmetic maintains a disjoint set of intervals and also provides for overlapping intervals to unite (Lit.: Dreyer, 2005).

Since a number $rin mathbb\left\{R\right\}$ can be interpreted as the interval $\left[r,r\right]$, you can combine intervals and real numbers.

With the help of these definitions, it is already possible to calculate the range of simple functions, such as $f\left(a,b,x\right) = a cdot x + b$. If, for example$a = \left[1,2\right]$, $b = \left[5,7\right]$ and $x = \left[2,3\right]$, it is clear

$f\left(a,b,x\right) = \left(\left[1,2\right] cdot \left[2,3\right]\right) + \left[5,7\right] = \left[1cdot 2, 2cdot 3\right] + \left[5,7\right] = \left[7,13\right]$.

Interpreting this as a function $f\left(a,b,x\right)$ of the variable $x$ with interval parameters $a$ and $b$, them it is possible to find the roots of this function. It is then

$f\left(\left[1,2\right],\left[5,7\right],x\right) = \left(\left[1,2\right] cdot x\right) + \left[5,7\right] = 0Leftrightarrow \left[1,2\right] cdot x = \left[-7, -5\right]Leftrightarrow x = \left[-7, -5\right]/\left[1,2\right]$,
the possible zeros are in the interval $\left[-7, \left\{-2.5\right\}\right]$.

As in the above example, the multiplication of intervals often only requires two multiplications. It is in fact

$\left[x_1, x_2\right] cdot \left[y_1, y_2\right] = \left[x_1 cdot y_1, x_2 cdot y_2\right]$, if $x_1, y_1 geq 0$.

The multiplication can be see as a destination area of a rectangle with varying edges. The result interval covers all levels from the smallest to the largest.

The same applies when one of the two intervals is non-positive and the other non-negative. Generally, multiplication can produce results as wide as $\left[\left\{-infty\right\}, \left\{infty\right\}\right]$, for example if $0 cdot infty$ is squared. This also occurs, for example, in a division, if the numerator and denominator both contain zero.

### Notation

To make the notation of intervals smaller in formulae, brackets can be used.

So we can use $\left[x\right] equiv \left[x_1, x_2\right]$ to represent an interval. For the set of all finite intervals, we can use

$\left[mathbb\left\{R\right\}\right] := big\left\{, \left[x_1, x_2\right] ,|, x_1 leq x_2 ,mbox\left\{and\right\}, x_1, x_2 in mathbb\left\{R\right\} cup \left\{-infty, infty\right\} big\right\}$
as an abbreviation. For a vector of intervals $big\left(\left[x\right]_1, ldots , \left[x\right]_n big\right) in \left[mathbb\left\{R\right\}\right]^n$ we can also used a bold font: $\left[mathbf\left\{x\right\}\right]$.

In such a compact notation, you should note that $\left[x\right]$ should not be confused between a so-called improper or single point interval $\left[x_1, x_1\right]$ and the lower and upper limit.

### Elementary functions

Interval methods can also apply to functions which do not just use simple arithmetic, and we must also use other basic functions for redefining intervals, using already known monotonicity properties.

For monotonic functions in one variable, the range of values is also easy. If $f: mathbb\left\{R\right\} rightarrow mathbb\left\{R\right\}$ is monotonically rising or falling in the interval $\left[x_1, x_2\right]$, then for all values in the interval $y_1, y_2 in \left[x_1, x_2\right]$ such that $y_1 leq y_2$, one of the following inequalities applies:

$f\left(y_1\right) leq f\left(y_2\right)$, or $f\left(y_1\right) geq f\left(y_2\right)$.

The range corresponding to the interval $\left[y_1, y_2\right] subseteq \left[x_1, x_2\right]$ can be calculated by applying the function to the endpoints $y_1$ and $y_2$:

$f\left(\left[y_1, y_2\right]\right) = left\left[min big \left\{f\left(y_1\right), f\left(y_2\right) big\right\}, max big\left\{ f\left(y_1\right), f\left(y_2\right) big\right\}right\right]$.

From this the following basic features for interval functions can easily be defined:

• Exponential function: $a^\left\{\left[x_1, x_2\right]\right\} = \left[a^\left\{x_1\right\},a^\left\{x_2\right\}\right]$, for $a > 1$,
• Logarithm: $log_abig\left(\left\{\left[x_1, x_2\right]\right\} big\right) = \left[log_a \left\{x_1\right\}, log_a \left\{x_2\right\}\right]$, for positive intervals $\left[x_1, x_2\right]$ and $a>1$
• Odd powers: $\left\{\left[x_1, x_2\right]\right\}^n = \left[\left\{x_1\right\}^n,\left\{x_2\right\}^n\right]$, for odd $nin mathbb\left\{N\right\}$.

For even powers, the range of values being considered is important, and needs to be dealt with before doing any multiplication. For example $x^n$ for $x in \left[-1,1\right]$ should produce the interval $\left[0,1\right]$ when $n = 2, 4, 6, ldots$. But if you take $\left[-1,1\right]^n$ by applying interval multiplication of form $\left[-1,1\right]cdot ldots cdot \left[-1,1\right]$ then the result will appear to be $\left[-1,1\right]$, wider than necessary.

Instead consider the function $x^n$ as a monotonically decreasing function for $x < 0$ and a monotonically increasing function for $x > 0$. So for even $nin mathbb\left\{N\right\}$:

• $\left\{\left[x_1, x_2\right]\right\}^n = \left[x_1^n, x_2^n\right]$, if $x_1 geq 0$,
• $\left\{\left[x_1, x_2\right]\right\}^n = \left[x_2^n, x_1^n\right]$, if $x_2 < 0$,
• $\left\{\left[x_1, x_2\right]\right\}^n = \left[0, max \left\{x_1^n, x_2^n \right\} \right]$, otherwise.

More generally, one can say that for piecewise monotonic functions it is sufficient to consider the endpoints $x_1, x_2$ of the interval $\left[x_1, x_2\right]$, together with the so-called critical points within the interval being those points where the monotonicity of the function changes direction.

For the sine and cosine functions, the critical points are at $left\left(\left\{\right\}^1!!/!\left\{\right\}_2 + \left\{n\right\}right\right) cdot pi$ or $\left\{n\right\} cdot pi$ for all $n in mathbb\left\{Z\right\}$ respectively. Only up to five points matter as the resulting interval will be $\left[-1,1\right]$ if at least half a period is in the input interval. For sine and cosine, only the endpoints need full evaluation as the critical points lead to easily pre-calculated values – namely -1, 0 , +1.

### Interval extensions of general functions

In general, it may not be easy to find such a simple description of the output interval for many functions. But it may still be possible to extend functions to interval arithmetic. If $f:mathbb\left\{R\right\}^n rightarrow mathbb\left\{R\right\}$ is a function from a real vector to a real number, then  $\left[f\right]:\left[mathbb\left\{R\right\}\right]^n rightarrow \left[mathbb\left\{R\right\}\right]$ is called an interval extension of $f$ if
$\left[f\right]\left(\left[mathbf\left\{x\right\}\right]\right) supseteq \left\{f\left(mathbf\left\{y\right\}\right) | mathbf\left\{y\right\} in \left[mathbf\left\{x\right\}\right]\right\}$.

This definition of the interval extension does not give a precise result. For example, both $\left[f\right]\left(\left[x_1,x_2\right]\right) =\left[e^\left\{x_1\right\}, e^\left\{x_2\right\}\right]$ and $\left[g\right]\left(\left[x_1,x_2\right]\right) =\left[\left\{-infty\right\}, \left\{infty\right\}\right]$ are allowable extensions of the exponential function. Extensions as tight as possible are desirable, taking into the relative costs of calculation and imprecision; in this case $\left[f\right]$ should be chosen as it give the tightest possible result.

The natural interval extension is achieved by combining the function rule $f\left(x_1, cdots, x_n\right)$ with the equivalents of the basic arithmetic and elementary functions.

The Taylor interval extension (of degree $k$ ) is a $k+1$ times differentiable function $f$ defined by

$\left[f\right]\left(\left[mathbf\left\{x\right\}\right]\right) := f\left(mathbf\left\{y\right\}\right) + sum_\left\{i=1\right\}^kfrac\left\{1\right\}\left\{i!\right\}mathrm\left\{D\right\}^i f\left(mathbf\left\{y\right\}\right) cdot \left(\left[mathbf\left\{x\right\}\right] - mathbf\left\{y\right\}\right)^i + \left[r\right]\left(\left[mathbf\left\{x\right\}\right], \left[mathbf\left\{x\right\}\right], mathbf\left\{y\right\}\right)$
, for some $mathbf\left\{y\right\} in \left[mathbf\left\{x\right\}\right]$, where $mathrm\left\{D\right\}^i f\left(mathbf\left\{y\right\}\right)$ is the $i$th order differential of $f$ at the point $mathbf\left\{y\right\}$ and $\left[r\right]$ is an interval extension of the Taylor remainder

$r\left(mathbf\left\{x\right\}, xi, mathbf\left\{y\right\}\right) = frac\left\{1\right\}\left\{\left(k+1\right)!\right\}mathrm\left\{D\right\}^\left\{k+1\right\} f\left(xi\right) cdot \left(mathbf\left\{x\right\}-mathbf\left\{y\right\}\right)^\left\{k+1\right\}.$

The vector $xi$ lies between $mathbf\left\{x\right\}$ and $mathbf\left\{y\right\}$ with $mathbf\left\{x\right\}, mathbf\left\{y\right\} in \left[mathbf\left\{x\right\}\right]$, $xi$ is protected by $\left[mathbf\left\{x\right\}\right]$. Usually you choose $mathbf\left\{y\right\}$ to be the midpoint of the interval and use the natural interval extension to assess the remainder.

The special case of the Taylor interval extension of degree $k = 0$ is also referred to as the average interval extension. For an interval extension of the Jacobian $\left[J_f\right]\left(mathbf\left\{\left[x\right]\right\}\right)$ you get

$\left[f\right]\left(\left[mathbf\left\{x\right\}\right]\right) :=$
f(mathbf{y}) + [J_f](mathbf{[x]}) cdot ([mathbf{x}] - mathbf{y}) .

A nonlinear function can be defined by linear features.

## Interval methods

The methods of classical numerical analysis can not be transferred one-to-one into interval-valued algorithms, as dependencies between numerical values are usually not taken into account.

### Rounded interval arithmetic

To working effectively in a real-life implementation, intervals must be compatible to floating point computing. The earlier operations were based on exact arithmetic, but in general fast numerical solution methods may not be available. The range of values of the function $f\left(x, y\right) = x + y$ for $x in \left[0.1, 0.8\right]$ and $y in \left[0.06, 0.08\right]$ are for example $\left[0.16, 0.88\right]$. Where the same calculation is done with single digit precision, the result would normally be $\left[0.2, 0.9\right]$. But $\left[0.2, 0.9\right] notsupseteq \left[0.16, 0.88\right]$, so this approach would contradict the basic principles of interval arithmetic contradict, as a part of the domain of $f\left(\left[0.1, 0.8\right], \left[0.06, 0.08\right]\right)$ would be lost. Instead, it is the outward rounded solution $\left[0.1, 0.9\right]$ which is used.

The standard IEEE 754 for binary floating-point arithmetic also sets out procedures for the implementation of rounding. An IEEE 754 compliant system allows programmers to round to the nearest floating point number; alternatives are rounding towards 0 (truncating), rounding toward positive infinity (i.e. up), or rounding towards negative infinity (i.e. down).

The required external rounding for interval arithmetic can thus be achieved by changing the rounding settings of the processor in the calculation of the upper limit (up) and lower limit (down). Alternatively, an appropriate small interval $\left[varepsilon_1, varepsilon_2\right]$ can be added.

### Dependency problem

The so-called dependency problem is a major obstacle to the application of interval arithmetic. Although interval methods can determine the range of elementary arithmetic operations and functions very accurately, this is not always true with more complicated functions. If an interval occurs several times in a calculation using parameters, and each occurrence is taken independently then this can lead to an unwanted expansion of the resulting intervals.

As an illustration, take the function $f$ defined by $f\left(x\right) = x^2 + x$. The values of this function over the interval $\left[-1, 1\right]$ are really $\left[-1/4 , 2\right]$. As the natural interval extension, it is calculated as $\left[-1, 1\right]^2 + \left[-1, 1\right] = \left[0,1\right] + \left[-1,1\right] = \left[-1,2\right]$, which is slightly larger; we have instead calculated the infimum and supremum of the function $h\left(x, y\right)= x^2+y$ over $x,y in \left[-1,1\right]$. There is a better expression of $f$ in which the variable $x$ only appears once, namely by rewriting $f\left(x\right) = x^2 + x$ as addition and squaring in the quadratic $f\left(x\right) = left\left(x + frac\left\{1\right\}\left\{2\right\}right\right)^2 -frac\left\{1\right\}\left\{4\right\}$. So the suitable interval calculation is

$left\left(\left[-1,1\right] + frac\left\{1\right\}\left\{2\right\}right\right)^2 -frac\left\{1\right\}\left\{4\right\} =$
left[-frac{1}{2}, frac{3}{2}right]^2 -frac{1}{4} = left[0, frac{9}{4}right] -frac{1}{4} = left[-frac{1}{4},2right] and gives the correct values.

In general, it can be shown that the exact range of values can be achieved, if each variable appears only once. However, not every function can be rewritten this way.

The dependency of the problem causing over-estimation of the value range can go as far as covering a large range, preventing more meaningful conclusions.

An additional increase in the range stems from the solution of areas that do not take the form of an interval vector. The solution set of the linear system

begin{matrix} x &=& y x &=& p end{matrix} for $pin \left[-1,1\right]$ is precisely the line between the points $\left(-1,-1\right)$ and $\left(1,1\right)$. Interval methods deliver the best case, but in the square $\left[-1,1\right] times \left[-1,1\right]$, The real solution is contained in this square (this is known as the wrapping effect).

### Linear interval systems

A linear interval system consists of a matrix interval extension $\left[mathbf\left\{A\right\}\right] in \left[mathbb\left\{R\right\}\right]^\left\{ntimes m\right\}$ and an interval vector $\left[mathbf\left\{b\right\}\right] in \left[mathbb\left\{R\right\}\right]^\left\{n\right\}$. We want the smallest cuboid $\left[mathbf\left\{x\right\}\right] in \left[mathbb\left\{R\right\}\right]^\left\{m\right\}$, for all vectors $mathbf\left\{x\right\} in mathbb\left\{R\right\}^\left\{m\right\}$ which there is a pair $\left(mathbf\left\{A\right\}, mathbf\left\{b\right\}\right)$ with $mathbf\left\{A\right\} in \left[mathbf\left\{A\right\}\right]$ and $mathbf\left\{b\right\} in \left[mathbf\left\{b\right\}\right]$ satisfying
$mathbf\left\{A\right\} cdot mathbf\left\{x\right\} = mathbf\left\{b\right\}$.

For quadratic systems - in other words, for $n = m$ - there can be such an interval vector $\left[mathbf\left\{x\right\}\right]$, which covers all possible solutions, found simply with the interval Gauss method. This replaces the numerical operations, in that the linear algebra method known as Gaussian elimination becomes its interval version. However, since this method uses the interval entities$\left[mathbf\left\{A\right\}\right]$ and $\left[mathbf\left\{b\right\}\right]$ repeatedly in the calculation, it can produce poor results for some problems Hence using the result of the interval-valued Gauss only provides first rough estimates, since although it contains the entire solution set, it also has a large area outside it.

A rough solution $\left[mathbf\left\{x\right\}\right]$ can often be improved by an interval version of the Gauss–Seidel method. The motivation for this is that the $i$-th row of the interval extension of the linear equation

begin{pmatrix} {[a_{11}]} & cdots & {[a_{1n}]}
`vdots & ddots & vdots  `
{[a_{n1}]} & cdots & {[a_{nn}]} end{pmatrix} cdot begin{pmatrix} {x_1} vdots {x_n} end{pmatrix} = begin{pmatrix} {[b_1]} vdots {[b_n]} end{pmatrix} can be determined by the variable $x_i$ if the division $1/\left[a_\left\{ii\right\}\right]$ is allowed. It is therefore simultaneously
$x_j in \left[x_j\right]$ and $x_j in frac\left\{\left[b_i\right]- sumlimits_\left\{k not= j\right\} \left[a_\left\{ik\right\}\right] cdot \left[x_k\right]\right\}\left\{\left[a_\left\{ij\right\}\right]\right\}$.
So you can now replace $\left[x_j\right]$ by
$\left[x_j\right] cap frac\left\{\left[b_i\right]- sumlimits_\left\{k not= j\right\} \left[a_\left\{ik\right\}\right] cdot \left[x_k\right]\right\}\left\{\left[a_\left\{ij\right\}\right]\right\}$,
and so the vector $\left[mathbf\left\{x\right\}\right]$ by each element. Since the procedure is more efficient for a diagonally dominant matrix, instead of the system $\left[mathbf\left\{A\right\}\right]cdot mathbf\left\{x\right\} = \left[mathbf\left\{b\right\}\right]mbox\left\{,\right\}$ you can often try multiplying it by an appropriate rational matrix $mathbf\left\{M\right\}$ with the resulting matrix equation
$\left(mathbf\left\{M\right\}cdot\left[mathbf\left\{A\right\}\right]\right)cdot mathbf\left\{x\right\} = mathbf\left\{M\right\}cdot\left[mathbf\left\{b\right\}\right]$
left to solve. If you choose, for example, $mathbf\left\{M\right\} = mathbf\left\{A\right\}^\left\{-1\right\}$ for the central matrix $mathbf\left\{A\right\} in \left[mathbf\left\{A\right\}\right]$, then $mathbf\left\{M\right\} cdot\left[mathbf\left\{A\right\}\right]$ is outer extension of the identity matrix.

These methods only work well if the widths of the intervals occurring are sufficiently small. For wider intervals it can be useful to use an interval-linear system on finite (albeit large) real number equivalent linear systems. If all the matrices $mathbf\left\{A\right\} in \left[mathbf\left\{A\right\}\right]$ are invertible, it is sufficient to consider all possible combinations (upper and lower) of the endpoints occurring in the intervals. The resulting problems can be resolved using conventional numerical methods. Interval arithmetic is still used to determine rounding errors.

This is only suitable for systems of smaller dimension, since with a fully occupied $n times n$ matrix, $2^\left\{n^2\right\}$ real matrices need to be inverted, with $2^n$ vectors for the right hand side. This approach was developed by Jiri Rohn and is still being developed.

### Interval Newton method

An interval variant of Newton's method for finding the zeros in an interval vector $\left[mathbf\left\{x\right\}\right]$ can be derived from the average value extension (Lit.: Hansen, 1992). For an unknown vector $mathbf\left\{z\right\}in \left[mathbf\left\{x\right\}\right]$ applied to $mathbf\left\{y\right\}in \left[mathbf\left\{x\right\}\right]$, gives

$f\left(mathbf\left\{z\right\}\right) in f\left(mathbf\left\{y\right\}\right) + \left[J_f\right]\left(mathbf\left\{\left[x\right]\right\}\right) cdot \left(mathbf\left\{z\right\} - mathbf\left\{y\right\}\right)$.
For a zero $mathbf\left\{z\right\}$, that is $f\left(z\right)=0$, and thus must satisfy
$f\left(mathbf\left\{y\right\}\right) + \left[J_f\right]\left(mathbf\left\{\left[x\right]\right\}\right) cdot \left(mathbf\left\{z\right\} - mathbf\left\{y\right\}\right)=0$.
This is equivalent to $mathbf\left\{z\right\} in mathbf\left\{y\right\} - \left[J_f\right]\left(mathbf\left\{\left[x\right]\right\}\right)^\left\{-1\right\}cdot f\left(mathbf\left\{y\right\}\right)$. An outer estimate of $\left[J_f\right]\left(mathbf\left\{\left[x\right]\right\}\right)^\left\{-1\right\}cdot f\left(mathbf\left\{y\right\}\right)\right)$ can be determined using linear methods.

In each step of the interval Newton method, an approximate starting value $\left[mathbf\left\{x\right\}\right]in \left[mathbb\left\{R\right\}\right]^n$ is replaced by $\left[mathbf\left\{x\right\}\right]cap left\left(mathbf\left\{y\right\} - \left[J_f\right]\left(mathbf\left\{\left[x\right]\right\}\right)^\left\{-1\right\}cdot f\left(mathbf\left\{y\right\}\right)right\right)$ and so the result can be improved iteratively. In contrast to traditional methods, the interval method approaches the result by containing the zeros. This guarantees that the result will produce all the zeros in the initial range. Conversely, it will prove that no zeros of $f$ were in the initial range $\left[mathbf\left\{x\right\}\right]$ if a Newton step produces the empty set.

The method converges on all zeros in the starting region. Division by zero can lead to separation of distinct zeros, though the separation may not be complete; it can be complemented by the bisection method.

As an example, consider the function $f\left(x\right)= x^2-2$, the starting range $\left[x\right] = \left[-2,2\right]$, and the point $y= 0$. You then have $J_f\left(x\right) = 2, x$ and the first Newton step gives

$\left[-2,2\right]cap left\left(0 - frac\left\{1\right\}\left\{2cdot\left[-2,2\right]\right\} \left(0-2\right)right\right) = \left[-2,2\right]cap Big\left(\left[\left\{-infty\right\}, \left\{-0.5\right\}\right]cup \left[\left\{0.5\right\}, \left\{infty\right\}\right] Big\right)$.
There is therefore a zero in $xin \left[\left\{-2\right\}, \left\{-0.5\right\}\right]cup big\left[\left\{0.5\right\}, \left\{2\right\}big\right]$. More Newton steps are used separately on $xin \left[\left\{-2\right\}, \left\{-0.5\right\}\right]$ and $\left[\left\{0.5\right\}, \left\{2\right\}\right]$. These converge to arbitrarily small intervals around $-sqrt\left\{2\right\}$ and $+sqrt\left\{2\right\}$.

The Interval Newton method can also be used with thick functions such as $g\left(x\right)= x^2-\left[2,3\right]$, which would in any case have interval results. The result then produces intervals containing $left\left[-sqrt\left\{3\right\},-sqrt\left\{2\right\} right\right] cup left\left[sqrt\left\{2\right\},sqrt\left\{3\right\} right\right]$.

### Bisection and covers

The various interval methods deliver conservative results as dependencies between the sizes of different intervals extensions are not taken into account. However the dependency problem becomes less significant for narrower intervals.

Covering an interval vector $\left[mathbf\left\{x\right\}\right]$ by smaller boxes $\left[mathbf\left\{x\right\}_1\right], dots , \left[mathbf\left\{x\right\}_k\right]mbox\left\{,\right\}$ so that $textstyle \left[mathbf\left\{x\right\}\right] = bigcup_\left\{i=1\right\}^k \left[mathbf\left\{x\right\}_i\right]mbox\left\{,\right\}$ is then valid for the range of values $textstyle f\left(\left[mathbf\left\{x\right\}\right]\right) = bigcup_\left\{i=1\right\}^k f\left(\left[mathbf\left\{x\right\}_i\right]\right)mbox\left\{.\right\}$ So for the interval extensions described above, $textstyle \left[f\right]\left(\left[mathbf\left\{x\right\}\right]\right) supseteq bigcup_\left\{i=1\right\}^k \left[f\right]\left(\left[mathbf\left\{x\right\}_i\right]\right)$ is valid. Since $\left[f\right]\left(\left[mathbf\left\{x\right\}\right]\right)$ is often a genuine superset of the right-hand side, this usually leads to an improved estimate.

Such a cover can be generated by the bisection method such as thick elements $\left[x_\left\{i1\right\}, x_\left\{i2\right\}\right]$ of the interval vector $\left[mathbf\left\{x\right\}\right] = \left(\left[x_\left\{11\right\}, x_\left\{12\right\}\right], dots, \left[x_\left\{n1\right\}, x_\left\{n2\right\}\right]\right)$ by splitting in the centre into the two intervals $\left[x_\left\{i1\right\}, \left(x_\left\{i1\right\}+x_\left\{i2\right\}\right)/2\right]$ and $\left[\left(x_\left\{i1\right\}+x_\left\{i2\right\}\right)/2, x_\left\{i2\right\}\right]$. It the result is still not suitable then further gradual subdivision is possible. Note that a cover of $2^r$ intervals results from $r$ divisions of vector elements, substantially increasing the computation costs.

With very wide intervals, it can be helpful to split all intervals into several subintervals with a constant (and smaller) width, a method known as mincing. This then avoids the calculations for intermediate bisection steps. Both methods are only suitable for problems of low dimension.

## Application

Interval arithmetic can be use in various areas, in order to be treated estimates for which no exact numerical values can stated (Lit.: Jaulin et al., 2001).

### Rounding error analysis

Interval arithmetic is used with error analysis, to control rounding errors arising from each calculation. The advantage of interval arithmetic is that after each operation there is an interval which reliably includes the true result. The distance between the interval boundaries gives the current calculation of rounding errors directly:
Error = $mathrm\left\{abs\right\}\left(a-b\right)$ for a given interval $\left[a,b\right]$.
Interval analysis adds to rather than substituting for traditional methods for error reduction, such as pivoting.

### Tolerance analysis

Parameters for which no exact figures can be allocated often arise during the simulation of technical and physical processes. The production process of technical components allows certain tolerances, so some parameters fluctuate within intervals. In addition, many fundamental constants not are not known precisely (Lit.: Dreyer, 2005).

If the behavior of such a system affected by tolerances satisfies, for example, $f\left(mathbf\left\{x\right\}, mathbf\left\{p\right\}\right) = 0$, for $mathbf\left\{p\right\} in \left[mathbf\left\{p\right\}\right]$ and unknown $mathbf\left\{x\right\}$ then the set of possible solutions

$\left\{mathbf\left\{x\right\},|, exists mathbf\left\{p\right\} in \left[mathbf\left\{p\right\}\right], f\left(mathbf\left\{x\right\}, mathbf\left\{p\right\}\right)= 0\right\}$,
can be found by interval methods. This provides an alternative to traditional propagation of error analysis. Unlike point methods, such as Monte Carlo simulation, interval arithmetic methodology ensures that no part of the solution area can be overlooked. However, the result is always a worst case analysis for the distribution of error, as other probability-based distributions are not considered.

### Fuzzy interval arithmetic

Interval arithmetic can also be used with affiliation functions for fuzzy quantities as they are used in fuzzy logic. Apart from the strict statements $xin \left[x\right]$ and $x notin \left[x\right]$, intermediate values are also possible, to which real numbers $mu in \left[0,1\right]$ are assigned. $mu = 1$ corresponds to definite membership while $mu = 0$ is non-membership. A distribution function assigns uncertainty which can be understood as a further interval.

For fuzzy arithmetic only a finite number of discrete affiliation stages $mu_i in \left[0,1\right]$ are considered. The form of such a distribution for an indistinct value can then represented by a sequence of intervals

$left\left[x^\left\{\left(1\right)\right\}right\right] supset left\left[x^\left\{\left(2\right)\right\}right\right] supset cdots supset left\left[x^\left\{\left(k\right)\right\} right\right]$. The interval $\left[x^\left\{\left(i\right)\right\}\right]$ corresponds exactly to the fluctuation range for the stage $mu_i$.

The appropriate distribution for a function $f\left(x_1, cdots, x_n\right)$ concerning indistinct values $x_1, cdots, x_n$ and the corresponding sequences $left\left[x_1^\left\{\left(1\right)\right\} right\right] supset cdots supset left\left[x_1^\left\{\left(k\right)\right\} right\right], cdots , left\left[x_n^\left\{\left(1\right)\right\} right\right] supset cdots supset left\left[x_n^\left\{\left(k\right)\right\} right\right]$ can be approximated by the sequence $left\left[y^\left\{\left(1\right)\right\}right\right] supset cdots supset left\left[y^\left\{\left(k\right)\right\}right\right]$. The values $left\left[y^\left\{\left(i\right)\right\}right\right]$ are given by $left\left[y^\left\{\left(i\right)\right\}right\right] = f left\left(left\left[x_\left\{1\right\}^\left\{\left(i\right)\right\}right\right], cdots left\left[x_\left\{n\right\}^\left\{\left(i\right)\right\}right\right]right\right)$ and can be calculated by interval methods. The value $left\left[y^\left\{\left(1\right)\right\}right\right]$ corresponds to the result of an interval calculation.

## History

Interval arithmetic is not a completely new phenomenon in mathematics; it has appeared several times under different names in the course of history. For example Archimedes calculated lower and upper bounds 223/71 < π < 22/7 in the 3rd century BC. Actual calculations with intervals has neither been as popular as other numerical techniques, nor been completely forgotten.

Rules for calculating with intervals and other subsets of the real numbers were published in a 1931 work by Rosalind Cicely Young, a doctoral candidate at the University of Cambridge. Arithmetic work on range numbers to improve reliability of digital systems were then published in a 1951 textbook on linear algebra by Paul Dwyer (University of Michigan); intervals were used to measure rounding errors associated with floating-point numbers.

The birth of modern interval arithmetic was marked by the appearance of the book Interval Analysis by Ramon E. Moore in 1966 (Lit.: Moore). He had the idea in Spring 1958, and a year later he published an article about computer interval arithmetic. . Its merit was that stating with a simple principle it provided is a general method for automated error analysis, not just errors resulting from rounding.

Independently in 1956, Mieczyslaw Warmus suggested formulae for calculations with intervals , though Moore found the first non-trivial applications.

In the following twenty years German groups of researchers carried out pioneering work around Götz Alefeld (Lit.: Alefeld and Herzberger) and Ulrich Kulisch (Lit.: Kulisch) at the University of Karlsruhe and later also at the Bergische University of Wuppertal. For example, Karl Nickel explored more effective implementations, while improved containment procedures for the solution set of systems of equations were due to Arnold Neumaier among others.. In the 1960s Eldon R. Hansen dealt with interval extensions for linear equations and then provided crucial contributions to global optimisation (Lit.: Hansen). Classical methods in this often are have the problem of determining the largest (or smallest) global value, but could only find a local optimum and could not find better values; Helmut Ratschek and Jon George Rokne developed branch and bound methods, which till then had only applies to integer values, by using intervals to provide applications for continuous values.

In 1988 Rudolf Lohner developed Fortran-based software for reliable solutions for initial value problems using ordinary differential equations.

The journal Reliable Computing (originally Interval Computations) has been published since the 1990s , dedicated to the reliability of computer-aided computations. As lead editor, R. Baker Kearfott, in addition to his work on global optimisation, has contributed significantly to the unification of notation and terminology used in interval arithmetic (Web: Kearfott).

In recent years work has concentrated in particular on the estimation of preimages of parameterised functions and to robust control theory by the COPRIN working group of INRIA in Sophia Antipolis in France (Web: INRIA).

## Patents

One of the main sponsors of the interval arithmetic, G. William Walster of Sun Microsystems, has - in part with Ramon E. Moore and Eldon R. Hansen - lodged several patents in the field of interval arithmetic atthe U.S. Patent and Trademark Office in the years 2002-04 . The validity of these patent applications have been disputed in the interval arithmetic research community, since they may possibly only show the past state of the art.

## Implementations

There are many software packages which permit the development of numerical applications using interval arithmetic . These are usually provided in the form of program libraries. There are also C++ and Fortran compilers handle interval data types and suitable operations as a language extension, so interval arithmetic is supported directly.

Since 1967 Extensions for Scientific Computation (XSC) have been developed in the University of Karlsruhe for various programming languages, such as C++, Fortran and Pascal. The first platform was a Zuse Z 23, for which a new interval data type with appropriate elementary operators was made available. There followed in 1976 Pascal-SC, a Pascal variant on a Zilog Z80 which it made possible to create fast complicated routines for automated result verification. Then came the Fortran 77-based ACRITH XSC for the System/370 architecture, which was later delivered by IBM. Starting from 1991 one could produce code for C compilers with Pascal XSC; a year later the C++ class library supported C-XSC on many different computer systems. In 1997 all XSC variants were made available under the General Public License. At the beginning of 2000 C-XSC 2.0 was released under the leadership of the working group for scientific computation at the Bergische University of Wuppertal, in order to correspond to the improved C++ standard.

Another C++- class library was created in 1993 at the Hamburg University of Technology called Profil/BIAS (Programmer's Runtime Optimized Fast Interval Library, Basic Interval Arithmetic), which made the usual interval operations more user friendly. It emphasised the efficient use of hardware, portability and independence of a particular presentation of intervals.

The Boost collection of C++ libraries contains a template class for intervals. Its authors are aiming to have interval arithmetic in the standard C++ language.

In addition computer algebra systems, such as Mathematica, Maple and MuPAD, can handle intervals. There is a Matlab extension Intlab which builds on BLAS routines, as well as the Toolbox b4m which makes a Profil/BIAS interface..

## Further information

### Literature

• Götz Alefeld und Jürgen Herzberger: Einführung in die Intervallrechnung. Bibliographisches Institut, Reihe Informatik, Band 12, B.I.-Wissenschaftsverlag, Mannheim - Wien - Zürich, ISBN 3-411-01466-0
• Alexander Dreyer: Interval Analysis of Analog Circuits with Component Tolerances. Doctoral thesis, Shaker Verlag, Aachen, 2003, ISBN 3-8322-4555-3.
• Eldon Hansen and G. William Walster: Global Optimization using Interval Analysis, Second Edition, Revised and Expanded, Marcel Dekker, New York, 2004, ISBN 0-8247-4059-9.
• L. Jaulin, M. Kieffer, O. Didrit, and É.Walter: Applied Interval Analysis: With examples in parameter estimation robust control and robotics. Springer, London, 2001, ISBN 1-85233-219-0.
• Ulrich Kulisch: Wissenschaftliches Rechnen mit Ergebnisverifikation. Eine Einführung, Vieweg-Verlag, Wiesbaden 1989, ISBN 3-528-08943-1.
• R. E. Moore: Interval Analysis. Prentice-Hall, Englewood Cliff, NJ, 1966, ISBN 0-13-476853-1.

### References

Search another word or see unbounded intervalon Dictionary | Thesaurus |Spanish
Copyright © 2014 Dictionary.com, LLC. All rights reserved.
• Please Login or Sign Up to use the Recent Searches feature


text:
how to separate gamma-butyrolactone from N-methyl-2-pyrrolidone

Since these two chemicals have different freezing temps (pyrrolidone is $-11~\mathrm{^\circ F}$ [$-24~\mathrm{^\circ C}$] and $\unicode[Times]{x3b3}$-butyrolactone freezes (also called melting) at $-46~\mathrm{^\circ F}$ [$-43~\mathrm{^\circ C}$]), could a person wanting to separate these just immerse them in liquid nitrogen (or something else?) to get the desired chemical to freeze, then filter off the unfrozen butyrolactone? Other routes seem quite difficult for a non chemist. Any objections or other routes? Anything you can add? Even a step by process will be much appreciated.

• I do wonder why you are interested in the separation of GHB as a non-chemist. – Jan Oct 16 '15 at 17:19
• Can you add info on the relative fraction of each in the mixture as well as which one you want to recover pure? Both of those factors have significant impact on what would be a useful method to apply. – Andrew Feb 2 at 14:22

Cud [sic] a person wanting to separate these just emerse [sic] them into liquid nitro [sic] or any [sic] to get the desired chemical to freeze then filter off the unfrozen butyrolacton [sic]?

With liquid nitrogen this would not be possible because liquid nitrogen condenses/boils at -195 °C. It would freeze both the pyrrolidone and the lactone.

• Well. Then say what would a person use to separate these two compounds that would not require distillation and adding of chemicals. Freezing the undesirable must be possible ? – josh Mar 8 '15 at 22:58
• I'm not sure which compound (both?) you need to recover. If you want to recover just the NMP, then you could probably separate it from the GBL by hydrolyzing the GLB with a strong base, for 4-hydroxybutyrate salts, and then doing a solvent extraction with chloroform or hexanes to separate the NMP from the GBL-derived salts. Then the NMP can be re-isolated by evaporation of the chloroform or hexanes. – Curt F. Mar 9 '15 at 0:20
• My answer originally said LN2 "freezes" but of course I meant "condenses". I'm talking about the boiling point not the freezing point so I am editing my answer. – Curt F. Mar 9 '15 at 19:57

As Curt F. has already pointed out, liquid nitrogen is an overkill and won't help here.

You might want to try one of the following cooling mixtures - values are taken from (http://www.chemieunterricht.de/dc2/tip/08_98.htm):

• 81 g $\ce{CaCl2*6H2O}$ + 100 g ice : -21,5 °C (this might not be enough)
• 66 g $\ce{NaBr}$ + 100 g ice : -28 °C
• 105 g ethanol + 100 g ice : -30 °C

to enrich NMP in ther solid fraction.


text:
FireCloud is now powered by Terra! -- STARTING MAY 1st, 2019 THIS WEBPAGE WILL NO LONGER BE UPDATED.
From now on, please visit the Terra Help Center for documentation, tutorials, roadmap and feature announcements.
Want to talk to a human? Email the helpdesk, post feature requests or chat with peers in the community forum.
FIRECLOUD | Doc #10738 | (howto) Import metadata

# (howto) Import metadataTutorials | Created 2017-11-07 | Last updated 2018-04-27

#### Copying from an existing workspace

1. Choose the workspace you want to import metadata from. You will notice that you can only import data from workspaces that are compatible with the Authorization domain you have set.
2. Pick the participants, samples, pairs, or sets you want. Importing sets will bring over all the data required for the set. For example, if you import a sample set, the sample and participant data linked to the set will also be copied over. Notes: • Import conflicts can occur if you already have an identical participant, sample or pair in your workspace that matches what you are importing. FireCloud will notify you that the entity already exists in the workspace. • Copying metadata from another workspace will not import any linked files into your workspace bucket. Rather, it will refer to file paths in the bucket of the workspace you copied. Thus, if that workspace bucket is deleted, your workspace data model will no longer refer to an existing bucket path.

#### Importing a file

You import metadata corresponding to entity type -- Participant, Sample, or Pair -- by uploading load files in tab-separated-value format, a type of text file (.tsv or .txt). Separate files must be used for uploading each entity type. The first line of each file must contain the appropriate field names in their respective column headers. See the individual entity entries for examples of load files.

Note that for each of the basic entities, the data model also supports set entities, which are essentially lists of the basic entity type:

• Participant Set
• Sample Set
• Pair Set

In set load files, each line lists the membership of a non-set entity (e.g., participant) in a set (e.g., participant set). The first column contains the identifier of the set entity and the second column contains a key referencing a member of that set. For example, a load file for a participant set looks like this:

Note that multiple rows in a set load file may have the same set entity id (e.g. TCGA_COAD).

Load files must be imported in a strict order due to references to other entities.

The order is as follows ("A > B" means entity type A must precede B in order of upload):

• participants > samples
• samples > pairs
• participants > participant sets
• samples > sample sets
• pairs > pair sets
• set membership > set entity, e.g., participants > samples > sample set membership > sample set entity.

You may be in the situation where you have multiple files or strings of metadata that belong to one participant, sample, pair, or sets of these. For example, say you have been given genotyping files in VCF format for a collection of samples, for a total of twenty-two files per sample set. For each sample set, you don’t want to create a new column in the data table for each file because that's time-consuming. You would also have to launch the analysis in FireCloud repeatedly to run on each file. Instead, you want to build a WDL that inputs an array of VCF files because you’d like your tools to run on each item in the array without manual intervention.

To get the array into your data model, you can write WDL code that will output a file of file paths or strings into an array format. This requires a file that contains a list of file paths or strings as the input. A task in your WDL can read the lines of the file, output it to your data model as an array, then you can use the method configuration to assign it to a workspace attribute (“workspace.X”) or an attribute of the participant, sample, pair, or set that you are running on (“this.X”).

Here are two examples that can be altered for your use case. In the example above, the input would be a file that has a list of VCF file paths, one per line using “gs://” format.

Example 1 has a command portion left blank so that you can manipulate the array if you desire. This WDL will copy your files to the virtual machine the task spins up, which makes sense if you are manipulating the array of files further. 50 GB disk size is to account for those files that are being copied to the virtual machine and should be changed for your use case. If you do not want to manipulate the array, see Example 2.

#### Example 1:

Example 1’s Method and Method Configuration are published in the Methods Repository.

workflow fof_usage_wf {
File file_of_files
input:
fof = file_of_files
}
output {
}
}
File fof
command {
#do stuff with arrays below
#....
}
runtime {
docker : "ubuntu:16.04"
disks: "local-disk 50 HDD"
memory: "2 GB"
}
output {
Array[File] array_of_files = my_files
}
}

#### Example 2:

workflow fof_usage_wf {
File file_of_files
}


text:
Want to share your content on R-bloggers? click here if you have a blog, or here if you don't.

Win-Vector LLC recently announced the rquery R package, an operator based query generator.

In this note I want to share some exciting and favorable initial rquery benchmark timings.

Let’s take a look at rquery’s new “ad hoc” mode (made convenient through wrapr‘s new “wrapr_applicable” feature). This is where rquery works on in-memory data.frame data by sending it to a database, processing on the database, and then pulling the data back. We concede this is a strange way to process data, and not rquery’s primary purpose (the primary purpose being generation of safe high performance SQL for big data engines such as Spark and PostgreSQL). However, our experiments show that it is in fact a competitive technique.

We’ve summarized the results of several experiments (experiment details here) in the following graph (graphing code here). The benchmark task was hand implementing logistic regression scoring. This is an example query we have been using for some time.

The graph above the distribution of repeated run times for:

• data.table in memory: How long it takes data.table to complete the task starting from an in-memory data.frame. We will take data.table’s 256MS average runtime as the definition of “fast”, as data.table is commonly seen as the fastest system for in-memory data manipulation in R.
• rquery in memory: How long it takes rquery to complete the task starting from an in-memory data.frame and returning to an in-memory data.frame. The actual implementation is performed by moving data to a PostgreSQL database for processing and then collecting the result back. The observed 352MS average runtime is 38% slower than data.table. However, as we will see, that is actually a good result.
• dplyr tbl in memory: A standard dplyr in-memory pipeline working on a data.frame that is first converted into a tbl structure (to see if this is a significant speedup).
• dplyr in memory no grouped filter: A re-structured dplyr pipeline avoiding filtering inside a grouped context.
• dplyr from memory to db and back: Moved the data to a database, perform dplyr steps there, and then copy the data back. The runtime average is 602MS making it much faster than in-memory dplyr, but still 135% slower than data.table, 71% slower than rquery.

As is detailed in the experiment backing materials the task is processing 40,000 records through either of the following non-trivial pipelines (the first one for dplyr, and the second one for rquery):

dplyr_pipeline <- . %>%
group_by(subjectID) %>%
mutate(probability =
exp(assessmentTotal * scale)/
sum(exp(assessmentTotal * scale), na.rm = TRUE)) %>%
arrange(probability, surveyCategory) %>%
filter(row_number() == n()) %>%
ungroup() %>%
rename(diagnosis = surveyCategory) %>%
select(subjectID, diagnosis, probability) %>%
arrange(subjectID)

rquery_pipeline <- . := {
extend_nse(.,
probability :=
exp(assessmentTotal * scale)/
sum(exp(assessmentTotal * scale)),
count := count(1),
partitionby = 'subjectID') %.>%
extend_nse(.,
rank := rank(),
partitionby = 'subjectID',
orderby = c('probability', 'surveyCategory'))  %.>%
rename_columns(., 'diagnosis' := 'surveyCategory') %.>%
select_rows_nse(., rank == count) %.>%
select_columns(., c('subjectID',
'diagnosis',
'probability')) %.>%
orderby(., 'subjectID')
}

The primary purpose of rquery is pure in-database processing; in-memory processing is only a convenience. So let’s look at database only timings. In these tasks the data starts in the database (as is typical for large data projects) and is either consumed (by a row count called “count”) or saved as a database table (called “land”). In neither case does data move in or out of the database (skipping those overheads).

And, as we demonstrated earlier, rquery’s query generator has additional features (not shown here) that can yield additional speedup in production environments (and also increase query safety and query power).

I think results this good this early in the project are very promising. They are the product of some design decisions that I think will continue to pay off and some intentional scope restrictions (including that rquery only targets SQL engines, and initially only a few including Spark, PostgreSQL, and with some caveats SQLite). More work needs to be done to add all the SQL translation features needed for general production use, but we think we have demonstrated a good foundation to build on.


text:
Notes On Second Order Derivatives - CBSE Class 12 Maths
Consider a function y = f(x) (the derivative of y with respect to x) dy/dx = f '(x) d/dx(dy/dx) is called the second order derivative of y w.r.t. x. d/dx(dy/dx) = d2y/dx2 or D2y or y'' or y2 d/dx(f '(x)) = f '' (x) Third order derivative of y w.r.t. x = d3y/dx3 Fourth order derivative of y w.r.t. x = d4y/dx4

#### Summary

Consider a function y = f(x) (the derivative of y with respect to x) dy/dx = f '(x) d/dx(dy/dx) is called the second order derivative of y w.r.t. x. d/dx(dy/dx) = d2y/dx2 or D2y or y'' or y2 d/dx(f '(x)) = f '' (x) Third order derivative of y w.r.t. x = d3y/dx3 Fourth order derivative of y w.r.t. x = d4y/dx4

Previous
Next


text:
# Fixed point results for generalized contractive multivalued maps

Volume 10, Issue 5, pp 2359--2365

Publication Date: 2017-05-24

http://dx.doi.org/10.22436/jnsa.010.05.08

### Authors

Aljazi M. Alkhammash - Department of Mathematics, King Abdulaziz University, P. O. Box 80203, Jeddah 21589, Saudi Arabia.
Afrah A. N. Abdou - Department of Mathematics, King Abdulaziz University, AL Faisaliah Campus, Jeddah, Saudi Arabia.
Abdul Latif - Department of Mathematics, King Abdulaziz University, P. O. Box 80203, Jeddah 21589, Saudi Arabia.

### Abstract

In this paper, we prove some results on the existence of fixed points for multivalued maps with respect to general distance. Our results improve and generalize a number of known fixed point results including the fixed point results.

### Keywords

Metric space, fixed point, w-distance, multivalued contractive map, Banach limit.

### References

[1] C.-S. Chuang, L.-J. Lin, W. Takahashi, Fixed point theorems for single-valued and set-valued mappings on complete metric spaces, J. Nonlinear Convex Anal., 13 (2012), 515–527.
[2] Y.-Q. Feng, S.-Y. Liu, Fixed point theorems for multi-valued contractive mappings and multi-valued Caristi type mappings, J. Math. Anal. Appl., 317 (2006), 103–112.
[3] K. Hasegawa, T. Komiya, W. Takahashi, Fixed point theorems for general contractive mappings in metric spaces and estimating expressions, Sci. Math. Jpn., 74 (2011), 15–27.
[4] T. Husain, A. Latif, Fixed points of multivalued nonexpansive maps, Internat. J. Math. Math. Sci., 14 (1991), 421–430.
[5] O. Kada, T. Suzuki, W. Takahashi, Nonconvex minimization theorems and fixed point theorems in complete metric spaces, Math. Japon., 44 (1996), 381–391.
[6] M. Kikkawa, T. Suzuki, Three fixed point theorems for generalized contractions with constants in complete metric spaces, Nonlinear Anal., 69 (2008), 2942–2949.
[7] D. Klim, D. Wardowski, Fixed point theorems for set-valued contractions in complete metric spaces, J. Math. Anal. Appl., 334 (2007), 132–139.
[8] A. Latif, A. A. N. Abdou, Fixed points of generalized contractive maps, Fixed Point Theory Appl., 2009 (2009), 9 pages.
[9] A. Latif, A. A. N. Abdou, Multivalued generalized nonlinear contractive maps and fixed points, Nonlinear Anal., 74 (2011), 1436–1444.
[10] A. Latif, W. A. Albar, Fixed point results in complete metric spaces, Demonstratio Math., 41 (2008), 145–150.
[11] L.-J. Lin, T. Z. Yu, G. Kassay, Existence of equilibria for multivalued mappings and its application to vectorial equilibria, J. Optim. Theory Appl., 114 (2002), 189–208.
[12] N. B. Minh, N. X. Tan, Some sufficient conditions for the existence of equilibrium points concerning multivalued mappings, Vietnam J. Math., 28 (2000), 295–310.
[13] S. B. Nadler, Jr., Multi-valued contraction mappings, Pacific J. Math., 30 (1969), 475–488.
[14] X.-L. Qin, S. Y. Cho, Convergence analysis of a monotone projection algorithm in reflexive Banach spaces, Acta Math. Sci. Ser. B Engl. Ed., 37 (2017), 488–502.
[15] S. Shukla, Set-valued generalized contractions in 0-complete partial metric spaces, J. Nonlinear Funct. Anal., 2014 (2014), 20 pages.
[16] T. Suzuki, A generalized Banach contraction principle that characterizes metric completeness, Proc. Amer. Math. Soc., 136 (2008), 1861–1869.
[17] T. Suzuki, W. Takahashi, Fixed point theorems and characterizations of metric completeness, Topol. Methods Nonlinear Anal., 8 (1996), 371–382.
[18] W. Takahashi, Existence theorems generalizing fixed point theorems for multivalued mappings, Fixed point theory and applications, Marseille, (1989), Pitman Res. Notes Math. Ser., Longman Sci. Tech., Harlow, 252 (1991), 397–406.
[19] W. Takahashi, Nonlinear functional analysis, Fixed point theory and its applications, Yokohama Publishers, Yokohama, (2000).
[20] W. Takahashi, N.-C. Wong, J.-C. Yao, Fixed point theorems for general contractive mappings with W-distances in metric spaces, J. Nonlinear Convex Anal., 14 (2013), 637–648.
[21] F.-H. Zhao, L. Yang, Hybrid projection methods for equilibrium problems and fixed point problems of infinite family of multivalued asymptotically nonexpansive mappings, J. Nonlinear Funct. Anal., 2016 (2016), 13 pages.


text:
# Earned run average

In baseball statistics, earned run average (ERA) is the average of earned runs allowed by a pitcher per nine innings pitched (i.e. the traditional length of a game). It is determined by dividing the number of earned runs allowed by the number of innings pitched and multiplying by nine. Thus, a lower ERA is better. Runs resulting from passed balls or defensive errors (including pitchers' defensive errors) are recorded as unearned runs and omitted from ERA calculations.


text:
# Math Help - Trig derv. problem

1. ## Trig derv. problem

Find F'(x)=x2(1 + cos(x))

Should I dist. the x^2?

I cannot seem to get started.
Thanks.

2. Yes you can, then use the product rule on the second term: $F'(x) = x^2+x^2 \cos(x)$. Or you can use the product rule directly with $u = x^2 \text{ and } v = 1+\cos(x)$. You get the same result.

Out of interest are you trying to find the second derivative or is F'(x) a typo?

3. I have a whole gaggle of things I have to do with this problem, and I've been putting it off. But i want to get it done to go to a baseball game(fella watch) tomorrow. Sigh. Responsibility. Would Substitution be easier or should I just buck up and do it?

4. A sub won't help, you'd still have to do the product rule which really isn't that much trouble

5. so: 2x+2xCos(x)-x^2Sin(x)?

6. Originally Posted by FreaKariDunk
so: 2x+2xCos(x)-x^2Sin(x)?
Yes. You can also factor out x to give: $x(2-2\cos(x)-x\sin(x))$

7. Just in case FreaKariDunk reads this before e^(pi*i) gets back, factoring out x will actually give: $x \left ( 2 + 2\cos{x} - x\sin{x} \right )$.

8. Thank you y'all for all your help. All work and No play makes me grumpy. :P