Home    Reference Manuals    Return   

Users Manual for Program FUNC  

Table of Contents

Introduction

Program FUNC operates on variables in time-domain. The mode of operation of the program is controlled in the input data command FUNC.

Input data commands

Input data are read in free format, valid separators between the input values are <space>, <comma>, <tab>, <equal sign> or <carriage return>. The commands can be written both in lower and upper case letters. The operation of the program is controlled by the commands described below; some of the commands also need arguments.

Summary of all main commands

FUNC

To select the mode of the FUNC program the user has the choice of the following alternatives:

ABS	Calculates the absolute value of the Y-variable in INFIL1
ADD	Adds the Y-variable in INFIL1 to the Y-variable in INFIL2
ADD_C	Adds a scalar to the Y-variable in INFIL1
ADDX_C	Adds a scalar to the X-variable in INFIL1
AVERAGE	Calculates the average value of the Y-variable in INFIL1
CABS	Calculates the complex absolute value of the complex Y-variable in INFIL1
CIRCLE	Creates a variable describing a circle
CONJG	Calculates the complex conjugate of the complex Y-variable in INFIL1
CONST	Creates a variable describing a horizontal line
COS	Creates a variable describing a cosinus variable.
CROSS-CORR	Calculates the cross-correlation function of INFIL1 and INFIL2
DERIV_M	Creates the derivative of a variable
DIV	Divides the Y-variable in INFIL1 by the Y-variable in INFIL2
FIT_X4_LEG	Fits a fourth order polynomial to the Y-variable in INFIL1
HPASS1_0	Filters the Y-variable in INFIL1 through a first order high-pass filter
HPASS2_0	Filters the Y-variable in INFIL1 through a second order high-pass filter
INTEG_HEUN	Integrates a variable read from file
INTPL_L	Interpolates the Y-variable in INFIL1 linearly
INV	Inverts the Y-variable in INFIL1
LPASS1_0	Filters the Y-variable in INFIL1 through a first order low-pass filter.
LPASS2_0	Filters the Y-variable in INFIL1 through a second order low-pass filter.
LPASS2_M	Filters the Y-variable in INFIL1 through a second order low-pass filter with variable cut-off frequency.
MEAN_M	Calculates the average value of INFIL1 in a sliding window
MED	Calculates the average value of the Y-variable in INFIL1 and the corresponding Y-variable in INFIL2
MUL	Multiplies the Y-variable in INFIL1 by the Y-variable in INFIL2
MUL_C	Multiplies the Y-variable in INFIL1 by a scalar
MULX_C	Multiplies the X-variable in INFIL1 by a scalar
NOISE_NORMAL	Creates a variable containing a normal distributed noise
PLINE_1	Creates a variable describing a straight line
REDUCE	Filter a function by reducing the number of points describing the curve into a minimum
RMEAN	Filters the Y-variable INFIL1 by removing a sliding mean value.
RMS	Calculates the RMS-value of the Y-variable in INFIL1
RS	The same as in RMS but does not calculate the average
SIN	Creates a variable describing a sine-wave
SPLINE	Interpolates the Y-variable in INFIL1 by splines
SPLINE_G	Interpolates the Y-variable in INFIL1 by B-splines
SPLINE_G_REL	Interpolates the Y-variable in INFIL1 by B-splines
SUB	Subtracts the Y-variable in INFIL2 from the Y-variable in INFIL1
SUM	Totals all Y-values in INFIL1.

ABS

Calculates the absolute value of the Y-variable in INFIL1.
Operation ABS reads curve stored in INFIL1, calculates the absolute values at all points, writes the result to file UTFIL.
DATA must be of type SNGL.

ADD

Adds the Y-variable in INFIL1 to the Y-variable in INFIL2.
Operation ADD reads the curves stored in INFIL1 and INFIL2, calculates the sum at all points, writes the result to file UTFIL. If INFIL1 and INFIL2 have different number of points, the results will be as long as the shortest curve.
DATA must be of type SNGL.

ADD_C

