// Created on: 1991-08-09
// Created by: Jean Claude VAUTHIER
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#ifndef _BSplCLib_HeaderFile
#define _BSplCLib_HeaderFile

#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>

#include <TColStd_Array1OfReal.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <Standard_Boolean.hxx>
#include <BSplCLib_KnotDistribution.hxx>
#include <BSplCLib_MultDistribution.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <BSplCLib_EvaluatorFunction.hxx>
#include <TColStd_Array2OfReal.hxx>
class gp_Pnt;
class gp_Pnt2d;
class gp_Vec;
class gp_Vec2d;
class math_Matrix;


//! BSplCLib   B-spline curve Library.
//!
//! The BSplCLib package is  a basic library  for BSplines. It
//! provides three categories of functions.
//!
//! * Management methods to  process knots and multiplicities.
//!
//! * Multi-Dimensions  spline methods.  BSpline methods where
//! poles have an arbitrary number of dimensions. They divides
//! in two groups :
//!
//! - Global methods modifying the  whole set of  poles. The
//! poles are    described   by an array   of   Reals and  a
//! Dimension. Example : Inserting knots.
//!
//! - Local methods  computing  points and derivatives.  The
//! poles  are described by a pointer  on  a local array  of
//! Reals and a Dimension. The local array is modified.
//!
//! *  2D  and 3D spline   curves  methods.
//!
//! Methods  for 2d and 3d BSplines  curves  rational or not
//! rational.
//!
//! Those methods have the following structure :
//!
//! - They extract the pole informations in a working array.
//!
//! -  They      process the  working   array    with   the
//! multi-dimension  methods. (for example  a  3d  rational
//! curve is processed as a 4 dimension curve).
//!
//! - They get back the result in the original dimension.
//!
//! Note that the  bspline   surface methods found   in the
//! package BSplSLib  uses  the same  structure and rely on
//! BSplCLib.
//!
//! In the following list  of methods the  2d and 3d  curve
//! methods   will be  described   with  the  corresponding
//! multi-dimension method.
//!
//! The 3d or 2d B-spline curve is defined with :
//!
//! . its control points : TColgp_Array1OfPnt(2d)        Poles
//! . its weights        : TColStd_Array1OfReal          Weights
//! . its knots          : TColStd_Array1OfReal          Knots
//! . its multiplicities : TColStd_Array1OfInteger       Mults
//! . its degree         : Standard_Integer              Degree
//! . its periodicity    : Standard_Boolean              Periodic
//!
//! Warnings :
//! The bounds of Poles and Weights should be the same.
//! The bounds of Knots and Mults   should be the same.
//!
//! Note: weight and multiplicity arrays can be passed by pointer for
//! some functions so that NULL pointer is valid.
//! That means no weights/no multiplicities passed.
//!
//! No weights (BSplCLib::NoWeights()) means the curve is non rational.
//! No mults (BSplCLib::NoMults()) means the knots are "flat" knots.
//!
//! KeyWords :
//! B-spline curve, Functions, Library
//!
//! References :
//! . A survey of curves and surfaces methods in CADG Wolfgang
//! BOHM CAGD 1 (1984)
//! . On de Boor-like algorithms and blossoming Wolfgang BOEHM
//! cagd 5 (1988)
//! . Blossoming and knot insertion algorithms for B-spline curves
//! Ronald N. GOLDMAN
//! . Modelisation des surfaces en CAO, Henri GIAUME Peugeot SA
//! . Curves and Surfaces for Computer Aided Geometric Design,
//! a practical guide Gerald Farin
class BSplCLib 
{
public:

  DEFINE_STANDARD_ALLOC

  
  //! This routine searches the position of the real value theX
  //! in the monotonically increasing set of real values theArray using bisection algorithm.
  //!
  //! If the given value is out of range or array values, algorithm returns either
  //! theArray.Lower()-1 or theArray.Upper()+1 depending on theX position in the ordered set.
  //!
  //! This routine is used to locate a knot value in a set of knots.
  Standard_EXPORT static void Hunt (const TColStd_Array1OfReal& theArray,
                                    const Standard_Real theX,
                                    Standard_Integer& theXPos);
  
  //! Computes the index of the knots value which gives
  //! the start point of the curve.
  Standard_EXPORT static Standard_Integer FirstUKnotIndex (const Standard_Integer Degree, const TColStd_Array1OfInteger& Mults);
  
  //! Computes the index of the knots value which gives
  //! the end point of the curve.
  Standard_EXPORT static Standard_Integer LastUKnotIndex (const Standard_Integer Degree, const TColStd_Array1OfInteger& Mults);
  
  //! Computes the index  of  the  flats knots  sequence
  //! corresponding  to  <Index> in  the  knots sequence
  //! which multiplicities are <Mults>.
  Standard_EXPORT static Standard_Integer FlatIndex (const Standard_Integer Degree, const Standard_Integer Index, const TColStd_Array1OfInteger& Mults, const Standard_Boolean Periodic);
  
  //! Locates  the parametric value    U  in the knots
  //! sequence  between  the  knot K1   and the knot  K2.
  //! The value return in Index verifies.
  //!
  //! Knots(Index) <= U < Knots(Index + 1)
  //! if U <= Knots (K1) then Index = K1
  //! if U >= Knots (K2) then Index = K2 - 1
  //!
  //! If Periodic is True U  may be  modified  to fit in
  //! the range  Knots(K1), Knots(K2).  In any case  the
  //! correct value is returned in NewU.
  //!
  //! Warnings :Index is used  as input   data to initialize  the
  //! searching  function.
  //! Warning: Knots have to be "withe repetitions"
  Standard_EXPORT static void LocateParameter (const Standard_Integer Degree, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const Standard_Real U, const Standard_Boolean IsPeriodic, const Standard_Integer FromK1, const Standard_Integer ToK2, Standard_Integer& KnotIndex, Standard_Real& NewU);
  
  //! Locates  the parametric value    U  in the knots
  //! sequence  between  the  knot K1   and the knot  K2.
  //! The value return in Index verifies.
  //!
  //! Knots(Index) <= U < Knots(Index + 1)
  //! if U <= Knots (K1) then Index = K1
  //! if U >= Knots (K2) then Index = K2 - 1
  //!
  //! If Periodic is True U  may be  modified  to fit in
  //! the range  Knots(K1), Knots(K2).  In any case  the
  //! correct value is returned in NewU.
  //!
  //! Warnings :Index is used  as input   data to initialize  the
  //! searching  function.
  //! Warning: Knots have to be "flat"
  Standard_EXPORT static void LocateParameter (const Standard_Integer Degree, const TColStd_Array1OfReal& Knots, const Standard_Real U, const Standard_Boolean IsPeriodic, const Standard_Integer FromK1, const Standard_Integer ToK2, Standard_Integer& KnotIndex, Standard_Real& NewU);
  
  Standard_EXPORT static void LocateParameter (const Standard_Integer Degree, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, const Standard_Real U, const Standard_Boolean Periodic, Standard_Integer& Index, Standard_Real& NewU);
  
  //! Finds the greatest multiplicity in a set of knots
  //! between  K1  and K2.   Mults  is  the  multiplicity
  //! associated with each knot value.
  Standard_EXPORT static Standard_Integer MaxKnotMult (const TColStd_Array1OfInteger& Mults, const Standard_Integer K1, const Standard_Integer K2);
  
  //! Finds the lowest multiplicity in  a  set of knots
  //! between   K1  and K2.   Mults is  the  multiplicity
  //! associated with each knot value.
  Standard_EXPORT static Standard_Integer MinKnotMult (const TColStd_Array1OfInteger& Mults, const Standard_Integer K1, const Standard_Integer K2);
  
  //! Returns the number of poles of the curve. Returns 0 if
  //! one of the multiplicities is incorrect.
  //!
  //! * Non positive.
  //!
  //! * Greater than Degree,  or  Degree+1  at the first and
  //! last knot of a non periodic curve.
  //!
  //! *  The  last periodicity  on  a periodic  curve is not
  //! equal to the first.
  Standard_EXPORT static Standard_Integer NbPoles (const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfInteger& Mults);
  
  //! Returns the length  of the sequence  of knots with
  //! repetition.
  //!
  //! Periodic :
  //!
  //! Sum(Mults(i), i = Mults.Lower(); i <= Mults.Upper());
  //!
  //! Non Periodic :
  //!
  //! Sum(Mults(i); i = Mults.Lower(); i < Mults.Upper())
  //! + 2 * Degree
  Standard_EXPORT static Standard_Integer KnotSequenceLength (const TColStd_Array1OfInteger& Mults, const Standard_Integer Degree, const Standard_Boolean Periodic);
  
  Standard_EXPORT static void KnotSequence (const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColStd_Array1OfReal& KnotSeq, const Standard_Boolean Periodic = Standard_False);
  
  //! Computes  the  sequence   of knots KnotSeq  with
  //! repetition  of the  knots  of multiplicity  greater
  //! than 1.
  //!
  //! Length of KnotSeq must be KnotSequenceLength(Mults,Degree,Periodic)
  Standard_EXPORT static void KnotSequence (const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const Standard_Integer Degree, const Standard_Boolean Periodic, TColStd_Array1OfReal& KnotSeq);
  
  //! Returns the  length  of the   sequence of  knots  (and
  //! Mults)  without repetition.
  Standard_EXPORT static Standard_Integer KnotsLength (const TColStd_Array1OfReal& KnotSeq, const Standard_Boolean Periodic = Standard_False);
  
  //! Computes  the  sequence   of knots Knots  without
  //! repetition  of the  knots  of multiplicity  greater
  //! than 1.
  //!
  //! Length  of <Knots> and  <Mults> must be
  //! KnotsLength(KnotSequence,Periodic)
  Standard_EXPORT static void Knots (const TColStd_Array1OfReal& KnotSeq, TColStd_Array1OfReal& Knots, TColStd_Array1OfInteger& Mults, const Standard_Boolean Periodic = Standard_False);
  
  //! Analyses if the  knots distribution is "Uniform"
  //! or  "NonUniform" between  the  knot  FromK1 and the
  //! knot ToK2.  There is  no repetition of  knot in the
  //! knots'sequence <Knots>.
  Standard_EXPORT static BSplCLib_KnotDistribution KnotForm (const TColStd_Array1OfReal& Knots, const Standard_Integer FromK1, const Standard_Integer ToK2);
  

