FUNCTION derive_definite_integral_domain

(* SCHEMA FUNCTIONAL_DATA_AND_SCHEMATIC_REPRESENTATION_MIM_LF; *)

(* R.Bodington - not valid express ed1
FUNCTION dependently_instantiated(set_of_input_instances : SET OF GENERIC; 
  set_of_input_types : SET OF STRING; previous_in_chain : LIST OF GENERIC) : 
  BOOLEAN;
   (* generated by longform-generator *)
LOCAL
  number_of_input_instances : INTEGER;
  number_of_referring_instances : INTEGER;
  bag_of_referring_instances :  BAG  OF GENERIC := [];
  dependently_instantiated_flag : BOOLEAN;
  previous_in_chain_plus : LIST OF GENERIC := [];
  recursion : BOOLEAN;
  result : BOOLEAN := TRUE;
  set_of_types : SET OF STRING := [];
END_LOCAL;
  IF EXISTS(set_of_input_instances) THEN
    number_of_input_instances := SIZEOF(set_of_input_instances);
    set_of_input_types := set_of_input_types + 'GENERIC';
    REPEAT i := 1 TO number_of_input_instances;
      bag_of_referring_instances := USEDIN(set_of_input_instances[i], '');
      IF EXISTS(bag_of_referring_instances) THEN
        number_of_referring_instances := SIZEOF(bag_of_referring_instances);
        dependently_instantiated_flag := FALSE;
        REPEAT j := 1 TO number_of_referring_instances;
          set_of_types := TYPEOF(bag_of_referring_instances[j]);
          IF set_of_types <= set_of_input_types THEN
            IF EXISTS(previous_in_chain) THEN
              recursion := TRUE;
              REPEAT k := 1 TO SIZEOF(previous_in_chain);
                IF previous_in_chain[k] :=: bag_of_referring_instances[j] THEN
                  recursion := FALSE;
                  ESCAPE;
                END_IF;
              END_REPEAT;
            END_IF;
            IF recursion THEN
              previous_in_chain_plus := previous_in_chain + 
              set_of_input_instances[i];
              IF dependently_instantiated([bag_of_referring_instances[j]], 
              set_of_input_types, previous_in_chain_plus) THEN
                dependently_instantiated_flag := TRUE;
                ESCAPE;
              ELSE
                SKIP;
              END_IF;
            END_IF;
          ELSE
            dependently_instantiated_flag := TRUE;
            ESCAPE;
          END_IF;
        END_REPEAT;
        IF NOT dependently_instantiated_flag THEN
          RETURN (FALSE);
        END_IF;
      ELSE
        RETURN (FALSE);
      END_IF;
    END_REPEAT;
  ELSE
    RETURN (FALSE);
  END_IF;
  RETURN (TRUE);
END_FUNCTION; *)
 
FUNCTION derive_definite_integral_domain(igrl : definite_integral_function) : 
  tuple_space;
   
  FUNCTION process_product_space(spc : product_space; idx : INTEGER; prefix : 
    INTEGER; vdomn : maths_space) : product_space;
  LOCAL
    uspc : uniform_product_space;
    expnt : INTEGER;
    factors : LIST OF maths_space;
  END_LOCAL;
    IF schema_prefix + 'UNIFORM_PRODUCT_SPACE' IN TYPEOF(spc) THEN
      uspc := spc;
      expnt := uspc.exponent + prefix;
      IF idx <= uspc.exponent THEN
        expnt := expnt - 1;
      END_IF;
      IF expnt = 0 THEN
        RETURN (make_listed_product_space([]));
      ELSE
        RETURN (make_uniform_product_space(uspc.base, expnt));
      END_IF;
    ELSE
      factors := spc\listed_product_space.factors;
      IF idx <= SIZEOF(factors) THEN
        REMOVE(factors, idx);
      END_IF;
      IF prefix > 0 THEN
        INSERT(factors, vdomn, 0);
        IF prefix > 1 THEN
          INSERT(factors, vdomn, 0);
        END_IF;
      END_IF;
      RETURN (make_listed_product_space(factors));
    END_IF;
  END_FUNCTION;
LOCAL
  idomn : tuple_space := igrl.integrand.domain;
  types : SET OF STRING := TYPEOF(idomn);
  idx : INTEGER := igrl.variable_of_integration;
  tupled : BOOLEAN := bool((space_dimension(idomn) = 1) AND (schema_prefix + 
  'TUPLE_SPACE' IN types));
  prefix : INTEGER := 0;
  espc : extended_tuple_space;
  vdomn : maths_space;
END_LOCAL;
  IF tupled THEN
    idomn := factor1(idomn);
    types := TYPEOF(idomn);
  END_IF;
  IF igrl.lower_limit_neg_infinity THEN
    prefix := prefix + 1;
  END_IF;
  IF igrl.upper_limit_pos_infinity THEN
    prefix := prefix + 1;
  END_IF;
  vdomn := factor_space(idomn, idx);
  IF schema_prefix + 'EXTENDED_TUPLE_SPACE' IN types THEN
    espc := idomn;
    idomn := make_extended_tuple_space(process_product_space(espc.base, idx, 
    prefix, vdomn), espc.extender);
  ELSE
    idomn := process_product_space(idomn, idx, prefix, vdomn);
  END_IF;
  IF tupled THEN
    RETURN (one_tuples_of(idomn));
  ELSE
    RETURN (idomn);
  END_IF;
END_FUNCTION;

Referenced By

Generated by STEP Tools® EXPRESS to HTML Converter
2012-03-27T17:17:33-04:00