ada calendar

ada calendar

[shoko]

hi
how can i add one week to clendar.time record using duration ?

Re: ada calendar

[Stephen Leake]

shoko2004@hotmail.com (shoko) writes:

> hi
> how can i add one week to clendar.time record using duration ?

with Ada.Calendar; use Ada.Calendar;
procedure One_Week
is
   One_Minute : constant Duration := 60.0;
   One_Hour   : constant Duration := 60 * One_Minute;
   One_Day    : constant Duration := 24 * One_Hour;
   One_Week   : constant Duration := 7 * One_Day;

   Now : Time := Clock;
begin
   Now := Now + One_Week;
end One_Week;

-- 
-- Stephe

Re: ada calendar

[tmoran]

> how can i add one week to clendar.time record using duration ?
Seems like the simplest way to add a week to T would be
for Day in 1 .. 7 loop
  T := T+24*60*60.0;
end loop;

Re: ada calendar

[Marius Amado Alves]

On Fri, 2003-12-05 at 22:55, tmoran@acm.org wrote:
> > how can i add one week to clendar.time record using duration ?
> Seems like the simplest way to add a week to T would be
> for Day in 1 .. 7 loop
>   T := T+24*60*60.0;
> end loop;

It's hard to be simple, uh?

T := T + 7 * 24 * 60 * 60.0

Re: ada calendar

[Nick Roberts]

Stephen Leake wrote:

>>how can i add one week to clendar.time record using duration ?
> 
> with Ada.Calendar; use Ada.Calendar;
> procedure One_Week
> is
>    One_Minute : constant Duration := 60.0;
>    One_Hour   : constant Duration := 60 * One_Minute;
>    One_Day    : constant Duration := 24 * One_Hour;
>    One_Week   : constant Duration := 7 * One_Day;
> 
>    Now : Time := Clock;
> begin
>    Now := Now + One_Week;
> end One_Week;

This may work on some implementations. If it fails, the compiler should 
issue a fatal error. In this case, Tom Moran's suggestion:

    One_Minute : constant Duration := 60.0;
    One_Hour   : constant Duration := 60 * One_Minute;
    One_Day    : constant Duration := 24 * One_Hour;

    Now : Time := Clock;
    begin
       for Day in 1 .. 7 loop
         Now := Now + One_Day;
       end loop;

ought to work. There is a proposal to add this functionality in the next 
revision of the language (AI-351).

-- 
Nick Roberts

Re: ada calendar

[tmoran]

> T := T + 7 * 24 * 60 * 60.0
"The implementation of type Duration shall allow representation of
time intervals (both positive and negative) up to at least 86400
seconds (one day);" ARM 9.6(27)  So "7 * 24 * 60 * 60.0" may or
may not work.

Re: ada calendar

[Marius Amado Alves]

On Sat, 2003-12-06 at 00:21, tmoran@acm.org wrote:
> > T := T + 7 * 24 * 60 * 60.0
> "The implementation of type Duration shall allow representation of
> time intervals (both positive and negative) up to at least 86400
> seconds (one day);" ARM 9.6(27)  So "7 * 24 * 60 * 60.0" may or
> may not work.

Sure, but T by definition is something that spans a week or more, so a
'proper' type is expected here *by design*, no?

(And I seem to remember there is a longer duration type somewhere in the
standard. Some Ada.Real_Time package or some such.)

ada calendar

[shoko]

tmoran@acm.org wrote in message news:<ci9Ab.34439$_M.151549@attbi_s54>...
> > T := T + 7 * 24 * 60 * 60.0
> "The implementation of type Duration shall allow representation of
> time intervals (both positive and negative) up to at least 86400
> seconds (one day);" ARM 9.6(27)  So "7 * 24 * 60 * 60.0" may or
> may not work.

thanks a lot
now if i have the following date:"27/06/2003"
and i want to insert him to a function that accept calendar.time
how do i do it

and how do i convert calendar.time to string?


thanks

Re: ada calendar

[David C. Hoos]

with Ada.Calendar;
.
.
.
use type Ada.Calendar.Time; -- visibility to + operator
for d in 1 ..7 loop
   T := T + Day_Duration'Last;
end loop;



