aboutsummaryrefslogtreecommitdiff
path: root/lib/gmp/mini-gmp.h
blob: 8c94ca2ed0dd809f54d61762bbb7a199115c5bd9 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256

/* mini-gmp, a minimalistic implementation of a GNU GMP subset.

Copyright 2011, 2012, 2013 Free Software Foundation, Inc.

This file is part of the GNU MP Library.

The GNU MP Library is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 3 of the License, or (at your
option) any later version.

The GNU MP Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
License for more details.

You should have received a copy of the GNU Lesser General Public License
along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.  */

/* About mini-gmp: This is a minimal implementation of a subset of the
   GMP interface. It is intended for inclusion into applications which
   have modest bignums needs, as a fallback when the real GMP library
   is not installed.

   This file defines the public interface. */

#ifndef __MINI_GMP_H__
#define __MINI_GMP_H__

/* For size_t */
#include <stddef.h>

#if defined (__cplusplus)
extern "C" {
#endif

void mp_set_memory_functions (void *(*) (size_t),
			      void *(*) (void *, size_t, size_t),
			      void (*) (void *, size_t));

void mp_get_memory_functions (void *(**) (size_t),
			      void *(**) (void *, size_t, size_t),
			      void (**) (void *, size_t));

typedef unsigned long mp_limb_t;
typedef long mp_size_t;
typedef unsigned long mp_bitcnt_t;

typedef mp_limb_t *mp_ptr;
typedef const mp_limb_t *mp_srcptr;

typedef struct
{
  int _mp_alloc;		/* Number of *limbs* allocated and pointed
				   to by the _mp_d field.  */
  int _mp_size;			/* abs(_mp_size) is the number of limbs the
				   last field points to.  If _mp_size is
				   negative this is a negative number.  */
  mp_limb_t *_mp_d;		/* Pointer to the limbs.  */
} __mpz_struct;

typedef __mpz_struct mpz_t[1];

typedef __mpz_struct *mpz_ptr;
typedef const __mpz_struct *mpz_srcptr;

void mpn_copyi (mp_ptr, mp_srcptr, mp_size_t);
void mpn_copyd (mp_ptr, mp_srcptr, mp_size_t);

int mpn_cmp (mp_srcptr, mp_srcptr, mp_size_t);

mp_limb_t mpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);

mp_limb_t mpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t mpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);

mp_limb_t mpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t mpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);

mp_limb_t mpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
void mpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void mpn_sqr (mp_ptr, mp_srcptr, mp_size_t);

mp_limb_t mpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_limb_t mpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);

mp_limb_t mpn_invert_3by2 (mp_limb_t, mp_limb_t);
#define mpn_invert_limb(x) mpn_invert_3by2 ((x), 0)

size_t mpn_get_str (unsigned char *, int, mp_ptr, mp_size_t);
mp_size_t mpn_set_str (mp_ptr, const unsigned char *, size_t, int);

void mpz_init (mpz_t);
void mpz_init2 (mpz_t, mp_bitcnt_t);
void mpz_clear (mpz_t);

#define mpz_odd_p(z)   (((z)->_mp_size != 0) & (int) (z)->_mp_d[0])
#define mpz_even_p(z)  (! mpz_odd_p (z))

int mpz_sgn (const mpz_t);
int mpz_cmp_si (const mpz_t, long);
int mpz_cmp_ui (const mpz_t, unsigned long);
int mpz_cmp (const mpz_t, const mpz_t);
int mpz_cmpabs_ui (const mpz_t, unsigned long);
int mpz_cmpabs (const mpz_t, const mpz_t);
int mpz_cmp_d (const mpz_t, double);
int mpz_cmpabs_d (const mpz_t, double);

void mpz_abs (mpz_t, const mpz_t);
void mpz_neg (mpz_t, const mpz_t);
void mpz_swap (mpz_t, mpz_t);

void mpz_add_ui (mpz_t, const mpz_t, unsigned long);
void mpz_add (mpz_t, const mpz_t, const mpz_t);
void mpz_sub_ui (mpz_t, const mpz_t, unsigned long);
void mpz_ui_sub (mpz_t, unsigned long, const mpz_t);
void mpz_sub (mpz_t, const mpz_t, const mpz_t);

void mpz_mul_si (mpz_t, const mpz_t, long int);
void mpz_mul_ui (mpz_t, const mpz_t, unsigned long int);
void mpz_mul (mpz_t, const mpz_t, const mpz_t);
void mpz_mul_2exp (mpz_t, const mpz_t, mp_bitcnt_t);

