File : torus_ops.ads

with Ada.Text_IO, Reps, Fouriers_Init, Lin;
use Ada.Text_IO, Reps, Fouriers_Init, Lin;
with Fouriers, Fouriers.Ops, Fouriers.IO;
with Taylors, Taylors.Ops;

pragma Elaborate_All (Ada.Text_IO, Taylors.Ops, Fouriers.Ops, Fouriers.IO);

generic

  Lmax, Wmax, Pdeg: in Positive;
  Dho: in Natural;
  Sigma, Kappa: Rep;
  type Scalar is private;

  with function IsNumeric(S: Scalar) return Boolean is <>;
  with function Scal(K: Integer) return Scalar is <>;
  with function Scal(R: Rep) return Scalar is <>;
  with function Ball(R: Rep) return Scalar is <>;
  with function Ball(S: Scalar) return Scalar is <>;
  with function Err0(S: Scalar) return Boolean is <>;
  with function "<"(S1,S2: Scalar) return Boolean is <>;
  with function IntFloor(S: Scalar) return Integer is <>;
  with function IntCeiling(S: Scalar) return Integer is <>;
  with function Approx(S: Scalar) return Rep is <>;
  with function Inf(S: Scalar) return Rep is <>;
  with function Sup(S: Scalar) return Rep is <>;
  with function SupAbs(S: Scalar) return Rep is <>;
  with function "abs"(S: Scalar) return Scalar is <>;
  with function Min(S1,S2: Scalar) return Scalar is <>;
  with function Max(S1,S2: Scalar) return Scalar is <>;
  with function Cap(R: Radius; S: Scalar) return Scalar is <>;
  with function "-"(S: Scalar) return Scalar is <>;

  with function Center(S: Scalar) return Scalar is <>;
  with function Widen(S: Scalar) return Scalar is <>;
  with procedure ResetCenter(S: in out Scalar) is <>;
  with function ResetCenter(S: Scalar) return Scalar is <>;
  with procedure Split(S: in Scalar; S0,SE: out Scalar) is <>;
  with procedure ErrMult(R: in Rep; S: in out Scalar) is <>;
  with function "+"(S,T: Scalar) return Scalar is <>;
  with function "-"(S,T: Scalar) return Scalar is <>;
  with function "*"(R: Rep; S: Scalar) return Scalar is <>;
  with function "/"(S: Scalar; R: Rep) return Scalar is <>;
  with function Sqr(S: Scalar) return Scalar is <>;
  with function "*"(S,T: Scalar) return Scalar is <>;
  with function Inv(S: Scalar) return Scalar is <>;
  with function "/"(S,T: Scalar) return Scalar is <>;
  with function "**"(S: Scalar; I: Integer) return Scalar is <>;

  with function Cosh(S: Scalar) return Scalar is <>;
  with function Sinh(S: Scalar) return Scalar is <>;
  with function Exp(S: Scalar) return Scalar is <>;
  with function Log(S: Scalar) return Scalar is <>;
  with function Lambda(M,N: Integer) return Scalar is <>;

  with procedure Show(S: in Scalar; NewLine: in Boolean := True) is <>;
  with procedure Get(F: in File_Type; S: out Scalar; Decimal: in Boolean := True) is <>;
  with procedure Put(F: in File_Type; S: in Scalar; Decimal: in Boolean := True) is <>;

package Torus_Ops is

  ScalZero: constant Scalar := Scal(Zero);
  ScalOne:  constant Scalar := Scal(One);
  Theta:    constant Scalar := Lambda(1,-1);
  InvTheta: constant Scalar := Lambda(0,-1);

  package Scal_Fou is new Fouriers (Lmax => Lmax, Wmax => Wmax, Pdeg => Pdeg, Dho => Dho, Scalar => Scalar);
  package Scal_Fou_Ops is new Scal_Fou.Ops;
  package Scal_Fou_IO is new Scal_Fou.IO;
  package Scal_Tay  renames Scal_Fou.Components;
  package Scal_Tay_Ops renames Scal_Fou_Ops.Components_Ops;

  use Scal_Fou, Scal_Fou_Ops, Scal_Fou_IO, Scal_Tay, Scal_Tay_Ops;

  type Canonical is
    record
      Q: Fourier;  -- odd
      P: Fourier;  -- even
    end record;

  type Torus is
    record
      Q: Sobolev;  -- odd
      P: Sobolev;  -- even
    end record;

  procedure ShowParam;                                              -- Does what is sais
  procedure Show(U: in Canonical; Cut: in Rep := Zero);             -- Show coeffs of U  (of modulus>Cut)
  procedure Read(Name: in String; R: in Weights; U: out Canonical;
                 Decimal: in Boolean := True);                      -- Read U from file Name
  procedure Write(Name: in String;
                  U: in Canonical; Decimal: in Boolean := True);    -- Write U to file Name
  procedure Show(T: in Torus; Cut: in Rep := Zero);                 -- Show coeffs of T  (of modulus>Cut)
  procedure Read(Name: in String; R: in Radius; T: out Torus;
                 Decimal: in Boolean := True);                      -- Read T from file Name
  procedure Write(Name: in String;
                  T: in Torus; Decimal: in Boolean := True);        -- Write T to file Name

  function Rho(T: Torus) return Radius;                             -- Radius defining domain of T
  function Rho(U: Canonical) return Weights;                        -- Weights defining domain of U
  procedure SetZero(R: in Radius; T: out Torus);                    -- T := 0
  function "-"(T1,T2: Torus) return Torus;                          -- Return T1-T2
  function Norm(R,B: Radius; T: Torus) return Scalar;               -- ||T||_R

  function NormDer(R: Weights; B: Radius; U: Canonical) return Scalar; -- |DU|_R
  function Val(Z: Scalar; U: Canonical) return Scalar;              -- Z component of U(0,Z)
  function DerVal3(Z: Scalar; U: Canonical) return Scalar;          -- Z component of D_z U(0,Z)
  function ValQ0(U: Canonical) return Taylor;                       -- Z component of U(0,.)
  procedure TmuComp(Mu: in Scalar; U1: in Canonical; U2: out Canonical); -- U2 := T_mu o U1
  procedure Comp(U1,U2: in Canonical; U3: out Canonical);           -- U3 := U1 o U2
  procedure Comp(U: in Canonical; T1: in Torus; T2: out Torus);     -- T2 := U o T1

  procedure TmuComp(Mu: in Scalar; T1: in Torus; T2: out Torus);    -- T2 := T_mu o T1
  procedure TmuComp(Mu: in Scalar; T: in out Torus);                -- T := T_mu o T
  procedure CompTinv(T1: in Torus; T2: out Torus);                  -- T2 := T1 o T^{-1}

  procedure NN(Mu: in Scalar; U: in Canonical;
               T1: in Torus; T2: out Torus);                        -- Contraction NN

private

  Trunc: constant Boolean := IsNumeric(ScalZero);

end Torus_Ops;