  //! Analyses the distribution of multiplicities between
  //! the knot FromK1 and the Knot ToK2.
  Standard_EXPORT static BSplCLib_MultDistribution MultForm (const TColStd_Array1OfInteger& Mults, const Standard_Integer FromK1, const Standard_Integer ToK2);
  
  //! Analyzes the array of knots.
  //! Returns the form and the maximum knot multiplicity.
  Standard_EXPORT static void KnotAnalysis (const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& CKnots, const TColStd_Array1OfInteger& CMults, GeomAbs_BSplKnotDistribution& KnotForm, Standard_Integer& MaxKnotMult);
  

  //! Reparametrizes a B-spline curve to [U1, U2].
  //! The knot values are recomputed such that Knots (Lower) = U1
  //! and Knots (Upper) = U2   but the knot form is not modified.
  //! Warnings :
  //! In the array Knots the values must be in ascending order.
  //! U1 must not be equal to U2 to avoid division by zero.
  Standard_EXPORT static void Reparametrize (const Standard_Real U1, const Standard_Real U2, TColStd_Array1OfReal& Knots);
  
  //! Reverses  the  array   knots  to  become  the knots
  //! sequence of the reversed curve.
  Standard_EXPORT static void Reverse (TColStd_Array1OfReal& Knots);
  
  //! Reverses  the  array of multiplicities.
  Standard_EXPORT static void Reverse (TColStd_Array1OfInteger& Mults);
  
  //! Reverses the array of poles. Last is the  index of
  //! the new first pole. On  a  non periodic curve last
  //! is Poles.Upper(). On a periodic curve last is
  //!
  //! (number of flat knots - degree - 1)
  //!
  //! or
  //!
  //! (sum of multiplicities(but  for the last) + degree
  //! - 1)
  Standard_EXPORT static void Reverse (TColgp_Array1OfPnt& Poles, const Standard_Integer Last);
  
  //! Reverses the array of poles.
  Standard_EXPORT static void Reverse (TColgp_Array1OfPnt2d& Poles, const Standard_Integer Last);
  
  //! Reverses the array of poles.
  Standard_EXPORT static void Reverse (TColStd_Array1OfReal& Weights, const Standard_Integer Last);
  

  //! Returns False if all the weights  of the  array <Weights>
  //! between   I1 an I2   are  identic.   Epsilon  is used for
  //! comparing  weights. If Epsilon  is 0. the  Epsilon of the
  //! first weight is used.
  Standard_EXPORT static Standard_Boolean IsRational (const TColStd_Array1OfReal& Weights, const Standard_Integer I1, const Standard_Integer I2, const Standard_Real Epsilon = 0.0);
  
  //! returns the degree maxima for a BSplineCurve.
    static Standard_Integer MaxDegree();
  
  //! Perform the Boor  algorithm  to  evaluate a point at
  //! parameter <U>, with <Degree> and <Dimension>.
  //!
  //! Poles is  an array of  Reals of size
  //!
  //! <Dimension> *  <Degree>+1
  //!
  //! Containing  the poles.  At  the end <Poles> contains
  //! the current point.
  Standard_EXPORT static void Eval (const Standard_Real U, const Standard_Integer Degree, Standard_Real& Knots, const Standard_Integer Dimension, Standard_Real& Poles);
  
  //! Performs the  Boor Algorithm  at  parameter <U> with
  //! the given <Degree> and the  array of <Knots> on  the
  //! poles <Poles> of dimension  <Dimension>.  The schema
  //! is  computed  until  level  <Depth>  on a   basis of
  //! <Length+1> poles.
  //!
  //! * Knots is an array of reals of length :
  //!
  //! <Length> + <Degree>
  //!
  //! * Poles is an array of reals of length :
  //!
  //! (2 * <Length> + 1) * <Dimension>
  //!
  //! The poles values  must be  set  in the array at the
  //! positions.
  //!
  //! 0..Dimension,
  //!
  //! 2 * Dimension ..
  //! 3 * Dimension
  //!
  //! 4  * Dimension ..
  //! 5  * Dimension
  //!
  //! ...
  //!
  //! The results are found in the array poles depending
  //! on the Depth. (See the method GetPole).
  Standard_EXPORT static void BoorScheme (const Standard_Real U, const Standard_Integer Degree, Standard_Real& Knots, const Standard_Integer Dimension, Standard_Real& Poles, const Standard_Integer Depth, const Standard_Integer Length);
  
  //! Compute  the content of  Pole before the BoorScheme.
  //! This method is used to remove poles.
  //!
  //! U is the poles to  remove, Knots should contains the
  //! knots of the curve after knot removal.
  //!
  //! The first  and last poles  do not  change, the other
  //! poles are computed by averaging two possible values.
  //! The distance between  the  two   possible  poles  is
  //! computed, if it  is higher than <Tolerance> False is
  //! returned.
  Standard_EXPORT static Standard_Boolean AntiBoorScheme (const Standard_Real U, const Standard_Integer Degree, Standard_Real& Knots, const Standard_Integer Dimension, Standard_Real& Poles, const Standard_Integer Depth, const Standard_Integer Length, const Standard_Real Tolerance);
  
  //! Computes   the   poles of  the    BSpline  giving the
  //! derivatives of order <Order>.
  //!
  //! The formula for the first order is
  //!
  //! Pole(i) = Degree * (Pole(i+1) - Pole(i)) /
  //! (Knots(i+Degree+1) - Knots(i+1))
  //!
  //! This formula  is repeated  (Degree  is decremented at
  //! each step).
  Standard_EXPORT static void Derivative (const Standard_Integer Degree, Standard_Real& Knots, const Standard_Integer Dimension, const Standard_Integer Length, const Standard_Integer Order, Standard_Real& Poles);
  
  //! Performs the Bohm  Algorithm at  parameter <U>. This
  //! algorithm computes the value and all the derivatives
  //! up to order N (N <= Degree).
  //!
  //! <Poles> is the original array of poles.
  //!
  //! The   result in  <Poles>  is    the value and    the
  //! derivatives.  Poles[0] is  the value,  Poles[Degree]
  //! is the last  derivative.
  Standard_EXPORT static void Bohm (const Standard_Real U, const Standard_Integer Degree, const Standard_Integer N, Standard_Real& Knots, const Standard_Integer Dimension, Standard_Real& Poles);
  
  //! Used as argument for a non rational curve.
    static TColStd_Array1OfReal* NoWeights();
  
  //! Used as argument for a flatknots evaluation.
    static TColStd_Array1OfInteger* NoMults();
  
  //! Stores in LK  the usefull knots  for the BoorSchem
  //! on the span Knots(Index) - Knots(Index+1)
  Standard_EXPORT static void BuildKnots (const Standard_Integer Degree, const Standard_Integer Index, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, Standard_Real& LK);
  
  //! Return the index of the  first Pole to  use on the
  //! span  Mults(Index)  - Mults(Index+1).  This  index
  //! must be added to Poles.Lower().
  Standard_EXPORT static Standard_Integer PoleIndex (const Standard_Integer Degree, const Standard_Integer Index, const Standard_Boolean Periodic, const TColStd_Array1OfInteger& Mults);
  
  Standard_EXPORT static void BuildEval (const Standard_Integer Degree, const Standard_Integer Index, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal* Weights, Standard_Real& LP);
  
  Standard_EXPORT static void BuildEval (const Standard_Integer Degree, const Standard_Integer Index, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, Standard_Real& LP);
  
  //! Copy in <LP>  the poles and  weights for  the Eval
  //! scheme. starting from  Poles(Poles.Lower()+Index)
  Standard_EXPORT static void BuildEval (const Standard_Integer Degree, const Standard_Integer Index, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, Standard_Real& LP);
  
  //! Copy in <LP>  poles for <Dimension>  Boor  scheme.
  //! Starting  from    <Index>     *  <Dimension>, copy
  //! <Length+1> poles.
  Standard_EXPORT static void BuildBoor (const Standard_Integer Index, const Standard_Integer Length, const Standard_Integer Dimension, const TColStd_Array1OfReal& Poles, Standard_Real& LP);
  
  //! Returns the index in  the Boor result array of the
  //! poles <Index>. If  the Boor  algorithm was perform
  //! with <Length> and <Depth>.
  Standard_EXPORT static Standard_Integer BoorIndex (const Standard_Integer Index, const Standard_Integer Length, const Standard_Integer Depth);
  
  //! Copy  the  pole at  position  <Index>  in  the Boor
  //! scheme of   dimension <Dimension> to  <Position> in
  //! the array <Pole>. <Position> is updated.
  Standard_EXPORT static void GetPole (const Standard_Integer Index, const Standard_Integer Length, const Standard_Integer Depth, const Standard_Integer Dimension, Standard_Real& LocPoles, Standard_Integer& Position, TColStd_Array1OfReal& Pole);
  
  //! Returns in <NbPoles, NbKnots> the  new number of poles
  //! and  knots    if  the  sequence   of  knots <AddKnots,
  //! AddMults> is inserted in the sequence <Knots, Mults>.
  //!
  //! Epsilon is used to compare knots for equality.
  //!
  //! If Add is True  the multiplicities on  equal knots are
  //! added.
  //!
  //! If Add is False the max value of the multiplicities is
  //! kept.
  //!
  //! Return False if :
  //! The knew knots are knot increasing.
  //! The new knots are not in the range.
  Standard_EXPORT static Standard_Boolean PrepareInsertKnots (const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const TColStd_Array1OfReal& AddKnots, const TColStd_Array1OfInteger* AddMults, Standard_Integer& NbPoles, Standard_Integer& NbKnots, const Standard_Real Epsilon, const Standard_Boolean Add = Standard_True);
  
  Standard_EXPORT static void InsertKnots (const Standard_Integer Degree, const Standard_Boolean Periodic, const Standard_Integer Dimension, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const TColStd_Array1OfReal& AddKnots, const TColStd_Array1OfInteger* AddMults, TColStd_Array1OfReal& NewPoles, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, const Standard_Real Epsilon, const Standard_Boolean Add = Standard_True);
  
  Standard_EXPORT static void InsertKnots (const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const TColStd_Array1OfReal& AddKnots, const TColStd_Array1OfInteger* AddMults, TColgp_Array1OfPnt& NewPoles, TColStd_Array1OfReal* NewWeights, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, const Standard_Real Epsilon, const Standard_Boolean Add = Standard_True);
  
