
      Ŀ
                                                                     
                           OptiVec for Delphi                        
                                                                     
                           Shareware Version 5                       
      

Contents:
     1. Introduction
     2. System requirements
     3. Installation
     4. Running the examples
     5. Documentation
     6. What's New?
     7. Copyright
     8. Registered Version


1. Introduction
---------------
Vector functions instead of loops - if it matters to you how fast and how
accurate your data are processed!
The largest portion of almost all programs processing numerical data
consists of loops. Replace these loops by the specialized vector
functions of OptiVec, and exploit all the advantages of vectorized
programming:

- OptiVec was almost entirely written in Assembly language. The result is a
  highly optimized and numerically accurate code, running 2-3 times faster
  than compiled loops.

- fully vectorized forms of all operators and functions of the language
  Pascal for all integer and floating-point (including complex!) data types

- Additionally many other real and complex math functions, statistics,
  analysis, FFT techniques, graphics - in total more than 3000!

- Simple and logical syntax, for example
  "VD_exp( Y, X, size );"      for Y[i] := exp( X[i] ) with "Double" arrays,
  "VE_FFT( Y, X, size, 1 );"   for extended-precision forward FFT

- Efficient matrix and curve-fitting routines


2. System requirements
----------------------
This version of OptiVec is designed for PC systems,
equipped at least with a 486DX or an Athlon processor. PentiumXX is, of
course, preferable.
Depending on your choice when downloading or ordering, you got the
version for

- Borland Delphi 4, 5, 6, 7, 9 (2005), or 10 (2006,2007).

  Shareware version:  LIB4D:  full-precision units back-compatible to
                              486DX/Pentium with check of dimension
                              consistency, optimized for single-processor
                              computers
                      LIB7M:  multi-processor capable high-perfomance
                              unit for Pentium 4 or higher
                      
  Registered version: large range of libraries, optimized for different
                      combinations of speed/precision/compatibility:
                      "P4", full-precision units back-compatible to
                            486DX/Pentium
                      "P6", gaining up to 50% higher speed in VF_ functions,
                            while sacrificing 2-3 digits of accuracy,
                            back-compatible to Pentium III+
                      "P7", same as "P6", plus about 20% higher speed for
                            VD_ functions by sacrificing 2-3 digits,
                            back-compatible to Pentium 4+
                      "P8", same as "P7", plus about 40% higher speed for
                            VCF_ functions involving complex multiplications;
                            VCD_ functions gain only 0-10%.
                      "Multi-processor", auto-threading libraries, optimized
                            for use on multi-core processors and multi-
                            processor architectures
                      "Large-Vector", gaining some speed through by-passing
                            the cache for very large vectors
                      "Dimension-consistency debug" (only P4).

3. Installation
---------------
a) To install OptiVec on Windows NT, 2000, XP, Vista etc.,
   you need to log in with administrator privileges.

b) Manually create the directory into which you wish to install OptiVec.
   This may be something like C:\OPTIVEC or whatever you like.

c) Unzip the file OVDxx.ZIP into the directory you just created.

d) In that directory, you now find the file INSTALL.EXE. Execute it.
   INSTALL.EXE moves all OptiVec files into their correct subdirectory
   and starts the clock for the 90-day trial period.
   You may change the default directory structure by hand once the
   installation is complete.

e) After you completed the installation, you must set the Units search path
   according to your OptiVec directory choice.
   To this end, open the menu
   "Project / Options / Directories and Conditionals" in the Delphi IDE.

   Say, your OptiVec directory is C:\OPTIVEC. Then, your units search path is
   C:\OPTIVEC\LIB4D  for the LIB4D units (the ones we recommend to start with)
   or  C:\OPTIVEC\LIB7M  for the high-performance units

   Add this path into the line "Search path".
   (Remember: a semicolon is used to separate entries in these fields.)

   You must do so for every project for which you wish to use OptiVec
   functions.

f) If you use the command-line compiler DCC32.EXE, you must
   add this path also in the configuration file, DCC32.CFG,
   or in the command line, like:

   dcc32 -u"c:\optivec\lib4d" vdemo.dpr

g) If you wish to use OptiVec for more than one target compiler (for example,
   both for Delphi and for Borland C++), you can install these OptiVec
   versions all into the same directory, say  C:\OPTIVEC.



4. Running the examples
-----------------------
Check your installation by compiling and running the demo programme
VDEMO.DPR