Adds a scalar to the Y-variable in INFIL1
Operation ADD reads the curve stored in INFIL1, adds the value of scalar AMPL to the Y-variable at all points, writes the result to file UTFIL.
DATA must be of type SNGL.

ADDX_C

Adds a scalar to the X-variable in INFIL1
Operation ADD reads the curve stored in INFIL1, adds the value of scalar AMPL to the X-variable at all points, writes the result to file UTFIL.
DATA must be of type SNGL.

AVERAGE

Calculates the average value of the Y-variable in INFIL1.
Operation AVERAGE reads the curve stored in INFIL1, sums all Y-values, calculate the average value, writes the result as a scalar to file UTFIL.
DATA must be of type SNGL.

The scalar written to UTFIL consists of the following four points:
point #1 = (FIN(1), 0.)
point #2 = (FIN(1), the average value)
point #3 = (FIN(2), the average value)
point #4 = (FIN(2), 0.)

CABS

Calculates the complex absolute value of the complex Y-variable in INFIL1.
Operation CABS reads curve stored in INFIL1, calculates the complex absolute values at all points, writes the result to file UTFIL.
DATA must be of type CMPLX.

CIRCLE

Create a part of a circle with radius R. The origin of the circle is located at the coordinates (x0,y0). The creation of the curve starts at the horizontal coordinate x_start and ends at x_stop. The upper part of the circle is generated if part=+1, the lower part is generated if part=-1. The consecutive distance between the generated point is defined in the input data parameter DX. If not DX is a multiple of x_stop-x_start program FUNC will stop just before x_stop is reached. The other input data to FUNC=CIRCLE is given in the array FIN.
FIN= x0, y0, R, x_start, x_stop, part
DATA must be of type SNGL.

CONJG

Calculates the complex conjugate of the complex Y-variable in INFIL1.
Operation CONJG reads curve stored in INFIL1, calculates the complex conjugate at all points, writes the result to file UTFIL.
DATA must be of type CMPLX.

CONST

Creates a variable describing a horizontal line.
Operation CONST generates a curve starting at X(1)= 0. ending at X(n)= LENGTH, all Y-values will be set equal to AMPL. Number of points stored will be equal to n= LENGTH / DX. The result will be written to file UTFIL.
DATA must be of type SNGL.

COS

Creates a variable describing a cosinus variable.
Operation COS generates a curve starting at X(1)= 0. ending at X(n)= LENGTH, the Y-values will be set equal to Y(i)=AMPL*cos(X(i)). Number of points stored will be equal to n= LENGTH / DX. The result will be written to file UTFIL.
DATA must be of type SNGL.

CROSS-CORR

Calculates the cross-correlation function of INFIL1 and INFIL2.
A FUNC-input data file performing cross-correlation calculations can be found under examples. The result will be written to file UTFIL.
DATA must be of type SNGL.

DERIV_M

Creates the derivative of a variable.
The derivation is symmetric in every point dy(t)= (y(t+dt)-Y(t-dt))/(2*dt), except in the first and last point.
The input data variable will be read from file INFIL1.
The result will be written to file UTFIL.
DATA must be of type SNGL.

DIV

Divides the Y-variable in INFIL1 by the Y-variable in INFIL2. Operation DIV reads the curves stored in INFIL1 and INFIL2, calculates the division Yvar(INFIL1) / Yvar(INFIL2) at all points, writes the result to file UTFIL. If INFIL1 and INFIL2 have different number of points, the results will be as long as the shortest curve.
DATA must be of type SNGL.

FIT_X4_LEG

Fits a fourth order polynomial to the Y-variable in INFIL1.
The output from the fourth order polynomial is written as a vector on file UTFIL. The results in file UTFIL is written with equidistant steps defined in command DX. The length of the results written to UTFIL is defined in command LENGTH.
DATA must be of type SNGL.

HPASS1_0

First order high-pass filter, with initial value 0(zero).
Cut-off frequency is defined in variable FIN(1) [Hz]. The result is stored as a vector on file UTFIL.
DATA must be of type SNGL.

HPASS2_0

Second order high-pass filter, with initial value 0(zero).
Cut-off frequency is defined in variable FIN(1) [Hz]. Relative damping is defined in variable FIN(2) [1]. The result is stored as a vector on file UTFIL.
DATA must be of type SNGL.

