-- This package provides functions that indicate constraints on
-- complex functions. The three categories of constraints are:
--
-- ON_BRANCH_CUT_<function> indicating the actual parameter is on a
-- the functions branch cut or singularity by returning TRUE.
--
-- IN_PRINCIPAL_DOMAIN_<function> indicationg the actual parameter is
-- in the principal domain by returning TRUE.
--
-- IN_DEFINED_RANGE_<function> indicating the actual parameter is in
-- the defined range of the function by returning TRUE.
--
-- All functions return BOOLEAN results of TRUE or FALSE.
-- Only functions having a particular constraint are listed.

-- instantiate after instantiation and use clause on GENERIC_COMPLEX_TYPES

generic
  type FLOAT_TYPE is digits <>;
  type COMPLEX is private;
  with function RE( Z : COMPLEX) return FLOAT_TYPE is <>;
  with function IM( Z : COMPLEX) return FLOAT_TYPE is <>; 
package GENERIC_COMPLEX_CONSTRAINTS is

  function ON_BRANCH_CUT_SQRT( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_LOG( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_COT( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_ARCSIN( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_ARCCOS( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_ARCTAN( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_ARCCOT( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_COTH( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_ARCSINH( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_ARCCOSH( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_ARCTANH( Z: COMPLEX ) return BOOLEAN;
  function ON_BRANCH_CUT_ARCCOTH( Z: COMPLEX ) return BOOLEAN;

  function IN_PRINCIPAL_DOMAIN_EXP( Z: COMPLEX ) return BOOLEAN;
  function IN_PRINCIPAL_DOMAIN_SIN( Z: COMPLEX ) return BOOLEAN;
  function IN_PRINCIPAL_DOMAIN_COS( Z: COMPLEX ) return BOOLEAN;
  function IN_PRINCIPAL_DOMAIN_TAN( Z: COMPLEX ) return BOOLEAN;
  function IN_PRINCIPAL_DOMAIN_COT( Z: COMPLEX ) return BOOLEAN;
  function IN_PRINCIPAL_DOMAIN_SINH( Z: COMPLEX ) return BOOLEAN;
  function IN_PRINCIPAL_DOMAIN_COSH( Z: COMPLEX ) return BOOLEAN;
  function IN_PRINCIPAL_DOMAIN_TANH( Z: COMPLEX ) return BOOLEAN;
  function IN_PRINCIPAL_DOMAIN_COTH( Z: COMPLEX ) return BOOLEAN;

  function IN_DEFINED_RANGE_SQRT( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_LOG( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_ARCSIN( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_ARCCOS( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_ARCTAN( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_ARCCOT( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_ARCSINH( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_ARCCOSH( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_ARCTANH( Z: COMPLEX ) return BOOLEAN;
  function IN_DEFINED_RANGE_ARCCOTH( Z: COMPLEX ) return BOOLEAN;

end GENERIC_COMPLEX_CONSTRAINTS;

package body GENERIC_COMPLEX_CONSTRAINTS is

  PI : constant := 3.14159_26535_89793_23846_26433_83279_50288_41971 ;
  PI_2 : constant := PI/2.0;

  function ON_BRANCH_CUT_SQRT( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- negative real axis
    if REZ<0.0 and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_SQRT;

  function ON_BRANCH_CUT_LOG( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- negative real axis
    if REZ<=0.0 and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_LOG;

  function ON_BRANCH_CUT_COT( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- origin
    if REZ=0.0 and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_COT;

  function ON_BRANCH_CUT_ARCSIN( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- real axis not in [-1.0, 1.0]
    if (REZ<-1.0 or REZ>1.0) and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_ARCSIN;

  function ON_BRANCH_CUT_ARCCOS( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- real axis not in [-1.0, 1.0]
    if (REZ<-1.0 or REZ>1.0) and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_ARCCOS;

  function ON_BRANCH_CUT_ARCTAN( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- imaginary axis not in [-i, i]
    if REZ=0.0 and (IMZ<=-1.0 or IMZ>=1.0) then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_ARCTAN;

  function ON_BRANCH_CUT_ARCCOT( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- imaginary axis in [-i, i]
    if REZ=0.0 and (IMZ>=-1.0 and IMZ<1.0) then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_ARCCOT;

  function ON_BRANCH_CUT_COTH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- origin
    if REZ=0.0 and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_COTH;

  function ON_BRANCH_CUT_ARCSINH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- imaginary axis not in [-i, i]
    if REZ=0.0 and (IMZ<-1.0 or IMZ>1.0) then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_ARCSINH;

  function ON_BRANCH_CUT_ARCCOSH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- real axis less than 1.0
    if REZ<1.0 and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_ARCCOSH;

  function ON_BRANCH_CUT_ARCTANH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- real axis not in [-1.0, 1.0]
    if (REZ<=-1.0 or REZ>=1.0) and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_ARCTANH;

  function ON_BRANCH_CUT_ARCCOTH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- real axis in [-1.0, 1.0]
    if (REZ>=-1.0 and REZ<=1.0) and IMZ=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end ON_BRANCH_CUT_ARCCOTH;

  function IN_PRINCIPAL_DOMAIN_EXP( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-i PI,i PI], periodic in i2PI
    if IMZ>=-PI and IMZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_EXP;

  function IN_PRINCIPAL_DOMAIN_SIN( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-P1/2, PI/2], periodic in 2PI
    if REZ>=PI_2 and REZ<=PI_2 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_SIN;

  function IN_PRINCIPAL_DOMAIN_COS( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [0, PI], periodic in 2PI
    if REZ>=0.0 and REZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_COS;

  function IN_PRINCIPAL_DOMAIN_TAN( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-PI/2, PI/2], periodic in 2PI
    if REZ>=PI_2 and REZ<=PI_2 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_TAN;

  function IN_PRINCIPAL_DOMAIN_COT( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [0, PI], periodic in 2PI
    if REZ>=0.0 and REZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_COT;

  function IN_PRINCIPAL_DOMAIN_SINH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-i PI/2, i PI/2], periodic in i 2PI
    if IMZ>=-PI_2 and IMZ<=PI_2 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_SINH;

  function IN_PRINCIPAL_DOMAIN_COSH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [0, i PI], periodic in i 2PI
    if IMZ>=0.0 and IMZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_COSH;

  function IN_PRINCIPAL_DOMAIN_TANH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-i PI/2, i PI/2], periodic in i 2PI
    if IMZ=-PI_2 and IMZ<=PI_2 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_TANH;

  function IN_PRINCIPAL_DOMAIN_COTH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [0, i PI], periodic in i 2PI
    if IMZ>=0.0 and IMZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_PRINCIPAL_DOMAIN_COTH;


  function IN_DEFINED_RANGE_SQRT( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- right half plane including imaginary axis
    if REZ>=0.0 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_SQRT;

  function IN_DEFINED_RANGE_LOG( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- imaginary part in [-PI,PI]
    if IMZ>=-PI and IMZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_LOG;

  function IN_DEFINED_RANGE_ARCSIN( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-PI/2, PI/2]
    if REZ>=-PI_2 and REZ<=PI_2 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_ARCSIN;

  function IN_DEFINED_RANGE_ARCCOS( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [0, PI]
    if REZ>=0.0 and REZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_ARCCOS;

  function IN_DEFINED_RANGE_ARCTAN( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-PI/2, PI/2]
    if REZ>=-PI_2 and REZ<=PI_2 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_ARCTAN;

  function IN_DEFINED_RANGE_ARCCOT( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [0, PI]
    if REZ>=0.0 and REZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_ARCCOT;


  function IN_DEFINED_RANGE_ARCSINH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-i PI/2, i PI/2]
    if IMZ>=-PI_2 and IMZ<=PI_2 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_ARCSINH;

  function IN_DEFINED_RANGE_ARCCOSH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [0, i PI]
    if IMZ>=0.0 and IMZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_ARCCOSH;

  function IN_DEFINED_RANGE_ARCTANH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [-i PI/2, i PI/2]
    if IMZ>=-PI_2 and IMZ<=PI_2 then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_ARCTANH;

  function IN_DEFINED_RANGE_ARCCOTH( Z: COMPLEX ) return BOOLEAN is
    REZ : FLOAT_TYPE := RE(Z);
    IMZ : FLOAT_TYPE := IM(Z);
  begin
    -- [0, i PI]
    if IMZ>=0.0 and IMZ<=PI then
      return TRUE;
    else
      return FALSE;
    end if;
  end IN_DEFINED_RANGE_ARCCOTH;

end GENERIC_COMPLEX_CONSTRAINTS;