"shoko" <shoko2004@hotmail.com> wrote in message
news:4948f537.0312051300.d246254@posting.google.com...
> hi
> how can i add one week to clendar.time record using duration ?

Re: ada calendar

[Marius Amado Alves]

On Sat, 2003-12-06 at 15:53, shoko wrote:
...
> now if i have the following date:"27/06/2003"
> and i want to insert him to a function that accept calendar.time
> how do i do it
...

You can do it with Ada.Calendar:

  Your_Function (Time_Of
    (Year_Number'Value (S (7 .. 10)),
     Month_Number'Value (S (4 .. 5)),
     Day_Number'Value (S (1 .. 2))));

where S is your string containing "27/06/2003" or similar.

Re: ada calendar

[Jeffrey Carter]

shoko wrote:

> now if i have the following date:"27/06/2003"
> and i want to insert him to a function that accept calendar.time
> how do i do it

You break it apart, convert the pieces to Integer (or an appropriate 
subtype of Integer defined in Ada.Calendar), and pass the values to 
Ada.Calendar.Time_Of.

> and how do i convert calendar.time to string?

You break it into values using Ada.Calendar.Split, convert the values to 
Strings, and concatenate the Strings together with your desired 
separators between them.

If you can use an existing package to achieve this, 
PragmARC.Date_Handler can produce almost any representation of a Time 
you can think of:

http://home.earthlink.net/~jrcarter010/pragmarc.htm

-- 
Jeff Carter
"Mr. President, we must not allow a mine-shaft gap!"
Dr. Strangelove
33

Re: ada calendar

[Duncan Sands]

On Sunday 07 December 2003 03:49, Jeffrey Carter wrote:
> shoko wrote:
> > now if i have the following date:"27/06/2003"
> > and i want to insert him to a function that accept calendar.time
> > how do i do it
>
> You break it apart, convert the pieces to Integer (or an appropriate
> subtype of Integer defined in Ada.Calendar), and pass the values to
> Ada.Calendar.Time_Of.
>
> > and how do i convert calendar.time to string?

GNAT comes with GNAT.Calendar.Time_IO.

Duncan.

Re: ada calendar

[Reinert Korsnes]

Nick Roberts wrote:

> Stephen Leake wrote:
> 
>>>how can i add one week to clendar.time record using duration ?
>> 
>> with Ada.Calendar; use Ada.Calendar;
>> procedure One_Week
>> is
>>    One_Minute : constant Duration := 60.0;
>>    One_Hour   : constant Duration := 60 * One_Minute;
>>    One_Day    : constant Duration := 24 * One_Hour;
>>    One_Week   : constant Duration := 7 * One_Day;
>> 
>>    Now : Time := Clock;
>> begin
>>    Now := Now + One_Week;
>> end One_Week;
> 
> This may work on some implementations. If it fails, the compiler should
> issue a fatal error. In this case, Tom Moran's suggestion:
> 
>     One_Minute : constant Duration := 60.0;
>     One_Hour   : constant Duration := 60 * One_Minute;
>     One_Day    : constant Duration := 24 * One_Hour;
> 
>     Now : Time := Clock;
>     begin
>        for Day in 1 .. 7 loop
>          Now := Now + One_Day;
>        end loop;
> 
> ought to work. There is a proposal to add this functionality in the next
> revision of the language (AI-351).
> 

Will this revision include definitions based on precise
description of movements of the Earth ?  The rotation
of the Earth is not so well defined and if one wants very
high precision - as one may want within some applications
of theoretical (geo-)physics/astronomy - then I guess such
calendar definitions cannot be implemented in a computer language ?

The "Ada calender" will be more like the "official/standard calendar" -
but this is subject to frequent modifications ?

Or does there exist a stable calendar standard which everybody agree on ? 

reinert

Re: ada calendar

[Pascal Obry]

Marius Amado Alves <amado.alves@netcabo.pt> writes:

> You can do it with Ada.Calendar:
> 
>   Your_Function (Time_Of
>     (Year_Number'Value (S (7 .. 10)),
>      Month_Number'Value (S (4 .. 5)),
>      Day_Number'Value (S (1 .. 2))));
> 
> where S is your string containing "27/06/2003" or similar.

There is no guarantee that S start to 1. It should be using S'First as
offset to compute all slices.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: ada calendar

[Nick Roberts]

Pascal Obry wrote:

> Marius Amado Alves <amado.alves@netcabo.pt> writes:
> 
>>You can do it with Ada.Calendar:
>>
>>  Your_Function (Time_Of
>>    (Year_Number'Value (S (7 .. 10)),
>>     Month_Number'Value (S (4 .. 5)),
>>     Day_Number'Value (S (1 .. 2))));
>>
>>where S is your string containing "27/06/2003" or similar.
> 
> There is no guarantee that S start to 1. It should be using S'First as
> offset to compute all slices.

True, but there's an alternative technique, and possibly a better one in 
this kind of case, using implicit array conversion:

    subtype Date_String is String(1..10);
    X: constant Date_String := S; -- checks length and slides if necessary
    ...
    if X(3) /= '/' or X(6) /= '/' then raise ...; end if;
    Your_Function( Time_Of( Year_Number'Value ( X(7..10) ),
                            Month_Number'Value( X(4..5)  ),
                            Day_Number'Value  ( X(1..2)  ) ) );

Obviously, if possible, it is desirable to declare S itself of a subtype 
such as Date_String.

This technique shows the person reading (reviewing) the code that X does 
indeed start at 1. If the declaration of Date_String is distant from the 
use of a variable of this subtype, you can always use an 'if' test (or 
pragma Assert, or a comment) to reiterate that the bounds are 1 and 10.

-- 
Nick Roberts

Re: ada calendar

[tmoran]

> Will this revision include definitions based on precise
> description of movements of the Earth ?  The rotation
   My understanding is that Ada.Calendar is basically a wall clock - it
can be reset by the operator for Daylight Savings, leap seconds, clock
skew, or whatever.  It's the right thing to use for printing a date & time
on a report, for instance.  Ada.Real_Time has a monotonic clock so it's
generally the right thing for elapsed time.  Inserting a leap second for
instance would cause the clock to run backwards one second, which would be
illegal for Ada.Real_Time.Clock, but perfectly OK for Ada.Calendar.Clock

Re: ada calendar

[Wes Groleau]

>>> You can do it with Ada.Calendar:
>>>
>>>  Your_Function (Time_Of
>>>    (Year_Number'Value (S (7 .. 10)),
>>>     Month_Number'Value (S (4 .. 5)),
>>>     Day_Number'Value (S (1 .. 2))));
>>>
>>> where S is your string containing "27/06/2003" or similar.
>>
>> There is no guarantee that S start to 1. It should be using S'First as
>> offset to compute all slices.
> 
> True, but there's an alternative technique, and possibly a better one in 
> this kind of case, using implicit array conversion:
> 
>    subtype Date_String is String(1..10);
>    X: constant Date_String := S; -- checks length and slides if necessary
>    ...
>    if X(3) /= '/' or X(6) /= '/' then raise ...; end if;

Or one could use predefined string operations
to split the string on '/' marks/

Or Index to find the '/' marks.

These would add robustness--leading zeroes and
extra spaces would be neither required nor would
they mess it up.

-- 
Wes Groleau
   "To know what you prefer, instead of humbly saying
    Amen to what the world tells you you should prefer,
    is to have kept your soul alive."
                          -- Robert Louis Stevenson

Re: ada calendar

[Nick Roberts]

tmoran@acm.org wrote:

>>Will this revision include definitions based on precise
>>description of movements of the Earth ?  The rotation
> 
>    My understanding is that Ada.Calendar is basically a wall clock - it
> can be reset by the operator for Daylight Savings, leap seconds, clock
> skew, or whatever.  It's the right thing to use for printing a date & time
> on a report, for instance.  Ada.Real_Time has a monotonic clock so it's
> generally the right thing for elapsed time.  Inserting a leap second for
> instance would cause the clock to run backwards one second, which would be
> illegal for Ada.Real_Time.Clock, but perfectly OK for Ada.Calendar.Clock

I think this is quite correct. The proposal does include minimal (very 
minimal) time zone functionality, but I suspect this might be removed by 
the ARG (or WG9), as being too horrible to contemplate.

[For one thing, it is only the rather obscure UT0 time system that is 
actually based on movements of the Earth; UT1 corrects it for 'wobble'. UTC 
is based on atomic clocks, and is corrected in steps of precisely 1 second 
every now and then to bring it within 0.9 s of UT1. As for the all the 
different time zones in use around the world, that is a deep mire where 
only the very foolish or the very brave (or those who enjoy maintaining 
huge databases) dare to tread.]

-- 
Nick Roberts

Re: ada calendar

[Robert I. Eachus]

Nick Roberts wrote:

> I think this is quite correct. The proposal does include minimal (very 
> minimal) time zone functionality, but I suspect this might be removed by 
> the ARG (or WG9), as being too horrible to contemplate.

The latest version of the proposed additions for Ada 0Y can be found at:
http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00351.TXT?rev=1.2>

I haven't had time to review it throughly yet, I've been spending way 
too much time on AI-318 & AI-325 (initial values for limited types).

-- 
                                           Robert I. Eachus

100% Ada, no bugs--the only way to create software.

Re: ada calendar

[Thomas Wolf]

rieachus@comcast.net wrote:
> The latest version of the proposed additions for Ada 0Y can be found at:
> http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00351.TXT?rev=1.2>

I see that this proposal includes some functionality for dealing with
leap seconds. It proposes (among other things)

procedure Difference (Left, Right : Time;
                      Days : out Day_Count;
                      Seconds : out Duration;
		      Leap_Seconds : out Leap_Seconds_Count);
    Returns the difference between Left and Right.
    Days is the number of days of difference, Seconds is the
    remainder seconds of difference, and Leap_Seconds is the number
    of leap seconds.
    If Left < Right, then Seconds <= 0.0, Days <= 0, and
    Leap_Seconds <= 0.
    Otherwise, all values are non-negative.

How is this supposed to work if Left or both Left and Right are in
the future? You cannot predict when the next leap second will be
inserted -- it depends on the irregularities of Earth's rotation,
and IERS inserts a leap second whenever necessary (well, at the end
of June or December) to keep the difference between UT1 und UTC <
0.9 sec.

Also implementing this for past dates needs a look-up table.

So, what is the number of leap seconds between 2004-01-01, 00:00:00
and 2105-01-01 00:00:00? Executing the proposed subprogram now would
probably return Leap_Seconds = 0, but executing it in 20 years, it
would probably have to return a non-zero value. (Because by then,
IERS will most probably have inserted at least one additional leap
second.)

-- 
-----------------------------------------------------------------
Thomas Wolf                          e-mail: t_wolf@angelfire.com

Re: ada calendar

[Randy Brukardt]

"Thomas Wolf" <t_wolf@angelfire.com> wrote in message
news:MPG.1a412f88b61dac9c989681@news.ip-plus.ch...
> rieachus@comcast.net wrote:
> > The latest version of the proposed additions for Ada 0Y can be found at:
> > http://www.ada-auth.org/cgi-bin/cvsweb.cgi/AIs/AI-00351.TXT?rev=1.2>
>
> I see that this proposal includes some functionality for dealing with
> leap seconds. It proposes (among other things)
...
> How is this supposed to work if Left or both Left and Right are in
> the future? You cannot predict when the next leap second will be
> inserted -- it depends on the irregularities of Earth's rotation,
> and IERS inserts a leap second whenever necessary (well, at the end
> of June or December) to keep the difference between UT1 und UTC <
> 0.9 sec.
>
> Also implementing this for past dates needs a look-up table.

No, you failed to read the Implementation Advice. The intent is that this is
mapped to whatever functionality is provided by the underlying timebase. In
particular, if the timebase doesn't provide leap second information, all of
these routines should return zero for the number of leap seconds. (And, by
definition, that should be true for times in the future.)

The only reason for these functions is so that using a timebase that does
provide leap seconds (and they are getting more common) won't screw up
programs.

Note that I personally think these leap second functions are a mistake.
There are sometimes 86401.0 seconds in a day, and Ada should simply be
honest and say that. (Indeed, doing so makes the other functions in this AI
more critical, because the assumptions used in typical code are wrong.)

In any case, the ARG is far from a resolution on this proposal. (We didn't
discuss it in San Diego, the only Amendment AI that we didn't look at.)

                 Randy Brukardt
                 ARG Editor (and author of AI-351).