INTEG_HEUN

Integrates a variable.
The integration is made according to Heun's method..
The input data variable will be read from file INFIL1.
The result will be written to file UTFIL.
DATA must be of type SNGL.

INTPL_L

Interpolates the Y-variable in INFIL1 in equidistant linearly.
Input data variable DX defines the equidistant step in which the variable will be interpolated in.
If FIN(1) is defined in input data the interpolation will start at FIN(1), otherwise the interpolation will start at the first coordinate in INFIL1.
If FIN(2) is defined in input data the interpolation will stop at FIN(2), otherwise the interpolation will stop at the end of INFIL1.
The result is stored as curve in file UTFIL.
DATA must be of type SNGL.

INV

Inversion of a variable.
Operation INV reads curve stored in INFIL1, calculates the inversion of the Y-value at all points, writes the result to file UTFIL.
DATA must be of type SNGL.

LPASS1_0

First order low-pass filter, initial value 0(zero).
Cut-off frequency is defined in variable FIN(1) [Hz]. The result is stored as curve on file UTFIL.
DATA shall be of type SNGL.

LPASS2_0

Second order low-pass filter, initial value 0(zero).
Cut-off frequency is defined in variable FIN(1) [Hz]. Relative damping is defined in variable FIN(2) [1]. The result is stored as curve on file UTFIL.
DATA shall be of type SNGL.

LPASS2_M

Filters the Y-variable read from INFIL1 through two first order low-pass filters with variable cut-off frequency.
Before the filtering process starts the input data file is interpolated in equidistant steps DX. The two first order low-pass filters are connected in series, the first filter operating in positive direction and the second filter is operating in negative direction. In input data variable FIN the user controls the filtering properties:

FIN(1)	=	Defines the start coordinat from where the interpolation begins. Default value: the first point in INFIL1.
FIN(2)	=	Defines the end coordinat from where the interpolation stops. Default value: the last point in INFIL1.
FIN(3)	=	Base cut-off angular frequency in [rad/s]
FIN(4)	=	Cut-off angular frequency in [rad/s], to be added on FIN(3) when large variations in input data occurs.

The result is stored as a vector on file UTFIL.
DATA must be of type SNGL.

MEAN_M

Sliding average value calculations.
Filter MEAN_M reads curve stored in INFIL1, calculates the average value in a window of width FIN(1), slides the window over the curve read from INFIL1, writes the result to file UTFIL.
DATA must be of type SNGL.

MED

Calculates the average value of the Y-variable in INFIL1 and the corresponding Y-variable in INFIL2.
Operation MED reads the curves stored in INFIL1 and INFIL2, calculates the average value at all points, writes the result to file UTFIL. If INFIL1 and INFIL2 have different number of points, the results will be as long as the shortest curve.
DATA must be of type SNGL.

MUL

Multiplies the Y-variable in INFIL1 by the Y-variable in INFIL2.
Operation MUL reads the curves stored in INFIL1 and INFIL2, calculates the product Yvar(UTFIL)= Yvar(INFIL1) * Yvar(INFIL2) at all points, writes the result to file UTFIL. If INFIL1 and INFIL2 have different number of points, the results will be as long as the shortest curve.
DATA must be of type SNGL.

MUL_C

Multiplies a scalar to the Y-variable in INFIL1
Operation MUL_C reads the curve stored in INFIL1, calculates the product Yvar(UTFIL)= AMPL * Yvar(INFIL1) at all points, writes the result to file UTFIL.
DATA must be of type SNGL.

MULX_C

Multiplies a scalar to the X-variable in INFIL1
Operation MULX_C reads the curve stored in INFIL1, calculates the product Xvar(UTFIL)= AMPL * Xvar(INFIL1) at all points, writes the result to file UTFIL.
DATA must be of type SNGL.

NOISE_NORMAL

Creates a variable containing a normal distributed noise.
The average value of the noise is defined in FIN(1). The standard deviation of the noise is defined in FIN(2). Distance between two consecutive points in the X-axle is defined in DX. Length of the output variable is defined in LENGTH.
DATA must be of type SNGL.

