← Back to branch summary

~ubuntu-branches/ubuntu/hardy/ghostscript/hardy

« back to all changes in this revision

Viewing changes to src/zdouble.c

  • Committer: Bazaar Package Importer
  • Author(s): Till Kamppeter
  • Date: 2007-11-22 12:17:43 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071122121743-cd70s3ypq0r243mp
Tags: 8.61.dfsg.1-0ubtuntu1
* New upstream release
  o Final 8.61 release
* debian/patches/09_ijs_krgb_support.dpatch: Adapted to upstream changes.
* debian/rules: Updated CUPS-related variables for "make install" calls.
* debian/rules: Remove /usr/include/ghostscript from the ghostscript
  package, they go into lings-dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/zdouble.c
11
11
   San Rafael, CA  94903, U.S.A., +1(415)492-9861, for further information.
12
12
*/
13
13
 
14
 
/* $Id: zdouble.c 8022 2007-06-05 22:23:38Z giles $ */
 
14
/* $Id: zdouble.c 8250 2007-09-25 13:31:24Z giles $ */
15
15
/* Double-precision floating point arithmetic operators */
16
16
#include "math_.h"
17
17
#include "memory_.h"
33
33
 */
34
34
 
35
35
/* Forward references */
36
 
private int double_params_result(os_ptr, int, double *);
37
 
private int double_params(os_ptr, int, double *);
38
 
private int double_result(i_ctx_t *, int, double);
39
 
private int double_unary(i_ctx_t *, double (*)(double));
 
36
static int double_params_result(os_ptr, int, double *);
 
37
static int double_params(os_ptr, int, double *);
 
38
static int double_result(i_ctx_t *, int, double);
 
39
static int double_unary(i_ctx_t *, double (*)(double));
40
40
 
41
41
#define dbegin_unary()\
42
42
        os_ptr op = osp;\
57
57
/* ------ Arithmetic ------ */
58
58
 
59
59
/* <dnum1> <dnum2> <dresult> .dadd <dresult> */
60
 
private int
 
60
static int
61
61
zdadd(i_ctx_t *i_ctx_p)
62
62
{
63
63
    dbegin_binary();
65
65
}
66
66
 
67
67
/* <dnum1> <dnum2> <dresult> .ddiv <dresult> */
68
 
private int
 
68
static int
69
69
zddiv(i_ctx_t *i_ctx_p)
70
70
{
71
71
    dbegin_binary();
75
75
}
76
76
 
77
77
/* <dnum1> <dnum2> <dresult> .dmul <dresult> */
78
 
private int
 
78
static int
79
79
zdmul(i_ctx_t *i_ctx_p)
80
80
{
81
81
    dbegin_binary();
83
83
}
84
84
 
85
85
/* <dnum1> <dnum2> <dresult> .dsub <dresult> */
86
 
private int
 
