source: git/doc/changes_in_singular4.texi @ 8d1432e

@comment this file contains the list of new features and difference between Singular 3.* and Singular 4.*

The purpose of this section is to describe new features and changes
between Singular 3-1-7 and Singular 4.* (formerly known as Spielwiese) both for developers
and Singular users. In what follows we will refer to the systems as Singular 3 and Singular 4.

@menu
* Version schema for Singular::
* Notes for Singular users::
* Notes for developers::
* Building Singular::
@end menu

@c ---------------------------------------------------------------------------
@node Version schema for Singular, Notes for Singular users, , Singular 3 and Singular 4
@subsection Version schema for Singular
@cindex Version schema for Singular
@cindex Version number

@sc{Singular} version is of the form @code{a.b.c.d} which may also be written
as @code{a-b-c-d} where a,b,c and d are numbers:
@itemize
@item a is changed with major, incompatible changes
@item b is changed with incompatible changes (of some commands/libraries)
@item c is changed with compatible chnages (i.e. new commands,
      extended options, new algorithms, etc.)
@item d is changed with each release (i.e. with bug fixes, etc.)
@end itemize
@sc{Singular} does also have "inofficiall" build orginating from
a code version between "officiall" version: such builds display
"Development version a.b.c" in the header while "official" versions
show "version a.b.c". Also the manual describes version a-b-c.
To get the complete version number, use
@code{system("version");} or use @code{SINGULAR_VERSION} in C.

@c ---------------------------------------------------------------------------
@node Notes for Singular users, Notes for developers, Version schema for Singular, Singular 3 and Singular 4
@subsection Notes for Singular users
@cindex Notes for Singular users

@subsubheading Coefficient rings
@cindex Coefficient rings

To allow for easy integration of new coefficient rings into Singular, the the way
coefficient rings are being handled has been redesigned.

In general, the user syntax has not changed, however there are some changes in the behaviour of Singular:

@c table @asis
@itemize @bullet
@item setting @code{minpoly} results in changing the current coefficient domain
and clears all previously defined varaiables of that ring

@item Minor changes in the output of coefficient ring description. Moreover the output of elements of certain rings has been improved (for example, reals).

@item Algebraic and transcendental extensions of rationals and finite fields
      have been reimplemented. In particular, the heuristics for clearing denominators and factoring out content
      have been changed. In some cases this leads to a different, mathematically equivalent results of Groebner
      bases and related computations. For example a Groebner basis element may differ by a unit.

@item Most noteably, due to the redesign of the coefficient rings, if the user sets the minimal polynomial
      all variables dependent on the current ring are deleted.

@end itemize
@c @end table

@subsubheading Ring-dependent options
@cindex Ring-dependent options

Formally global Singular @ref{option} now belong to individual polynomial rings. This includes:

@c table @asis
@itemize @bullet
@item @code{intStrategy}
@item @code{redTail}
@item @code{redThrough}
@end itemize
@c @end table

Also the following settings now belong to individual (currently active) polynomial rings:

@c @item @code{degBound}
@c @item @code{multBound}

@c table @asis
@itemize @bullet
@item @code{short}
@item @code{minpoly}
@item @code{noether}
@end itemize
@c @end table


Hence setting these options only affects the current ring. Be aware of this
when switching between different rings, since the options affect the
result of various computations (in particular Groebner bases).

@subsubheading New libraries depending on Singular 4
@cindex New libraries depending on Singular 4

In Singular 4 there several new features are implemented within a
dynamic module @code{syzextra.so}, not available in Singular 3.
It implements the low-level functions for Schreyer resolutions and many auxiliary functions.
The following new libraries @ref{deRham_lib}, @ref{schreyer_lib} depend on it:

@c table @asis
@itemize @bullet
@item @ref{deRham_lib} - computes de Rham cohomology
@item @ref{schreyer_lib} - computes Schreyer resolution via several approaches. It also serves as a high-level wrapper to the dynamic module @code{syzextra.so}
@end itemize
@c @end table

@subsubheading Path names
@cindex Path names

@c table @asis
@itemize @bullet
@item The tree structure of the binary Singular distribution has been changed.
The typical tree now looks as show at @uref{https://github.com/Singular/Sources/wiki/Sw-tree}

@item Accordingly Singular search paths (where Singular searches for libraries, dynamic modules, etc.) have been changed. You can display them by calling Singular by @code{Singular -v}.

@item currently, multi-arch installations of Singular 4 aere not possible.
@end itemize
@c @end table

@subsubheading Library versioning
@cindex Library versioning

Due to switching from Subversion to GIT revision control system for the Singular source code,
library version variables (displayed when loading a library) have changed.


@subsubheading New orderings for modules
@cindex New orderings for modules

The now can assign weights to module components, when defining a monomial ordering. For example
@smallexample
ring R = 0, (x,y,z), (am(1,2,3,   10,20,30,40), dp, C);
deg(x*gen(1));
@expansion{} 11
@end smallexample

will assign weights 1,2,3 to x,y,z respectively, and weights 10,20,30,40,0,0,... to
components of any free module defined over R. This ordering will first sort
by this weighted degree, then by dp on the ring monomials and then will give priority
to the large component index.

@subsubheading Future benefits of Singular 4
@cindex Future benefits of Singular 4

The redesign of Singular will allow us to provide new features in the future, for example:

@c table @asis
@itemize @bullet
@item Interpreter type for coefficient rings.
@item User defined coefficient rings.
@item Improved syntax for defining polynomial rings.
@end itemize
@c @end table




@c ---------------------------------------------------------------------------
@node Notes for developers, Building Singular, Notes for Singular users, Singular 3 and Singular 4
@subsection Notes for developers
@cindex Notes for developers

There has been an entensive process of refactoring, redesign and modularization
of Singular to facilitate easier maintenance and future development:

@c table @asis
@itemize @bullet
@item Build System : automake, libfac has been integrated into Factory
@item Removed MP (Multi protocol) in favor of SSI links.
@item Separation/modularization into libraries and packages
@c add diagram as an image?
@item For easy integration of new coeffcient rings,
we defined a generic interface for coefficient
rings and a supporting framework for making them
accessible to the user.

In particular we have separated everything related to coeffcient rings into a separate library @code{libcoeffs}.
Dependency tree between restructured packages is show at @uref{http://www.singular.uni-kl.de/dox/singular.png}

In order to use @code{libSingular} as a C++ library, see @ref{libSingular}.

@end itemize
@c @end table



@c @subsubheading Changes to build system
@c @cindex Changes to build system


@c ---------------------------------------------------------------------------
@node Building Singular, , Notes for developers, Singular 3 and Singular 4
@subsection Building Singular
@cindex Building Singular

The user can build and install Singular with the following standard UNIX-like procedure:

@c table @asis
@itemize @bullet
@item Download and extract the latest official source package (.tar.gz).
@item Run the configure script, for instance, @code{./configure}.
@item Build Singular by running @code{make}.
@item Install Singular by running @code{make install}.
@end itemize
@c @end table

In contrast to Singular 3, there are now many more configuration options.

All possible options for configure can be seen by running the configure script with
option @code{--help}. On a multicore compute consider running make with the
option @code{-f [cores]}.

@subsection Side-by-side installation

Due to choosing paths according to FS standards it is no longer possible
to have a side-by-side installation of different Singular versions or versions for different architectures.
@c ---------------------------------------------------------------------------