void mpz_cdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_qr (mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_cdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_q (mpz_t, const mpz_t, const mpz_t);
void mpz_cdiv_r (mpz_t, const mpz_t, const mpz_t);
void mpz_fdiv_r (mpz_t, const mpz_t, const mpz_t);
void mpz_tdiv_r (mpz_t, const mpz_t, const mpz_t);

void mpz_cdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_fdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_tdiv_q_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_cdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_fdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);
void mpz_tdiv_r_2exp (mpz_t, const mpz_t, mp_bitcnt_t);

void mpz_mod (mpz_t, const mpz_t, const mpz_t);

void mpz_divexact (mpz_t, const mpz_t, const mpz_t);

int mpz_divisible_p (const mpz_t, const mpz_t);

unsigned long mpz_cdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_qr_ui (mpz_t, mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_q_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_fdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_tdiv_r_ui (mpz_t, const mpz_t, unsigned long);
unsigned long mpz_cdiv_ui (const mpz_t, unsigned long);
unsigned long mpz_fdiv_ui (const mpz_t, unsigned long);
unsigned long mpz_tdiv_ui (const mpz_t, unsigned long);

unsigned long mpz_mod_ui (mpz_t, const mpz_t, unsigned long);

void mpz_divexact_ui (mpz_t, const mpz_t, unsigned long);

int mpz_divisible_ui_p (const mpz_t, unsigned long);

unsigned long mpz_gcd_ui (mpz_t, const mpz_t, unsigned long);
void mpz_gcd (mpz_t, const mpz_t, const mpz_t);
void mpz_gcdext (mpz_t, mpz_t, mpz_t, const mpz_t, const mpz_t);
void mpz_lcm_ui (mpz_t, const mpz_t, unsigned long);
void mpz_lcm (mpz_t, const mpz_t, const mpz_t);
int mpz_invert (mpz_t, const mpz_t, const mpz_t);

void mpz_sqrtrem (mpz_t, mpz_t, const mpz_t);
void mpz_sqrt (mpz_t, const mpz_t);

void mpz_pow_ui (mpz_t, const mpz_t, unsigned long);
void mpz_ui_pow_ui (mpz_t, unsigned long, unsigned long);
void mpz_powm (mpz_t, const mpz_t, const mpz_t, const mpz_t);
void mpz_powm_ui (mpz_t, const mpz_t, unsigned long, const mpz_t);

void mpz_rootrem (mpz_t, mpz_t, const mpz_t, unsigned long);
int mpz_root (mpz_t, const mpz_t, unsigned long);

void mpz_fac_ui (mpz_t, unsigned long);
void mpz_bin_uiui (mpz_t, unsigned long, unsigned long);

int mpz_tstbit (const mpz_t, mp_bitcnt_t);
void mpz_setbit (mpz_t, mp_bitcnt_t);
void mpz_clrbit (mpz_t, mp_bitcnt_t);
void mpz_combit (mpz_t, mp_bitcnt_t);

void mpz_com (mpz_t, const mpz_t);
void mpz_and (mpz_t, const mpz_t, const mpz_t);
void mpz_ior (mpz_t, const mpz_t, const mpz_t);
void mpz_xor (mpz_t, const mpz_t, const mpz_t);

mp_bitcnt_t mpz_popcount (const mpz_t);
mp_bitcnt_t mpz_hamdist (const mpz_t, const mpz_t);
mp_bitcnt_t mpz_scan0 (const mpz_t, mp_bitcnt_t);
mp_bitcnt_t mpz_scan1 (const mpz_t, mp_bitcnt_t);

int mpz_fits_slong_p (const mpz_t);
int mpz_fits_ulong_p (const mpz_t);
long int mpz_get_si (const mpz_t);
unsigned long int mpz_get_ui (const mpz_t);
double mpz_get_d (const mpz_t);
size_t mpz_size (const mpz_t);
mp_limb_t mpz_getlimbn (const mpz_t, mp_size_t);

void mpz_set_si (mpz_t, signed long int);
void mpz_set_ui (mpz_t, unsigned long int);
void mpz_set (mpz_t, const mpz_t);
void mpz_set_d (mpz_t, double);

void mpz_init_set_si (mpz_t, signed long int);
void mpz_init_set_ui (mpz_t, unsigned long int);
void mpz_init_set (mpz_t, const mpz_t);
void mpz_init_set_d (mpz_t, double);

size_t mpz_sizeinbase (const mpz_t, int);
char *mpz_get_str (char *, int, const mpz_t);
int mpz_set_str (mpz_t, const char *, int);
int mpz_init_set_str (mpz_t, const char *, int);

/* This long list taken from gmp.h. */
/* For reference, "defined(EOF)" cannot be used here.  In g++ 2.95.4,
   <iostream> defines EOF but not FILE.  */
#if defined (FILE)                                              \
  || defined (H_STDIO)                                          \
  || defined (_H_STDIO)               /* AIX */                 \
  || defined (_STDIO_H)               /* glibc, Sun, SCO */     \
  || defined (_STDIO_H_)              /* BSD, OSF */            \
  || defined (__STDIO_H)              /* Borland */             \
  || defined (__STDIO_H__)            /* IRIX */                \
  || defined (_STDIO_INCLUDED)        /* HPUX */                \
  || defined (__dj_include_stdio_h_)  /* DJGPP */               \
  || defined (_FILE_DEFINED)          /* Microsoft */           \
  || defined (__STDIO__)              /* Apple MPW MrC */       \
  || defined (_MSL_STDIO_H)           /* Metrowerks */          \
  || defined (_STDIO_H_INCLUDED)      /* QNX4 */		\
  || defined (_ISO_STDIO_ISO_H)       /* Sun C++ */		\
  || defined (__STDIO_LOADED)         /* VMS */
size_t mpz_out_str (FILE *, int, const mpz_t);
#endif

void mpz_import (mpz_t, size_t, int, size_t, int, size_t, const void *);
void *mpz_export (void *, size_t *, int, size_t, int, size_t, const mpz_t);

#if defined (__cplusplus)
}
#endif
#endif /* __MINI_GMP_H__ */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-19 01:52:15 +0000
n class="hl opt">*item = other.m_items[i]; if(item != NULL) { m_items[i] = item->clone(); } } return *this; } std::string InventoryList::getName() { return m_name; } u32 InventoryList::getSize() { return m_items.size(); } u32 InventoryList::getUsedSlots() { u32 num = 0; for(u32 i=0; i<m_items.size(); i++) { InventoryItem *item = m_items[i]; if(item != NULL) num++; } return num; } InventoryItem * InventoryList::getItem(u32 i) { if(i > m_items.size() - 1) return NULL; return m_items[i]; } InventoryItem * InventoryList::changeItem(u32 i, InventoryItem *newitem) { assert(i < m_items.size()); InventoryItem *olditem = m_items[i]; m_items[i] = newitem; return olditem; } void InventoryList::deleteItem(u32 i) { assert(i < m_items.size()); InventoryItem *item = changeItem(i, NULL); if(item) delete item; } InventoryItem * InventoryList::addItem(InventoryItem *newitem) { /* First try to find if it could be added to some existing items */ for(u32 i=0; i<m_items.size(); i++) { // Ignore empty slots if(m_items[i] == NULL) continue; // Try adding newitem = addItem(i, newitem); if(newitem == NULL) return NULL; // All was eaten } /* Then try to add it to empty slots */ for(u32 i=0; i<m_items.size(); i++) { // Ignore unempty slots if(m_items[i] != NULL) continue; // Try adding newitem = addItem(i, newitem); if(newitem == NULL) return NULL; // All was eaten } // Return leftover return newitem; } InventoryItem * InventoryList::addItem(u32 i, InventoryItem *newitem) { // If it is an empty position, it's an easy job. InventoryItem *to_item = m_items[i]; if(to_item == NULL) { m_items[i] = newitem; return NULL; } // If not addable, return the item if(newitem->addableTo(to_item) == false) return newitem; // If the item fits fully in the slot, add counter and delete it if(newitem->getCount() <= to_item->freeSpace()) { to_item->add(newitem->getCount()); delete newitem; return NULL; } // Else the item does not fit fully. Add all that fits and return // the rest. else { u16 freespace = to_item->freeSpace(); to_item->add(freespace); newitem->remove(freespace); return newitem; } } InventoryItem * InventoryList::takeItem(u32 i, u32 count) { if(count == 0) return NULL; InventoryItem *item = m_items[i]; // If it is an empty position, return NULL if(item == NULL) return NULL; if(count >= item->getCount()) { // Get the item by swapping NULL to its place return changeItem(i, NULL); } else { InventoryItem *item2 = item->clone(); item->remove(count); item2->setCount(count); return item2; } return false; } void InventoryList::decrementMaterials(u16 count) { for(u32 i=0; i<m_items.size(); i++) { InventoryItem *item = takeItem(i, count); if(item) delete item; } } void InventoryList::print(std::ostream &o) { o<<"InventoryList:"<<std::endl; for(u32 i=0; i<m_items.size(); i++) { InventoryItem *item = m_items[i]; if(item != NULL) { o<<i<<": "; item->serialize(o); o<<"\n"; } } } /* Inventory */ Inventory::~Inventory() { clear(); } void Inventory::clear() { for(u32 i=0; i<m_lists.size(); i++) { delete m_lists[i]; } m_lists.clear(); } Inventory::Inventory() { } Inventory::Inventory(const Inventory &other) { *this = other; } Inventory & Inventory::operator = (const Inventory &other) { clear(); for(u32 i=0; i<other.m_lists.size(); i++) { m_lists.push_back(new InventoryList(*other.m_lists[i])); } return *this; } void Inventory::serialize(std::ostream &os) { for(u32 i=0; i<m_lists.size(); i++) { InventoryList *list = m_lists[i]; os<<"List "<<list->getName()<<" "<<list->getSize()<<"\n"; list->serialize(os); } os<<"EndInventory\n"; } void Inventory::deSerialize(std::istream &is) { clear(); for(;;) { std::string line; std::getline(is, line, '\n'); std::istringstream iss(line); std::string name; std::getline(iss, name, ' '); if(name == "EndInventory") { break; } else if(name == "List") { std::string listname; u32 listsize; std::getline(iss, listname, ' '); iss>>listsize; InventoryList *list = new InventoryList(listname, listsize); list->deSerialize(is); m_lists.push_back(list); } else { throw SerializationError("Unknown inventory identifier"); } } } InventoryList * Inventory::addList(const std::string &name, u32 size) { s32 i = getListIndex(name); if(i != -1) { if(m_lists[i]->getSize() != size) { delete m_lists[i]; m_lists[i] = new InventoryList(name, size); } return m_lists[i]; } else { m_lists.push_back(new InventoryList(name, size)); return m_lists.getLast(); } } InventoryList * Inventory::getList(const std::string &name) { s32 i = getListIndex(name); if(i == -1) return NULL; return m_lists[i]; } s32 Inventory::getListIndex(const std::string &name) { for(u32 i=0; i<m_lists.size(); i++) { if(m_lists[i]->getName() == name) return i; } return -1; } /* InventoryAction */ InventoryAction * InventoryAction::deSerialize(std::istream &is) { std::string type; std::getline(is, type, ' '); InventoryAction *a = NULL; if(type == "Move") { a = new IMoveAction(is); } return a; } void IMoveAction::apply(Inventory *inventory) { /*dstream<<"from_name="<<from_name<<" to_name="<<to_name<<std::endl; dstream<<"from_i="<<from_i<<" to_i="<<to_i<<std::endl;*/ InventoryList *list_from = inventory->getList(from_name); InventoryList *list_to = inventory->getList(to_name); /*dstream<<"list_from="<<list_from<<" list_to="<<list_to <<std::endl;*/ /*if(list_from) dstream<<" list_from->getItem(from_i)="<<list_from->getItem(from_i) <<std::endl; if(list_to) dstream<<" list_to->getItem(to_i)="<<list_to->getItem(to_i) <<std::endl;*/ /* If a list doesn't exist or the source item doesn't exist or the source and the destination slots are the same */ if(!list_from || !list_to || list_from->getItem(from_i) == NULL || (list_from == list_to && from_i == to_i)) { dstream<<__FUNCTION_NAME<<": Operation not allowed"<<std::endl; return; } // Take item from source list InventoryItem *item1 = NULL; if(count == 0) item1 = list_from->changeItem(from_i, NULL); else item1 = list_from->takeItem(from_i, count); // Try to add the item to destination list InventoryItem *olditem = item1; item1 = list_to->addItem(to_i, item1); // If nothing is returned, the item was fully added if(item1 == NULL) return; // If olditem is returned, nothing was added. bool nothing_added = (item1 == olditem); // If something else is returned, part of the item was left unadded. // Add the other part back to the source item list_from->addItem(from_i, item1); // If olditem is returned, nothing was added. // Swap the items if(nothing_added) { // Take item from source list item1 = list_from->changeItem(from_i, NULL); // Adding was not possible, swap the items. InventoryItem *item2 = list_to->changeItem(to_i, item1); // Put item from destination list to the source list list_from->changeItem(from_i, item2); return; } } //END
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-19 01:52:15 +0000