c_cpp/etc/calc/cal/dms.cal

   1 /*
   2  * dms - calculate in degrees, minutes, and seconds (based on deg)
   3  *
   4  * Copyright (C) 1999,2010  David I. Bell and Landon Curt Noll
   5  *
   6  * Calc is open software; you can redistribute it and/or modify it under
   7  * the terms of the version 2.1 of the GNU Lesser General Public License
   8  * as published by the Free Software Foundation.
   9  *
  10  * Calc is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
  13  * Public License for more details.
  14  *
  15  * A copy of version 2.1 of the GNU Lesser General Public License is
  16  * distributed with calc under the filename COPYING-LGPL.  You should have
  17  * received a copy with calc; if not, write to Free Software Foundation, Inc.
  18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * @(#) $Revision: 30.2 $
  21  * @(#) $Id: dms.cal,v 30.2 2010/09/02 06:14:16 chongo Exp $
  22  * @(#) $Source: /usr/local/src/bin/calc/cal/RCS/dms.cal,v $
  23  *
  24  * Under source code control:   1990/02/15 01:50:33
  25  * File existed as early as:    before 1990
  26  *
  27  * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  28  */
  29
  30
  31 obj dms {deg, min, sec};
  32
  33 define dms(deg, min, sec)
  34 {
  35     local obj dms ans;          /* return value */
  36
  37     /* default missing args to 0 */
  38     if (isnull(sec)) {
  39         sec = 0;
  40     }
  41     if (isnull(min)) {
  42         min = 0;
  43     }
  44
  45     /* load object */
  46     ans.deg = deg;
  47     ans.min = min;
  48     ans.sec = sec;
  49
  50     /* return properly formed object */
  51     ans = fixdms(ans);
  52     return ans;
  53 }
  54
  55
  56 define dms_add(a, b)
  57 {
  58     local obj dms ans;          /* return value */
  59
  60     /* initalize value to 1st arg */
  61     if (istype(a, ans)) {
  62         /* 1st arg is dms object, load it */
  63         ans.deg = a.deg;
  64         ans.min = a.min;
  65         ans.sec = a.sec;
  66     } else {
  67         /* 1st arg is not dms, assume scalar degrees */
  68         ans.deg = a;
  69         ans.min = 0;
  70         ans.sec = 0;
  71     }
  72
  73     /* add value of 2nd arg */
  74     if (istype(b, ans)) {
  75         /* 2nd arg is dms object, add it */
  76         ans.deg += b.deg;
  77         ans.min += b.min;
  78         ans.sec += b.sec;
  79     } else {
  80         /* 2nd arg is not dms, add scalar degrees */
  81         ans.deg += b;
  82     }
  83
  84     /* return normalized result */
  85     ans = fixdms(ans);
  86     return ans;
  87 }
  88
  89
  90 define dms_neg(a)
  91 {
  92     local obj dms ans;          /* return value */
  93
  94     /* negate argument */
  95     if (istype(a, ans)) {
  96         /* 1st arg is dms object, load it */
  97         ans.deg = -a.deg;
  98         ans.min = -a.min;
  99         ans.sec = -a.sec;
 100     } else {
 101         /* 2nd arg is not dms, negate scalar degrees */
 102         ans.deg = -a;
 103         ans.min = 0;
 104         ans.sec = 0;
 105     }
 106
 107     /* return normalized result */
 108     ans = fixdms(ans);
 109     return ans;
 110 }
 111
 112
 113 define dms_sub(a, b)
 114 {
 115     local obj dms ans;          /* return value */
 116
 117     /* initalize value to 1st arg */
 118     if (istype(a, ans)) {
 119         /* 1st arg is dms object, load it */
 120         ans.deg = a.deg;
 121         ans.min = a.min;
 122         ans.sec = a.sec;
 123     } else {
 124         /* 1st arg is not dms, assume scalar degrees */
 125         ans.deg = a;
 126         ans.min = 0;
 127         ans.sec = 0;
 128     }
 129
 130     /* subtract value of 2nd arg */
 131     if (istype(b, ans)) {
 132         /* 2nd arg is dms object, subtract it */
 133         ans.deg -= b.deg;
 134         ans.min -= b.min;
 135         ans.sec -= b.sec;
 136     } else {
 137         /* 2nd arg is not dms, subtract scalar degrees */
 138         ans.deg -= b;
 139     }
 140
 141     /* return normalized result */
 142     ans = fixdms(ans);
 143     return ans;
 144 }
 145
 146
 147 define dms_mul(a, b)
 148 {
 149     local obj dms ans;          /* return value */
 150
 151     /* dms object multiplication */
 152     if (istype(a, ans) && istype(b, ans)) {
 153         ans.deg = dms_abs(a) * dms_abs(b);
 154         ans.min = 0;
 155         ans.sec = 0;
 156
 157     /* scalar multiplication */
 158     } else if (istype(a, ans)) {
 159         ans.deg = a.deg * b;
 160         ans.min = a.min * b;
 161         ans.sec = a.sec * b;
 162     } else {
 163         ans.deg = b.deg * a;
 164         ans.min = b.min * a;
 165         ans.sec = b.sec * a;
 166     }
 167
 168     /* return normalized result */
 169     ans = fixdms(ans);
 170     return ans;
 171 }
 172
 173
 174 define dms_print(a)
 175 {
 176     local obj dms ans;          /* temp object for dms type testing */
 177
 178     /* firewall - arg must be a dms object */
 179     if (! istype(a, ans)) {
 180         quit "dms_print called with non dms object";
 181     }
 182
 183     /* print in dms form */
 184     print a.deg : 'd' : a.min : 'm' : a.sec : 's' :;
 185 }
 186
 187
 188 define dms_abs(a)
 189 {
 190     local obj dms ans;          /* temp object for dms type testing */
 191     local deg;                  /* return scalar value */
 192
 193     /* firewall - just absolute value non dms objects */
 194     if (! istype(a, ans)) {
 195         return abs(a);
 196     }
 197
 198     /* compute degrees */
 199     deg = a.deg + a.min / 60 + a.sec / 3600;
 200
 201     /* return degrees */
 202     return deg;
 203 }
 204
 205
 206 define dms_norm(a)
 207 {
 208     local obj dms ans;          /* temp object for dms type testing */
 209     local deg;                  /* degrees */
 210
 211     /* firewall - arg must be a dms object */
 212     if (! istype(a, ans)) {
 213         quit "dms_norm called with non dms object";
 214     }
 215
 216     /* square degrees (norm is the square of absolute value */
 217     deg = dms_abs(a);
 218
 219     /* return degrees */
 220     return deg*deg;
 221 }
 222
 223
 224 define dms_test(a)
 225 {
 226     local obj dms ans;          /* temp value */
 227
 228     /* firewall - arg must be a dms object */
 229     if (! istype(a, ans)) {
 230         quit "dms_test called with non dms object";
 231     }
 232
 233     /* return false of non-zero */
 234     ans = fixdms(a);
 235     if (ans.deg == 0 && ans.min == 0 && ans.sec == 0) {
 236         /* false */
 237         return 0;
 238     }
 239     /* true */
 240     return 1;
 241 }
 242
 243
 244 define dms_int(a)
 245 {
 246     local obj dms ans;          /* return value */
 247
 248     /* firewall - arg must be a dms object */
 249     if (! istype(a, ans)) {
 250         quit "dms_int called with non dms object";
 251     }
 252
 253     /* normalize the argument */
 254     ans = fixdms(a);
 255
 256     /* truncate to the nearest second */
 257     ans.sec = int(ans.sec);
 258
 259     /* return value to the nearest second */
 260     return ans;
 261 }
 262
 263
 264 define dms_frac(a)
 265 {
 266     local obj dms ans;          /* return value */
 267
 268     /* firewall - arg must be a dms object */
 269     if (! istype(a, ans)) {
 270         quit "dms_frac called with non dms object";
 271     }
 272
 273     /* normalize the argument */
 274     ans = fixdms(a);
 275
 276     /* remove all but fractional seconds */
 277     ans.deg = 0;
 278     ans.min = 0;
 279     ans.sec = frac(ans.sec);
 280
 281     /* return value to the second fraction */
 282     return ans;
 283 }
 284
 285
 286 define dms_rel(a,b)
 287 {
 288     local abs_a, abs_b;         /* scalars of the arguments */
 289
 290     /* compute scalars of the arguments */
 291     abs_a = dms_abs(a);
 292     abs_b = dms_abs(b);
 293
 294     /* return the comparison */
 295     return cmp(abs_a, abs_b);
 296 }
 297
 298
 299 define dms_cmp(a,b)
 300 {
 301     local abs_a, abs_b;         /* scalars of the arguments */
 302
 303     /* compute scalars of the arguments */
 304     abs_a = dms_abs(a);
 305     abs_b = dms_abs(b);
 306
 307     /* return the equality comparison */
 308     return (abs_a == abs_b);
 309 }
 310
 311
 312 define dms_inc(a)
 313 {
 314     local obj dms ans;          /* return value */
 315
 316     /* increment a dms object */
 317     if (istype(a, ans)) {
 318         ans = a;
 319         ++ans.sec;
 320
 321         /* return normalized result */
 322         ans = fixdms(ans);
 323         return ans;
 324     }
 325
 326     /* increment a scalar */
 327     return a+1;
 328 }
 329
 330
 331 define dms_dec(a)
 332 {
 333     local obj dms ans;          /* return value */
 334
 335     /* decrement a dms object */
 336     if (istype(a, ans)) {
 337         ans = a;
 338         --ans.sec;
 339
 340         /* return normalized result */
 341         ans = fixdms(ans);
 342         return ans;
 343     }
 344
 345     /* decrement a scalar */
 346     return a-1;
 347 }
 348
 349
 350 define fixdms(a)
 351 {
 352     local obj dms ans;          /* temp value */
 353
 354     /* firewall */
 355     if (! istype(a, ans)) {
 356         quit "attempt to fix a non dms object";
 357     }
 358
 359     /* force minutes to be intergral */
 360     a.min += frac(a.deg) * 60;
 361     a.deg = int(a.deg);
 362
 363     /* force degrees to be intergral */
 364     a.sec += frac(a.min) * 60;
 365     a.min = int(a.min);
 366
 367     /* carry excess seconds into minutes */
 368     a.min += a.sec // 60;
 369     a.sec %= 60;
 370
 371     /* carry excess minutes into degrees */
 372     a.deg += a.min // 60;
 373     a.min %= 60;
 374
 375     /* round degrees :-) */
 376     a.deg %= 360;
 377
 378     /* return normalized result */
 379     return a;
 380 }
 381
 382 if (config("resource_debug") & 3) {
 383     print "obj dms {deg, min, sec} defined";
 384 }