← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/poppler/goo/FixedPoint.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/poppler/goo/FixedPoint.h
 
1
//========================================================================
 
2
//
 
3
// FixedPoint.h
 
4
//
 
5
// Fixed point type, with C++ operators.
 
6
//
 
7
// Copyright 2004 Glyph & Cog, LLC
 
8
//
 
9
//========================================================================
 
10
 
 
11
#ifndef FIXEDPOINT_H
 
12
#define FIXEDPOINT_H
 
13
 
 
14
#include "poppler/poppler-config.h"
 
15
 
 
16
#if USE_FIXEDPOINT
 
17
 
 
18
#ifdef USE_GCC_PRAGMAS
 
19
#pragma interface
 
20
#endif
 
21
 
 
22
#include <stdio.h>
 
23
#include <stdlib.h>
 
24
#include "gtypes.h"
 
25
 
 
26
#define fixptShift 16
 
27
#define fixptMaskL ((1 << fixptShift) - 1)
 
28
#define fixptMaskH (~fixptMaskL)
 
29
 
 
30
typedef long long FixPtInt64;
 
31
 
 
32
class FixedPoint {
 
33
public:
 
34
 
 
35
  FixedPoint() { val = 0; }
 
36
  FixedPoint(const FixedPoint &x) { val = x.val; }
 
37
  FixedPoint(double x) { val = (int)(x * (1 << fixptShift) + 0.5); }
 
38
  FixedPoint(int x) { val = x << fixptShift; }
 
39
  FixedPoint(long x) { val = x << fixptShift; }
 
40
 
 
41
  operator float()
 
42
    { return (float) val * ((float)1 / (float)(1 << fixptShift)); }
 
43
  operator double()
 
44
    { return (double) val * (1.0 / (double)(1 << fixptShift)); }
 
45
  operator int()
 
46
    { return val >> fixptShift; }
 
47
 
 
48
  int getRaw() { return val; }
 
49
 
 
50
  FixedPoint operator =(FixedPoint x) { val = x.val; return *this; }
 
51
 
 
52
  int operator ==(FixedPoint x) { return val == x.val; }
 
53
  int operator ==(double x) { return *this == (FixedPoint)x; }
 
54
  int operator ==(int x) { return *this == (FixedPoint)x; }
 
55
  int operator ==(long x) { return *this == (FixedPoint)x; }
 
56
 
 
57
  int operator !=(FixedPoint x) { return val != x.val; }
 
58
  int operator !=(double x) { return *this != (FixedPoint)x; }
 
59
  int operator !=(int x) { return *this != (FixedPoint)x; }
 
60
  int operator !=(long x) { return *this != (FixedPoint)x; }
 
61
 
 
62
  int operator <(FixedPoint x) { return val < x.val; }
 
63
  int operator <(double x) { return *this < (FixedPoint)x; }
 
64
  int operator <(int x) { return *this < (FixedPoint)x; }
 
65
  int operator <(long x) { return *this < (FixedPoint)x; }
 
66
 
 
67
  int operator <=(FixedPoint x) { return val <= x.val; }
 
68
  int operator <=(double x) { return *this <= (FixedPoint)x; }
 
69
  int operator <=(int x) { return *this <= (FixedPoint)x; }
 
70
  int operator <=(long x) { return *this <= (FixedPoint)x; }
 
71
 
 
72
  int operator >(FixedPoint x) { return val > x.val; }
 
73
  int operator >(double x) { return *this > (FixedPoint)x; }
 
74
  int operator >(int x) { return *this > (FixedPoint)x; }
 
75
  int operator >(long x) { return *this > (FixedPoint)x; }
 
76
 
 
77
  int operator >=(FixedPoint x) { return val >= x.val; }
 
78
  int operator >=(double x) { return *this >= (FixedPoint)x; }
 
79
  int operator >=(int x) { return *this >= (FixedPoint)x; }
 
80
  int operator >=(long x) { return *this >= (FixedPoint)x; }
 
81
 
 
82
  FixedPoint operator -() { return make(-val); }
 
83
 
 
84
  FixedPoint operator +(FixedPoint x) { return make(val + x.val); }
 
85
  FixedPoint operator +(double x) { return *this + (FixedPoint)x; }
 
86
  FixedPoint operator +(int x) { return *this + (FixedPoint)x; }
 
87
  FixedPoint operator +(long x) { return *this + (FixedPoint)x; }
 
88
 
 
89
  FixedPoint operator +=(FixedPoint x) { val = val + x.val; return *this; }
 
90
  FixedPoint operator +=(double x) { return *this += (FixedPoint)x; }
 
91
  FixedPoint operator +=(int x) { return *this += (FixedPoint)x; }
 
92
  FixedPoint operator +=(long x) { return *this += (FixedPoint)x; }
 
93
 
 
94
  FixedPoint operator -(FixedPoint x) { return make(val - x.val); }
 
95
  FixedPoint operator -(double x) { return *this - (FixedPoint)x; }
 
96
  FixedPoint operator -(int x) { return *this - (FixedPoint)x; }
 
97
  FixedPoint operator -(long x) { return *this - (FixedPoint)x; }
 
98
 
 
99
  FixedPoint operator -=(FixedPoint x) { val = val - x.val; return *this; }
 
100
  FixedPoint operator -=(double x) { return *this -= (FixedPoint)x; }
 
101
  FixedPoint operator -=(int x) { return *this -= (FixedPoint)x; }
 
102
  FixedPoint operator -=(long x) { return *this -= (FixedPoint)x; }
 
103
 
 
104
  FixedPoint operator *(FixedPoint x) { return make(mul(val, x.val)); }
 
105
  FixedPoint operator *(double x) { return *this * (FixedPoint)x; }
 
106
  FixedPoint operator *(int x) { return *this * (FixedPoint)x; }
 
107
  FixedPoint operator *(long x) { return *this * (FixedPoint)x; }
 
108
 
 
109
  FixedPoint operator *=(FixedPoint x) { val = mul(val, x.val); return *this; }
 
110
  FixedPoint operator *=(double x) { return *this *= (FixedPoint)x; }
 
111
  FixedPoint operator *=(int x) { return *this *= (FixedPoint)x; }
 
112
  FixedPoint operator *=(long x) { return *this *= (FixedPoint)x; }
 
113
 
 
114
  FixedPoint operator /(FixedPoint x) { return make(div(val, x.val)); }
 
115
  FixedPoint operator /(double x) { return *this / (FixedPoint)x; }
 
116
  FixedPoint operator /(int x) { return *this / (FixedPoint)x; }
 
117
  FixedPoint operator /(long x) { return *this / (FixedPoint)x; }
 
118
 
 
119
  FixedPoint operator /=(FixedPoint x) { val = div(val, x.val); return *this; }
 
120
  FixedPoint operator /=(double x) { return *this /= (FixedPoint)x; }
 
121
  FixedPoint operator /=(int x) { return *this /= (FixedPoint)x; }
 
122
  FixedPoint operator /=(long x) { return *this /= (FixedPoint)x; }
 
123
 
 
124
  static FixedPoint abs(FixedPoint x) { return make(::abs(x.val)); }
 
125
 
 
126
  static int floor(FixedPoint x) { return x.val >> fixptShift; }
 
127
 
 
128
  static int ceil(FixedPoint x)
 
129
    { return (x.val & fixptMaskL) ? ((x.val >> fixptShift) + 1)
 
130
                                  : (x.val >> fixptShift); }
 
131
 
 
132
  static int round(FixedPoint x)
 
133
    { return (x.val + (1 << (fixptShift - 1))) >> fixptShift; }
 
134
 
 
135
  static FixedPoint sqrt(FixedPoint x);
 
136
 
 
137
  static FixedPoint pow(FixedPoint x, FixedPoint y);
 
138
 
 
139
  // Compute *result = x/y; return false if there is an underflow or
 
140
  // overflow.
 
141
  static GBool divCheck(FixedPoint x, FixedPoint y, FixedPoint *result);
 
142
 
 
143
private:
 
144
 
 
145
  static FixedPoint make(int valA) { FixedPoint x; x.val = valA; return x; }
 
146
 
 
147
  static int mul(int x, int y);
 
148
  static int div(int x, int y);
 
149
 
 
150
  int val;                      // 16.16 fixed point
 
151
};
 
152
 
 
153
#endif // USE_FIXEDPOINT
 
154
 
 
155
#endif