86
static int
87
87
zdsub(i_ctx_t *i_ctx_p)
88
88
{
89
89
    dbegin_binary();
93
93
/* ------ Simple functions ------ */
94
94
 
95
95
/* <dnum> <dresult> .dabs <dresult> */
96
 
private int
 
96
static int
97
97
zdabs(i_ctx_t *i_ctx_p)
98
98
{
99
99
    return double_unary(i_ctx_p, fabs);
100
100
}
101
101
 
102
102
/* <dnum> <dresult> .dceiling <dresult> */
103
 
private int
 
103
static int
104
104
zdceiling(i_ctx_t *i_ctx_p)
105
105
{
106
106
    return double_unary(i_ctx_p, ceil);
107
107
}
108
108
 
109
109
/* <dnum> <dresult> .dfloor <dresult> */
110
 
private int
 
110
static int
111
111
zdfloor(i_ctx_t *i_ctx_p)
112
112
{
113
113
    return double_unary(i_ctx_p, floor);
114
114
}
115
115
 
116
116
/* <dnum> <dresult> .dneg <dresult> */
117
 
private int
 
117
static int
118
118
zdneg(i_ctx_t *i_ctx_p)
119
119
{
120
120
    dbegin_unary();
122
122
}
123
123
 
124
124
/* <dnum> <dresult> .dround <dresult> */
125
 
private int
 
125
static int
126
126
zdround(i_ctx_t *i_ctx_p)
127
127
{
128
128
    dbegin_unary();
130
130
}
131
131
 
132
132
/* <dnum> <dresult> .dsqrt <dresult> */
133
 
private int
 
133
static int
134
134
zdsqrt(i_ctx_t *i_ctx_p)
135
135
{
136
136
    dbegin_unary();
140
140
}
141
141
 
142
142
/* <dnum> <dresult> .dtruncate <dresult> */
143
 
private int
 
143
static int
144
144
zdtruncate(i_ctx_t *i_ctx_p)
145
145
{
146
146
    dbegin_unary();
149
149
 
150
150
/* ------ Transcendental functions ------ */
151
151
 
152
 
private int
 
152
static int
153
153
darc(i_ctx_t *i_ctx_p, double (*afunc)(double))
154
154
{
155
155
    dbegin_unary();
156
156
    return double_result(i_ctx_p, 1, (*afunc)(num) * radians_to_degrees);
157
157
}
158
158
/* <dnum> <dresult> .darccos <dresult> */
159
 
private int
 
159
static int
160
160
zdarccos(i_ctx_t *i_ctx_p)
161
161
{
162
162
    return darc(i_ctx_p, acos);
163
163
}
164
164
/* <dnum> <dresult> .darcsin <dresult> */
165
 
private int
 
165
static int
166
166
zdarcsin(i_ctx_t *i_ctx_p)
167
167
{
168
168
    return darc(i_ctx_p, asin);
169
169
}
170
170
 
171
171
/* <dnum> <ddenom> <dresult> .datan <dresult> */
172
 
private int
 
172
static int
173
173
zdatan(i_ctx_t *i_ctx_p)
174
174
{
175
175
    double result;
188
188
}
189
189
 
190
190
/* <dnum> <dresult> .dcos <dresult> */
191
 
private int
 
191
static int
192
192
zdcos(i_ctx_t *i_ctx_p)
193
193
{
194
194
    return double_unary(i_ctx_p, gs_cos_degrees);
195
195
}
196
196
 
197
197
/* <dbase> <dexponent> <dresult> .dexp <dresult> */
198
 
private int
 
198
static int
199
199
zdexp(i_ctx_t *i_ctx_p)
200
200
{
201
201
    double ipart;
208
208
    return double_result(i_ctx_p, 2, pow(num[0], num[1]));
209
209
}
210
210
 
211
 
private int
 
211
static int
212
212
dlog(i_ctx_t *i_ctx_p, double (*lfunc)(double))
213
213
{
214
214
    dbegin_unary();
217
217
    return double_result(i_ctx_p, 1, (*lfunc)(num));
218
218
}
219
219
/* <dposnum> <dresult> .dln <dresult> */
220
 
private int
 
220
static int
221
221
zdln(i_ctx_t *i_ctx_p)
222
222
{
223
223
    return dlog(i_ctx_p, log);
224
224
}
225
225
/* <dposnum> <dresult> .dlog <dresult> */
226
 
private int
 
226
static int
227
227
zdlog(i_ctx_t *i_ctx_p)
228
228
{
229
229
    return dlog(i_ctx_p, log10);
230
230
}
231
231
 
232
232
/* <dnum> <dresult> .dsin <dresult> */
233
 
private int
 
233
static int
234
234
zdsin(i_ctx_t *i_ctx_p)
235
235
{
236
236
    return double_unary(i_ctx_p, gs_sin_degrees);
238
238
 
239
239
/* ------ Comparison ------ */
240
240
 
241
 
private int
 
241
static int
242
242
dcompare(i_ctx_t *i_ctx_p, int mask)
243
243
{
244
244
    os_ptr op = osp;
254
254
    return 0;
255
255
}
256
256
/* <dnum1> <dnum2> .deq <bool> */
257
 
private int
 
257
static int
258
258
zdeq(i_ctx_t *i_ctx_p)
259
259
{
260
260
    return dcompare(i_ctx_p, 2);
261
261
}
262
262
/* <dnum1> <dnum2> .dge <bool> */
263
 
private int
 
263
static int
264
264
zdge(i_ctx_t *i_ctx_p)
265
265
{
266
266
    return dcompare(i_ctx_p, 6);
267
267
}
268
268
/* <dnum1> <dnum2> .dgt <bool> */
269
 
private int
 
269
static int
270
270
zdgt(i_ctx_t *i_ctx_p)
271
271
{
272
272
    return dcompare(i_ctx_p, 4);
273
273
}
274
274
/* <dnum1> <dnum2> .dle <bool> */
275
 
private int
 
275
static int
276
276
zdle(i_ctx_t *i_ctx_p)
277
277
{
278
278
    return dcompare(i_ctx_p, 3);
279
279
}
280
280
/* <dnum1> <dnum2> .dlt <bool> */
281
 
private int
 
281
static int
282
282
zdlt(i_ctx_t *i_ctx_p)
283
283
{
284
284
    return dcompare(i_ctx_p, 1);
285
285
}
286
286
/* <dnum1> <dnum2> .dne <bool> */
287
 
private int
 
287
static int
288
288
zdne(i_ctx_t *i_ctx_p)
289
289
{
290
290
    return dcompare(i_ctx_p, 5);
296
296
#define MAX_CHARS 50
297
297
 
298
298
/* <dnum> <dresult> .cvd <dresult> */
299
 
private int
 
299
static int
300
300
zcvd(i_ctx_t *i_ctx_p)
301
301
{
302
302
    dbegin_unary();
304
304
}
305
305
 
306
306
/* <string> <dresult> .cvsd <dresult> */
307
 
private int
 
307
static int
308
308
zcvsd(i_ctx_t *i_ctx_p)
309
309
{
310
310
    os_ptr op = osp;
342
342
}
343
343
 
344
344
/* <dnum> .dcvi <int> */
345
 
private int
 
345
static int
346
346
zdcvi(i_ctx_t *i_ctx_p)
347
347
{
348
348
    os_ptr op = osp;
363
363
}
364
364
 
365
365
/* <dnum> .dcvr <real> */
366
 
private int
 
366
static int
367
367
zdcvr(i_ctx_t *i_ctx_p)
368
368
{
369
369
    os_ptr op = osp;
385
385
}
386
386
 
387
387
/* <dnum> <string> .dcvs <substring> */
388
 
private int
 
388
static int
389
389
zdcvs(i_ctx_t *i_ctx_p)
390
390
{
391
391
    os_ptr op = osp;
472
472
/* ------ Internal procedures ------ */
473
473
 
474
474
/* Get some double arguments. */
475
 
private int
 
475
static int
476
476
double_params(os_ptr op, int count, double *pval)
477
477
{
478
478
    pval += count;
503
503
}
504
504
 
505
505
/* Get some double arguments, and check for a double result. */
506
 
private int
 
506
static int
507
507
double_params_result(os_ptr op, int count, double *pval)
508
508
{
509
509
    check_write_type(*op, t_string);
513
513
}
514
514
 
515
515
/* Return a double result. */
516
 
private int
 
516
static int
517
517
double_result(i_ctx_t *i_ctx_p, int count, double result)
518
518
{
519
519
    os_ptr op = osp;
526
526
}
527
527
 
528
528
/* Apply a unary function to a double operand. */
529
 
private int
 
529
static int
530
530
double_unary(i_ctx_t *i_ctx_p, double (*func)(double))
531
531
{
532
532
    dbegin_unary();