Difference between revisions of "ApCoCoA-1:Num.AVI"

From ApCoCoAWiki
(New page: <command> <title>Numerical.BBasisOfPointsAVI</title> <short_description>border basis of almost vanishing ideal for a set of points</short_description> <syntax> $numerical.BBasisO...)
 
m (replaced <quotes> tag by real quotes)
 
(27 intermediate revisions by 6 users not shown)
Line 1: Line 1:
   <command>
+
   {{Version|1}}
     <title>Numerical.BBasisOfPointsAVI</title>
+
<command>
     <short_description>border basis of almost vanishing ideal for a set of points</short_description>
+
     <title>Num.AVI</title>
 +
     <short_description>Computes a border basis of an almost vanishing ideal for a set of points.</short_description>
 
<syntax>
 
<syntax>
$numerical.BBasisOfPointsAVI(Points, Tau, GetO, Delta, NormalizeType, RREFNormalizeType, RREFUseEps, RREFType):Object
+
Num.AVI(Points:MAT, Epsilon:RAT):Object
 +
Num.AVI(Points:MAT, Epsilon:RAT, Delta:RAT, ForbiddenTerms:LIST, NormalizeType:INT):Object
 
</syntax>
 
</syntax>
    <description>
 
{{ApCoCoAServer}} Please also note that you will have to use an ApCoCoAServer with enabled BLAS/LAPACK support.
 
  
This command computes an approximate border basis of an almost vanishing ideal for a set of points using the AVI algorithm, which adresses some problems found in the ABM Algorithm.
+
<description>
The current ring has to be a ring over the rationals with a standard-degree
+
<em>Please note:</em> The function(s) explained on this page is/are using the <em>ApCoCoAServer</em>. You will have to start the ApCoCoAServer in order to use it/them.
compatible term-ordering. The matrix Points contains the points: each
+
<par/>
 +
This function computes an approximate border basis of an almost vanishing ideal for a set of points using the AVI algorithm. AVI is an acronym of "Approximate Vanishing Ideal".
 +
<par/>
 +
The current ring has to be a ring over the rational numbers with a standard-degree
 +
compatible term-ordering. The matrix <tt>Points</tt> contains the points: each
 
point is a row in the matrix, so the number of columns must equal the
 
point is a row in the matrix, so the number of columns must equal the
 
number of indeterminates in the current ring.  
 
number of indeterminates in the current ring.  
  
Tau is a rational <formula>&gt;0</formula>
+
<itemize>
describing which singular values should be treated as 0 (smaller values for
+
<item>@param <em>Points</em> The points for which a border basis is computed.</item>
tau lead to bigger errors of the polynomials evaluated at the point
 
set).  Tau should be in the interval <formula>(0,1)</formula>. As a rule of thumb,
 
Tau is the expected percentage of error on the input points.  
 
  
 +
<item>@param <em>Epsilon</em> A positive rational number describing which singular values should be treated as 0 (smaller values for <tt>Epsilon</tt> lead to bigger errors of the polynomials evaluated at the point set). <tt>Epsilon</tt> should be in the interval (0,1). As a rule of thumb, <tt>Epsilon</tt> is the expected percentage of error on the input points. </item>
  
GetO must be either True or False.  If it is true, the command returns a list  
+
<item>@return A list of two results. First the border basis as a list of polynomials, second the vector space basis of <tt>P/I</tt> as a list of terms.</item>
of two values: the first contains the border basis, the
+
</itemize>
second one a vector space basis of <formula>P/I</formula> comprising those power products
 
lying outside the leading term ideal of I. If GetO is false, the function
 
returns only the border basis (not in a list).
 
  
 +
The following parameters are optional:
 +
<itemize>
 +
<item>@param <em>Delta</em> A positive rational number. <tt>Delta</tt> describes the computing precision. In different steps, it is crucial, if a value is 0 or not. The algorithm assumes every value in <tt>[-Delta, Delta]</tt> to be 0. The default value for <tt>Delta</tt> is 0.00000000001.</item>
  
The last 5 parameters are optional.  
+
<item>@param <em>ForbiddenTerms</em> A list containing the terms which are not allowed to show up in the order ideal.</item>
  
 +
<item>@param <em>NormalizeType</em> A integer of the range 1..4. The default value is 2. This parameter describes, if/how the input points are normalized. If <tt>NormalizeType</tt> equals 1, each coordinate is divided by the maximal absolute value of the corresponding column of the matrix. This ensures that all coordinates of points are in [-1,1]. With <tt>NormalizeType=2</tt> no normalization is done at all. <tt>NormalizeType=3</tt> shifts each coordinate to [-1,1]. So it's minimum is mapped to -1 and the maximum to one, describing a unique affine mapping. The last option is <tt>NormalizeType=4</tt>. In this case, each coordinate is normalized, using the column's euclidian norm.</item>
  
Delta must be a positiv rational. Delta describes the computing precision. In different steps, it is crucial, if a value is 0 or not. The algorithm assumes every value in [-Delta, Delta] to be 0. The default value for Delta is 0.00000000001.
+
</itemize>
  
 +
<example>
 +
Use P::=QQ[x,y,z];
  