a) using the IDE:
      - Open VDEMO.DPR
      - set the search path as described above
      - compile and run.

b) using the command-line compiler:
      type
      DCC32 -u"C:\OPTIVEC\LIB4D" VDEMO.DPR

Similarly, try the data-fitting functions demo, FITDEMO.DPR,
the complex-number math demo,  CDEMO.DPR,  and the Mandelbrodt demo,
MANDEL.DPR.

If you get errors like "Unknown Function ...", you probably did not set
the unit search path correctly.


5. Documentation
----------------
The full OptiVec documentation is to be found in the files
HANDBOOK.HTM, FUNCREF.HTM, MATRIX.HTM, and CMATH.HTM to be read with
an HTML browser like Netscape or Microsoft IE.


6. What's New?
--------------
Version 5.2
-  Introduction of the dimension-checking debug library. The single-most
   frequent cause of hard-to-find errors in vector and matrix programs
   are dimension mismatches, leading to read or write operations outside
   the vector / matrix boundaries. The resulting heap corruption usually
   results in errors or crashes far away from the offending operation,
   which makes it often very hard to find the reason of such errors.
   The dimension-checking libraries, marked by the letter "D" in the
   library name, perform a safety check  at the beginning of every vector
   function called, thereby allowing to identify and fix these errors.
   For now, all vector functions and the most important matrix functions
   perform this check; the remaining matrix functions will follow in a
   later release.

-  Bug fixes in the nonlinear fitting functions, affecting the "breakout"
   part and the weighted variants.

-  Only versions for Delphi 2006 or higher:
   Implementation of the operators +  -  *  /  =  ==  !=  for complex numbers
   in the unit CMATH. Previous Delphi versions had not allowed to implement
   these operators.

Version 5.1.1:
-  Stability and accuracy improvement in V?_polyfit

-  Bug fix in V?_natCubSplineInterpol  (would sometimes crash instead
        of returning to calling routine)

Version 5.1:
-  The multi-core optimized libraries are introduced.
   All mathematical and arithmetic functions, all Fourier-Transform methods,
   and the matrix multiplication functions are fully multi-core optimized.

-  You should call V_initMT at the beginning of any multi-thread applications
   making use of OptiVec functions (if you use the single-core or the
   multi-core optimized libraries does not matter for this point).
   V_initMT also performs initializations which avoid previously
   encountered thread-safety issues inside the memory management functions
   like V?_vector.

-  Calculation of the center of gravity, both for vectors and for matrices:
   V?_centerOfGravityInd,  V?_centerOfGravityV,
   M?_centerOfGravityInd,  M?_centerOfGravityV
   The V?_centerOfGravityInd variant takes the element indices as axis,
   whereas V?_centerOfGravityV takes a specified X axis.

-  P8 libraries (requiring Intel Core2xxx or AMD64xxx processors)
   are included. Any operation involving single-precision complex-number
   multiplication is roughly 50% faster, paying for this increased speed
   by sacrificing 1-2 digits of accuracy.
   Double-precision complex multiplications profit, too, but much less so
   than single-precision.

-  The speed of the Fourier Transform routines was improved once more.
   This latest tweak makes itself felt mostly for smaller vectors and for
   2D FFT.

-  Alternative forms of the functions for element rotations. The new forms
   take the necessary buffer memory as an argument instead of requesting
   it from the operating system each time they are called:
   V?_rotate_buf,
   M?_Rows_rotate_buf,
   M?_Cols_rotate_buf

-  Bug fixes in:
   V?_Kepler, V?x_Kepler
   M?sym_eigenvalues
   M?_SVsolve  and  M?_solveBySVD for underdetermined matrices (ht < len)
   VE_polyinterpol and VE_ratinterpol

-  P7 libraries only:
   Bug fix in MD_TmulM  (large MY with uneven lenY caused an error)

-  P7 libraries, used with non-aligned vectors (e.g., static arrays) only:
   Bug fixes in:
   MD_SVsolve, affecting also MD_solveBySVD, MD_safeSolve, VD_linfit,
   and VD_nonlinfit,
   VCD_addC, VCD_subC
   V_UStoUL, V_UStoU

(Version 5.0 skipped for Delphi)

Version 4.4.5:
-  The non-linear data-fitting functions are now thread-safe