PLINE_1

Creates a variable describing a straight line.
The line is defined by the coordinates (x1,y1) and (x2,y2). The consecutive distance between the generated point is defined in the input data parameter DX. If not DX is a multiple of x_stop-x_start program FUNC will stop just before x_stop is reached. All input data to FUNC=PLINE_1 is given in the array FIN.
FIN= x1, y1, x2, y2,
A FUNC-input data file using PLINE_1 can be found under examples.
DATA must be of type SNGL.

REDUCE

Filter a function by reducing the number of points describing the curve into a minimum.
The filter is mainly used for detecting circular- and transition curves, in a track recording. All input data to FUNC=REDUCE is given in array FIN.
FIN= eps, epsg, alfa
Where:

eps	=	Max deviation from the current curvature
epsg	=	Above this amplitude the error is calculated as a relative error
alfa	=	If the slope of the curve decreases under alfa the curve is considered to be purely horizontal.

RMEAN

Filters the Y-variable INFIL1 by removing a sliding mean value.
Filter RMEAN reads curve stored in INFIL1, calculates the average value in a window of width FIN(1), subtract current point with the value of the sliding mean value according to: Yvar(UTFIL)= Yvar(INFIL1) - Yslide_mean(INFIL1) writes the result to file UTFIL.
The effect of the RMEAN-filter is similar to a low-pass filter, but all frequency components will have the same time delay.
DATA must be of type SNGL.

RMS

Calculates the RMS-value of the Y-variable in INFIL1.
Operation RMS reads the curve stored in INFIL1, calculates the Root Mean Square value of all Y-values, writes the result as a scalar to file UTFIL.
DATA must be of type SNGL.

The scalar written to UTFIL consists of the following four points:
point #1 = (FIN(1), 0.)
point #2 = (FIN(1), the RMS value)
point #3 = (FIN(2), the RMS value)
point #4 = (FIN(2), 0.)

RS

The same as RMS but does not do the average calculation. Operation RS reads the curve stored in INFIL1, sums the square of all Y-values, calculates the square-root of the sum, writes the result as a scalar to file UTFIL.
DATA must be of type SNGL.

The scalar written to UTFIL consists of the following four points:
point #1 = (FIN(1), 0.)
point #2 = (FIN(1), the RS value)
point #3 = (FIN(2), the RS value)
point #4 = (FIN(2), 0.)

Operation RS can be used for calculating the RMS-value of a Fourier series.

SIN

Creates a variable describing a sine-wave.
Operation SIN generates a curve starting at X(1)= 0. ending at X(n)= LENGTH, the Y-values will be set equal to Y(i)=AMPL*sin(X(i)). Number of points stored will be equal to n= LENGTH / DX. The result will be written to file UTFIL.
A FUNC-input data file using SIN can be found under examples. DATA must be of type SNGL.

SPLINE

Interpolates the Y-variable in INFIL1 in equidistant steps by splines.
Input data variable DX defines the equidistant step in which the variable will be interpolated in.
If FIN(1) is defined in input data the interpolation will start at FIN(1), otherwise the interpolation will start at the first coordinate in INFIL1.
If FIN(2) is defined in input data the interpolation will stop at FIN(2), otherwise the interpolation will stop at the end of INFIL1.
The result is stored as a vector on file UTFIL.
DATA must be of type SNGL.

SPLINE_G

Interpolates the Y-variable in INFIL1 in equidistant steps by splines.
Input data variable DX defines the equidistant step in which the variable will be interpolated in. Input data variable FIN(1) defines how well the spline interpolated result shall fit to the original data read from file INFIL1. FIN(1) is the mean-square error between the original curve INFIL1 and the created curve UTFIL.
If FIN(2) is defined in input data the interpolation will start at FIN(2), otherwise the interpolation will start at the first coordinate in INFIL1.
If FIN(3) is defined in input data the interpolation will stop at FIN(3), otherwise the interpolation will stop at the end of INFIL1.
The result is stored as a vector on file UTFIL.
A FUNC-input data file performing spline interpolations can be found under examples.
DATA must be of type SNGL.