  //! Insert   a  sequence  of  knots <AddKnots> with
  //! multiplicities   <AddMults>. <AddKnots>   must  be a   non
  //! decreasing sequence and verifies :
  //!
  //! Knots(Knots.Lower()) <= AddKnots(AddKnots.Lower())
  //! Knots(Knots.Upper()) >= AddKnots(AddKnots.Upper())
  //!
  //! The NewPoles and NewWeights arrays must have a length :
  //! Poles.Length() + Sum(AddMults())
  //!
  //! When a knot  to insert is identic  to an existing knot the
  //! multiplicities   are added.
  //!
  //! Epsilon is used to test knots for equality.
  //!
  //! When AddMult is negative or null the knot is not inserted.
  //! No multiplicity will becomes higher than the degree.
  //!
  //! The new Knots and Multiplicities  are copied in <NewKnots>
  //! and  <NewMults>.
  //!
  //! All the New arrays should be correctly dimensioned.
  //!
  //! When all  the new knots  are existing knots, i.e. only the
  //! multiplicities  will  change it is   safe to  use the same
  //! arrays as input and output.
  Standard_EXPORT static void InsertKnots (const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const TColStd_Array1OfReal& AddKnots, const TColStd_Array1OfInteger* AddMults, TColgp_Array1OfPnt2d& NewPoles, TColStd_Array1OfReal* NewWeights, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, const Standard_Real Epsilon, const Standard_Boolean Add = Standard_True);
  