NormalizeType must be one of 1,2,3 ,4. The default value is 1. This parameter describes, if / how the input points are normalized.
+
Points := Mat([[1,0,0],[0,0,1],[0,1,0]]);
If NormalizeType equals 1, each coordinate is divided by the maximal absolut value of the matrix's corresponding column. This ensures that all point's coordinates are in [-1,1].
+
Num.AVI(Points,0.001);
With NormalizeType=2 no normalization is done at all.
+
-- CoCoAServer: computing Cpu Time = 0
NormalizeType=3 shifts each coordinate to [-1,1]. So it's minimum is mapped to -1 and the maximum to one, describing a unique affine mapping.
+
-------------------------------
The last option is NormalizeType=4. In this case, each coordinate is normalized, using the column's euclidian norm.
+
[[x + y + 4503599627370495/4503599627370496z - 4503599627370497/4503599627370496, xy, y^2 - y, xz, yz, z^2 - z], [1, z, y]]
Due to backward compatibility, the default is 1, although 3 is in most cases a better choice.
+
-------------------------------
 
 
 
 
RREFNormalizeType describes, how in each RREF steps the columns are normalized. The options correspond to the ones for NormalizeType and the default is 1 again.
 
 
 
 
 
RREFUseEps must be either true or false! If RREFUseEps is true, the given Delta is used within the RREF to decide if a value equals 0 or not. If this parameter is false,
 
a replacement value for Delta is used, which is based on the matrix's norm.
 
 
 
 
 
The last parameter is RREFType. This must be 1 or 2. If RREFType=1, the rref operates column-wise. Otherwise it works row-wise. The default is 1.
 
<example>
 
Points := Mat([[1,0,0],[0,0,1],[0,2,0]]);
 
$numerical.BBasisOfPoints(Points,0.001,True);
 
 
-------------------------------
 
-------------------------------
[[x + 9007199254740991/18014398509481984y + z - 1, z^2 - 9007199254740991/9007199254740992z, 1/2yz, xz, 1/4y^2 - 9007199254740991/18014398509481984y, 1/2xy], [y, z, 1]]
 
 
 
</example>
 
</example>
 
     </description>
 
     </description>
 
     <seealso>
 
     <seealso>
       <see>Introduction to CoCoAServer</see>
+
       <see>ApCoCoA-1:Introduction to CoCoAServer|Introduction to CoCoAServer</see>
       <see>Numerical.GBasisOfPoints</see>
+
       <see>ApCoCoA-1:Num.SubAVI|Num.SubAVI</see>
      <see>Numerical.HBasisOfPoints</see>
 
      <see>Numerical.GBasisOfPointsInIdeal</see>
 
      <see>Numerical.BBasisOfPointsInIdeal</see>
 
      <see>Numerical.HBasisOfPointsInIdeal</see>
 
      <see>Numerical.FirstVanishingRelations</see>
 
      <see>Numerical.FirstVanishingRelationsInIdeal</see>
 
 
     </seealso>
 
     </seealso>
 
     <types>
 
     <types>
       <type>cocoaserver</type>
+
       <type>apcocoaserver</type>
 +
      <type>points</type>
 
     </types>
 
     </types>
     <key>heldt</key>
+
     <key>numerical.AVI</key>
     <key>numerical.bbasisofpoints</key>
+
     <key>AVI</key>
     <wiki-category>Package_Numerical</wiki-category>
+
    <key>num.avi</key>
 +
     <wiki-category>ApCoCoA-1:Package_numerical</wiki-category>
 
   </command>
 
   </command>

Latest revision as of 13:45, 29 October 2020

This article is about a function from ApCoCoA-1.

Num.AVI

Computes a border basis of an almost vanishing ideal for a set of points.

Syntax

Num.AVI(Points:MAT, Epsilon:RAT):Object
Num.AVI(Points:MAT, Epsilon:RAT, Delta:RAT, ForbiddenTerms:LIST, NormalizeType:INT):Object

Description

Please note: The function(s) explained on this page is/are using the ApCoCoAServer. You will have to start the ApCoCoAServer in order to use it/them.

This function computes an approximate border basis of an almost vanishing ideal for a set of points using the AVI algorithm. AVI is an acronym of "Approximate Vanishing Ideal".

The current ring has to be a ring over the rational numbers with a standard-degree

compatible term-ordering. The matrix Points contains the points: each

point is a row in the matrix, so the number of columns must equal the number of indeterminates in the current ring.

  • @param Points The points for which a border basis is computed.

  • @param Epsilon A positive rational number describing which singular values should be treated as 0 (smaller values for Epsilon lead to bigger errors of the polynomials evaluated at the point set). Epsilon should be in the interval (0,1). As a rule of thumb, Epsilon is the expected percentage of error on the input points.

  • @return A list of two results. First the border basis as a list of polynomials, second the vector space basis of P/I as a list of terms.

The following parameters are optional:

  • @param Delta A positive rational number. Delta describes the computing precision. In different steps, it is crucial, if a value is 0 or not. The algorithm assumes every value in [-Delta, Delta] to be 0. The default value for Delta is 0.00000000001.

  • @param ForbiddenTerms A list containing the terms which are not allowed to show up in the order ideal.

  • @param NormalizeType A integer of the range 1..4. The default value is 2. This parameter describes, if/how the input points are normalized. If NormalizeType equals 1, each coordinate is divided by the maximal absolute value of the corresponding column of the matrix. This ensures that all coordinates of points are in [-1,1]. With NormalizeType=2 no normalization is done at all. NormalizeType=3 shifts each coordinate to [-1,1]. So it's minimum is mapped to -1 and the maximum to one, describing a unique affine mapping. The last option is NormalizeType=4. In this case, each coordinate is normalized, using the column's euclidian norm.


Example

Use P::=QQ[x,y,z];

Points := Mat([[1,0,0],[0,0,1],[0,1,0]]);
Num.AVI(Points,0.001);
-- CoCoAServer: computing Cpu Time = 0
-------------------------------
[[x + y + 4503599627370495/4503599627370496z - 4503599627370497/4503599627370496, xy, y^2 - y, xz, yz, z^2 - z], [1, z, y]]
-------------------------------
-------------------------------

See also

Introduction to CoCoAServer

Num.SubAVI