By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
446,190 Members | 822 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 446,190 IT Pros & Developers. It's quick & easy.

128 bit integer code needed

P: n/a
Hi

I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.

Has anyone here code that uses 128 bit integers?

Thanks in advance

P.S. This feature is now native in the 64 bit version, i.e.
not using operator overloading as in the 32 bit version.

--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32
Jun 27 '08 #1
Share this Question
Share on Google+
9 Replies


P: n/a
jacob navia <ja***@nospam.comwrites:
I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.
Sounds interesting. Out of curiosity, just how are you defining your
128-bit integer types? C99 introduced the concept of "extended
integer types" (C99 6.2.5); are you using that? If not, I encourage
you to do so. And are you making intmax_t and uintmax_t 128 bits?
Has anyone here code that uses 128 bit integers?
Sorry, I don't, but you might look for code that manipulates IPv6
addresses. (Then again, since few implementations provide 128-bit
integers, I'm sure most IPv6 code doesn't try to use them.)

--
Keith Thompson (The_Other_Keith) <ks***@mib.org>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
Jun 27 '08 #2

P: n/a
On Apr 29, 5:13*am, jacob navia <ja...@nospam.comwrote:
Hi

I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.

Has anyone here code that uses 128 bit integers?

Thanks in advance

P.S. This feature is now native in the 64 bit version, i.e.
not using operator overloading as in the 32 bit version.
http://svn.gnucash.org/docs/HEAD/group__Math128.html
http://developer.apple.com/hardwared...ds/vBigNum.tgz

If you check out news:sci.crypt, you will find a boatload of this
stuff.
Jun 27 '08 #3

P: n/a
jacob navia <ja***@nospam.comwrites:
I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.

Has anyone here code that uses 128 bit integers?
[...]

You might look for code that uses some extended-width integer library
such as GMP, but that doesn't need values beyond what can be
represented in 128 bits. As I wrote before, the fact that most
implementations don't provide 128-bit integers is likely to make it
hard to find code that depends on them, but the above may be a good
way to find code that *would* use 128-bit integers if they were
available.

That's admittedly vague. I'd provide more specific references if I
had any.

--
Keith Thompson (The_Other_Keith) <ks***@mib.org>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
Jun 27 '08 #4

P: n/a
user923005 wrote:
On Apr 29, 5:13 am, jacob navia <ja...@nospam.comwrote:
>Hi

I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.

Has anyone here code that uses 128 bit integers?

Thanks in advance

P.S. This feature is now native in the 64 bit version, i.e.
not using operator overloading as in the 32 bit version.

http://svn.gnucash.org/docs/HEAD/group__Math128.html
http://developer.apple.com/hardwared...ds/vBigNum.tgz

If you check out news:sci.crypt, you will find a boatload of this
stuff.
Thanks for the tips
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32
Jun 27 '08 #5

P: n/a
Keith Thompson wrote:
jacob navia <ja***@nospam.comwrites:
>I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.

Sounds interesting. Out of curiosity, just how are you defining your
128-bit integer types?
__int128

There is no unsigned as yet. Many other things must be done first:
o printing them with printf. Format "%I128d"
o scanning them with scanf. Same format
o Algebraic simplifications in the compiler
C99 introduced the concept of "extended
integer types" (C99 6.2.5); are you using that? If not, I encourage
you to do so. And are you making intmax_t and uintmax_t 128 bits?
Very probably but that is too son. I have to get the basics right first.

In 32 bits I use operator overloading and there is no printf support...
This is different.
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32
Jun 27 '08 #6

P: n/a

"jacob navia" <ja***@nospam.comwrote in message
news:fv**********@aioe.org...
Hi

I am incorporating 128 Bit integer code into lcc-win and it would be nice
to have some code to test this feature.

Has anyone here code that uses 128 bit integers?

Thanks in advance

P.S. This feature is now native in the 64 bit version, i.e.
not using operator overloading as in the 32 bit version.
my case, I just beat together more basic tests and verified output
manually...

however, in my case I also have an even more debatable feature:
128 bit pointers...

basic idea: 16 bit tag, 48 bit segment, 64 bit offset.
purpose: persistent storage, possibly DSM.
why such big segments: so they can be unique and generated with an RNG.

....
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32

Jun 27 '08 #7

P: n/a
jacob navia <ja***@nospam.comwrites:
Keith Thompson wrote:
>jacob navia <ja***@nospam.comwrites:
>>I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.

Sounds interesting. Out of curiosity, just how are you defining your
128-bit integer types?

__int128

There is no unsigned as yet. Many other things must be done first:
o printing them with printf. Format "%I128d"
o scanning them with scanf. Same format
As long as you provide the proper macros in <inttypes.hand typedefs
in <stdint.h>, users won't have to know what format strings you use
for printf and scanf. If I can refer to int128_t (or intleast128_t or
intfast128_t), I don't have to worry about whether the underlying type
is called __int128 or __longlonglong.

(To be clear, this is not a criticism of your choice of "__int128" or
"%I128d".)

[snip]

--
Keith Thompson (The_Other_Keith) <ks***@mib.org>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
Jun 27 '08 #8