SPLINE_G_REL

Interpolates the Y-variable in INFIL1 in equidistant steps by splines.
Input data variable DX defines the equidistant step in which the variable will be interpolated in. Input data variable FIN(1) defines how well the spline interpolated result shall fit to the original data read from file INFIL1. In contrast to SPLINE_G FIN(1) is given as a relative error between the original curve INFIL1 and the created curve UTFIL.
If FIN(2) is defined in input data the interpolation will start at FIN(2), otherwise the interpolation will start at the first coordinate in INFIL1.
If FIN(3) is defined in input data the interpolation will stop at FIN(3), otherwise the interpolation will stop at the end of INFIL1.
The result is stored as a vector on file UTFIL.
A FUNC-input data file performing spline interpolations can be found under examples.
DATA must be of type SNGL.

SUB

Subtracts the Y-variable in INFIL2 from the Y-variable in INFIL1
Operation SUB reads the curves stored in INFIL1 and INFIL2, subtracts the Yvalues at all points, writes the result to file UTFIL. If INFIL1 and INFIL2 have different number of points, the results will be as long as the shortest curve.
DATA must be of type SNGL.

SUM

Totals all Y-values in INFIL1.
Operation SUM reads the curve stored in INFIL1, sums all Y-values, writes the sum as a scalar to file UTFIL.
DATA must be of type SNGL.

The scalar written to UTFIL consists of the following four points:
point #1 = (FIN(1), 0.)
point #2 = (FIN(1), the sum)
point #3 = (FIN(2), the sum)
point #4 = (FIN(2), 0.)

---

INFIL1

Input data file, variable 1
Lines beginning with a #-sign are treated as commentary lines.
Declared = Character*80    Default = Blank

INFIL2

Input data file, variable 2
Lines beginning with a #-sign are treated as commentary lines.
Declared = Character*80    Default = Blank

DATA

Sets the data type, single or complex precision
DATA can be given the following two values:
 SNGL for single precision
 CMPLX for complex precision
Declared = Character*5    Default = 'CMPLX'

FORMF1

Format in which INFIL1 shall be read The string should be enclosed in parenthesis e.g. '(E15.3, 20X, E15.3)'. The format specification must be written in a way that it can be used in a FORTRAN read statement. The format specification given in the example above enables program FUNC to read the first 15 characters in file INFIL1 into the X-variable, the next 20 characters will be skipped, the next 15 characters will be read into the Y-variable.
In order to read file INFIL1 in free format, FORMIN can be given one of the following values:

                                           
 '(A,A)'            = reads column 1 & 2   
 '(A,X,A)'          = reads column 1 & 3   
 '(A,X,X,A)'        = reads column 1 & 4   
 '(A,X,X,X,A)'      = reads column 1 & 5   
 '(A,X,X,X,X,A)'    = reads column 1 & 6   
 '(A,X,X,X,X,X,A)'  = reads column 1 & 7   
 '(A,X,X,X,X,X,X,A)'= reads column 1 & 8   
 '(X,A,A)'          = reads column 1 & 3   
 '(X,A,X,A)'        = reads column 1 & 4   
 '(X,A,X,X,A)'      = reads column 1 & 5   
 '(X,A,X,X,X,A)'    = reads column 1 & 6   
 '(X,A,X,X,X,X,A)'  = reads column 1 & 7   
 '(X,A,X,X,X,X,X,A)'= reads column 1 & 8   
                                           

When DATA='CMPLX', file INFIL1 can be read in free format if FORMF1 is set equal to 'CMPLX'. When FORMF1='CMPLX', the first four columns will be read from INFIL1.
Declared = Character*80    Default = 'CMPLX'

FORMF2

Format in which INFIL2 shall be read
How to use input command INFIL2, please look under INFIL1.
Declared = Character*80    Default = 'CMPLX'

CHECK_FORMF1

Controls if the format FORMF1 shall be checked or not.
CHECK_FORMF1 can be given the following values:

