Ran in:

0 个投票

Ran in:
I was working with BigIntegers to solve a problem on Cody, where I got stuck upon something.
import java.math.*
BigInteger(10)
ans = 10
BigInteger(1234)
ans = -46
BigInteger(num2str(1234))
ans = 1234
I tried to find why this happens but I couldn't find any useful resources. I have no knowledge of Java if anyone needs to know.
Is the default input to BigInteger a string/character array? (Which I suspect so)
Also an odd behaviour (which I don't understand)? Can someone explan why this happens?
for i=1:11
BigInteger(2^i+1)
end
ans = 3 ans = 5 ans = 9 ans = 17 ans = 33 ans = 65 ans = -127 ans = 1 ans = 1 ans = 1 ans = 1

请先登录，再回答此问题。

 采纳的回答

Walter Roberson
Walter Roberson 2022-2-1

1 个投票

https://docs.oracle.com/javase/7/docs/api/java/math/BigInteger.html
The single-parameter form of BigInteger with a numeric parameter is
"BigInteger(byte[] val)
Translates a byte array containing the two's-complement binary representation of a BigInteger into a BigInteger."
So when you pass in a numeric value, it converts the numeric value to a signed byte.
When you pass in the result of num2str() you are using a different constructor,
"BigInteger(String val)
Translates the decimal String representation of a BigInteger into a BigInteger."

5 个评论
显示 3更早的评论 隐藏 3更早的评论

Dyuman Joshi
Dyuman Joshi 2022-2-3
"Translates a byte array containing the two's-complement binary representation of a BigInteger into a BigInteger."
But it doesn't for all values, as we saw from the loop.
This is from the link you mentioned - "The input array is assumed to be in big-endian byte-order: the most significant byte is in the zeroth element."
Could you please explain this?
Walter Roberson
Walter Roberson 2022-2-3
Take
x8 = uint8(mod(fix(double(x)),256));
Now construct a numel(x8) * 8 bit number that is mathematically
BigInt = sum(x8 .* (256.^ (numel(x8)-1:-1:0)))
so like .... + x8(end-2) * 256^2 + x8(end-1) * 256^1 + x8(end) * 256^0
so the first element in x8 is the "most significant" (changes the final result by the most), and the last element in x8 is the "least significant" (makes a different of no more than 255)
But mark the integer as being a signed integer. Another way of saying that is
if x8(1) >= 128
BigIntSigned = BigInt - 256^numel(x8)
else
BigIntSigned - BigInt;
end
So when you get to 2^7+1 then that is 129, fix(129) is 129, mod(129,256) is 129. It is the only entry so numel() is 1. It is >= 128, so you take the 129 - 256^1 which is 129 - 256 which is -127 . Which matches
>> BigInteger(129)
ans =
-127
Dyuman Joshi
Dyuman Joshi 2022-2-15
Thanks for the explanation, I understand it much better now.
I have one more question, why 256?
Walter Roberson
Walter Roberson 2022-2-15
One byte holds 8 bits, and 2^8 = 256 .
The BigInteger class always uses full bytes -- you cannot define a BigInteger that is (for example) 11 bits long
Dyuman Joshi
Dyuman Joshi 2022-2-15
That makes it clear, thanks!

请先登录，再进行评论。

更多回答（0 个）

类别

在 帮助中心 和 File Exchange 中查找有关 Matrix Indexing 的更多信息

产品

标签

Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!

Translated by