  Standard_EXPORT static void InsertKnot (const Standard_Integer UIndex, const Standard_Real U, const Standard_Integer UMult, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColgp_Array1OfPnt& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  //! Insert a new knot U of multiplicity UMult in the
  //! knot sequence.
  //!
  //! The  location of the new Knot  should be given as an input
  //! data.  UIndex locates the new knot U  in the knot sequence
  //! and Knots (UIndex) < U < Knots (UIndex + 1).
  //!
  //! The new control points corresponding to this insertion are
  //! returned. Knots and Mults are not updated.
  Standard_EXPORT static void InsertKnot (const Standard_Integer UIndex, const Standard_Real U, const Standard_Integer UMult, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColgp_Array1OfPnt2d& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  Standard_EXPORT static void RaiseMultiplicity (const Standard_Integer KnotIndex, const Standard_Integer Mult, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColgp_Array1OfPnt& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  //! Raise the multiplicity of knot to <UMult>.
  //!
  //! The new control points  are  returned. Knots and Mults are
  //! not updated.
  Standard_EXPORT static void RaiseMultiplicity (const Standard_Integer KnotIndex, const Standard_Integer Mult, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColgp_Array1OfPnt2d& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  Standard_EXPORT static Standard_Boolean RemoveKnot (const Standard_Integer Index, const Standard_Integer Mult, const Standard_Integer Degree, const Standard_Boolean Periodic, const Standard_Integer Dimension, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColStd_Array1OfReal& NewPoles, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, const Standard_Real Tolerance);
  
  Standard_EXPORT static Standard_Boolean RemoveKnot (const Standard_Integer Index, const Standard_Integer Mult, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColgp_Array1OfPnt& NewPoles, TColStd_Array1OfReal* NewWeights, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, const Standard_Real Tolerance);
  
  //! Decrement the  multiplicity  of <Knots(Index)>
  //! to <Mult>. If <Mult>   is  null the   knot  is
  //! removed.
  //!
  //! As there are two ways to compute the new poles
  //! the midlle   will  be used  as  long    as the
  //! distance is lower than Tolerance.
  //!
  //! If a  distance is  bigger  than  tolerance the
  //! methods returns False  and  the new arrays are
  //! not modified.
  //!
  //! A low  tolerance can be  used  to test  if the
  //! knot  can be  removed  without  modifying  the
  //! curve.
  //!
  //! A high tolerance  can be used  to "smooth" the
  //! curve.
  Standard_EXPORT static Standard_Boolean RemoveKnot (const Standard_Integer Index, const Standard_Integer Mult, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColgp_Array1OfPnt2d& NewPoles, TColStd_Array1OfReal* NewWeights, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, const Standard_Real Tolerance);
  
  //! Returns the   number   of  knots   of  a  curve   with
  //! multiplicities <Mults> after elevating the degree from
  //! <Degree> to <NewDegree>. See the IncreaseDegree method
  //! for more comments.
  Standard_EXPORT static Standard_Integer IncreaseDegreeCountKnots (const Standard_Integer Degree, const Standard_Integer NewDegree, const Standard_Boolean Periodic, const TColStd_Array1OfInteger& Mults);
  
  Standard_EXPORT static void IncreaseDegree (const Standard_Integer Degree, const Standard_Integer NewDegree, const Standard_Boolean Periodic, const Standard_Integer Dimension, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColStd_Array1OfReal& NewPoles, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults);
  
  Standard_EXPORT static void IncreaseDegree (const Standard_Integer Degree, const Standard_Integer NewDegree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColgp_Array1OfPnt& NewPoles, TColStd_Array1OfReal* NewWeights, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults);
  
  Standard_EXPORT static void IncreaseDegree (const Standard_Integer Degree, const Standard_Integer NewDegree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, TColgp_Array1OfPnt2d& NewPoles, TColStd_Array1OfReal* NewWeights, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults);
  
  Standard_EXPORT static void IncreaseDegree (const Standard_Integer NewDegree, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, TColgp_Array1OfPnt& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  //! Increase the degree of a bspline (or bezier) curve
  //! of   dimension  <Dimension>  form <Degree>      to
  //! <NewDegree>.
  //!
  //! The number of poles in the new curve is :
  //!
  //! Poles.Length() + (NewDegree - Degree) * Number of spans
  //!
  //! Where the number of spans is :
  //!
  //! LastUKnotIndex(Mults) - FirstUKnotIndex(Mults) + 1
  //!
  //! for a non-periodic curve
  //!
  //! And Knots.Length() - 1 for a periodic curve.
  //!
  //! The multiplicities of all  knots  are increased by
  //! the degree elevation.
  //!
  //! The new knots are usually  the same knots with the
  //! exception of  a non-periodic curve with  the first
  //! and last multiplicity not  equal to Degree+1 where
  //! knots are removed  form the start  and the  bottom
  //! untils the sum of the  multiplicities is  equal to
  //! NewDegree+1  at the  knots   corresponding  to the
  //! first and last parameters of the curve.
  //!
  //! Example  :  Suppose a  curve  of degree 3 starting
  //! with following knots and multiplicities :
  //!
  //! knot : 0.  1.  2.
  //! mult : 1   2   1
  //!
  //! The  FirstUKnot is  2.     because the   sum    of
  //! multiplicities is Degree+1 : 1 + 2 + 1 = 4 = 3 + 1
  //!
  //! i.e. the first parameter  of the  curve is  2. and
  //! will still be   2.  after degree  elevation.   Let
  //! raises this curve to degree 4.  The multiplicities
  //! are increased by 2.
  //!
  //! They   become 2 3  2.   But     we need a   sum of
  //! multiplicities  of 5 at knot  2. So the first knot
  //! is removed and the new knots are :
  //!
  //! knot : 1.  2.
  //! mult : 3   2
  //!
  //! The multipicity   of the first  knot may   also be
  //! reduced if the sum is still to big.
  //!
  //! In the  most common situations (periodic  curve or
  //! curve with first and last multiplicities equals to
  //! Degree+1) the knots are knot changes.
  //!
  //! The method IncreaseDegreeCountKnots can be used to
  //! compute the new number of knots.
  Standard_EXPORT static void IncreaseDegree (const Standard_Integer NewDegree, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, TColgp_Array1OfPnt2d& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  //! Set in <NbKnots> and <NbPolesToAdd> the number of Knots and
  //! Poles   of  the NotPeriodic  Curve   identical  at the
  //! periodic     curve with    a  degree    <Degree>  ,  a
  //! knots-distribution with Multiplicities <Mults>.
  Standard_EXPORT static void PrepareUnperiodize (const Standard_Integer Degree, const TColStd_Array1OfInteger& Mults, Standard_Integer& NbKnots, Standard_Integer& NbPoles);
  
  Standard_EXPORT static void Unperiodize (const Standard_Integer Degree, const Standard_Integer Dimension, const TColStd_Array1OfInteger& Mults, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfReal& Poles, TColStd_Array1OfInteger& NewMults, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfReal& NewPoles);
  
  Standard_EXPORT static void Unperiodize (const Standard_Integer Degree, const TColStd_Array1OfInteger& Mults, const TColStd_Array1OfReal& Knots, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, TColStd_Array1OfInteger& NewMults, TColStd_Array1OfReal& NewKnots, TColgp_Array1OfPnt& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  Standard_EXPORT static void Unperiodize (const Standard_Integer Degree, const TColStd_Array1OfInteger& Mults, const TColStd_Array1OfReal& Knots, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, TColStd_Array1OfInteger& NewMults, TColStd_Array1OfReal& NewKnots, TColgp_Array1OfPnt2d& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  //! Set in <NbKnots> and <NbPoles> the number of Knots and
  //! Poles of the  curve resulting  of  the trimming of the
  //! BSplinecurve definded with <degree>, <knots>, <mults>
  Standard_EXPORT static void PrepareTrimming (const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const Standard_Real U1, const Standard_Real U2, Standard_Integer& NbKnots, Standard_Integer& NbPoles);
  
  Standard_EXPORT static void Trimming (const Standard_Integer Degree, const Standard_Boolean Periodic, const Standard_Integer Dimension, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const TColStd_Array1OfReal& Poles, const Standard_Real U1, const Standard_Real U2, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, TColStd_Array1OfReal& NewPoles);
  
  Standard_EXPORT static void Trimming (const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const Standard_Real U1, const Standard_Real U2, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, TColgp_Array1OfPnt& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  Standard_EXPORT static void Trimming (const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger& Mults, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const Standard_Real U1, const Standard_Real U2, TColStd_Array1OfReal& NewKnots, TColStd_Array1OfInteger& NewMults, TColgp_Array1OfPnt2d& NewPoles, TColStd_Array1OfReal* NewWeights);
  
  Standard_EXPORT static void D0 (const Standard_Real U, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, Standard_Real& P);
  
  Standard_EXPORT static void D0 (const Standard_Real U, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Pnt& P);
  
  Standard_EXPORT static void D0 (const Standard_Real U, const Standard_Integer UIndex, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Pnt2d& P);
  
  Standard_EXPORT static void D0 (const Standard_Real U, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& P);
  
  Standard_EXPORT static void D0 (const Standard_Real U, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& P);
  
  Standard_EXPORT static void D1 (const Standard_Real U, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, Standard_Real& P, Standard_Real& V);
  
  Standard_EXPORT static void D1 (const Standard_Real U, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Pnt& P, gp_Vec& V);
  
  Standard_EXPORT static void D1 (const Standard_Real U, const Standard_Integer UIndex, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Pnt2d& P, gp_Vec2d& V);
  
  Standard_EXPORT static void D1 (const Standard_Real U, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& P, gp_Vec& V);
  
  Standard_EXPORT static void D1 (const Standard_Real U, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& P, gp_Vec2d& V);
  
  Standard_EXPORT static void D2 (const Standard_Real U, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, Standard_Real& P, Standard_Real& V1, Standard_Real& V2);
  
  Standard_EXPORT static void D2 (const Standard_Real U, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
  
  Standard_EXPORT static void D2 (const Standard_Real U, const Standard_Integer UIndex, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
  
  Standard_EXPORT static void D2 (const Standard_Real U, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
  
  Standard_EXPORT static void D2 (const Standard_Real U, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
  
  Standard_EXPORT static void D3 (const Standard_Real U, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, Standard_Real& P, Standard_Real& V1, Standard_Real& V2, Standard_Real& V3);
  
  Standard_EXPORT static void D3 (const Standard_Real U, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
  
  Standard_EXPORT static void D3 (const Standard_Real U, const Standard_Integer UIndex, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3);
  
  Standard_EXPORT static void D3 (const Standard_Real U, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
  
  Standard_EXPORT static void D3 (const Standard_Real U, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3);
  
  Standard_EXPORT static void DN (const Standard_Real U, const Standard_Integer N, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, Standard_Real& VN);
  
  Standard_EXPORT static void DN (const Standard_Real U, const Standard_Integer N, const Standard_Integer Index, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Vec& VN);
  
  Standard_EXPORT static void DN (const Standard_Real U, const Standard_Integer N, const Standard_Integer UIndex, const Standard_Integer Degree, const Standard_Boolean Periodic, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& Knots, const TColStd_Array1OfInteger* Mults, gp_Vec2d& V);
  
  Standard_EXPORT static void DN (const Standard_Real U, const Standard_Integer N, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal& Weights, gp_Pnt& P, gp_Vec& VN);
  
  //! The  above  functions  compute   values and
  //! derivatives in the following situations :
  //!
  //! * 3D, 2D and 1D
  //!
  //! * Rational or not Rational.
  //!
  //! * Knots  and multiplicities or "flat knots" without
  //! multiplicities.
  //!
  //! * The  <Index>  is   the the  localization  of  the
  //! parameter in the knot sequence.  If <Index> is  out
  //! of range the correct value will be searched.
  //!
  //! VERY IMPORTANT!!!
  //! USE  BSplCLib::NoWeights()  as Weights argument for non
  //! rational curves computations.
  Standard_EXPORT static void DN (const Standard_Real U, const Standard_Integer N, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal& Weights, gp_Pnt2d& P, gp_Vec2d& VN);
  
  //! This  evaluates  the Bspline  Basis  at  a
  //! given  parameter  Parameter   up   to  the
  //! requested   DerivativeOrder  and store the
  //! result  in the  array BsplineBasis  in the
  //! following   fashion
  //! BSplineBasis(1,1)   =
  //! value of first non vanishing
  //! Bspline function which has Index FirstNonZeroBsplineIndex
  //! BsplineBasis(1,2)   =
  //! value of second non vanishing
  //! Bspline   function which  has   Index
  //! FirstNonZeroBsplineIndex + 1
  //! BsplineBasis(1,n)   =
  //! value of second non vanishing non vanishing
  //! Bspline   function which  has   Index
  //! FirstNonZeroBsplineIndex + n (n <= Order)
  //! BSplineBasis(2,1)   =
  //! value of derivative of first non vanishing
  //! Bspline function which has Index FirstNonZeroBsplineIndex
  //! BSplineBasis(N,1)   =
  //! value of Nth derivative of first non vanishing
  //! Bspline function which has Index FirstNonZeroBsplineIndex
  //! if N <= DerivativeOrder + 1
  Standard_EXPORT static Standard_Integer EvalBsplineBasis (const Standard_Integer DerivativeOrder,
                                                            const Standard_Integer Order,
                                                            const TColStd_Array1OfReal& FlatKnots,
                                                            const Standard_Real Parameter,
                                                            Standard_Integer& FirstNonZeroBsplineIndex,
                                                            math_Matrix& BsplineBasis,
                                                            const Standard_Boolean isPeriodic = Standard_False);
  
  //! This Builds   a fully  blown   Matrix of
  //! (ni)
  //! Bi    (tj)
  //!
  //! with i  and j within 1..Order + NumPoles
  //! The  integer ni is   the ith slot of the
  //! array OrderArray, tj is the jth slot of
  //! the array Parameters
  Standard_EXPORT static Standard_Integer BuildBSpMatrix (const TColStd_Array1OfReal& Parameters, const TColStd_Array1OfInteger& OrderArray, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer Degree, math_Matrix& Matrix, Standard_Integer& UpperBandWidth, Standard_Integer& LowerBandWidth);
  
  //! this  factors  the Banded Matrix in
  //! the LU form with a Banded storage of
  //! components of the L matrix
  //! WARNING : do not use if the Matrix is
  //! totally positive (It is the case for
  //! Bspline matrices build as above with
  //! parameters being the Schoenberg points
  Standard_EXPORT static Standard_Integer FactorBandedMatrix (math_Matrix& Matrix, const Standard_Integer UpperBandWidth, const Standard_Integer LowerBandWidth, Standard_Integer& PivotIndexProblem);
  
  //! This solves  the system Matrix.X =  B
  //! with when Matrix is factored in LU form
  //! The  Array   is    an   seen   as    an
  //! Array[1..N][1..ArrayDimension] with N =
  //! the  rank  of the  matrix  Matrix.  The
  //! result is stored   in Array  when  each
  //! coordinate is  solved that is  B is the
  //! array whose values are
  //! B[i] = Array[i][p] for each p in 1..ArrayDimension
  Standard_EXPORT static Standard_Integer SolveBandedSystem (const math_Matrix& Matrix, const Standard_Integer UpperBandWidth, const Standard_Integer LowerBandWidth, const Standard_Integer ArrayDimension, Standard_Real& Array);
  
  //! This solves  the system Matrix.X =  B
  //! with when Matrix is factored in LU form
  //! The  Array   has the length of
  //! the  rank  of the  matrix  Matrix.  The
  //! result is stored   in Array  when  each
  //! coordinate is  solved that is  B is the
  //! array whose values are
  //! B[i] = Array[i][p] for each p in 1..ArrayDimension
  Standard_EXPORT static Standard_Integer SolveBandedSystem (const math_Matrix& Matrix, const Standard_Integer UpperBandWidth, const Standard_Integer LowerBandWidth, TColgp_Array1OfPnt2d& Array);
  
  //! This solves  the system Matrix.X =  B
  //! with when Matrix is factored in LU form
  //! The  Array   has the length of
  //! the  rank  of the  matrix  Matrix.  The
  //! result is stored   in Array  when  each
  //! coordinate is  solved that is  B is the
  //! array whose values are
  //! B[i] = Array[i][p] for each p in 1..ArrayDimension
  Standard_EXPORT static Standard_Integer SolveBandedSystem (const math_Matrix& Matrix, const Standard_Integer UpperBandWidth, const Standard_Integer LowerBandWidth, TColgp_Array1OfPnt& Array);
  
  Standard_EXPORT static Standard_Integer SolveBandedSystem (const math_Matrix& Matrix, const Standard_Integer UpperBandWidth, const Standard_Integer LowerBandWidth, const Standard_Boolean HomogenousFlag, const Standard_Integer ArrayDimension, Standard_Real& Array, Standard_Real& Weights);
  
  //! This solves the  system Matrix.X =  B
  //! with when Matrix is factored in LU form
  //! The    Array   is    an   seen  as   an
  //! Array[1..N][1..ArrayDimension] with N =
  //! the  rank  of  the  matrix Matrix.  The
  //! result is  stored   in Array when  each
  //! coordinate is  solved that is B  is the
  //! array  whose   values     are   B[i]  =
  //! Array[i][p]       for     each  p    in
  //! 1..ArrayDimension. If  HomogeneousFlag ==
  //! 0  the  Poles  are  multiplied by   the
  //! Weights   uppon   Entry   and      once
  //! interpolation   is    carried  over the
  //! result of the  poles are divided by the
  //! result of   the   interpolation of  the
  //! weights. Otherwise if HomogenousFlag == 1
  //! the Poles and Weigths are treated homogenously
  //! that is that those are interpolated as they
  //! are and result is returned without division
  //! by the interpolated weigths.
  Standard_EXPORT static Standard_Integer SolveBandedSystem (const math_Matrix& Matrix, const Standard_Integer UpperBandWidth, const Standard_Integer LowerBandWidth, const Standard_Boolean HomogenousFlag, TColgp_Array1OfPnt2d& Array, TColStd_Array1OfReal& Weights);
  
  //! This solves  the system Matrix.X =  B
  //! with when Matrix is factored in LU form
  //! The  Array   is    an   seen   as    an
  //! Array[1..N][1..ArrayDimension] with N =
  //! the  rank  of the  matrix  Matrix.  The
  //! result is stored   in Array  when  each
  //! coordinate is  solved that is  B is the
  //! array whose values are
  //! B[i] = Array[i][p] for each p in 1..ArrayDimension
  //! If  HomogeneousFlag ==
  //! 0  the  Poles  are  multiplied by   the
  //! Weights   uppon   Entry   and      once
  //! interpolation   is    carried  over the
  //! result of the  poles are divided by the
  //! result of   the   interpolation of  the
  //! weights. Otherwise if HomogenousFlag == 1
  //! the Poles and Weigths are treated homogenously
  //! that is that those are interpolated as they
  //! are and result is returned without division
  //! by the interpolated weigths.
  Standard_EXPORT static Standard_Integer SolveBandedSystem (const math_Matrix& Matrix, const Standard_Integer UpperBandWidth, const Standard_Integer LowerBandWidth, const Standard_Boolean HomogeneousFlag, TColgp_Array1OfPnt& Array, TColStd_Array1OfReal& Weights);
  
  //! Merges  two knot vector by   setting the starting and
  //! ending values to StartValue and EndValue
  Standard_EXPORT static void MergeBSplineKnots (const Standard_Real Tolerance, const Standard_Real StartValue, const Standard_Real EndValue, const Standard_Integer Degree1, const TColStd_Array1OfReal& Knots1, const TColStd_Array1OfInteger& Mults1, const Standard_Integer Degree2, const TColStd_Array1OfReal& Knots2, const TColStd_Array1OfInteger& Mults2, Standard_Integer& NumPoles, Handle(TColStd_HArray1OfReal)& NewKnots, Handle(TColStd_HArray1OfInteger)& NewMults);
  
  //! This function will compose  a given Vectorial BSpline F(t)
  //! defined  by its  BSplineDegree and BSplineFlatKnotsl,
  //! its Poles  array which are coded as  an array of Real
  //! of  the  form  [1..NumPoles][1..PolesDimension] with  a
  //! function     a(t) which is   assumed to   satisfy the
  //! following:
  //!
  //! 1. F(a(t))  is a polynomial BSpline
  //! that can be expressed  exactly as a BSpline of degree
  //! NewDegree on the knots FlatKnots
  //!
  //! 2. a(t) defines a differentiable
  //! isomorphism between the range of FlatKnots to the range
  //! of BSplineFlatKnots which is the
  //! same as the  range of F(t)
  //!
  //! Warning: it is
  //! the caller's responsability to insure that conditions
  //! 1. and  2. above are  satisfied : no check whatsoever
  //! is made in this method
  //!
  //! theStatus will return 0 if OK else it will return the pivot index
  //! of the matrix that was inverted to compute the multiplied
  //! BSpline : the method used is interpolation at Schoenenberg
  //! points of F(a(t))
  Standard_EXPORT static void FunctionReparameterise (const BSplCLib_EvaluatorFunction& Function, const Standard_Integer BSplineDegree, const TColStd_Array1OfReal& BSplineFlatKnots, const Standard_Integer PolesDimension, Standard_Real& Poles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer NewDegree, Standard_Real& NewPoles, Standard_Integer& theStatus);
  
  //! This function will compose  a given Vectorial BSpline F(t)
  //! defined  by its  BSplineDegree and BSplineFlatKnotsl,
  //! its Poles  array which are coded as  an array of Real
  //! of  the  form  [1..NumPoles][1..PolesDimension] with  a
  //! function     a(t) which is   assumed to   satisfy the
  //! following:
  //!
  //! 1. F(a(t))  is a polynomial BSpline
  //! that can be expressed  exactly as a BSpline of degree
  //! NewDegree on the knots FlatKnots
  //!
  //! 2. a(t) defines a differentiable
  //! isomorphism between the range of FlatKnots to the range
  //! of BSplineFlatKnots which is the
  //! same as the  range of F(t)
  //!
  //! Warning: it is
  //! the caller's responsability to insure that conditions
  //! 1. and  2. above are  satisfied : no check whatsoever
  //! is made in this method
  //!
  //! theStatus will return 0 if OK else it will return the pivot index
  //! of the matrix that was inverted to compute the multiplied
  //! BSpline : the method used is interpolation at Schoenenberg
  //! points of F(a(t))
  Standard_EXPORT static void FunctionReparameterise (const BSplCLib_EvaluatorFunction& Function, const Standard_Integer BSplineDegree, const TColStd_Array1OfReal& BSplineFlatKnots, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer NewDegree, TColStd_Array1OfReal& NewPoles, Standard_Integer& theStatus);
  
  //! this will compose  a given Vectorial BSpline F(t)
  //! defined  by its  BSplineDegree and BSplineFlatKnotsl,
  //! its Poles  array which are coded as  an array of Real
  //! of  the  form  [1..NumPoles][1..PolesDimension] with  a
  //! function     a(t) which is   assumed to   satisfy the
  //! following  : 1. F(a(t))  is a polynomial BSpline
  //! that can be expressed  exactly as a BSpline of degree
  //! NewDegree on the knots FlatKnots
  //! 2. a(t) defines a differentiable
  //! isomorphism between the range of FlatKnots to the range
  //! of BSplineFlatKnots which is the
  //! same as the  range of F(t)
  //! Warning: it is
  //! the caller's responsability to insure that conditions
  //! 1. and  2. above are  satisfied : no check whatsoever
  //! is made in this method
  //! theStatus will return 0 if OK else it will return the pivot index
  //! of the matrix that was inverted to compute the multiplied
  //! BSpline : the method used is interpolation at Schoenenberg
  //! points of F(a(t))
  Standard_EXPORT static void FunctionReparameterise (const BSplCLib_EvaluatorFunction& Function, const Standard_Integer BSplineDegree, const TColStd_Array1OfReal& BSplineFlatKnots, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer NewDegree, TColgp_Array1OfPnt& NewPoles, Standard_Integer& theStatus);
  
  //! this will compose  a given Vectorial BSpline F(t)
  //! defined  by its  BSplineDegree and BSplineFlatKnotsl,
  //! its Poles  array which are coded as  an array of Real
  //! of  the  form  [1..NumPoles][1..PolesDimension] with  a
  //! function     a(t) which is   assumed to   satisfy the
  //! following  : 1. F(a(t))  is a polynomial BSpline
  //! that can be expressed  exactly as a BSpline of degree
  //! NewDegree on the knots FlatKnots
  //! 2. a(t) defines a differentiable
  //! isomorphism between the range of FlatKnots to the range
  //! of BSplineFlatKnots which is the
  //! same as the  range of F(t)
  //! Warning: it is
  //! the caller's responsability to insure that conditions
  //! 1. and  2. above are  satisfied : no check whatsoever
  //! is made in this method
  //! theStatus will return 0 if OK else it will return the pivot index
  //! of the matrix that was inverted to compute the multiplied
  //! BSpline : the method used is interpolation at Schoenenberg
  //! points of F(a(t))
  Standard_EXPORT static void FunctionReparameterise (const BSplCLib_EvaluatorFunction& Function, const Standard_Integer BSplineDegree, const TColStd_Array1OfReal& BSplineFlatKnots, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer NewDegree, TColgp_Array1OfPnt2d& NewPoles, Standard_Integer& theStatus);
  
  //! this will  multiply a given Vectorial BSpline F(t)
  //! defined  by its  BSplineDegree and BSplineFlatKnotsl,
  //! its Poles  array which are coded as  an array of Real
  //! of  the  form  [1..NumPoles][1..PolesDimension] by  a
  //! function     a(t) which is   assumed to   satisfy the
  //! following  : 1. a(t)  * F(t)  is a polynomial BSpline
  //! that can be expressed  exactly as a BSpline of degree
  //! NewDegree on the knots FlatKnots 2. the range of a(t)
  //! is the same as the  range of F(t)
  //! Warning: it is
  //! the caller's responsability to insure that conditions
  //! 1. and  2. above are  satisfied : no check whatsoever
  //! is made in this method
  //! theStatus will return 0 if OK else it will return the pivot index
  //! of the matrix that was inverted to compute the multiplied
  //! BSpline : the method used is interpolation at Schoenenberg
  //! points of a(t)*F(t)
  Standard_EXPORT static void FunctionMultiply (const BSplCLib_EvaluatorFunction& Function, const Standard_Integer BSplineDegree, const TColStd_Array1OfReal& BSplineFlatKnots, const Standard_Integer PolesDimension, Standard_Real& Poles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer NewDegree, Standard_Real& NewPoles, Standard_Integer& theStatus);
  
  //! this will  multiply a given Vectorial BSpline F(t)
  //! defined  by its  BSplineDegree and BSplineFlatKnotsl,
  //! its Poles  array which are coded as  an array of Real
  //! of  the  form  [1..NumPoles][1..PolesDimension] by  a
  //! function     a(t) which is   assumed to   satisfy the
  //! following  : 1. a(t)  * F(t)  is a polynomial BSpline
  //! that can be expressed  exactly as a BSpline of degree
  //! NewDegree on the knots FlatKnots 2. the range of a(t)
  //! is the same as the  range of F(t)
  //! Warning: it is
  //! the caller's responsability to insure that conditions
  //! 1. and  2. above are  satisfied : no check whatsoever
  //! is made in this method
  //! theStatus will return 0 if OK else it will return the pivot index
  //! of the matrix that was inverted to compute the multiplied
  //! BSpline : the method used is interpolation at Schoenenberg
  //! points of a(t)*F(t)
  Standard_EXPORT static void FunctionMultiply (const BSplCLib_EvaluatorFunction& Function, const Standard_Integer BSplineDegree, const TColStd_Array1OfReal& BSplineFlatKnots, const TColStd_Array1OfReal& Poles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer NewDegree, TColStd_Array1OfReal& NewPoles, Standard_Integer& theStatus);
  
  //! this will  multiply a given Vectorial BSpline F(t)
  //! defined  by its  BSplineDegree and BSplineFlatKnotsl,
  //! its Poles  array which are coded as  an array of Real
  //! of  the  form  [1..NumPoles][1..PolesDimension] by  a
  //! function     a(t) which is   assumed to   satisfy the
  //! following  : 1. a(t)  * F(t)  is a polynomial BSpline
  //! that can be expressed  exactly as a BSpline of degree
  //! NewDegree on the knots FlatKnots 2. the range of a(t)
  //! is the same as the  range of F(t)
  //! Warning: it is
  //! the caller's responsability to insure that conditions
  //! 1. and  2. above are  satisfied : no check whatsoever
  //! is made in this method
  //! theStatus will return 0 if OK else it will return the pivot index
  //! of the matrix that was inverted to compute the multiplied
  //! BSpline : the method used is interpolation at Schoenenberg
  //! points of a(t)*F(t)
  Standard_EXPORT static void FunctionMultiply (const BSplCLib_EvaluatorFunction& Function, const Standard_Integer BSplineDegree, const TColStd_Array1OfReal& BSplineFlatKnots, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer NewDegree, TColgp_Array1OfPnt2d& NewPoles, Standard_Integer& theStatus);
  
  //! this will  multiply a given Vectorial BSpline F(t)
  //! defined  by its  BSplineDegree and BSplineFlatKnotsl,
  //! its Poles  array which are coded as  an array of Real
  //! of  the  form  [1..NumPoles][1..PolesDimension] by  a
  //! function     a(t) which is   assumed to   satisfy the
  //! following  : 1. a(t)  * F(t)  is a polynomial BSpline
  //! that can be expressed  exactly as a BSpline of degree
  //! NewDegree on the knots FlatKnots 2. the range of a(t)
  //! is the same as the  range of F(t)
  //! Warning: it is
  //! the caller's responsability to insure that conditions
  //! 1. and  2. above are  satisfied : no check whatsoever
  //! is made in this method
  //! theStatus will return 0 if OK else it will return the pivot index
  //! of the matrix that was inverted to compute the multiplied
  //! BSpline : the method used is interpolation at Schoenenberg
  //! points of a(t)*F(t)
  Standard_EXPORT static void FunctionMultiply (const BSplCLib_EvaluatorFunction& Function, const Standard_Integer BSplineDegree, const TColStd_Array1OfReal& BSplineFlatKnots, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer NewDegree, TColgp_Array1OfPnt& NewPoles, Standard_Integer& theStatus);
  
  //! Perform the De Boor   algorithm  to  evaluate a point at
  //! parameter <U>, with <Degree> and <Dimension>.
  //!
  //! Poles is  an array of  Reals of size
  //!
  //! <Dimension> *  <Degree>+1
  //!
  //! Containing the  poles.  At  the end <Poles> contains
  //! the current point.   Poles Contain all  the poles of
  //! the BsplineCurve, Knots  also Contains all the knots
  //! of the BsplineCurve.  ExtrapMode has two slots [0] =
  //! Degree used to extrapolate before the first knot [1]
  //! = Degre used to  extrapolate after the last knot has
  //! to be between 1 and  Degree
  Standard_EXPORT static void Eval (const Standard_Real U, const Standard_Boolean PeriodicFlag, const Standard_Integer DerivativeRequest, Standard_Integer& ExtrapMode, const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer ArrayDimension, Standard_Real& Poles, Standard_Real& Result);
  
  //! Perform the  De Boor algorithm  to evaluate a point at
  //! parameter   <U>,  with   <Degree>    and  <Dimension>.
  //! Evaluates by multiplying the  Poles by the Weights and
  //! gives  the homogeneous  result  in PolesResult that is
  //! the results of the evaluation of the numerator once it
  //! has     been  multiplied   by  the     weights and  in
  //! WeightsResult one has  the result of the evaluation of
  //! the denominator
  //!
  //! Warning:   <PolesResult> and <WeightsResult>  must be   dimensionned
  //! properly.
  Standard_EXPORT static void Eval (const Standard_Real U, const Standard_Boolean PeriodicFlag, const Standard_Integer DerivativeRequest, Standard_Integer& ExtrapMode, const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer ArrayDimension, Standard_Real& Poles, Standard_Real& Weights, Standard_Real& PolesResult, Standard_Real& WeightsResult);
  
  //! Perform the evaluation of the Bspline Basis
  //! and then multiplies by the weights
  //! this just evaluates the current point
  Standard_EXPORT static void Eval (const Standard_Real U, const Standard_Boolean PeriodicFlag, const Standard_Boolean HomogeneousFlag, Standard_Integer& ExtrapMode, const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal& Weights, gp_Pnt& Point, Standard_Real& Weight);
  
  //! Perform the evaluation of the Bspline Basis
  //! and then multiplies by the weights
  //! this just evaluates the current point
  Standard_EXPORT static void Eval (const Standard_Real U, const Standard_Boolean PeriodicFlag, const Standard_Boolean HomogeneousFlag, Standard_Integer& ExtrapMode, const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal& Weights, gp_Pnt2d& Point, Standard_Real& Weight);
  
  //! Extend a BSpline nD using the tangency map
  //! <C1Coefficient> is the coefficient of reparametrisation
  //! <Continuity> must be equal to 1, 2 or 3.
  //! <Degree> must be greater or equal than <Continuity> + 1.
  //!
  //! Warning:   <KnotsResult> and <PolesResult>  must be   dimensionned
  //! properly.
  Standard_EXPORT static void TangExtendToConstraint (const TColStd_Array1OfReal& FlatKnots, const Standard_Real C1Coefficient, const Standard_Integer NumPoles, Standard_Real& Poles, const Standard_Integer Dimension, const Standard_Integer Degree, const TColStd_Array1OfReal& ConstraintPoint, const Standard_Integer Continuity, const Standard_Boolean After, Standard_Integer& NbPolesResult, Standard_Integer& NbKnotsRsult, Standard_Real& KnotsResult, Standard_Real& PolesResult);
  
  //! Perform the evaluation of the of the cache
  //! the parameter must be normalized between
  //! the 0 and 1 for the span.
  //! The Cache must be valid when calling this
  //! routine. Geom Package will insure that.
  //! and then multiplies by the weights
  //! this just evaluates the current point
  //! the CacheParameter is where the Cache was
  //! constructed the SpanLength is to normalize
  //! the polynomial in the cache to avoid bad conditioning
  //! effects
  Standard_EXPORT static void CacheD0 (const Standard_Real U, const Standard_Integer Degree, const Standard_Real CacheParameter, const Standard_Real SpanLenght, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& Point);
  
  //! Perform the evaluation of the Bspline Basis
  //! and then multiplies by the weights
  //! this just evaluates the current point
  //! the parameter must be normalized between
  //! the 0 and 1 for the span.
  //! The Cache must be valid when calling this
  //! routine. Geom Package will insure that.
  //! and then multiplies by the weights
  //! ththe CacheParameter is where the Cache was
  //! constructed the SpanLength is to normalize
  //! the polynomial in the cache to avoid bad conditioning
  //! effectsis just evaluates the current point
  Standard_EXPORT static void CacheD0 (const Standard_Real U, const Standard_Integer Degree, const Standard_Real CacheParameter, const Standard_Real SpanLenght, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& Point);
  
  //! Calls CacheD0 for Bezier  Curves Arrays computed with
  //! the method PolesCoefficients.
  //! Warning: To be used for Beziercurves ONLY!!!
    static void CoefsD0 (const Standard_Real U, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& Point);
  
  //! Calls CacheD0 for Bezier  Curves Arrays computed with
  //! the method PolesCoefficients.
  //! Warning: To be used for Beziercurves ONLY!!!
    static void CoefsD0 (const Standard_Real U, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& Point);
  
  //! Perform the evaluation of the of the cache
  //! the parameter must be normalized between
  //! the 0 and 1 for the span.
  //! The Cache must be valid when calling this
  //! routine. Geom Package will insure that.
  //! and then multiplies by the weights
  //! this just evaluates the current point
  //! the CacheParameter is where the Cache was
  //! constructed the SpanLength is to normalize
  //! the polynomial in the cache to avoid bad conditioning
  //! effects
  Standard_EXPORT static void CacheD1 (const Standard_Real U, const Standard_Integer Degree, const Standard_Real CacheParameter, const Standard_Real SpanLenght, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& Point, gp_Vec& Vec);
  
  //! Perform the evaluation of the Bspline Basis
  //! and then multiplies by the weights
  //! this just evaluates the current point
  //! the parameter must be normalized between
  //! the 0 and 1 for the span.
  //! The Cache must be valid when calling this
  //! routine. Geom Package will insure that.
  //! and then multiplies by the weights
  //! ththe CacheParameter is where the Cache was
  //! constructed the SpanLength is to normalize
  //! the polynomial in the cache to avoid bad conditioning
  //! effectsis just evaluates the current point
  Standard_EXPORT static void CacheD1 (const Standard_Real U, const Standard_Integer Degree, const Standard_Real CacheParameter, const Standard_Real SpanLenght, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& Point, gp_Vec2d& Vec);
  
  //! Calls CacheD1 for Bezier  Curves Arrays computed with
  //! the method PolesCoefficients.
  //! Warning: To be used for Beziercurves ONLY!!!
    static void CoefsD1 (const Standard_Real U, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& Point, gp_Vec& Vec);
  
  //! Calls CacheD1 for Bezier  Curves Arrays computed with
  //! the method PolesCoefficients.
  //! Warning: To be used for Beziercurves ONLY!!!
    static void CoefsD1 (const Standard_Real U, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& Point, gp_Vec2d& Vec);
  
  //! Perform the evaluation of the of the cache
  //! the parameter must be normalized between
  //! the 0 and 1 for the span.
  //! The Cache must be valid when calling this
  //! routine. Geom Package will insure that.
  //! and then multiplies by the weights
  //! this just evaluates the current point
  //! the CacheParameter is where the Cache was
  //! constructed the SpanLength is to normalize
  //! the polynomial in the cache to avoid bad conditioning
  //! effects
  Standard_EXPORT static void CacheD2 (const Standard_Real U, const Standard_Integer Degree, const Standard_Real CacheParameter, const Standard_Real SpanLenght, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& Point, gp_Vec& Vec1, gp_Vec& Vec2);
  
  //! Perform the evaluation of the Bspline Basis
  //! and then multiplies by the weights
  //! this just evaluates the current point
  //! the parameter must be normalized between
  //! the 0 and 1 for the span.
  //! The Cache must be valid when calling this
  //! routine. Geom Package will insure that.
  //! and then multiplies by the weights
  //! ththe CacheParameter is where the Cache was
  //! constructed the SpanLength is to normalize
  //! the polynomial in the cache to avoid bad conditioning
  //! effectsis just evaluates the current point
  Standard_EXPORT static void CacheD2 (const Standard_Real U, const Standard_Integer Degree, const Standard_Real CacheParameter, const Standard_Real SpanLenght, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& Point, gp_Vec2d& Vec1, gp_Vec2d& Vec2);
  
  //! Calls CacheD1 for Bezier  Curves Arrays computed with
  //! the method PolesCoefficients.
  //! Warning: To be used for Beziercurves ONLY!!!
    static void CoefsD2 (const Standard_Real U, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& Point, gp_Vec& Vec1, gp_Vec& Vec2);
  
  //! Calls CacheD1 for Bezier  Curves Arrays computed with
  //! the method PolesCoefficients.
  //! Warning: To be used for Beziercurves ONLY!!!
    static void CoefsD2 (const Standard_Real U, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& Point, gp_Vec2d& Vec1, gp_Vec2d& Vec2);
  
  //! Perform the evaluation of the of the cache
  //! the parameter must be normalized between
  //! the 0 and 1 for the span.
  //! The Cache must be valid when calling this
  //! routine. Geom Package will insure that.
  //! and then multiplies by the weights
  //! this just evaluates the current point
  //! the CacheParameter is where the Cache was
  //! constructed the SpanLength is to normalize
  //! the polynomial in the cache to avoid bad conditioning
  //! effects
  Standard_EXPORT static void CacheD3 (const Standard_Real U, const Standard_Integer Degree, const Standard_Real CacheParameter, const Standard_Real SpanLenght, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& Point, gp_Vec& Vec1, gp_Vec& Vec2, gp_Vec& Vec3);
  
  //! Perform the evaluation of the Bspline Basis
  //! and then multiplies by the weights
  //! this just evaluates the current point
  //! the parameter must be normalized between
  //! the 0 and 1 for the span.
  //! The Cache must be valid when calling this
  //! routine. Geom Package will insure that.
  //! and then multiplies by the weights
  //! ththe CacheParameter is where the Cache was
  //! constructed the SpanLength is to normalize
  //! the polynomial in the cache to avoid bad conditioning
  //! effectsis just evaluates the current point
  Standard_EXPORT static void CacheD3 (const Standard_Real U, const Standard_Integer Degree, const Standard_Real CacheParameter, const Standard_Real SpanLenght, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& Point, gp_Vec2d& Vec1, gp_Vec2d& Vec2, gp_Vec2d& Vec3);
  
  //! Calls CacheD1 for Bezier  Curves Arrays computed with
  //! the method PolesCoefficients.
  //! Warning: To be used for Beziercurves ONLY!!!
    static void CoefsD3 (const Standard_Real U, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt& Point, gp_Vec& Vec1, gp_Vec& Vec2, gp_Vec& Vec3);
  
  //! Calls CacheD1 for Bezier  Curves Arrays computed with
  //! the method PolesCoefficients.
  //! Warning: To be used for Beziercurves ONLY!!!
    static void CoefsD3 (const Standard_Real U, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, gp_Pnt2d& Point, gp_Vec2d& Vec1, gp_Vec2d& Vec2, gp_Vec2d& Vec3);
  
  //! Perform the evaluation of the Taylor expansion
  //! of the Bspline normalized between 0 and 1.
  //! If rational computes the homogeneous Taylor expension
  //! for the numerator and stores it in CachePoles
  Standard_EXPORT static void BuildCache (const Standard_Real U, const Standard_Real InverseOfSpanDomain, const Standard_Boolean PeriodicFlag, const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, TColgp_Array1OfPnt& CachePoles, TColStd_Array1OfReal* CacheWeights);
  
  //! Perform the evaluation of the Taylor expansion
  //! of the Bspline normalized between 0 and 1.
  //! If rational computes the homogeneous Taylor expension
  //! for the numerator and stores it in CachePoles
  Standard_EXPORT static void BuildCache (const Standard_Real U, const Standard_Real InverseOfSpanDomain, const Standard_Boolean PeriodicFlag, const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, TColgp_Array1OfPnt2d& CachePoles, TColStd_Array1OfReal* CacheWeights);
  
  //! Perform the evaluation of the Taylor expansion
  //! of the Bspline normalized between 0 and 1.
  //! Structure of result optimized for BSplCLib_Cache.
  Standard_EXPORT static void BuildCache (const Standard_Real theParameter, const Standard_Real theSpanDomain, const Standard_Boolean thePeriodicFlag, const Standard_Integer theDegree, const Standard_Integer theSpanIndex, const TColStd_Array1OfReal& theFlatKnots, const TColgp_Array1OfPnt& thePoles, const TColStd_Array1OfReal* theWeights, TColStd_Array2OfReal& theCacheArray);
  
  //! Perform the evaluation of the Taylor expansion
  //! of the Bspline normalized between 0 and 1.
  //! Structure of result optimized for BSplCLib_Cache.
  Standard_EXPORT static void BuildCache (const Standard_Real theParameter, const Standard_Real theSpanDomain, const Standard_Boolean thePeriodicFlag, const Standard_Integer theDegree, const Standard_Integer theSpanIndex, const TColStd_Array1OfReal& theFlatKnots, const TColgp_Array1OfPnt2d& thePoles, const TColStd_Array1OfReal* theWeights, TColStd_Array2OfReal& theCacheArray);
  
    static void PolesCoefficients (const TColgp_Array1OfPnt2d& Poles, TColgp_Array1OfPnt2d& CachePoles);
  
  Standard_EXPORT static void PolesCoefficients (const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, TColgp_Array1OfPnt2d& CachePoles, TColStd_Array1OfReal* CacheWeights);
  
    static void PolesCoefficients (const TColgp_Array1OfPnt& Poles, TColgp_Array1OfPnt& CachePoles);
  
  //! Encapsulation   of  BuildCache    to   perform   the
  //! evaluation  of the Taylor expansion for beziercurves
  //! at parameter 0.
  //! Warning: To be used for Beziercurves ONLY!!!
  Standard_EXPORT static void PolesCoefficients (const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, TColgp_Array1OfPnt& CachePoles, TColStd_Array1OfReal* CacheWeights);
  
  //! Returns pointer to statically allocated array representing
  //! flat knots for bezier curve of the specified degree.
  //! Raises OutOfRange if Degree > MaxDegree()
  Standard_EXPORT static const Standard_Real& FlatBezierKnots (const Standard_Integer Degree);
  
  //! builds the Schoenberg points from the flat knot
  //! used to interpolate a BSpline since the
  //! BSpline matrix is invertible.
  Standard_EXPORT static void BuildSchoenbergPoints (const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, TColStd_Array1OfReal& Parameters);
  
  //! Performs the interpolation of  the data given in
  //! the Poles  array  according  to the  requests in
  //! ContactOrderArray    that is      :           if
  //! ContactOrderArray(i) has value  d it means  that
  //! Poles(i)   containes the dth  derivative of  the
  //! function to be interpolated. The length L of the
  //! following arrays must be the same :
  //! Parameters, ContactOrderArray, Poles,
  //! The length of FlatKnots is Degree + L + 1
  //! Warning:
  //! the method used to do that interpolation is
  //! gauss elimination WITHOUT pivoting. Thus if the
  //! diagonal is not dominant there is no guarantee
  //! that the algorithm will work. Nevertheless for
  //! Cubic interpolation or interpolation at Scheonberg
  //! points the method will work
  //! The InversionProblem will report 0 if there was no
  //! problem else it will give the index of the faulty
  //! pivot
  Standard_EXPORT static void Interpolate (const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColStd_Array1OfReal& Parameters, const TColStd_Array1OfInteger& ContactOrderArray, TColgp_Array1OfPnt& Poles, Standard_Integer& InversionProblem);
  
  //! Performs the interpolation of  the data given in
  //! the Poles  array  according  to the  requests in
  //! ContactOrderArray    that is      :           if
  //! ContactOrderArray(i) has value  d it means  that
  //! Poles(i)   containes the dth  derivative of  the
  //! function to be interpolated. The length L of the
  //! following arrays must be the same :
  //! Parameters, ContactOrderArray, Poles,
  //! The length of FlatKnots is Degree + L + 1
  //! Warning:
  //! the method used to do that interpolation is
  //! gauss elimination WITHOUT pivoting. Thus if the
  //! diagonal is not dominant there is no guarantee
  //! that the algorithm will work. Nevertheless for
  //! Cubic interpolation at knots or interpolation at Scheonberg
  //! points the method will work.
  //! The InversionProblem w
  //! ll report 0 if there was no
  //! problem else it will give the index of the faulty
  //! pivot
  Standard_EXPORT static void Interpolate (const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColStd_Array1OfReal& Parameters, const TColStd_Array1OfInteger& ContactOrderArray, TColgp_Array1OfPnt2d& Poles, Standard_Integer& InversionProblem);
  
  //! Performs the interpolation of  the data given in
  //! the Poles  array  according  to the  requests in
  //! ContactOrderArray    that is      :           if
  //! ContactOrderArray(i) has value  d it means  that
  //! Poles(i)   containes the dth  derivative of  the
  //! function to be interpolated. The length L of the
  //! following arrays must be the same :
  //! Parameters, ContactOrderArray, Poles,
  //! The length of FlatKnots is Degree + L + 1
  //! Warning:
  //! the method used to do that interpolation is
  //! gauss elimination WITHOUT pivoting. Thus if the
  //! diagonal is not dominant there is no guarantee
  //! that the algorithm will work. Nevertheless for
  //! Cubic interpolation at knots or interpolation at Scheonberg
  //! points the method will work.
  //! The InversionProblem will report 0 if there was no
  //! problem else it will give the index of the faulty
  //! pivot
  Standard_EXPORT static void Interpolate (const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColStd_Array1OfReal& Parameters, const TColStd_Array1OfInteger& ContactOrderArray, TColgp_Array1OfPnt& Poles, TColStd_Array1OfReal& Weights, Standard_Integer& InversionProblem);
  
  //! Performs the interpolation of  the data given in
  //! the Poles  array  according  to the  requests in
  //! ContactOrderArray    that is      :           if
  //! ContactOrderArray(i) has value  d it means  that
  //! Poles(i)   containes the dth  derivative of  the
  //! function to be interpolated. The length L of the
  //! following arrays must be the same :
  //! Parameters, ContactOrderArray, Poles,
  //! The length of FlatKnots is Degree + L + 1
  //! Warning:
  //! the method used to do that interpolation is
  //! gauss elimination WITHOUT pivoting. Thus if the
  //! diagonal is not dominant there is no guarantee
  //! that the algorithm will work. Nevertheless for
  //! Cubic interpolation at knots or interpolation at Scheonberg
  //! points the method will work.
  //! The InversionProblem w
  //! ll report 0 if there was no
  //! problem else it will give the i
  Standard_EXPORT static void Interpolate (const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColStd_Array1OfReal& Parameters, const TColStd_Array1OfInteger& ContactOrderArray, TColgp_Array1OfPnt2d& Poles, TColStd_Array1OfReal& Weights, Standard_Integer& InversionProblem);
  
  //! Performs the interpolation of  the data given in
  //! the Poles  array  according  to the  requests in
  //! ContactOrderArray    that is      :           if
  //! ContactOrderArray(i) has value  d it means  that
  //! Poles(i)   containes the dth  derivative of  the
  //! function to be interpolated. The length L of the
  //! following arrays must be the same :
  //! Parameters, ContactOrderArray
  //! The length of FlatKnots is Degree + L + 1
  //! The  PolesArray   is    an   seen   as    an
  //! Array[1..N][1..ArrayDimension] with N = tge length
  //! of the parameters array
  //! Warning:
  //! the method used to do that interpolation is
  //! gauss elimination WITHOUT pivoting. Thus if the
  //! diagonal is not dominant there is no guarantee
  //! that the algorithm will work. Nevertheless for
  //! Cubic interpolation or interpolation at Scheonberg
  //! points the method will work
  //! The InversionProblem will report 0 if there was no
  //! problem else it will give the index of the faulty
  //! pivot
  Standard_EXPORT static void Interpolate (const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColStd_Array1OfReal& Parameters, const TColStd_Array1OfInteger& ContactOrderArray, const Standard_Integer ArrayDimension, Standard_Real& Poles, Standard_Integer& InversionProblem);
  
  Standard_EXPORT static void Interpolate (const Standard_Integer Degree, const TColStd_Array1OfReal& FlatKnots, const TColStd_Array1OfReal& Parameters, const TColStd_Array1OfInteger& ContactOrderArray, const Standard_Integer ArrayDimension, Standard_Real& Poles, Standard_Real& Weights, Standard_Integer& InversionProblem);
  
  //! Find the new poles which allows  an old point (with a
  //! given  u as parameter) to reach a new position
  //! Index1 and Index2 indicate the range of poles we can move
  //! (1, NbPoles-1) or (2, NbPoles) -> no constraint for one side
  //! don't enter (1,NbPoles) -> error: rigid move
  //! (2, NbPoles-1) -> the ends are enforced
  //! (3, NbPoles-2) -> the ends and the tangency are enforced
  //! if Problem in BSplineBasis calculation, no change for the curve
  //! and FirstIndex, LastIndex = 0
  Standard_EXPORT static void MovePoint (const Standard_Real U, const gp_Vec2d& Displ, const Standard_Integer Index1, const Standard_Integer Index2, const Standard_Integer Degree, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& FlatKnots, Standard_Integer& FirstIndex, Standard_Integer& LastIndex, TColgp_Array1OfPnt2d& NewPoles);
  
  //! Find the new poles which allows  an old point (with a
  //! given  u as parameter) to reach a new position
  //! Index1 and Index2 indicate the range of poles we can move
  //! (1, NbPoles-1) or (2, NbPoles) -> no constraint for one side
  //! don't enter (1,NbPoles) -> error: rigid move
  //! (2, NbPoles-1) -> the ends are enforced
  //! (3, NbPoles-2) -> the ends and the tangency are enforced
  //! if Problem in BSplineBasis calculation, no change for the curve
  //! and FirstIndex, LastIndex = 0
  Standard_EXPORT static void MovePoint (const Standard_Real U, const gp_Vec& Displ, const Standard_Integer Index1, const Standard_Integer Index2, const Standard_Integer Degree, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& FlatKnots, Standard_Integer& FirstIndex, Standard_Integer& LastIndex, TColgp_Array1OfPnt& NewPoles);
  
  //! This is the dimension free version of the utility
  //! U is the parameter  must be within the  first FlatKnots and the
  //! last FlatKnots  Delta is the amount the  curve has  to be moved
  //! DeltaDerivative is the  amount the derivative  has to be moved.
  //! Delta  and   DeltaDerivative   must be    array   of  dimension
  //! ArrayDimension  Degree  is the degree  of   the BSpline and the
  //! FlatKnots are the knots of the BSpline  Starting Condition if =
  //! -1 means the starting point of the curve can move
  //! = 0 means the
  //! starting  point  of the cuve  cannot  move but  tangen  starting
  //! point of the curve cannot move
  //! = 1 means the starting point and tangents cannot move
  //! = 2 means the starting point tangent and curvature cannot move
  //! = ...
  //! Same holds for EndingCondition
  //! Poles are the poles of the curve
  //! Weights are the weights of the curve if not NULL
  //! NewPoles are the poles of the deformed curve
  //! ErrorStatus will be 0 if no error happened
  //! 1 if there are not enough knots/poles
  //! the imposed conditions
  //! The way to solve this problem is to add knots to the BSpline
  //! If StartCondition = 1 and EndCondition = 1 then you need at least
  //! 4 + 2 = 6 poles so for example to have a C1 cubic you will need
  //! have at least 2 internal knots.
  Standard_EXPORT static void MovePointAndTangent (const Standard_Real U, const Standard_Integer ArrayDimension, Standard_Real& Delta, Standard_Real& DeltaDerivative, const Standard_Real Tolerance, const Standard_Integer Degree, const Standard_Integer StartingCondition, const Standard_Integer EndingCondition, Standard_Real& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& FlatKnots, Standard_Real& NewPoles, Standard_Integer& ErrorStatus);
  
  //! This is the dimension free version of the utility
  //! U is the parameter  must be within the  first FlatKnots and the
  //! last FlatKnots  Delta is the amount the  curve has  to be moved
  //! DeltaDerivative is the  amount the derivative  has to be moved.
  //! Delta  and   DeltaDerivative   must be    array   of  dimension
  //! ArrayDimension  Degree  is the degree  of   the BSpline and the
  //! FlatKnots are the knots of the BSpline  Starting Condition if =
  //! -1 means the starting point of the curve can move
  //! = 0 means the
  //! starting  point  of the cuve  cannot  move but  tangen  starting
  //! point of the curve cannot move
  //! = 1 means the starting point and tangents cannot move
  //! = 2 means the starting point tangent and curvature cannot move
  //! = ...
  //! Same holds for EndingCondition
  //! Poles are the poles of the curve
  //! Weights are the weights of the curve if not NULL
  //! NewPoles are the poles of the deformed curve
  //! ErrorStatus will be 0 if no error happened
  //! 1 if there are not enough knots/poles
  //! the imposed conditions
  //! The way to solve this problem is to add knots to the BSpline
  //! If StartCondition = 1 and EndCondition = 1 then you need at least
  //! 4 + 2 = 6 poles so for example to have a C1 cubic you will need
  //! have at least 2 internal knots.
  Standard_EXPORT static void MovePointAndTangent (const Standard_Real U, const gp_Vec& Delta, const gp_Vec& DeltaDerivative, const Standard_Real Tolerance, const Standard_Integer Degree, const Standard_Integer StartingCondition, const Standard_Integer EndingCondition, const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& FlatKnots, TColgp_Array1OfPnt& NewPoles, Standard_Integer& ErrorStatus);
  
  //! This is the dimension free version of the utility
  //! U is the parameter  must be within the  first FlatKnots and the
  //! last FlatKnots  Delta is the amount the  curve has  to be moved
  //! DeltaDerivative is the  amount the derivative  has to be moved.
  //! Delta  and   DeltaDerivative   must be    array   of  dimension
  //! ArrayDimension  Degree  is the degree  of   the BSpline and the
  //! FlatKnots are the knots of the BSpline  Starting Condition if =
  //! -1 means the starting point of the curve can move
  //! = 0 means the
  //! starting  point  of the cuve  cannot  move but  tangen  starting
  //! point of the curve cannot move
  //! = 1 means the starting point and tangents cannot move
  //! = 2 means the starting point tangent and curvature cannot move
  //! = ...
  //! Same holds for EndingCondition
  //! Poles are the poles of the curve
  //! Weights are the weights of the curve if not NULL
  //! NewPoles are the poles of the deformed curve
  //! ErrorStatus will be 0 if no error happened
  //! 1 if there are not enough knots/poles
  //! the imposed conditions
  //! The way to solve this problem is to add knots to the BSpline
  //! If StartCondition = 1 and EndCondition = 1 then you need at least
  //! 4 + 2 = 6 poles so for example to have a C1 cubic you will need
  //! have at least 2 internal knots.
  Standard_EXPORT static void MovePointAndTangent (const Standard_Real U, const gp_Vec2d& Delta, const gp_Vec2d& DeltaDerivative, const Standard_Real Tolerance, const Standard_Integer Degree, const Standard_Integer StartingCondition, const Standard_Integer EndingCondition, const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& FlatKnots, TColgp_Array1OfPnt2d& NewPoles, Standard_Integer& ErrorStatus);
  

  //! given a tolerance in 3D space returns a
  //! tolerance    in U parameter space such that
  //! all u1 and u0 in the domain of the curve f(u)
  //! | u1 - u0 | < UTolerance and
  //! we have |f (u1) - f (u0)| < Tolerance3D
  Standard_EXPORT static void Resolution (Standard_Real& PolesArray, const Standard_Integer ArrayDimension, const Standard_Integer NumPoles, const TColStd_Array1OfReal* Weights, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer Degree, const Standard_Real Tolerance3D, Standard_Real& UTolerance);
  

  //! given a tolerance in 3D space returns a
  //! tolerance    in U parameter space such that
  //! all u1 and u0 in the domain of the curve f(u)
  //! | u1 - u0 | < UTolerance and
  //! we have |f (u1) - f (u0)| < Tolerance3D
  Standard_EXPORT static void Resolution (const TColgp_Array1OfPnt& Poles, const TColStd_Array1OfReal* Weights, const Standard_Integer NumPoles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer Degree, const Standard_Real Tolerance3D, Standard_Real& UTolerance);
  

  //! given a tolerance in 3D space returns a
  //! tolerance    in U parameter space such that
  //! all u1 and u0 in the domain of the curve f(u)
  //! | u1 - u0 | < UTolerance and
  //! we have |f (u1) - f (u0)| < Tolerance3D
  Standard_EXPORT static void Resolution (const TColgp_Array1OfPnt2d& Poles, const TColStd_Array1OfReal* Weights, const Standard_Integer NumPoles, const TColStd_Array1OfReal& FlatKnots, const Standard_Integer Degree, const Standard_Real Tolerance3D, Standard_Real& UTolerance);




protected:





private:

  
  Standard_EXPORT static void LocateParameter (const TColStd_Array1OfReal& Knots, const Standard_Real U, const Standard_Boolean Periodic, const Standard_Integer K1, const Standard_Integer K2, Standard_Integer& Index, Standard_Real& NewU, const Standard_Real Uf, const Standard_Real Ue);




};


#include <BSplCLib.lxx>





#endif // _BSplCLib_HeaderFile