extern int max_recursion_level;
// convenience macros
+
#define is_of_type(OBJ,TYPE) \
(dynamic_cast<TYPE *>(const_cast<GiNaC::basic *>(&OBJ))!=0)
#define is_ex_exactly_of_type(OBJ,TYPE) \
((*(OBJ).bp).tinfo()==GiNaC::TINFO_##TYPE)
-
-// global functions
-
-inline unsigned rotate_left_31(unsigned n)
-{
- // clear highest bit and shift 1 bit to the left
- n=(n & 0x7FFFFFFFU) << 1;
-
- // overflow? clear highest bit and set lowest bit
- if (n & 0x80000000U) {
- n=(n & 0x7FFFFFFFU) | 0x00000001U;
- }
-
- ASSERT(n<0x80000000U);
-
- return n;
-}
-
-inline unsigned golden_ratio_hash(unsigned n)
-{
-#if 0
- // This requires ´long long´ (or an equivalent 64 bit type)---which is,
- // unfortunately, not ANSI-compliant:
- unsigned long long l = n * 0x4f1bbcddLL;
- return (l & 0x7fffffffU) ^ (l >> 32);
-#else
- // This requires ´long double´ to have a mantissa of at least 64 bit---
- // which is not guaranteed by any standard:
- const static long double golden_ratio=.618033988749894848204586834370;
- long double m=golden_ratio*n;
- return unsigned((m-int(m))*0x80000000);
-#endif
-}
-
} // namespace GiNaC
#endif // ndef __GINAC_BASIC_H__
#include "expairseq.h"
#include "lst.h"
#include "debugmsg.h"
+#include "utils.h"
namespace GiNaC {
return ncmul(v,1);
}
+/** Force inclusion of functions from initcns_gamma and inifcns_zeta
+ * for static lib (so ginsh will see them). */
+unsigned force_include_gamma = function_index_gamma;
+unsigned force_include_zeta = function_index_zeta;
+
} // namespace GiNaC
/** Riemann's Zeta-function. */
DECLARE_FUNCTION_1P(zeta)
-DECLARE_FUNCTION_2P(zeta)
-
+//DECLARE_FUNCTION_2P(zeta)
+
/** Gamma-function. */
DECLARE_FUNCTION_1P(gamma)
/** Psi-function (aka polygamma-function). */
-DECLARE_FUNCTION_1P(psi)
+//DECLARE_FUNCTION_1P(psi)
DECLARE_FUNCTION_2P(psi)
/** Factorial function. */
namespace GiNaC {
+/** Integer binary logarithm */
unsigned log2(unsigned n)
{
unsigned k;
return k;
}
+/** Compare two pointers (just to establish some sort of canonical order).
+ * @return -1, 0, or 1 */
int compare_pointers(void const * a, void const * b)
{
if (a<b) {
return 0;
}
-// comment skeletton for header files
+
+// comment skeleton for header files
// member functions
-// comment skeletton for implementation files
+// comment skeleton for implementation files
//////////
#include <strstream>
#include <string>
#include "config.h"
+#include "assertion.h"
namespace GiNaC {
int compare_pointers(void const * a, void const * b);
+/** Rotate lower 31 bits of unsigned value by one bit to the left
+ * (upper bits get cleared). */
+inline unsigned rotate_left_31(unsigned n)
+{
+ // clear highest bit and shift 1 bit to the left
+ n=(n & 0x7FFFFFFFU) << 1;
+
+ // overflow? clear highest bit and set lowest bit
+ if (n & 0x80000000U) {
+ n=(n & 0x7FFFFFFFU) | 0x00000001U;
+ }
+ ASSERT(n<0x80000000U);
+
+ return n;
+}
+
+/** Golden ratio hash function. */
+inline unsigned golden_ratio_hash(unsigned n)
+{
+ // This function requires arithmetic with at least 64 significant bits
+#if SIZEOF_LONG_DOUBLE > 8
+ // If "long double" is bigger than 64 bits, we assume that the mantissa
+ // has at least 64 bits. This is not guaranteed but it's a good guess.
+ const static long double golden_ratio = .618033988749894848204586834370;
+ long double m = golden_ratio * n;
+ return unsigned((m - int(m)) * 0x80000000);
+#elif SIZEOF_LONG >= 8
+ // "long" has 64 bits, so we prefer it because it might be more efficient
+ // than "long long"
+ unsigned long l = n * 0x4f1bbcddL;
+ return (l & 0x7fffffffU) ^ (l >> 32);
+#elif SIZEOF_LONG_LONG >= 8
+ // This requires ´long long´ (or an equivalent 64 bit type)---which is,
+ // unfortunately, not ANSI-compliant:
+ unsigned long long l = n * 0x4f1bbcddLL;
+ return (l & 0x7fffffffU) ^ (l >> 32);
+#else
+#error "No 64 bit data type. You lose."
+#endif
+}
+
// modified from stl_algo.h: always do com(*first1,*first2) instead of comp(*first2,*first1)
template <class InputIterator1, class InputIterator2, class OutputIterator,
class Compare>