Return to math.c CVS log

Up to [Research Unix] / researchv10no / cmd / picasso

Annotation of researchv10no/cmd/picasso/math.c, revision 1.1.1.1

1.1       root        1: /*     Copyright (c) 1988 AT&T */
                      2: /*       All Rights Reserved   */
                      3: 
                      4: /*     THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T     */
                      5: /*     The copyright notice above does not evidence any        */
                      6: /*     actual or intended publication of such source code.     */
                      7: 
                      8: /*     @(#)picasso:math.c      1.0     */
                      9: #include       "picasso.h"
                     10: #include       "y.tab.h"
                     11: 
                     12: double Log(x)
                     13:        double  x;
                     14: {
                     15:        return errcheck(log(x), "log");
                     16: }
                     17: 
                     18: double Log10(x)
                     19:        double  x;
                     20: {
                     21:        return errcheck(log10(x), "log");
                     22: }
                     23: 
                     24: double Exp(x)
                     25:        double  x;
                     26: {
                     27:        return errcheck(exp(x), "exp");
                     28: }
                     29: 
                     30: double Sqrt(x)
                     31:        double  x;
                     32: {
                     33:        return errcheck(sqrt(x), "sqrt");
                     34: }
                     35: 
                     36: double Cos(x)
                     37:        double  x;
                     38: {
                     39: /*     if (fmod(x,180.) == 90)
                     40:                return 0;       */
                     41:        return cos(x/* * M_PI/180 */);
                     42: }
                     43: 
                     44: double Sin(x)
                     45:        double  x;
                     46: {
                     47: /*     if (fmod(x,180.) == 0)
                     48:                return 0;       */
                     49:        return sin(x/* * M_PI/180 */);
                     50: }
                     51: 
                     52: double Pow(x, y)
                     53:        double  x, y;
                     54: {
                     55:        return errcheck(pow(x,y), "pow");
                     56: }
                     57: 
                     58: double Atan2(y, x)
                     59:        double  y, x;
                     60: {
                     61:        return (atan2(y, x)/* * 180.0/M_PI */);
                     62: }
                     63: 
                     64: double Minvar(s)
                     65:        char    *s;
                     66: {
                     67:        struct  symtab  *p;
                     68:        double  m;
                     69:        int     i;
                     70: 
                     71:        p = findvar(s, VARNAME);
                     72:        if (p->s_dim == 0)
                     73:                m = p->s_val.f; 
                     74:        else for (m = p->s_val.a[0], i = 1; i < p->s_dim; ++i)
                     75:                if (p->s_val.a[i] < m)
                     76:                        m = p->s_val.a[i];
                     77:        return m;
                     78: }
                     79: 
                     80: double Minlist()
                     81: {
                     82:        double  m;
                     83: 
                     84:        for (m = exprlist[--nexpr]; nexpr; )
                     85:                if (exprlist[--nexpr] < m)
                     86:                        m = exprlist[nexpr];
                     87:        return m;
                     88: }
                     89: 
                     90: double Maxvar(s)
                     91:        char    *s;
                     92: {
                     93:        struct  symtab  *p;
                     94:        double  m;
                     95:        int     i;
                     96: 
                     97:        p = findvar(s, VARNAME);
                     98:        if (p->s_dim == 0)
                     99:                m = p->s_val.f; 
                    100:        else for (m = p->s_val.a[0], i = 1; i < p->s_dim; ++i)
                    101:                if (p->s_val.a[i] > m)
                    102:                        m = p->s_val.a[i];
                    103:        return m;
                    104: }
                    105: 
                    106: double Maxlist()
                    107: {
                    108:        double  m;
                    109: 
                    110:        for (m = exprlist[--nexpr]; nexpr; )
                    111:                if (exprlist[--nexpr] > m)
                    112:                        m = exprlist[nexpr];
                    113:        return m;
                    114: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.