bigfloat II

[Don]

Paul D. Anderson wrote:
> Don Wrote:
> 
>> Paul D. Anderson wrote:
>>> The implementation will comply with IEEE 754-2008. I just wanted to illustrate that precision can depend on the operation as well as the operands.
>>>
>>> Paul
>> I'm not sure why you think there needs to be a precision depending on 
>> the operation.
>> The IEEE 754-2008 has the notion of "Widento" precision, but AFAIK it's 
>> primarily to support x87 -- it's pretty clear that the normal mode of 
>> operation is to use the precision which is the maximum precision of the 
>> operands. Even when there is a Widento mode, it's only provided for the 
>> non-storage formats (Ie, 80-bit reals only).
>>
>> I think it should operate the way int and long does:
>> typeof(x*y) is x if x.mant_dig >= y.mant_dig, else y.
>> What you might perhaps do is have a global setting for adjusting the 
>> default size of a newly constructed variable. But it would only affect 
>> constructors, not temporaries inside expressions.
> 
> I agree. I seem to have stated it badly, but I'm not suggesting there is a precision inherent in an operation. I'm just considering the possibility that the user may not want the full precision of the operands for the result of a particular operation.
> 
> Java's BigDecimal class allows for this by including a context object as a parameter to the operation. For D we would allow for this by changing the context, where the precision in the context would govern the precision of the result.
> 
> So the precision of a new variable, in the absence of an explicit instruction, would be the context precision, and the precision of the result of an operation would be no greater than the context precision, but would otherwise be the the larger of the precision of the operands.
> 
> So if a user wanted to perform arithmetic at a given precision he would set the context precision to that value. If he wanted the precision to grow to match the largest operand precision (i.e., no fixed precision) he would set the context precision to be larger than any expected value. (Or maybe we could explicitly provide for this.)

You could increase the precision of a calculation by changing the 
precision of one of the operands. For that to work, you would need a way 
to create a new variable which copies the precision from another one.

> 
> In any case, the operation would be carried out at the operand precision(s) and only rounded, if necessary, at the point of return.
> 
> I hope that's a clearer statement of what I'm implementing. If I've still missed something important, let me know.

In any case, it seems to me that it doesn't affect the code very much. 
It's much easier to decide such things once you have working code and 
some real use cases.