NCOLS	=	Which implies that the number of columns in INFIL1 shall be checked with respect to the format given in FORMF1. If the number of columns disagree program FUNC will be interrupted and an error message will be written.
NO	=	Which implies no checking of input data file INFIL1 and format FORMF1.

Declared = Character*14    Default = 'NCOLS'

CHECK_FORMF2

Controls if the format FORMF2 shall be checked or not.
CHECK_FORMF2 can be given the following values:

NCOLS	=	Which implies that the number of columns in INFIL2 shall be checked with respect to the format given in FORMF2. If the number of columns disagree program FUNC will be interrupted and an error message will be written.
NO	=	Which implies no checking of input data file INFIL2 and format FORMF2.

Declared = Character*14    Default = 'NCOLS'

UTFIL

Name of output data file.
The file is written according to the format given in FORMUT. Declared = Character*80    Default = Blank

TYPE_UTFIL

Define how to write the results in file UTFIL.
TYPE_UTFIL can be given the following values:

CREATE	=	Start writing from the beginning of the file, erasing any potential previous data in the file.
APPEND	=	Start writing at the end of the file, old results on UTFIL will be kept.

Declared = Character*6    Default = CREATE

FORMUT

Format in which UTFIL shall be written
The string should be written in FORTRAN and shall be enclosed in parenthesis. For documentation on the FORTRAN format statement, please look in any book describing the FORTRAN language.
FORMUT has two convinience values SNGL and CMPLX. If FORMUT is set to SNGL the output format will be written with format '(1P,E15.6,5X,E15.6)'. If FORMUT is set to CMPLX the output format will be written with format '(1P,2E15.6,5X,2E15.6)'.
If DATA=SNGL and FORMUT=CMPLX program FUNC will fill the imaginary columns with zeros. The combination DATA=CMPLX and FORMUT=SNGL is not valid.
Declared = Character*80    Default = CMPLX

FIN

Vector containing input data parameters, for the function selected in command FUNC.
Input data can be read from a specific address, if the user writes: FIN(N)= XX,YY. In the example input data XX will be stored in positon N in vector FIN and input data YY will be stored in positon N+1.
Declared = Real*4(1000)    Default = 1000*0.

AMPL

Input data scalar, AMPL has different meaning depending on FUNC.
Declared = Real*4    Default = 0.

LAMBDA

Input data scalar, its meaning depends on FUNC.
Declared = Real*4    Default = 0.

LENGTH

Input data scalar, its meaning depends on FUNC.
Declared = Real*4    Default = 0.

DX

Input data scalar, its meaning depends on FUNC.
Declared = Real*4    Default = 0. XVALUES_INCREASING Define how to treat the X-axles of the files.

XVALUES_INCREASING

Define how to treat the X-axles of the files infil1 and infil2.
XVALUES_INCREASING can be given the following values:

IGNORE	=	Don't check the values in the X-axle, accept any values in any order.
CHECK_POSITIVE	=	Check that the values are strictly increasing. If not, an error will occur and the program will write an error message and then stop further execution.
CHECK_NEGATIVE	=	Check that the values are strictly decreasing. If not, an error will occur and the program will write an error message and then stop further execution.
FORCE_POSITIVE	=	Check that the values are strictly increasing. If not, program FUNC will skip all data which not are increasing.
FORCE_NEGATIVE	=	Check that the values are strictly decreasing. If not, program FUNC will skip all data which not are decreasing.

Declared = Character*14    Default = IGNORE

EOF

Command which terminates further input data reading.

Examples:

The examples are divided into three groups:
- Creation of new curves
- Operations on one curve
- Operations on two curves

The files shall be given the extention .funcf to associate the files with program func in the gensys script genrun.