P: n/a
On Apr 29, 1:43*pm, jacob navia <ja...@nospam.comwrote:
user923005 wrote:
On Apr 29, 5:13 am, jacob navia <ja...@nospam.comwrote:
Hi
I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.
Has anyone here code that uses 128 bit integers?
Thanks in advance
P.S. This feature is now native in the 64 bit version, i.e.
not using operator overloading as in the 32 bit version.
http://svn.gnucash.org/docs/HEAD/group__Math128.html
http://developer.apple.com/hardwared...ds/vBigNum.tgz
If you check out news:sci.crypt, you will find a boatload of this
stuff.

Thanks for the tips
Here are some integer multiplication benchmarks:
http://cr.yp.to/speed/mult.html

Here are some crypto links:
http://directory.google.com/Top/Scie...ing_Libraries/
<OT>
I don't know if you can use C++, but the Crypto++ library has an
Integer class with all the operations defined.
integer.h(217): Integer& operator=(const Integer& t);
integer.h(220): Integer& operator+=(const Integer& t);
integer.h(222): Integer& operator-=(const Integer& t);
integer.h(224): Integer& operator*=(const Integer& t) {return *this =
Times(t);}
integer.h(226): Integer& operator/=(const Integer& t) {return *this =
DividedBy(t);}
integer.h(228): Integer& operator%=(const Integer& t) {return *this =
Modulo(t);}
integer.h(230): Integer& operator/=(word t) {return *this =
DividedBy(t);}
integer.h(232): Integer& operator%=(word t) {return *this =
Integer(POSITIVE, 0, Modulo(t));}
integer.h(235): Integer& operator<<=(size_t);
integer.h(237): Integer& operator>>=(size_t);
integer.h(273): bool operator!() const;
integer.h(275): Integer operator+() const {return *this;}
integer.h(277): Integer operator-() const;
integer.h(279): Integer& operator++();
integer.h(281): Integer& operator--();
integer.h(283): Integer operator++(int) {Integer temp = *this; +
+*this; return temp;}
integer.h(285): Integer operator--(int) {Integer temp = *this; --
*this; return temp;}
integer.h(313): Integer operator>>(size_t n) const {return
Integer(*this)>>=n;}
integer.h(315): Integer operator<<(size_t n) const {return
Integer(*this)<<=n;}
integer.h(360): friend CRYPTOPP_DLL std::istream& CRYPTOPP_API
operator>>(std::istream& in, Integer &a);
integer.h(362): friend CRYPTOPP_DLL std::ostream& CRYPTOPP_API
operator<<(std::ostream& out, const Integer &a);
integer.h(383):inline bool operator==(const CryptoPP::Integer& a,
const CryptoPP::Integer& b) {return a.Compare(b)==0;}
integer.h(385):inline bool operator!=(const CryptoPP::Integer& a,
const CryptoPP::Integer& b) {return a.Compare(b)!=0;}
integer.h(387):inline bool operator(const CryptoPP::Integer& a,
const CryptoPP::Integer& b) {return a.Compare(b)0;}
integer.h(389):inline bool operator>=(const CryptoPP::Integer& a,
const CryptoPP::Integer& b) {return a.Compare(b)>=0;}
integer.h(391):inline bool operator< (const CryptoPP::Integer& a,
const CryptoPP::Integer& b) {return a.Compare(b)< 0;}
integer.h(393):inline bool operator<=(const CryptoPP::Integer& a,
const CryptoPP::Integer& b) {return a.Compare(b)<=0;}
integer.h(395):inline CryptoPP::Integer operator+(const
CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Plus(b);}
integer.h(397):inline CryptoPP::Integer operator-(const
CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Minus(b);}
integer.h(399):inline CryptoPP::Integer operator*(const
CryptoPP::Integer &a, const CryptoPP::Integer &b) {return a.Times(b);}
integer.h(401):inline CryptoPP::Integer operator/(const
CryptoPP::Integer &a, const CryptoPP::Integer &b) {return
a.DividedBy(b);}
integer.h(403):inline CryptoPP::Integer operator%(const
CryptoPP::Integer &a, const CryptoPP::Integer &b) {return
a.Modulo(b);}
integer.h(405):inline CryptoPP::Integer operator/(const
CryptoPP::Integer &a, CryptoPP::word b) {return a.DividedBy(b);}
integer.h(407):inline CryptoPP::word operator%(const CryptoPP::Integer
&a, CryptoPP::word b) {return a.Modulo(b);}
</OT>

Jun 27 '08 #9

P: n/a
On Apr 29, 5:13*am, jacob navia <ja...@nospam.comwrote:
Hi

I am incorporating 128 Bit integer code into lcc-win and it would be
nice to have some code to test this feature.

Has anyone here code that uses 128 bit integers?

Thanks in advance

P.S. This feature is now native in the 64 bit version, i.e.
not using operator overloading as in the 32 bit version.
This stuff looks to be worth a look:
http://libtom.org/?page=features&new...5&whatfile=tfm
Jun 27 '08 #10

This discussion thread is closed

Replies have been disabled for this discussion.