Re: Saturated Math

["Randy Brukardt" <randy@rrsoftware.com>]

Marin David Condic wrote in message <3ED7437E.5060607@noplace.com>...
>Note that you'd also have some problems with assignment because Ada
>doesn't provide a means of overriding it. This is also the area where
>saturation would be the *most* useful.
>
>Consider that I want to compute some position for an actuator. I don't
>really care if the computation itself is done with infinite precision.
>What I care about is the *result* being limited to within the bounds of
>the actuator. So what I need is saturation on assignment and it would
>also be handy to be able to easily mix it with constants and other
>compatible types. We've done it with home-brewed packages, but it just
>seems to be more clumsy than if it were just a feature of the language.


I think that's rather different than what others have been talking
about. Saturation on operations is easy to implement cleanly, assignment
much less so. But Ada does have a way to override assignment, so that's
doable with a carefully crafted package. The question would be whether
the overhead was essessive. That of course would depend on the
implementation and on the number of objects of this type that was
declared.

     private with Ada.Finalization;
     generic
          type Literal_Type is range <>; -- Use for literals, defines
range of type.
     package Marins_Saturated_Math is
          type Saturated_Type is private;

          -- Operations:
          function "+" (Right : Saturated_Type) return Saturated_Type;
          function "-" (Right : Saturated_Type) return Saturated_Type;
          function "+" (Left, Right : Saturated_Type) return
Saturated_Type;
          ... -- Rest of the binary operations here.

          -- Operations to give literals:
          function "+" (Right : Literal_Type) return Saturated_Type;
          function "-" (Right : Literal_Type) return Saturated_Type;
          function "+" (Left : Saturated_Type; Right : Literal_Type)
return Saturated_Type;
          ... -- Rest of the binary operations here.

    private
          type Saturated_Type is new Ada.Finalization.Controlled with
record
                 Value : Literal_Type'Base; -- May exceed the range, but
is forced back on assignment.
          end record;
          procedure Adjust (Object : in out Saturated_Type);
          -- Initialize, Finalize not needed.
    end Marins_Saturated_Math;

And the implementation of Adjust would look like:

     procedure Adjust (Object : in out Saturated_Type) is
     begin
          if Object.Value > Literal_Type'Last then
                Object.Value := Literal_Type'Last;
         elsif Object.Value < Literal_Type'First then
                Object.Value := Literal_Type'First;
         end if;
     end Adjust;

Writing this package would be a pain, but it only has to be done once.

Also note that since this type doesn't override Finalize, a compiler
could eliminate all of the overhead of a controlled type. I don't think
that any compilers currently do that, but it is the sort of optimization
that compiler vendors do add for good customers. (The Adjust to call is
always known at compile-time, as long as 'Class is never used, which it
won't be for this type.)

                   Randy.