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
|
/**************************************************************************
* *
* Regina - A Normal Surface Theory Calculator *
* Python Interface *
* *
* Copyright (c) 1999-2009, Ben Burton *
* For further details contact Ben Burton (bab@debian.org). *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
* published by the Free Software Foundation; either version 2 of the *
* License, or (at your option) any later version. *
* *
* This program 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 *
* General Public License for more details. *
* *
* You should have received a copy of the GNU General Public *
* License along with this program; if not, write to the Free *
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
* MA 02110-1301, USA. *
* *
**************************************************************************/
/* end stub */
#include "maths/nprimes.h"
#include <boost/python.hpp>
using namespace boost::python;
using regina::NLargeInteger;
using regina::NPrimes;
namespace {
BOOST_PYTHON_FUNCTION_OVERLOADS(OL_prime, NPrimes::prime, 1, 2);
boost::python::list primeDecomp_list(const NLargeInteger& n) {
std::vector<NLargeInteger> factors = NPrimes::primeDecomp(n);
boost::python::list ans;
for (std::vector<NLargeInteger>::const_iterator it = factors.begin();
it != factors.end(); ++it)
ans.append(*it);
return ans;
}
boost::python::list primeDecomp_list_int(const NLargeInteger& n) {
std::vector<NLargeInteger> factors = NPrimes::primeDecomp(n);
boost::python::list ans;
for (std::vector<NLargeInteger>::const_iterator it = factors.begin();
it != factors.end(); ++it)
ans.append(it->longValue());
return ans;
}
boost::python::list primePowerDecomp_list(const NLargeInteger& n) {
std::vector<std::pair<NLargeInteger, unsigned long> >
factors = NPrimes::primePowerDecomp(n);
boost::python::list ans;
for (std::vector<std::pair<NLargeInteger, unsigned long> >::
const_iterator it = factors.begin(); it != factors.end(); ++it)
ans.append(make_tuple(it->first, it->second));
return ans;
}
boost::python::list primePowerDecomp_list_int(const NLargeInteger& n) {
std::vector<std::pair<NLargeInteger, unsigned long> >
factors = NPrimes::primePowerDecomp(n);
boost::python::list ans;
for (std::vector<std::pair<NLargeInteger, unsigned long> >::
const_iterator it = factors.begin(); it != factors.end(); ++it)
ans.append(make_tuple(it->first.longValue(), it->second));
return ans;
}
}
void addNPrimes() {
class_<NPrimes>("NPrimes", no_init)
.def("size", &NPrimes::size)
.def("prime", &NPrimes::prime, OL_prime())
.def("primeDecomp", primeDecomp_list)
.def("primeDecompInt", primeDecomp_list_int)
.def("primePowerDecomp", primePowerDecomp_list)
.def("primePowerDecompInt", primePowerDecomp_list_int)
.staticmethod("size")
.staticmethod("prime")
.staticmethod("primeDecomp")
.staticmethod("primeDecompInt")
.staticmethod("primePowerDecomp")
.staticmethod("primePowerDecompInt")
;
}
|