-  V?sym_eigenvalues signals success or failure (by singular or otherwise
   illegal input matrices) by the return value (FALSE or TRUE).

Version 4.4, 4.4.2, 4.4.3:
-  Compatibility with latest compiler versions: Delphi 2005,
   Delphi 2006 (both Borland Developer Studio 2006 and Turbo Delphi 2006),
   Delphi 2007.

-  Faster matrix decomposition and linear system solver for large matrices

-  bug fixes in VLI_not,  VUL_not (Pentium 4 only),
   MDp_FFTtoC (Pentium III, 4 only)
   VFx_exp (Pentium III, 4 only)
   M?_mulMT and M?_TmulM (affected matrices with only one column)


Version 4.3:
a) bug fix in M?_Row_insert and M?_Row_delete

Version 4.1:
b) Faster multiplication of large matrices:
   M?_mulM, M?_TmulM, M?_mulMT, and M?_TmulM now handle matrices of the order
   1024*1024 up to 10 times as fast, compared to previous versions.
   Small to middle-size matrices are not affected.
c) bug fix in V?_median: rare hanging in an infinite loop is now prevented

Version 4.0:
d) Pentium 4+ libraries
e) Mixed floating-point/integer Arithmetic operations like VF_addVI, VD_mulVUS
f) The rounding-to-integer functions now employ "silent" saturation instead of
   generating an error message in the case of overflow.
   
Version 3.3.2 / 3.3.3:
g) The P6 (Pentium III+) version is finally available also for Delphi
h) A bug in V_free, affecting thread safety in multithread applications,
   was fixed
i) New function VF_powexp for the calculation of x^r * exp(x)
Version 3.3:
k) Delphi 7 version; on the other side, support for Delphi 2 is discontinued
l) Parallel-enhanced series of Fourier-Transform methods, both one- and
   two-dimensional; 1.5 to 2.5 times as fast as previous FFT routines
m) Bug fixes in the complex accumulation functions, in several of the
   mixed-type accumulation functions (VCF_accV, VF_accVLI etc.),
   in ME_inv, and VFx_exp
n) accumulation of two vectors at once: VF_acc2V
o) addition / subtraction of two vectors at once: VF_add2V, VF_sub2V
p) coordinate transformation: VF_rotateCoordinates, VCF_rotateCoordinates

Version 3.2.3:
q) Faster matrix inversion
r) MF_block_equM,  MF_block_equMT,  MF_equMblock,  MF_equMblockT etc.:
   functions to extract blocks from matrices or copy them back
   (you need no longer use MF_submatrix and MF_submatrix_equM for
   that purpose).
s) complex random numbers: VCF_random etc.;
   initialization of matrices with random numbers: MF_random etc.

Version 3.2.2:
t) Function MFsym_sqrt
u) All nonlinfit functions check if the "best guess" A values lie within
   the specified limits before chi-square is calculated for the first time.
   Thereby, possible failure due to input A values outside the limits is
   avoided.


7. Copyright
------------
The copyright owner of this product as a whole and of all its constituent
parts is
         OptiCode
         Dr. Martin Sander Software Development
         Steinachstr. 9A
         D-69198 Schriesheim
         Germany
         e-mail: optivec@gmx.de
         http://www.optivec.com

This Shareware version of OptiVec is freely distributable in unchanged form.
For the distribution of applications created using OptiVec, you need the
registered version. The detailed licence terms are described in chapter 1.2
of the file HANDBOOK.HTM.


8. Registered Version
---------------------

If you like OptiVec and decide to use it, please be fair and register.

The registered Version of OptiVec for Delphi

-  supports Borland Delphi 4 through 7 and Delphi 2005, 2006, 2007 Win32

-  has individually optimized units for three degrees of
   processor backward-compatibility:
      Intel Core2xxx and AMD x64 multi-core processors
      Pentium 4 or higher
      Pentium III or higher
      486DX/Pentium+

-  entitles you to two years of free updates
   (by downloading from our web site)

-  costs USD 249 or EUR 199 for the commercial edition,
         USD  99 or EUR  89 for the educational edition,
   and can be ordered by e-mail from the author or through
   ShareIt:
   http://www.shareit.com/programs/103843.htm

See chapter 1.3 of the file HANDBOOK.HTM for further details about
ordering.


    * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Copyright (C) OptiCode - Dr. Martin Sander Software Dev. 1996-2008
