Fityk manual

Release 0.9.4
October 10, 2010
CONTENTS
1 Introduction 1
1.1 What is the program for? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 How to read this manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3 GUI vs CLI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
2 Getting started 3
2.1 The minimal example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 Invoking tyk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Graphical interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3 Reference 7
3.1 Data from experiment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3 Fitting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4 Settings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.5 Other commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4 Extensions 31
4.1 How to add your own built-in function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
A Appendix A. List of functions 35
B Appendix B. Grammar 39
C Appendix C. License 41
D Appendix D. About this manual 43
i
ii
CHAPTER
ONE
INTRODUCTION
1.1 What is the program for?
Fityk is a program for nonlinear tting of analytical functions (especially peak-shaped) to data (usually experi-
mental data). The most concise description: peak tting software. There are also people using it to remove the
baseline from data, or to display data only.
It is reportedly used in crystallography, chromatography, photoluminescence and photoelectron spectroscopy, in-
frared and Raman spectroscopy, to name but a few. Although the author has a general understanding only of
experimental methods other than powder diffraction, he would like to make it useful to as many people as possi-
ble.
Fityk offers various nonlinear tting methods, simple background subtraction and other manipulations to the
dataset, easy placement of peaks and changing of peak parameters, support for analysis of series of datasets,
automation of common tasks with scripts, and much more. The main advantage of the program is exibility
- parameters of peaks can be arbitrarily bound to each other, e.g. the width of a peak can be an independent
variable, the same as the width of another peak, or can be given by complex (and general for all peaks) formula.
Fityk is free software; you can redistribute and modify it under the terms of the GPL, version 2 or (at your
option) any later version. See Appendix C. License for details. You can download the latest version of tyk from
http://www.unipress.waw.pl/tyk (or http://tyk.sf.net). To contact the author, visit the same page.
1.2 How to read this manual
After this introduction, you may read the Getting started, look for tutorials in wiki and postpone reading the
manual until you need to write a script, put constraints on variables, add user-dened function or understand
better how the program works.
In case you are not familiar with the term weighted sum of squared residuals or you are not sure how it is weighted,
have a look at Nonlinear optimization. Remember that you must set correctly standard deviations of ys of points,
otherwise you will get wrong results.
1.3 GUI vs CLI
The program comes in two versions: the GUI (Graphical User Interface) version - more comfortable for most
users, and the CLI (Command Line Interface) version (named ctyk to differentiate).
If the CLI version was compiled with the GNU Readline Library, command line editing and command history as
per bash will be available. Especially useful is TAB-expanding. Data and curves tted to data are visualized with
gnuplot (if it is installed).
The GUI version is written using the wxWidgets library and can be run on Unix species with GTK+ and on MS
Windows. There are also people using it on MacOS X (see details in the wiki).
1
Fityk manual, Release 0.9.4
2 Chapter 1. Introduction
CHAPTER
TWO
GETTING STARTED
2.1 The minimal example
Let us analyze a diffraction pattern of NaCl. Our goal is to determine the position of the center of the highest
peak. It is needed for calculating the pressure under which the sample was measured, but this later detail in the
processing is irrelevent for the time being.
The data le used in this example is distributed with the program and can be found in the samples directory.
First load data from le nacl01.dat. You can do this by typing:
@0 < nacl01.dat
in the CLI version (or in the GUI version in the input box - at the bottom, just above the status bar). In the GUI,
you can also select Data Load File from the menu and choose the le.
If you use the GUI, you can zoom-in to the biggest peak using left mouse button on the auxiliary plot (the plot
below the main plot). To zoom out, press the View whole toolbar button. Other ways of zooming are described in
Mouse usage. If you want the data to be drawn with larger points or a line, or if you want to change the color of
the line or background, press right mouse button on the main plot and use Data point size or Color menu from
the pop-up menu. To change the color of data points, use the right-hand panel.
Now all data points are active. Because only the biggest peak is of interest for the sake of this example, the
remaining points can be deactivated. Type:
A = (23.0 < x < 26.0)
or change to range mode (press Data-Range Mode button on toolbar) and select range to be deactivated with
right mouse button.
As our example data has no background to worry about, our next step is to dene a peak with reasonable initial
values and t it to the data. We will use Gaussian. To see its formula, type: info Gaussian or look for it in
the documentation (in Appendix A. List of functions). Incidentally, most of the commands can be abbreviated, e.g.
you can type: i Gaussian.
To dene peak, type:
%p = Gaussian(~60000, ~24.6, ~0.2); F = %p
or:
%p = guess Gaussian
or select Gaussian from the list of functions on the toolbar and press the auto-add toolbar button. There are also
other ways to add peak in GUI such as add-peak mode. These mouse-driven ways give function a name like %_1,
%_2, etc.
Now let us t the function. Type: fit or select Fit Run from the menu (or press the toolbar button).
3
Fityk manual, Release 0.9.4
When tting, the weighted sum of squared residuals (see Nonlinear optimization) is being minimized.
Note: The default weights of points are not equal.
To see the peak parameters, type: info+ %p or (in the GUI) move the cursor to the top of the peak and try out
the context menu (right button), or use the right-hand panel.
Thats it! To do the same a second time (for example to a similar data set) you can write all the commands to a
le:
commands > myscript.fit
and later use it as script:
commands < myscript.fit
Alternatively, use Session Logging History dump and Session Execute script.
If you start tyk from command line, you can load data and/or execute scripts by giving lenames as arguments,
e.g.
bash$ fityk myscript.fit
2.2 Invoking tyk
On startup, the program executes a script from the $HOME/.fityk/init le (on MS Windows XP:
C:\Documents and Settings\USERNAME\.fityk\init). Following this, the programexecutes com-
mand passed with --cmd option, if given, and processes command line arguments:
if the argument starts with =->, the string following =-> is regarded as a command and executed (otherwise,
it is regarded as a lename).
if the lename has extension .t or the le begins with a # Fityk string, it is assumed to be a script and
is executed.
otherwise, it is assumed to be a data le. It is possible to specify columns in data le in
this way: file.xy:1:4::. Multiple y columns can be specied (file.xy:1:3,4,5:: or
file.xy:1:3..5::) it will load each y column as a separate dataset, with the same values of x.
There are also other parameters to the CLI and GUI versions of the program. Option -h (on MS Windows /h)
gives the full listing:
wojdyr@ubu:~/fityk/src$ ./fityk -h
Usage: fityk \[-h] \[-V] \[-c <str>] \[-I] \[-r] \[script or data file...]
-h, --help show this help message
-V, --version output version information and exit
-c, --cmd=<str> script passed in as string
-g, --config=<str> choose GUI configuration
-I, --no-init dont process $HOME/.fityk/init file
-r, --reorder reorder data (50.xy before 100.xy)
The example of non-interactive using CLI version on Linux:
wojdyr@ubu:~/foo$ cfityk -h
Usage: cfityk \[-h] \[-V] \[-c <str>] \[script or data file...]
-h, --help show this help message
-V, --version output version information and exit
-c, --cmd=<str> script passed in as string
-I, --no-init dont process $HOME/.fityk/init file
-q, --quit dont enter interactive shell
wojdyr@ubu:~/foo$ ls \
*
.rdf
4 Chapter 2. Getting started
Fityk manual, Release 0.9.4
dat_a.rdf dat_r.rdf out.rdf
wojdyr@ubu:~/foo$ cfityk -q -I "=-> set verbosity=quiet, autoplot=never" \\
> \
*
.rdf "=-> i+ min(x if y > 0) in @
*
"
in @0 dat_a: 1.8875
in @1 dat_r: 1.5105
in @2 out: 1.8305
2.3 Graphical interface
2.3.1 Plots and other windows
The GUI window of tyk consists of (from the top): menu bar, toolbar, main plot, auxiliary plot, output window,
input eld, status bar and of sidebar at right-hand side. The input eld allows you to type and execute commands
in a similar way as is done in the CLI version. The output window (which is congurable through a pop-up menu)
shows the results. Incidentally, all GUI commands are converted into text and are visible in the output window,
providing a simple way to learn the syntax.
The main plot can display data points, model that is to be tted to the data and component functions of the model.
Use the pop-up menu (click right button on the plot) to congure it. Some properties of the plot (e.g. colors of
data points) can be changed using the sidebar.
One of the most useful things which can be displayed by the auxiliary plot is the difference between the data and
the model (also controlled by a pop-up menu). Hopefully, a quick look at this menu and a minute or twos worth
of experiments will show the potential of this auxiliary plot.
Conguration of the GUI (visible windows, colors, etc.) can be saved using GUI Save current cong. Two
different congurations can be saved, which allows easy changing of colors for printing. On Unix platforms,
these congurations are stored in a le in the users home directory. On Windows - they are stored in the registry
(perhaps in the future they will also be stored in a le).
2.3.2 Mouse usage
The usage of the mouse on menu, dialog windows, input eld and output window is (hopefully) intuitive, so the
only remaining topic to be discussed here is how to effectively use the mouse on plots.
Let us start with the auxiliary plot. The right button displays a pop-up menu with a range of options, while the left
allows you to select the range to be displayed on the x-axis. Clicking with the middle button (or with left button
and Shift pressed simultaneously) will zoom out to display all data.
On the main plot, the meaning of the left and right mouse button depends on current mode (selected using either
the toolbar or menu). There are hints on the status bar. In normal mode, the left button is used for zooming and the
right invokes the pop-up menu. The same behaviour can be obtained in any mode by pressing Ctrl (or Alt.).
The middle button can be used to select a rectangle that you want to zoom in to. If an operation has two steps,
such as rectangle zooming (i.e. rst you press a button to select the rst corner, then move the mouse and release
the button to select the second corner of the rectangle), this can be cancelled by pressing another button when the
rst one is pressed.
2.3. Graphical interface 5
Fityk manual, Release 0.9.4
6 Chapter 2. Getting started
CHAPTER
THREE
REFERENCE
In this part of the manual:
all features, with exception of the graphical interface features, are described,
several concepts (such as simple-variable and compound-variable), that reect the internal design of the
program, are introduced,
the syntax of the Fityk mini-language is explained,
it is rarely mentioned, that in the GUI typing the commands can be usually avoided and most of the opera-
tions can be done with mouse clicking.
The Fityk mini-language consists of commands.
Basically, there is one command per line. If for some reason it is more comfortable to place more than one
command in one line, they can be separated with a semicolon (;).
Most of the commands can have arguments separated by a comma (,), e.g. delete %a, %b, %c.
Most of the commands can be shortened: e.g. you can type inf or in or i instead of info. See Appendix B.
Grammar for details.
The symbol # starts a comment - everything from the hash (#) to the end of the line is ignored.
3.1 Data from experiment
3.1.1 Loading data
Data les are read using the xylib library.
Points are loaded from les using the command:
dataslot < filename[:xcol:ycol:scol:block] [filetype options...]
where
dataslot should be replaced with @0, unless many datasets are to be used simultaneously (for details see:
Working with multiple datasets),
xcol, ycol, scol (supported only in text le) are columns corresponding to x, y and std. dev. of y. Column 0
means index of the point: 0 for the rst point, 1 for the second, etc.
block is only supported by formats with multiple blocks of data.
letype usually can be omitted, because in most of the cases the letype can be detected; the list of supported
letypes is at the end of this section
options depend on a letype and usually are omitted
7
Fityk manual, Release 0.9.4
If the lename contains blank characters, a semicolon or comma, it should be put inside single quotation marks
(together with colon-separated indices, if any).
Multiple y columns and/or blocks can be specied, see the examples below:
@0 < foo.vms
@0 < foo.fii text first_line_header
@0 < foo.dat:1:4:: # x,y - 1st and 4th columns
@0 < foo.dat:1:3,4:: # load two dataset (with y in columns 3,4)
@0 < foo.dat:1:3..5:: # load three dataset (with y in columns 3,4,5)
@0 < foo.dat:1:4..6,2:: # load four dataset (y: 4,5,6,2)
@0 < foo.dat:1:2..:: # load 2nd and all the next columns as y
@0 < foo.dat:1:2:3: # read std. dev. of y from 3rd column
@0 < foo.dat:0:1:: # x - 0,1,2,..., y - first column
@0 < foo.dat:0:1:: # the same
@0 < foo.raw::::0,1 # load two first blocks of data (as one dataset)
Information about loaded data can be obtained with:
info data [in @0]
Supported letypes
text ASCII text, multicolumn numeric data. The details are given in the next section.
dbws format used by DBWS (program for Rietveld analysis) and DMPLOT.
cpi Sietronics Sieray CPI format
uxd Siemens/Bruker UXD format (powder diffraction data)
bruker_raw Simens-Bruker RAW format (version 1,2,3)
canberra_mca Spectral data stored by Canberra MCA systems
rigaku_dat Rigaku dat format (powder diffraction data)
vamas VAMAS ISO-14976 (only experiment modes: SEM or MAPSV or MAPSVDP and only REGU-
LAR scan mode are supported)
philips_udf Philips UDF (powder diffraction data)
philips_rd Philips RD raw scan format V3 (powder diffraction data)
spe Princeton Instruments WinSpec SPE format (only 1-D data is supported)
pdcif CIF for powder diffraction
... what else would you like to have here?
Reading text les
The xylib library can read TSV or CSV formats (tab or comma separated values). In fact, the values can be
separated by any whitespace character or by one of ,;: punctations, or by any combination of these.
Empty lines and comments that start with hash (#) are skipped.
Since there is a lot of les in the world that contain numeric data mixed with text, unless the strict option
is given any text that can not be interpreted as a number is regarded a start of comment (the rest of the line is
ignored).
Note that the le is parsed regardless of blocks and columns specied by the user. The data read from the le
are rst stored in a table with m columns and n rows. If some of the lines have 3 numbers in it, and some have 5
numbers, we can either discard the lines that have 3 numbers or we can discard the numbers in 4th and 5th column.
Usually the latter is done, unless it seems that the shorter lines should be ignored. The line is ignored:
8 Chapter 3. Reference
Fityk manual, Release 0.9.4
if it is the last line in the le and it contains less numbers than other lines (probably the program was
terminated while writing the le),
if it contains only one number, but the prior lines had more numbers,
if all the (not ignored) prior lines and the next line are longer
Note: Xylib doesnt handle well nans and infs in the data. This will be improved in the future.
Data blocks and columns may have names. These names are used to set a title of the dataset (see Working with
multiple datasets for details). If the option first_line_header is given and the number of words in the rst
line is equal to the number of data columns, each word is used as a name of corresponding column. If the number
of words is different, the rst line is used as a name of the block. If the last_line_header option is given,
the line preceding the rst data line is used to set either column names or the block name.
If the le starts with the LAMMPS ( string, the last_line_header option is set implicitely. This is very
helpful when plotting data from LAMMPS log les.
3.1.2 Active and inactive points
We often have the situation that only a part of the data from a le is of interest. In Fityk, each point is either active
or inactive. Inactive points are excluded from tting and all calculations. A data transformation:
A = boolean-condition
can be used to change the state of points.
In the GUI, there is a Data-Range Mode that allows activating and disactivating points with mouse.
3.1.3 Standard deviation (or weight)
When tting data, we assume that only the y coordinate is subject to statistical errors in measurement. This is
a common assumption. To see how the ys standard deviation, , inuences tting (optimization), look at the
weighted sum of squared residuals formula in Nonlinear optimization. We can also think about weights of points
every point has a weight assigned, that is equal w
i
= 1/
2
i
.
Standard deviation of points can be read from le together with the x and y coordinates. Otherwise, it is set
either to max(y
1/2
, 1) or to 1, depending on the value of data_default_sigma option. Setting std. dev. as a
square root of the value is common and has theoretical ground when y is the number of independent events. You
can always change standard deviation, e.g. make it equal for every point with command: S=1. See Data point
transformations for details.
Note: It is often the case that user is not sure what standard deviation should be assumed, but it is her responsibility
to pick something.
3.1.4 Data point transformations
Every data point has four properties: x coordinate, y coordinate, standard deviation of y and active/inactive ag.
These properties can be changed using symbols X, Y, S and A, respectively. It is possible to either change a single
point or apply a transformation to all points. For example:
Y[3]=1.2 assigns the y coordinate of the 4th point (0 is rst),
Y = -y changes the sign of the y coordinate for all points.
On the left side of the equality sign you can have one of symbols X, Y, S, A, possibly with the index in brackets.
The symbols on the left side are case insensitive.
The right hand side is a mathematical expression that can have special variables:
lower case letters x, y, s, a represent properties of data points before transformation,
upper case X, Y, S, A stand for the same properties after transformation,
3.1. Data from experiment 9
Fityk manual, Release 0.9.4
M stands for the number of points.
n stands for the index of currently transformed point, e.g., Y=y[M-n-1] means that n-th point (n=0, 1, ...
M-1) is assigned y value of the n-th point from the end.
Before the transformation a new array of points is created as a copy of the old array. Operations are applied
sequentially from the rst point to the last one, so while Y[n+1] and y[n+1] have always the same value,
Y[n-1] and y[n-1] may differ. For example, the two commands:
Y = y[n] + y[n-1]
Y = y[n] + Y[n-1]
differ. The rst one adds to each point the value of the previous point. The second one adds the value of the
previous point after transformation, so effectively it adds the sum of all previous points. The index [n] could be
omitted (Y = y + y[n-1]). The value of undened points, like y[-1] and Y[-1], is explained later in this
section.
Expressions can contain:
real numbers in normal or scientic format (e.g. 1.23e5),
constants pi, true (1), false (0)
binary operators: +, -,
*
, /, ^,
boolean operators: and, or, not,
comparisions: >, >=, <, <=, ==, !=.
one argument functions:
sqrt
exp
log10
ln
sin
cos
tan
sinh
cosh
tanh
atan
asin
acos
erf
erfc
gamma
lgamma (=ln(|gamma()|))
abs
round (rounds to the nearest integer)
two argument functions:
mod (modulo)
min2
10 Chapter 3. Reference
Fityk manual, Release 0.9.4
max2 (e.g. max2(3,5) will give 5),
randuniform(a, b) (random number from interval (a, b)),
randnormal(mu, sigma) (random number from normal distribution),
voigt(a, b) =
b

_
+

exp(t
2
)
b
2
+(at)
2
dt
ternary ?: operator: condition ? expression1 : expression2, which returns expression1
if condition is true and expression2 otherwise.
A few examples.
In the case of diffraction patterns, it is possible to change the x scale between Q and 2:
X = 4
*
pi
*
sin(x/2
*
pi/180) / 1.54051 # Cu 2 -> Q
Negative y values can be zeroed with command:
Y=max2(y,0)
All standard deviations can be set to 1:
S=1
It is possible to select active range of data:
A = x > 40 and x < 60
All operations are performed on real numbers. Two numbers that differ less than (the value of is set by the
option epsilon) are considered equal.
Points can be created or deleted by changing the value of M. For example, the following commands:
M=500; x=n/100; y=sin(x)
create 500 points and generate a sinusoid.
Points are kept sorted according to their x coordinate. The sorting is performed after each transformation.
Note: Changing the x coordinate may change the order and indices of points.
Indices, like all other values, are computed in the real number domain. If the index is not integer (it is compared
using to the rounded value):
x, y, s, a are interpolated linearly. For example, y[2.5] is equal to (y[2]+[3])/2. If the index is less
than 0 or larger than M-1, the value for the rst or the last point, respectively, is returned.
For X, Y, S, A the index is rounded to integer. If the index is less than 0 or larger than M-1, 0 is returned.
Transformations separated by commas (,) form a sequance of transformations. During the sequance, the vectors
x, y, s and a that contain old values are not changed. This makes possible to swap the axes:
X=y, Y=x
The special index(arg) function returns the index of point that has x equal arg, or, if there is no such point, the
linear interpolation of two neighbouring indices. This enables equilibrating the step of data (with interpolation of
y and ):
X = x[0] + n
*
(x[M-1]-x[0]) / (M-1), Y = y[index(X)], S = s[index(X)]
It is possible to delete points for which given condition is true, using expression delete(condition), e.g.:
3.1. Data from experiment 11
Fityk manual, Release 0.9.4
delete(not a) # delete inactive points
# reduce twice the number of points, averaging x and adding y
x = (x[n]+x[n+1])/2
y = y[n]+y[n+1]
delete(mod(n,2) == 1)
The value of a data expression can be shown using command info. The precision of printed numbers is governed
by the info_numeric_format option. The info command can be also used as a calculator:
# i is a shortcut for info
i 2+2 #4
i sin(pi/4)+cos(pi/4) #1.41421
i gamma(10) #362880
If you have more than one dataset, you have to specify explicitly to which dataset the transformation applies to.
See Working with multiple datasets for details.
3.1.5 Aggregate functions
Aggregate functions have syntax:
aggregate(expression [if condition])
and return a single value, calculated from values of all points for which the given condition is true. If the condition
is omitted, all points in the dataset are taken into account.
The following aggregate functions are recognized:
min() the smallest value,
max() the largest value,
sum() the sum,
avg() the arithmetic mean,
stddev() the standard deviation,
darea() a function used to normalize the area (see the example below). It returns the sum of ex-
pression*(x[n+1]-x[n-1])/2. In particular, darea(y) returns the interpolated area under data points.
Note: There is no count function, use sum(1 if criterium) instead.
Examples:
i avg(y) # print the average y value
i max(y) # the largest y value
i max(y if x > 40 and x < 60) # the largest y value for x in (40, 60)
i max(y if a) # the largest y value in the active range
i sum(1 if y>100) # the number of points that have y above 100
i sum(1 if y>avg(y)) # aggregate functions can be nested
i y[min(n if y > 100)] # the first (from the left) value of y above 100
# take the first 2000 points, average them and subtract as background
Y = y - avg(y if n<2000)
Y = y / darea(y) # normalize data area
12 Chapter 3. Reference
Fityk manual, Release 0.9.4
3.1.6 Functions and variables in data transformation
You may postpone reading this section and read about the Model rst.
Variables ($foo) and functions (%bar) can be used in data transformations, e.g.:
Y = y / $foo # divides all ys by $foo
Y = y - %f(x) # subtracts function %f from data
Y = y - @0.F(x) # subtracts all functions in F
# Fit constant x-correction (e.g. a shift in the scale of the instrument
# collecting data), correct the data and remove the correction from the model.
Z = Constant(~0)
fit
X = x + @0.Z(x) # data transformation is here
Z = 0
In the Baseline Mode in the GUI, functions Spline() and Polyline() are used to substract background, that
have been manually marked by the user. Clicking Strip background results in a commands like this:
%bg0 = Spline(14.2979,62.1253, 39.5695,35.0676, 148.553,49.9493)
Y = y - %bg0(x)
Note: The GUI uses functions named %bgX, where X is the index of the dataset, and the type of the function
is either Spline or Polyline, to handle the baseline. This allows user to set the function manually (or in a
script) and then edit the baseline in the Baseline Mode.
Values of the function parameters (e.g. %fun.a0) and pseudo-parameters Center, Height, FWHM and Area (e.g.
%fun.Area) can also be used. Pseudo-parameters are supported only by functions, which know how to calculate
these properties.
It is also possible to calculate some properties of %functions:
numarea(%f, x1, x2, n) gives area integrated numerically from x1 to x2 using trapezoidal rule with
n equal steps.
findx(%f, x1, x2, y) nds x in interval (x1, x2) such that %f(x)=y using bisection method com-
bined with Newton-Raphson method. It is a requirement that %f(x1) < y < %f(x2).
extremum(%f, x1, x2) nds x in interval (x1, x2) such that %f(x)=0 using bisection method. It is a
requirement that %f(x1) and %f(x2) have different signs.
A few examples:
info numarea(%fun, 0, 100, 10000) # shows area of function %fun
info %_1(extremum(%_1, 40, 50)) # shows extremum value
# calculate FWHM numerically, value 50 can be tuned
$c = {%f.Center}
i findx(%f, $c, $c+50, %f.Height/2) - findx(%f, $c, $c-50, %f.Height/2)
i %f.FWHM # should give almost the same.
3.1.7 Working with multiple datasets
Let us call a set of data that usually comes from one le a dataset. All operations described above assume only
one dataset. If there are more datasets created, it must be explicitly stated which dataset the command is being
applied to, e.g. M=500 in @0. Datasets have numbers and are referenced by @ with the number, e.g. @3. @
*
means all datasets (e.g. Y=y/10 in @
*
).
To load dataset from le, use one of commands:
3.1. Data from experiment 13
Fityk manual, Release 0.9.4
@n < filename:xcol:ycol:scol:block filetype options...
@+ < filename:xcol:ycol:scol:block filetype options...
The rst one uses existing data slot and the second one creates a new slot. Using @+ increases the number of
datasets, and command delete @n decreases it.
The dataset can be duplicate (@+ = @n) or transformed, more on this in the next section.
Each dataset has a separate model, that can be tted to the data. This is explained in the next chapter.
Each dataset also has a title (it does not have to be unique, however). When loading le, a title is automatically
created:
if there is a name associated with the column ycol, the title is based on it;
otherwise, if there is a name associated with the data block read from le, the title is set to this name;
otherwise, the title is based on the lename
Titles can be changed using the command:
set @n.title=new-title
To print the title of the dataset, type info title in @n.
You calculate values of a data expression for each dataset and print a list of results, e.g. i+ avg(y) in @
*
.
3.1.8 Dataset transformations
There is also another kind of transformations, dataset tranformation, which operate on a whole dataset, not single
points:
@n = dataset-transformation @m
or more generally:
@n = dataset-transformation @m + @k + ...
where dataset-transformation can be one of:
sum_same_x Merges points which distance in x is smaller than epsilon. x of a merged point is the average, and
y and sigma are sums of components.
avg_same_x The same as sum_same_x, but y and sigma of a merged point is set as an average of components.
shirley_bg Calculates Shirley background (useful in X-ray photoelectron spectroscopy).
rm_shirley_bg Calculates data with removed Shirley background.
A sum of datasets (@n + @m + ...) contains all points from all component datasets. If datasets have the same
x values, the sum of y values can be obtained using @+ = sum_same_x @n + @m + ....
Examples:
@+ = @0 # duplicate the dataset
@+ = @0 + @1 # create a new dataset from @0 and @1
@0 = rm_shirley_bg @0 # remove Shirley background
14 Chapter 3. Reference
Fityk manual, Release 0.9.4
3.1.9 Exporting data
Command:
info dataslot (expression , ...) > file.tsv
can export data to an ASCII TSV (tab separated values) le.
To export data in a 3-column (x, y and standard deviation) format, use:
info @0 (x, y, s) > file.tsv
If a is not listed in the list of columns, like in the example above, only the active points are exported.
All expressions that can be used on the right-hand side of data transformations can also be used in the column list.
Additionally, F and Z can be used with dataset prex, e.g.
info @0 (n+1, x, y, F(x), y-F(x), Z(x), %foo(x), a, sin(pi
*
x)+y^2) > file.tsv
The option info_numeric_format can be used to change the format and precision of all numbers.
3.2 Model
3.2.1 Model - Introduction
The model F (the function that is tted to the data) is computed as a sum of component functions, F =

i
f
i
.
Each component function is one of the functions dened in the program, such as Gaussian or polynomial.
To avoid confusion we will always use:
the name model when referring to the total function tted to data.
and the name function only when referring to a component function.
Function f
i
= f
i
(x; a) is a function of x, and depends on a vector of parameters a. This vector contains all tted
parameters.
Because we often have the situation, that the error in the x coordinate of data points can be modeled with function
Z(x; a), we introduce this term to the model, and the nal formula is:
F(x; a) =

i
f
i
(x + Z(x; a); a)
where Z(x; a) =

i
z
i
(x; a)
Note that the same x-correction Z is used in all functions f
i
.
Now we will have a closer look at component functions. Every function f
i
has a type chosen from the function
types available in the program. The same is true about functions z
i
. One of these types is the Gaussian. It has the
following formula:
f
G
(x; a
0
, a
1
, a
2
) = a
0
exp
_
ln(2)
_
x a
1
a
2
_
2
_
There are three parameters of Gaussian. These parameters do not depend on x. There must be one variable bound
to each functions parameter.
3.2. Model 15
Fityk manual, Release 0.9.4
3.2.2 Variables
Variables in Fityk have names prexed with the dollar symbol ($). A variable is created by assigning a value to it,
e.g.
$foo=~5.3
$c=3.1
$bar=5
*
sin($foo)
The variables like the rst one, $foo, created by assigning to it a real number prexed with ~, will be called
simple-variables. The ~ means that the value assigned to the variable can be changed when tting the model to
the data.
Each simple-variable is independent. In optimization terms, it corresponds to one dimension of the space where
we will look for the minimum.
In the above example, the variable $c is actually a constant. $bar depends on the value of $foo. When $foo
changes, the value of $bar also changes. Variables like $bar will be called compound-variables. Compound-
variables can be build using operators +, -, *, /, ^ and the functions sqrt, exp, log10, ln, sin, cos, tan,
sinh, cosh, tanh, atan, asin, acos, erf, erfc, lgamma, abs, voigt. This is a subset of the functions
used in data transformations.
The value of the data expression can be used in the variable denition. The expression must be in braces, e.g.
$bleh={3+5}. The simple variable can be created by preceding the left brace with the tilde ($bleh=~{3+5}).
A few examples:
$foo = {y[0]}
$foo2 = {y[0] in @0} # dataset can be given if necessary
$foo3 = {min(y if a) in @0}
Sometimes it is useful to freeze a variable, i.e. to prevent it from changing while tting. There is no special syntax
for it, but it can be done using data expressions in this way:
$a = ~12.3 # $a is fittable
$a = {$a} # $a is not fittable
$a = ~{$a} # $a is fittable again
It is also possible to dene a variable as e.g. $bleh=~9.1
*
exp(~2). In this case two simple-variables (with
values 9.1 and 2) are created automatically.
Automatically created variables are named $_1, $_2, $_3, and so on.
Variables can be deleted using the command:
delete $variable
Some tting algorithms need to randomize the parameters of the tted function (i.e. they need to randomize simple
variables). For this purpose, the simple variable can have a specied domain. Note that the domain does not imply
any constraints on the value the variable can have it is only a hint for tting algorithms. Domains are used by
Nelder-Mead method and Genetic Algorithms. The syntax is as follows:
$a = ~12.3 [11 +- 5] # center and width of the domain are given
$b = ~12.3 [ +- 5] # if the center of the domain is not specified,
# the value of the variable is used
If the domain is not specied, the value of variable_domain_percent option is used (domain is +/- value-
of-variable * variable_domain_percent / 100)
16 Chapter 3. Reference
Fityk manual, Release 0.9.4
3.2.3 Function types and functions
Let us go back to functions. Function types have names that start with upper case letter, e.g. Linear or Voigt.
Functions (i.e. function instances) have names prexed with a percent symbol, e.g. %func. Every function has a
type and variables bound to its parameters.
info types shows the list of available function types. info FunctionType (e.g. info Pearson7)
shows formula of the FunctionType.
Functions can be created by giving the type and the correct number of variables in brackets, e.g.
%f1 = Gaussian(~66254., ~24.7, ~0.264)
%f2 = Gaussian(~6e4, $ctr, $b+$c)
%f3 = Gaussian(height=~66254., hwhm=~0.264, center=~24.7)
Every expression which is valid on the right-hand side of a variable assignment can be used as a variable. If
it is not just a name of a variable, an automatic variable is created. In the above examples, two variables were
implicitely created for %f2: rst for value 6e4 and the second for $b+$c).
If the names of functions parameters are given (like for %f3), the variables can be given in any order.
Function types can can have specied default values for some parameters. The variables for such parameters can
be omitted, e.g.:
=-> i Pearson7
Pearson7(height, center, hwhm, shape=2) = height/(1+((x-center)/hwhm)^2
*
(2^(1/shape)-1))^shape
=-> %f4 = Pearson7(height=~66254., center=~24.7, fwhm=~0.264) # no shape is given
New function %f4 was created.
A deep copy of function (i.e. all variables that it depends on are also copied) can be made using the command:
%function = copy(%another_function)
Functions can be also created with the command guess, as described in Guessing peak location.
You can change a variable bound to any of the function parameters in this manner:
=-> %f = Pearson7(height=~66254., center=~24.7, fwhm=~0.264)
New function %f was created.
=-> %f.center=~24.8
=-> $h = ~66254
=-> %f.height=$h
=-> info %f
%f = Pearson7($h, $_5, $_3, $_4)
=-> $h = ~60000 # variables are kept by name, so this also changes %f
=-> %p1.center = %p2.center + 3 # keep fixed distance between %p1 and %p2
Functions can be deleted using the command:
delete %function
3.2.4 Variadic functions
Variadic function types have variable number of parameters. Two variadic function types are dened:
Spline(x1, y1, x2, y2, ...)
Polyline(x1, y1, x2, y2, ...)
For example %f:
3.2. Model 17
Fityk manual, Release 0.9.4
%f = Spline(22.1, 37.9, 48.1, 17.2, 93.0, 20.7)
is the cubic spline interpolation through points (22.1, 37.9), (48.1, 17.2), ....
The Polyline function is similar, but gives the polyline interpolation.
Both Spline and Polyline functions are primarily used for the manual baseline subtraction via the GUI.
3.2.5 User-dened functions (UDF)
User-dened function types can be created using command define, and then used in the same way as built-in
functions.
Example:
define MyGaussian(height, center, hwhm) = height
*
exp(-ln(2)
*
((x-center)/hwhm)^2)
The name of new type must start with an upper-case letter, contain only letters and digits and have at least
two characters.
The name of the type is followed by parameters in brackets.
Parameter name must start with lowercase letter and, contain only lowercase letters, digit and the underscore
(_).
The name x is reserved, do not put it into parameter list, just use it on the right-hand side of the denition.
There are special names of parameters, that Fityk understands:
if the functions is peak-like: height, center, fwhm, area, hwhm,
if the function is more like linear: slope, intercept, avgy.
Parameters with such names do not need default values. fwhm mean full width at half maximum (FWHM),
hwhm means half width..., i.e. fwhm/2.
Each parameter should have a default value (see examples below). Default values allow adding a peak with
the command guess or with one click in the GUI.
The default value can be a number or expression that contains the special names listed above with exeption
of hwhm (use fwhm/2 instead).
UDFs can be dened in a few ways:
by giving a full formula, like in the example above,
as a re-parametrization of existing function (see the GaussianArea example below),
as a sum of already dened functions (see the GLSum example below),
x < expression ? Function1(...) : Function2(...) (see the SplitL example below).
When giving a full formula, right-hand side of the equality sign is similar to the deniton of variable, but the
formula can also depend on x. Hopefully the examples at the end of this section make the syntax clear.
How it works internally
The formula is parsed, derivatives of the formula are calculated symbolically, all expressions are simplied (but
there is a lot of space for optimization here) and bytecode for virtual machine (VM) is created.
When tting, the VM calculates the value of the function and derivatives for every point.
Possible (i.e. not implemented) optimizations include Common Subexpression Elimination and JIT compilation.
There is a simple substitution mechanism that makes writing complicated functions easier. Substitutions must be
assigned in the same line, after keyword where. Example:
18 Chapter 3. Reference
Fityk manual, Release 0.9.4
define ReadShockley(sigma0=1, a=1) = sigma0
*
t
*
(a - ln(t)) where t=x
*
pi/180
# more complicated example, with nested substitutions
define FullGBE(k, alpha) = k
*
alpha
*
eta
*
(eta / tanh(eta) - ln (2
*
sinh(eta))) where eta = 2
*
pi/alpha
*
sin(theta/2), theta=x
*
pi/180
Tip: Use the init le for often used denitions. See Invoking tyk for details.
Dened functions can be undened using command undefine.
Examples:
# this is how some built-in functions could be defined
define MyGaussian(height, center, hwhm) = height
*
exp(-ln(2)
*
((x-center)/hwhm)^2)
define MyLorentzian(height, center, hwhm) = height/(1+((x-center)/hwhm)^2)
define MyCubic(a0=height,a1=0, a2=0, a3=0) = a0 + a1
*
x + a2
*
x^2 + a3
*
x^3
# supersonic beam arrival time distribution
define SuBeArTiDi(c, s, v0, dv) = c
*
(s/x)^3
*
exp(-(((s/x)-v0)/dv)^2)/x
# area-based Gaussian can be defined as modification of built-in Gaussian
# (it is the same as built-in GaussianA function)
define GaussianArea(area, center, hwhm) = Gaussian(area/hwhm/sqrt(pi/ln(2)), center, hwhm)
# sum of Gaussian and Lorentzian, a.k.a. PseudoVoigt (should be in one line)
define GLSum(height, center, hwhm, shape) = Gaussian(height
*
(1-shape), center, hwhm)
+ Lorentzian(height
*
shape, center, hwhm)
# split-Gaussian, the same as built-in SplitGaussian (should be in one line)
define SplitG(height, center, hwhm1=fwhm
*
0.5, hwhm2=fwhm
*
0.5) =
x < center ? Lorentzian(height, center, hwhm1)
: Lorentzian(height, center, hwhm2)
# to change definition of UDF, first undefine previous definition
undefine GaussianArea
3.2.6 Speed of computations
With default settings, the value of every function is calculated at every point. Functions such as Gaussian of-
ten have non-neglegible values only in a small fraction of all points. To speed up the calculation, set the
option cut_function_level to a non-zero value. For each function the range with values greater than
cut_function_level will be estimated, and all values outside of this range are considered to be equal zero.
Note that not all functions support this optimization.
If you have a number of loaded dataset, and the functions in different datasets do not share parameters, it is faster
to t the datasets sequentially (fit in @0; fit in @1; ...) then parallelly (fit in @
*
).
Each simple-variable slows down the tting, although this is often negligible.
3.2.7 Model, F and Z
As already discussed, each dataset has a separate model that can be tted to the data. As can be seen from the
formula above, the model is dened as a set functions f
i
and a set of functions z
i
. These sets are named F and Z
respectively. The model is constructed by specifying names of functions in these two sets.
In many cases x-correction Z is not used. The tted curve is thus the sum of all functions in F.
Command
F += %function
3.2. Model 19
Fityk manual, Release 0.9.4
adds %function to F, command
Z += %function
adds %function to Z.
To remove %function from F (or Z) either do:
F -= %function
or delete %function.
If there is more than one dataset, F and Z must be prexed with the dataset number (e.g. @1.F += %function).
The following syntax is also valid:
# create and add funtion to F
%g = Gaussian(height=~66254., hwhm=~0.264, center=~24.7)
@0.F += %g
# create automatically named function and add it to F
@0.F += Gaussian(height=~66254., hwhm=~0.264, center=~24.7)
# clear F
@0.F = 0
# clear F and put three functions in it
@0.F = %a + %b + %c
# show info about the first and the last function in @0.F
info @0.F[0], @0.F[-1]
# the same as %bcp = copy(%b)
%bcp = copy(@0.F[1])
# make @1.F the exact (shallow) copy of @0.F
@1.F = @0.F
# make @1.F a deep copy of @0.F (all functions and variables
# are duplicated).
@1.F = copy(@0.F)
It is often required to keep the width or shape of peaks constant for all peaks in the dataset. To change the variables
bound to parameters with a given name for all functions in F, use the command:
F.param = variable
Examples:
# Set hwhm of all functions in F that have a parameter hwhm to $foo
# (hwhm here means half-width-at-half-maximum)
F.hwhm = $foo
# Bound the variable used for the shape of peak %_1 to shapes of all
# functions in F
F.shape = %_1.shape
# Create a new simple-variable for each function in F and bound the
# variable to parameter hwhm. All hwhm parameters will be independent.
F.hwhm = ~0.2
20 Chapter 3. Reference
Fityk manual, Release 0.9.4
3.2.8 Guessing peak location
It is possible to guess peak location and add it to F with the command:
[%name =] guess PeakType [[x1:x2]] [initial values...] [in @n]
e.g.
%f1 = guess Gaussian [22.1:30.5] in @0
# the same, but assign functions name automatically
guess Gaussian [22.1:30.5] in @0
# the same, but search for the peak in the whole dataset
guess Gaussian in @0
# the same, but works only if there is exactly one dataset loaded
guess Gaussian
guess Linear in @
*
# adds a function to every dataset
# guess width and height, but set center and shape explicitely
guess PseudoVoigt [22.1:30.5] center=$ctr, shape=~0.3 in @0
If the range is omitted, the whole dataset will be searched.
Name of the function is optional.
Some of the parameters can be specied with syntax parameter=variable.
As an exception, if the range is omitted and the parameter center is given, the peak is searched around the
center, +/- value of the option guess_at_center_pm.
Fityk offers only a primitive algorithm for peak-detection. It looks for the highest point in a given range, and than
tries to nd the width of the peak.
If the highest point is found near the boundary of the given range, it is very probable that it is not the peak top,
and, if the option can_cancel_guess is set to true, the guess is cancelled.
There are two real-number options related to guess: height_correction and width_correction. The
default value for them is 1. The guessed height and width are multiplied by the values of these options respectively.
Linear function is guessed using linear regression. It is actually tted (but weights of points are not used), not
guessed.
3.2.9 Displaying information
If you are using the GUI, most of the available information can be displayed with mouse clicks. Alternatively, you
can use the info command. Using info+ instead of info sometimes gives more verbose output.
Below is the list of arguments of info related to this chapter. The full list is in info: show information
info guess [range] Shows where the guess command would nd a peak.
info functions Lists all dened functions.
info variables Lists all dened variables.
info @n.F Shows information about F in dataset n.
info @n.Z Shows information about Z in dataset n.
info formula in @n Shows the mathematical formula of the tted model. Some primitive simplications
are applied to the formula. To prevent it, put plus sign (+) after info.
info @n.dF(x) Compares the symbolic and numerical derivatives in x (useful for debugging).
3.2. Model 21
Fityk manual, Release 0.9.4
info peaks in @n Show parameters of functions from dataset n. With the plus sign (+) after info, uncer-
tainties of the parameters are also included.
The model can be exported to le as data points, using the syntax described in Exporting data, or as mathematical
formula, using the info command redirected to a le:
info[+] formula in @n > filename
The style of the formula output, governed by the formula_export_style option, can be either normal
(exp(-x^2)) or gnuplot (exp(-x**2)).
The list of parameters of functions can be exported using the command:
info[+] peaks in @n > filename
With @
*
formulae or parameters used in all datasets are written.
3.3 Fitting
3.3.1 Nonlinear optimization
This is the core. We have a set of observations (data points), to which we want to t a model that depends on
adjustable parameters. Let me quote Numerical Recipes, chapter 15.0, page 656 (if you do not know the book,
visit http://www.nr.com):
The basic approach in all cases is usually the same: You choose or design a gure-of-merit function
(merit function, for short) that measures the agreement between the data and the model with a particu-
lar choice of parameters. The merit function is conventionally arranged so that small values represent
close agreement. The parameters of the model are then adjusted to achieve a minimum in the merit
function, yielding best-t parameters. The adjustment process is thus a problem in minimization in
many dimensions. [...] however, there exist special, more efcient, methods that are specic to mod-
eling, and we will discuss these in this chapter. There are important issues that go beyond the mere
nding of best-t parameters. Data are generally not exact. They are subject to measurement errors
(called noise in the context of signal-processing). Thus, typical data never exactly t the model that is
being used, even when that model is correct. We need the means to assess whether or not the model
is appropriate, that is, we need to test the goodness-of-t against some useful statistical standard. We
usually also need to know the accuracy with which parameters are determined by the data set. In other
words, we need to know the likely errors of the best-t parameters. Finally, it is not uncommon in
tting data to discover that the merit function is not unimodal, with a single minimum. In some cases,
we may be interested in global rather than local questions. Not, how good is this t? but rather,
how sure am I that there is not a very much better t in some corner of parameter space?
Our function of merit is WSSR - the weighted sum of squared residuals, also called chi-square:

2
(a) =
N

i=1
_
y
i
y(x
i
; a)

i
_
2
=
N

i=1
w
i
[y
i
y(x
i
; a)]
2
Weights are based on standard deviations, w
i
= 1/
2
i
. You can learn why squares of residuals are minimized e.g.
from chapter 15.1 of Numerical Recipes.
So we are looking for a global minimum of
2
. This eld of numerical research (looking for a minimum or
maximum) is usually called optimization; it is non-linear and global optimization. Fityk implements three very
different optimization methods. All are well-known and described in many standard textbooks.
The standard deviations of the best-t parameters are given by the square root of the corresponding diagonal
elements of the covariance matrix. The covariance matrix is based on standard deviations of data points. Formulae
can be found e.g. in GSL Manual, chapter Linear regression. Overview (weighted data version).
22 Chapter 3. Reference
Fityk manual, Release 0.9.4
3.3.2 Fitting related commands
To t model to data, use command
t[+] [number-of-iterations] [in @n ...]
The plus sign (+) prevents initialization of the tting method. It is used to continue the previous tting where it
left off.
All non-linear tting methods are iterative. number-of-iterations is the maximum number of iterations. There are
also other stopping criteria, so the number of executed iterations can be smaller.
fit in @
*
ts all datasets simultaneously.
Fitting methods can be set using the set command:
set fitting_method = method
where method is one of: Levenberg_Marquardt, Nelder_Mead_simplex, Genetic_Algorithms.
All non-linear tting methods are iterative, and there are two common stopping criteria:
the number of iterations and it can be specied after the fit command.
and the number of evaluations of the objective function (WSSR), specied by the value of option
max_wssr_evaluations (0=unlimited). It is approximately proportional to the time of computations.
There are also other criteria, different for each method.
On Unix, tting can be interrupted by sending the INT signal to the program. This is usually done by pressing
Ctrl-C in the terminal.
If you give too small number-of-iterations to the command fit, and t is not converged, it makes sense to use
command fit+ to process further iterations.
Setting set autoplot = on_fit_iteration will plot a model after every iteration, to visualize progress.
(see autoplot)
info fit shows goodness-of-t.
Available methods can be mixed together, e.g. it is sensible to obtain initial parameter estimates using the Simplex
method, and then t it using Levenberg-Marquardt.
Values of all parameters are stored before and after tting (if they change). This enables simple undo/redo func-
tionality. If in the meantime some functions or variables where added or removed, the program can still load the
old parameters, but the result can be unexpected. The following history-related commands are provided:
t undo move back to the previous parameters (undo tting).
t redo move forward in the parameter history
info t_history show number of items in the history
t history n load the n-th set of parameters from history
t history clear clear the history
3.3.3 Uncertainty in the model parameters
From the book J. Wolberg, Data Analysis Using the Method of Least Squares: Extracting the Most Information
from Experiments, Springer, 2006, p.50:
(...) we turn to the task of determining the uncertainties associated with the a
k
s. The usual measures
of uncertainty are standard deviation (i.e., ) or variance (i.e.,
2
) so we seek an expression that
allows us to estimate the
a
k
s. It can be shown (...) that the following expression gives us an
unbiased estimate of
a
k
:
3.3. Fitting 23
Fityk manual, Release 0.9.4

2
a
k
=
S
n p
C
1
kk
Note that
a
k
is a square root of the value above. In this formula n-p, the number of (active) data points minus the
number of independent parameters, is equal to the number of degrees of freedom. S is another symbol for
2
(the
latter symbol is used e.g. in Numerical Recipes).
Terms of the C matrix are given as (p. 47 in the same book):
C
jk
=
n

i=1
w
i
f
a
j
f
a
k

a
k
above is often called a standard error. Having standard errors, it is easy to calculate condence intervals.
Now another book will be cited: H. Motulsky and A. Christopoulos, Fitting Models to Biological Data Using
Linear and Nonlinear Regression: A Practical Guide to Curve Fitting, Oxford University Press, 2004. This book
can be downloaded for free as a manual to GraphPad Prism 4.
The standard errors reported by most nonlinear regression programs (...) are approximate or
asymptotic. Accordingly, the condence intervals computed using these errors should also be con-
sidered approximate.
It would be a mistake to assume that the 95% condence intervals reported by nonlinear regression
have exactly a 95% chance of enclosing the true parameter values. The chance that the true value
of the parameter is within the reported condence interval may not be exactly 95%. Even so, the
asymptotic condence intervals will give you a good sense of how precisely you have determined the
value of the parameter.
The calculations only work if nonlinear regression has converged on a sensible t. If the regression
converged on a false minimum, then the sum-of-squares as well as the parameter values will be wrong,
so the reported standard error and condence intervals wont be helpful.
The book describes also more accurate ways to calculate condence intervals, such use Monte Carlo simulations.
In Fityk:
info errors shows values of
a
k
.
info+ errors additionally shows the matrix C
1
.
Individual symmetric errors of simple-variables can be accessed as $variable.error or e.g.
%func.height.error.
condence intervals are on the TODO list (in the meantime you can compute them by hand, see p.103 in
the GraphPad book)
Note: In Fityk 0.9.0 and earlier info errors reported values of
_
C
1
kk
, which makes sense if the standard
deviations of ys are set accurately. This formula is derived in Numerical Recipes.
3.3.4 Levenberg-Marquardt
This is a standard nonlinear least-squares routine, and involves computing the rst derivatives of functions. For a
description of the L-M method see Numerical Recipes, chapter 15.5 or Siegmund Brandt, Data Analysis, chapter
10.15. Essentially, it combines an inverse-Hessian method with a steepest descent method by introducing a
factor. When is equal to 0, the method is equivalent to the inverse-Hessian method. When increases, the shift
vector is rotated toward the direction of steepest descent and the length of the shift vector decreases. (The shift
vector is a vector that is added to the parameter vector.) If a better t is found on iteration, is decreased it
is divided by the value of lm_lambda_down_factor option (default: 10). Otherwise, is multiplied by the
value of lm_lambda_up_factor (default: 10). The initial value is equal to lm_lambda_start (default:
0.0001).
The Marquardt method has two stopping criteria other than the common criteria.
24 Chapter 3. Reference
Fityk manual, Release 0.9.4
If it happens twice in sequence, that the relative change of the value of the objective function (WSSR) is
smaller than the value of the lm_stop_rel_change option, the t is considered to have converged and
is stopped.
If is greater than the value of the lm_max_lambda option (default: 10^15), usually when due to limited
numerical precision WSSR is no longer changing, the tting is also stopped.
3.3.5 Nelder-Mead downhill simplex method
To quote chapter 4.8.3, p. 86 of Peter Gans, Data Fitting in the Chemical Sciences by the Method of Least Squares:
A simplex is a geometrical entity that has n+1 vertices corresponding to variations in n parameters.
For two parameters the simplex is a triangle, for three parameters the simplex is a tetrahedron and so
forth. The value of the objective function is calculated at each of the vertices. An iteration consists of
the following process. Locate the vertex with the highest value of the objective function and replace
this vertex by one lying on the line between it and the centroid of the other vertices. Four possible re-
placements can be considered, which I call contraction, short reection, reection and expansion.[...]
It starts with an arbitrary simplex. Neither the shape nor position of this are critically important, ex-
cept insofar as it may determine which one of a set of multiple minima will be reached. The simplex
than expands and contracts as required in order to locate a valley if one exists. Then the size and shape
of the simplex is adjusted so that progress may be made towards the minimum. Note particularly that
if a pair of parameters are highly correlated, both will be simultaneously adjusted in about the correct
proportion, as the shape of the simplex is adapted to the local contours.[...] Unfortunately it does not
provide estimates of the parameter errors, etc. It is therefore to be recommended as a method for
obtaining initial parameter estimates that can be used in the standard least squares method.
This method is also described in previously mentioned Numerical Recipes (chapter 10.4) and Data Analysis (chap-
ter 10.8).
There are a few options for tuning this method. One of these is a stopping criterium nm_convergence. If the
value of the expression 2(M-m)/(M*+*m), where M and m are the values of the worst and best vertices respectively
(values of objective functions of vertices, to be precise!), is smaller then the value of nm_convergence option,
tting is stopped. In other words, tting is stopped if all vertices are almost at the same level.
The remaining options are related to initialization of the simplex. Before starting iterations, we have to choose
a set of points in space of the parameters, called vertices. Unless the option nm_move_all is set, one of these
points will be the current point values that parameters have at this moment. All but this one are drawn as
follows: each parameter of each vertex is drawn separately. It is drawn from a distribution that has its center in
the center of the domain of the parameter, and a width proportional to both width of the domain and value of the
nm_move_factor parameter. Distribution shape can be set using the option nm_distribution as one of:
uniform, gaussian, lorentzian and bound. The last one causes the value of the parameter to be either
the greatest or smallest value in the domain of the parameter one of the two bounds of the domain (assuming
that nm_move_factor is equal 1).
3.3.6 Genetic Algorithms
[TODO]
3.4 Settings
Note: This chapter is not about GUI settings (things like colors, fonts, etc.), but about settings that are common
for both CLI and GUI version.
Command info set shows the syntax of the set command and lists all possible options.
set option shows the current value of the option.
set option = value changes the option.
3.4. Settings 25
Fityk manual, Release 0.9.4
It is possible to change the value of the option temporarily using syntax:
with option1=value1 [,option2=value2] command args...
The examples at the end of this chapter should clarify this.
autoplot See autoplot.
can_cancel_guess See Guessing peak location.
cut_function_level See Speed of computations.
data_default_sigma See Standard deviation (or weight).
epsilon It is used for oating-point comparison: a and b are considered equal when |a-b|<epsilon. You may
want to decrease it when you work with very small values, like 10^-10.
exit_on_warning If the option exit_on_warning is set, any warning will close the program. This ensures
that no warnings can be overlooked.
tting_method See Fitting related commands.
formula_export_style See details in the section Model.
guess_at_center_pm See Guessing peak location.
height_correction See Guessing peak location.
info_numeric_format Format of numbers printed by the info command. It takes as a value a format string, the
same as sprintf() in the C language. For example set info_numeric_format=%.3f changes
the precision of numbers to 3 digits after the decimal point. Default value: %g.
lm_* Setting to tune Levenberg_Marquardt tting method.
max_wssr_evaluations See Fitting related commands.
nm_* Setting to tune Nelder-Mead downhill simplex tting method.
pseudo_random_seed Some tting methods and functions, such as randnormal in data expressions use a
pseudo-random number generator. In some situations one may want to have repeatable and predictable
results of the tting, e.g. to make a presentation. Seed for a new sequence of pseudo-random numbers can
be set using the option pseudo_random_seed. If it is set to 0, the seed is based on the current time and
a sequence of pseudo-random numbers is different each time.
refresh_period During time-consuming computations (like tting) user interface can remain not changed for this
time (in seconds). This option was introduced, because on one hand frequent refreshing of the programs
window notably slows down tting, and on the other hand irresponsive program is a frustrating experience.
variable_domain_percent See the section about variables.
verbosity Possible values: quiet, normal, verbose, debug.
width_correction See Guessing peak location.
Examples:
set fitting_method # show info
set fitting_method = Nelder_Mead_simplex # change default method
set verbosity = verbose
with fitting_method = Levenberg_Marquardt fit 10
with fitting_method=Levenberg_Marquardt, verbosity=quiet fit 10
26 Chapter 3. Reference
Fityk manual, Release 0.9.4
3.5 Other commands
3.5.1 plot: viewing data
In the GUI version there is hardly ever a need to use this command directly.
The command plot controls visualization of data and the model. It is used to plot a given area - in GUI it is
plotted in the programs main window, in CLI the popular program gnuplot is used, if available.
plot xrange yrange in @n
xrange and yrange have one of two following syntaxes:
[min:max]
.
The second is just a dot (.), and it implies that the appropriate range is not to be changed.
Examples:
plot [20.4:50] [10:20] # show x from 20.4 to 50 and y from 10 to 20
plot [20.4:] # x from 20.4 to the end,
# y range will be adjusted to encompass all data
plot . [:10] # x range will not be changed, y from the lowest point to 10
plot [:] [:] # all data will be shown
plot # all data will be shown
plot . . # nothing changes
The value of the option autoplot changes the automatic plotting behaviour. By default, the plot is refreshed
automatically after changing the data or the model. It is also possible to visualize each iteration of the tting
method by replotting the peaks after every iteration.
3.5.2 info: show information
First, there is an option verbosity (not related to command info) which sets the amount of messages displayed
when executing commands.
If you are using the GUI, most information can be displayed with mouse clicks. Alternatively, you can use the
info command. Using the info+ instead of info sometimes displays more detailed information.
The output of info can be redirected to a le using syntax:
info args > filename # this truncates the file
info args >> filename # this appends to the file
The following info arguments are recognized:
variables
$variable_name
types
TypeName
functions
%function_name
datasets
data [in @n]
3.5. Other commands 27
Fityk manual, Release 0.9.4
title [in @n]
lename [in @n]
commands
commands [n:m]
view
set
t [in @n]
t_history
errors [in @n]
formula [in @n]
peaks [in @n]
guess [x-range] [in @n]
data-expression [in @n]
[@n.]F
[@n.]Z
[@n.]dF(data-expression)
der mathematic-function
version
info der shows derivatives of given function:
=-> info der sin(a) + 3
*
exp(b/a)
f(a, b) = sin(a)+3
*
exp(b/a)
df / d a = cos(a)-3
*
exp(b/a)
*
b/a^2
df / d b = 3
*
exp(b/a)/a
3.5.3 commands, dump, sleep, reset, quit, !
All commands given during program execution are stored in memory. They can be listed by:
info commands [n:m]
or written to le:
info commands [n:m] > filename
To put all commands executed so far during the session into the le foo.fit, type:
info commands[:] > foo.fit
With the plus sign (+) (i.e. info+ commands [n:m]) information about the exit status of each command will
be added.
To log commands to a le when they are executed, use: Commands can be logged when they are executed:
commands > filename # log commands
commands+ > filename # log both commands and output
commands > /dev/null # stop logging
Scripts can be executed using the command:
28 Chapter 3. Reference
Fityk manual, Release 0.9.4
commands < filename
It is also possible to execute the standard output from external program:
commands ! program [args...]
The command:
dump > filename
writes the current state of the program (including all datasets) to a single .t le.
The command sleep sec makes the program wait sec seconds.
The command quit works as expected. If it is found in a script it quits the program, not only the script.
Commands that start with ! are passed (without !) to the system() call.
3.5. Other commands 29
Fityk manual, Release 0.9.4
30 Chapter 3. Reference
CHAPTER
FOUR
EXTENSIONS
4.1 How to add your own built-in function
Note: Add built-in function only if user-dened function (UDF) is too slow or too limited.
To add a built-in function, you have to change the source of the program and then recompile it. Users who want to
do this should be able to compile the program from source and know the basics of C, C++ or another programming
language.
The description that follows is not complete. If something is not clear, you can always send me e-mail, etc.
fp you can see in tyk source means a real (oating point) number (typedef double fp).
The name of your function should start with uppercase letter and contain only letters and digits. Let us add function
Foo with the formula: Foo(height, center, hwhm) = height/(1+((x-center)/hwhm)^2). C++ class representing Foo
will be named FuncFoo.
In src/func.cpp you will nd a list of functions:
...
FACTORY_FUNC(Polynomial6)
FACTORY_FUNC(Gaussian)
...
Now, add:
FACTORY_FUNC(Foo)
Then nd another list:
...
FuncPolynomial6::formula,
FuncGaussian::formula,
...
and add the line
FuncFoo::formula,
Note that in the second list all items but the last are followed by comma.
In the le src/bfunc.h you can now begin writing the denition of your class:
class FuncFoo : public Function
{
DECLARE_FUNC_OBLIGATORY_METHODS(Foo, Function)
31
Fityk manual, Release 0.9.4
If you want to make some calculations every time parameters of the function are changed, you can do it in method
do_precomputations. This possibility is provided for calculating expressions, which do not depend on x. Write
the declaration here:
void do_precomputations(std::vector<Variable
*
> const &variables);
and provide a proper denition of this method in src/bfunc.cpp.
If you want to optimize the calculation of your function by neglecting its value outside of a given range (see option
cut_function_level in the program), you will need to use the method:
bool get_nonzero_range (fp level, fp &left, fp &right) const;
This method takes the level below which the value of the function can be approximated by zero, and should set
the left and right variables to proper values of x, such that if x<left or x>right than |f(x)|<level. If the function sets
left and right, it should return true.
If your function does not have a center parameter, and there is a center-like point where you want the peak top
to be drawn, write:
bool has_center() const { return true; }
fp center() const { return vv[1]; }
In the second line, between return and the semicolon, there is an expression for the x coordinate of peak top; vv[0]
is the rst parameter of function, vv[1] is the second, etc.
Finally, close the denition of the class with:
};
Now go to le src/bfunc.cpp.
Write the function formula in this way:
const char
*
FuncFoo::formula
= "Foo(height, center, hwhm) = height/(1+((x-center)/hwhm)^2)";
The syntax of the formula is the similar as that of the UDF, but for built-in functions only the left hand side of the
formula is parsed. The right hand side is for documentation only.
Write how to calculate the value of the function:
CALCULATE_VALUE_BEGIN(Foo)
fp xa1a2 = (x - vv[1]) / vv[2];
fp inv_denomin = 1. / (1 + xa1a2
*
xa1a2);
CALCULATE_VALUE_END(vv[0]
*
inv_denomin)
The expression at the end (i.e. vv[0]*inv_denomin) is the calculated value. xa1xa2 and inv_denomin are variables
introduced to simplify the expression. Note the fp (you can also use double) at the beginning and semicolon
at the end of both lines. The meaning of vv has already been explained.
Usually it is more difcult to calculate derivatives:
CALCULATE_DERIV_BEGIN(Foo)
fp xa1a2 = (x - vv[1]) / vv[2];
fp inv_denomin = 1. / (1 + xa1a2
*
xa1a2);
dy_dv[0] = inv_denomin;
fp dcenter = 2
*
vv[0]
*
xa1a2 / vv[2]
*
inv_denomin
*
inv_denomin;
dy_dv[1] = dcenter;
dy_dv[2] = dcenter
*
xa1a2;
dy_dx = -dcenter;
CALCULATE_DERIV_END(vv[0]
*
inv_denomin)
32 Chapter 4. Extensions
Fityk manual, Release 0.9.4
You must set derivatives dy_dv[n] for n=0,1,...,(number of parameters of your function - 1) and dy_dx. In the last
brackets there is a value of the function again.
If you declared do_precomputations or get_nonzero_range methods, do not forget to write denitions
for them.
After compilation of the program check if the derivatives are calculated correctly using command info dF(x),
e.g. i dF(30.1). You can also use numarea, findx and extremum (see Functions and variables in data
transformation for details) to verify center, area, height and FWHM properties.
Hope this helps. Do not hesistate to change this description or ask questions if you have any. Consider sharing
your function with other users (using FitykWiki or mailing list).
4.1. How to add your own built-in function 33
Fityk manual, Release 0.9.4
34 Chapter 4. Extensions
APPENDIX
A
APPENDIX A. LIST OF FUNCTIONS
The list of all functions can be obtained using i+ types. Some formulae here have long parameter names (like
height, center and hwhm) replaced with a
i
Gaussian:
y = a
0
exp
_
ln(2)
_
x a
1
a
2
_
2
_
SplitGaussian:
y(x; a
0
, a
1
, a
2
, a
3
) =
_
Gaussian(x; a
0
, a
1
, a
2
) x a
1
Gaussian(x; a
0
, a
1
, a
3
) x > a
1
GaussianA:
y =
_
ln(2)

a
0
a
2
exp
_
ln(2)
_
x a
1
a
2
_
2
_
Lorentzian:
y =
a
0
1 +
_
xa
1
a
2
_
2
SplitLorentzian:
y(x; a
0
, a
1
, a
2
, a
3
) =
_
Lorentzian(x; a
0
, a
1
, a
2
) x a
1
Lorentzian(x; a
0
, a
1
, a
3
) x > a
1
LorentzianA:
y =
a
0
a
2
_
1 +
_
xa
1
a
2
_
2
_
Pearson VII (Pearson7):
y =
a
0
_
1 +
_
xa
1
a
2
_
2
_
2
1
a
3
1
_
_
a
3
35
Fityk manual, Release 0.9.4
split Pearson VII (SplitPearson7):
y(x; a
0
, a
1
, a
2
, a
3
, a
4
, a
5
) =
_
Pearson7(x; a
0
, a
1
, a
2
, a
4
) x a
1
Pearson7(x; a
0
, a
1
, a
3
, a
5
) x > a
1
Pearson VII Area (Pearson7A):
y =
a
0
(a
3
)
_
2
1
a
3
1
a
2
(a
3

1
2
)

_
1 +
_
xa
1
a
2
_
2
_
2
1
a
3
1
_
_
a
3
Pseudo-Voigt (PseudoVoigt):
y = a
0
_

_(1 a
3
) exp
_
ln(2)
_
x a
1
a
2
_
2
_
+
a
3
1 +
_
xa
1
a
2
_
2
_

_
Pseudo-Voigt is a name given to the sum of Gaussian and Lorentzian. a
3
parameters in Pearson VII and Pseudo-
Voigt are not related.
split Pseudo-Voigt (SplitPseudoVoigt):
y(x; a
0
, a
1
, a
2
, a
3
, a
4
, a
5
) =
_
PseudoVoigt(x; a
0
, a
1
, a
2
, a
4
) x a
1
PseudoVoigt(x; a
0
, a
1
, a
3
, a
5
) x > a
1
Pseudo-Voigt Area (PseudoVoigtA):
y = a
0
_

_
(1 a
3
)
_
ln(2)
a
2

exp
_
ln 2
_
x a
1
a
2
_
2
_
+
a
3
a
2
_
1 +
_
xa
1
a
2
_
2
_
_

_
Voigt:
y =
a
0
_
+

exp(t
2
)
a
2
3
+(
xa
1
a
2
t)
2
dt
_
+

exp(t
2
)
a
2
3
+t
2
dt
The Voigt function is a convolution of Gaussian and Lorentzian functions. a
0
= heigth, a
1
= center, a
2
is propor-
tional to the Gaussian width, and a
3
is proportional to the ratio of Lorentzian and Gaussian widths.
Voigt is computed according to R.J.Wells, Rapid approximation to the Voigt/Faddeeva function and its
derivatives, Journal of Quantitative Spectroscopy & Radiative Transfer 62 (1999) 29-48. (See also:
http://www.atm.ox.ac.uk/user/wells/voigt.html). The approximation is very fast, but not very exact.
FWHM is estimated using approximation by Olivero and Longbothum (JQSRT 17, 233 (1977)): 0.5346w
L
+
_
0.2169w
2
L
+ w
2
G
.
VoigtA:
y =
a
0

a
2
_
+

exp(t
2
)
a
2
3
+ (
xa
1
a
2
t)
2
dt
36 Appendix A. Appendix A. List of functions
Fityk manual, Release 0.9.4
Exponentially Modied Gaussian (EMG):
y =
ac

2
2d
exp
_
b x
d
+
c
2
2d
2
__
d
|d|
erf
_
b x

2c
+
c

2d
__
LogNormal:
y = hexp
_
_
_
ln(2)
_
ln
_
1 + 2b
xc
w
_
b
_
2
_
_
_
Doniach-Sunjic (DoniachSunjic):
y =
h
_
a
2
+ (1 a) arctan
_
xE
F
_
F + (x E)
2
Polynomial5:
y = a
0
+ a
1
x + a
2
x
2
+ a
3
x
3
+ a
4
x
4
+ a
5
x
5
37
Fityk manual, Release 0.9.4
38 Appendix A. Appendix A. List of functions
APPENDIX
B
APPENDIX B. GRAMMAR
The syntax of the tyk mini-language (it can be called a domain-specic language) will be dened formally during
the work on a new parser.
The syntax below (in extended BNF) is not complete and may change in the future.
Note that each line is parsed and executed separately and no new line characters are expected.
line ::= [{statement ;} statement] [comment]
comment ::= # { AllChars }
statement ::= [with_st] ( commands_st |
define_st |
delete_st |
fit_st |
guess_st |
info_st |
plot_st |
set_st |
undefine_st |
assign_st |
dataset_st |
dump_st |
"quit" |
"reset" |
"sleep" Number |
! { AllChars } |
transform_st )
with_st ::= With option {, option}
commands_st ::= Commands ...TODO
(
*
TODO: commands > file -> set logfile file
*
)
(
*
TODO: commands < file -> exec file
*
)
(
*
TODO: commands ! shell command -> exec ! shell command
*
)
define_st ::= Define ...TODO
delete_st ::= Delete ( (delete_arg {, delete_arg}) |
( ( data_expression ) in_arg ) )
delete_arg ::= Varname | func_id | Dataset
fit_st ::= Fit fit_arg in_arg
fit_arg ::= [+] Number |
"undo" |
"redo" |
"history" Number |
"clear_history"
39
Fityk manual, Release 0.9.4
guess_st ::= Guess ...TODO
info_st ::= Info info_arg {, info_arg} [redir]
dump_st ::= "dump" redir (
*
to be replaced with info state
*
)
plot_st ::= Plot ...TODO
set_st ::= Set (option {, option} | name)
undefine_st ::= Undefine Word {, Word}
assign_st ::= Varname = TODO |
func_id = TODO |
func_id . Word = TODO |
Dataset . F = TODO |
Dataset . F . Word = TODO |
Dataset . "title" = TODO
dataset_st ::= (Dataset | "@+") ( < Filename {option} |
= [Word] Dataset { + Dataset } {Word} )
transform_st ::= transform_lhs = data_expression
func_id = Funcname |
(
*
TODO: Dataset . z |
*
)
Dataset . F [ Number ]
option ::= name = value
string ::= QuotedString | Word
QuotedString ::= "" { AllChars - "" } ""
Word ::= { AllChars - (Whitespace | ; | , | # ) }
AllChars ::= ? all characters ?
Varname ::= $ Word
Funcname ::= % Word
Commands ::= "c" | "co" | "com" | ... | "commands"
Define ::= "def" | ... | "define"
Delete ::= "del" | ... | "delete"
Fit ::= "f" | "fi" | "fit"
Guess ::= "g" | ... | "guess"
Info ::= "i" | ... | "info"
Plot ::= "p" | ... | "plot"
Set ::= "s" | "se" | "set"
Undefine ::= "undef" | ... | "undefine"
With ::= "w" | ... | "with"
40 Appendix B. Appendix B. Grammar
APPENDIX
C
APPENDIX C. LICENSE
Fityk is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
Text of the license is distributed with the program in the le COPYING.
41
Fityk manual, Release 0.9.4
42 Appendix C. Appendix C. License
APPENDIX
D
APPENDIX D. ABOUT THIS MANUAL
This manual is written using ReStructuredText. All changes, improvements, corrections, etc. are welcome. Use
the Show Source link to get the source of the page, save it, edit, and send me either modied version or patch
containing changes.
Following people have contributed to this manual (in chronological order): Marcin Wojdyr (maintainer), Stan
Gierlotka, Jaap Folmer, Michael Richardson.
43