Re: project euler 26

[Ben Bacarisse <ben.usenet@bsb.me.uk>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On 2023-09-06 17:16, Ben Bacarisse wrote:
>
>> I am curious to know how reusable this is.  Can the packages be
>> instantiated in such a way that the argument ranges over the elements
>> of, say, and Ordered_Map?
>
> Sure:
>
>    with Ada.Containers.Ordered_Maps;
>
>    package Integer_Maps is
>       new Ada.Containers.Ordered_Maps (Integer, Integer);
>    use Integer_Maps;
>    package Cursor_Arguments is new Generic_Arguments (Cursor);

Ah!  So the arguments correspond to the "with" functions in the order
listed, and, since Cursor already has Next, there no need to specify
anything.  One could (I've just tried) use => notation.  You could have
written

  package Arguments is new Generic_Arguments (Next => Positive'Succ,
                                             Argument_Type => Positive);

in your first example -- swapping the order just to make the point
obvious.  This tripped me up when I was playing around with a Cursors
solution.

There are a couple of details that prevent your Maximum_At function from
working properly in this case though.  First, we can't have an empty
map, because X.Last can't be compared with X.First when either is
No_Element, so the test for Right < Left fails before the desired error
can be raised.

Second, if I try to use a Vector rather than an Ordered_Map, I am told
that:

test2.adb:97:05: error: instantiation error at line 12
test2.adb:97:05: error: no visible subprogram matches the specification for "<"

It would seem that vector cursors can't be compared using < (at least by
default).  Maybe the installation needs more arguments.

Anyway, I am still not sure how to write a generic test for an empty
range.

>    package Map_Values is new Generic_Values (Integer);
>    package Map_Functions is
>       new Generic_Discrete_Comparable_Valued
>           (Cursor_Arguments, Map_Values);
>
> Then given X is a map: X : Map;
>
>    Map_Functions.Maximum_At (X.First, X.Last, Element'Access)

It's possible I was not clear about what I was aiming for.  I was hoping
to be able to find the maximum of some arbitrary function, taking the
function's arguments from any sequential collection.  Either a simple
range of values, an array or vector of values, a list of values or even
an ordered map of values -- any ordered list of values.

The bottom line is the last argument should be something very general
like the Period function.

A fix (though it's not really ideal) would be to use function
composition here (inventing . as the composition operator):

  Map_Functions.Maximum_At (X.First, X.Last, Period'Access . Element'Access)

but I don't think Ada has a function composition operator, does it?

Another solution would be to write Maximum_At so that it knows it has a
cursor argument, but then I don't think it would work for native arrays,
would it?  And we'd loose plain ranges altogether.

>> Maybe a more generic a solution would involve passing something that can
>> be iterated over, rather than two values of an "enumerated" type?  I
>> mean enumerated in the mathematical sense -- it may be the wrong word in
>> Ada.
>
> Yes, but Ada does not have built-in range types. Therefore such design will
> not work out of the box with discrete types because 2..999 is not a proper
> object in Ada. However, talking about abstractions, you can create an
> interval type for the purpose or else use an ordered set of integers.

But then (I think) the only function one could pass would be something
like Element as in you example above.  Using an ordered set of integers
would not allow

  Map_Functions.Maximum_At (Set.First, Set.Last, Period'Access)

would it?

>> I am asking you but I am also the group.  I appreciate your help,
>> but don't want you to feel any obligation to keep helping!
>
> No problem.

You seem to be on your own as far as helping out is concerned!

-- 
Ben.