Creation of new curves

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
  FUNC = sin                                                            
  AMPL = 10. LAMBDA = 5.  LENGTH = 49.9  DX = .2                        
 #                                                                      
  UTFIL = test/sin_l5d2.sngl  FORMUT = SNGL DATA = SNGL                 
 #                                                                      
                                                                        

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
 #        Create a part of a circle                                     
 #                                                                      
  FUNC = circle                                                         
  DX   = .1                                                             
 #          x0,  y0,    R,   x1,  x2,  side                             
  FIN  =    0., -400., 400.,-20., 20.,  +1.,                            
                                                                        
  DATA  = SNGL                                                          
  UTFIL = ucat/circle.sngl  FORMUT = SNGL  TYPE_UTFIL = CREATE          
  EOF                                                                   
                                                                        

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
  FUNC = pline_1                                                        
  DX   = .1                                                             
 #           x1,      y1,   x2,   y2                                    
  FIN  =    27.238,  -9.728,  32.438,  -19.396,                         
                                                                        
  DATA  = SNGL                                                          
  UTFIL = ucat/pline.sngl  FORMUT = SNGL  TYPE_UTFIL = CREATE           
  EOF                                                                   
                                                                        

                                                                        
 #                                                                      
 #       Input data for program func                                    
 #                                                                      
 #       Create a Normal distributed noise                              
 #       Fin(1)= Average value                                          
 #       Fin(2)= Standard Deviation                                     
 #                                                                      
  FUNC = NOISE_NORMAL                                                   
  fin  = 0., 1.,         LENGTH = 140.  DX = 0.1                        
                                                                        
  DATA = SNGL                                                           
  UTFIL= ver_test/Nnoise.sngl  FORMUT= SNGL  TYPE_UTFIL= CREATE         
  eof                                                                   
                                                                        

Operations on one curve

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
 #                                                                      
  FUNC = ADDX_C    AMPL = -14                                           
                                                                        
  XVALUES_INCREASING = 'IGNORE'                                         
  INFIL1= ucat/cos_l5d2.sngl  FORMF1 = '(a,a)' DATA = SNGL              
  UTFIL = ucat/cos_add.sngl   FORMUT = SNGL TYPE_UTFIL = CREATE         
  EOF                                                                   
                                                                        

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
  FUNC = SPLINE_G                                                       
  AMPL = .2  DX=0.1                                                     
 #                                                                      
  XVALUES_INCREASING = 'FORCE_POSITIVE'                                 
  INFIL1= ver_test/puls2.sngl    FORMF1= '(a,a)'       DATA= SNGL       
  UTFIL = ver_test/psmooth.sngl  FORMUT= SNGL    TYPE_UTFIL= CREATE     
  EOF                                                                   
                                                                        

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
  FUNC = FIT_X4_LEG                                                     
                                                                        
  LENGTH = 10.  DX = .2                                                 
  INFIL1= ex1.print      FORMF1 = '(a,a)'       DATA = SNGL             
  UTFIL = ex1.print.fit  FORMUT = SNGL    TYPE_UTFIL = CREATE           
  eof                                                                   
                                                                        

Operations on two curves

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
  FUNC = ADD                                                            
                                                                        
  INFIL1= ucat/cos_l5d1.sngl  FORMF1 = '(a,a)' DATA = SNGL              
  INFIL2= ucat/cos_l5d2.sngl  FORMF2 = '(a,a)' DATA = SNGL              
  UTFIL = ucat/cos_sum.sngl   FORMUT = SNGL TYPE_UTFIL = CREATE         
  eof                                                                   
                                                                        

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
  FUNC = MED                                                            
                                                                        
  INFIL1= ucat/cos_l5d1.sngl  FORMF1 = '(a,a)' DATA = SNGL              
  INFIL2= ucat/cos_l5d2.sngl  FORMF2 = '(a,a)' DATA = SNGL              
  UTFIL = ucat/cos_med.sngl   FORMUT = SNGL TYPE_UTFIL = CREATE         
  eof                                                                   
                                                                        

                                                                        
 #                                                                      
 #        Input data for program func                                   
 #                                                                      
  FUNC = CROSS-CORR                                                     
 #                                                                      
  XVALUES_INCREASING = 'CHECK_POSITIVE'                                 
  INFIL1= invar1.sngl      FORMF1= '(a,a,x)'       DATA= SNGL           
  INFIL2= invar2.sngl      FORMF2= '(a,x,a)'       DATA= SNGL           
  UTFIL = cross-corr.sngl  FORMUT= SNGL      TYPE_UTFIL= CREATE         
  EOF