You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@vxquery.apache.org by Vinayak Borkar <vb...@yahoo.com> on 2012/06/15 16:09:22 UTC
Arithmetic Functions
Preston,
I have now added some scaffolding so that implementing the arithmetic
functions will be easier.
I have also added the code for xs:integer + xs:integer which is needed
for the 1 + 1 example, ant it works end-to-end.
Look at the AddScalarEvaluatorFactory class. You will be creating a
class like that for each of Subtract, Multiply, and Divide by extending
AbstractArithmeticScalarEvaluatorFactory.
The only method that you have to implement when you extend
AbstractArithmeticScalarEvaluatorFactory is the
createArithmeticOperation() method that creates an instance of
AbstractArithmeticOperation.
For example, the one for Add looks like this:
@Override
protected AbstractArithmeticOperation createArithmeticOperation() {
return new AddOperation();
}
The AddOperation implements all the logic for what it means to add two
values of various types.
The AbstractArithmeticScalarEvaluatorFactory has all the logic to
correctly dispatch to the correct method in AbstractArithmeticOperation
based on XQuery rules.
As your next step, please implement all the methods in AddOperation. The
methods in this class look like
void operateXY(X x, Y y, DataOutput dOut)
where X and Y are type names.
For example the method that computes the result for xs:integer and
xs:double would read:
void operateIntegerDouble(LongPointable longp, DoublePointable doublep,
DataOutput dOut)
Since Add is commutative, you can implement about half of the methods by
delegating to the other half (by switching the arguments). The
convention you should follow is have operateXY delegate to operateYX
when X is lexicographically greater than Y.
So in the above example, operateIntegerDouble will delegate to
operateDoubleInteger in the AddOperation class.
Note that this trick does not apply to Minus and Divide, but applied to
Multiply.
Let us know how it goes with implementing the unimplemented methods in
AddOperation and then implemnting the other arithmetic operation classes.
Vinayak
Re: Arithmetic Functions
Posted by Eldon Carman <ec...@ucr.edu>.
I have implemented several functions. The attached patch shows the
changes. How can I write a xquery to test the different numeric
types? I tried casting value to one I want, but it always comes back
as an integer.
Also it looks like the decimal pointable is only supported by xquery
and not Hyracks. Should we add all the other features you find in the
other classes for FloatPointable, IntegerPointable and
DoublePointable? As it stands, we do not have access to some functions
like floatValue().
Thanks for your feedback.
Preston
On Fri, Jun 15, 2012 at 7:09 AM, Vinayak Borkar <vb...@yahoo.com> wrote:
> Preston,
>
>
> I have now added some scaffolding so that implementing the arithmetic
> functions will be easier.
>
> I have also added the code for xs:integer + xs:integer which is needed for
> the 1 + 1 example, ant it works end-to-end.
>
> Look at the AddScalarEvaluatorFactory class. You will be creating a class
> like that for each of Subtract, Multiply, and Divide by extending
> AbstractArithmeticScalarEvaluatorFactory.
>
> The only method that you have to implement when you extend
> AbstractArithmeticScalarEvaluatorFactory is the createArithmeticOperation()
> method that creates an instance of AbstractArithmeticOperation.
>
> For example, the one for Add looks like this:
>
> @Override
> protected AbstractArithmeticOperation createArithmeticOperation() {
> return new AddOperation();
> }
>
>
> The AddOperation implements all the logic for what it means to add two
> values of various types.
>
> The AbstractArithmeticScalarEvaluatorFactory has all the logic to correctly
> dispatch to the correct method in AbstractArithmeticOperation based on
> XQuery rules.
>
> As your next step, please implement all the methods in AddOperation. The
> methods in this class look like
>
> void operateXY(X x, Y y, DataOutput dOut)
>
> where X and Y are type names.
>
> For example the method that computes the result for xs:integer and xs:double
> would read:
>
> void operateIntegerDouble(LongPointable longp, DoublePointable doublep,
> DataOutput dOut)
>
> Since Add is commutative, you can implement about half of the methods by
> delegating to the other half (by switching the arguments). The convention
> you should follow is have operateXY delegate to operateYX when X is
> lexicographically greater than Y.
>
> So in the above example, operateIntegerDouble will delegate to
> operateDoubleInteger in the AddOperation class.
>
> Note that this trick does not apply to Minus and Divide, but applied to
> Multiply.
>
> Let us know how it goes with implementing the unimplemented methods in
> AddOperation and then implemnting the other arithmetic operation classes.
>
> Vinayak
Re: Arithmetic Functions
Posted by Vinayak Borkar <vb...@yahoo.com>.
Where is the patch? Did you forget to attache it to the mail?
Thanks,
Vinayak
On 6/17/12 6:10 PM, Eldon Carman wrote:
> I went through add, subtract, divide and multiply. Here is a patch of
> my changes. I skipped the date functions, since we have not talked
> about the date format and the Pointable classes are just stubbed out.
> The XSDecimalPointable has been updated off a copy of DoublePointable
> and just renamed. Not sure if this is correct, but now all the
> Integer, Float and Double all used the same functions when doing the
> operations.
>
> When you have time I would like your feedback.
>
> Thanks
> Preston
>
> On Fri, Jun 15, 2012 at 5:24 PM, Till Westmann <ti...@westmann.org> wrote:
>>
>> On Jun 15, 2012, at 5:06 PM, Eldon Carman wrote:
>>
>>> Ok. Now for these mixed types that are added together, there is a
>>> promotion order. Basically the largest numeric type gets used. I have
>>> been trying to find documentation on the promotion order. Is that what
>>> I listed before? (size order)
>>>
>>> 1. double (double-precision 64-bit floating point type) - Java type double
>>> 2. float (single-precision 32-bit floating point type) - Java type float
>>> 3. decimal (a minimum of 18 decimal digits) - Java type double ???
>>> 4. integer (a decimal type with a fixed decimal point) - Java type long
>>>
>>> Also do you know where that is in the xquery specification?
>>
>> Here it is:
>> http://www.w3.org/TR/xquery/#id-type-promotion-and-operator-mapping
>>
>>> On Fri, Jun 15, 2012 at 4:39 PM, Vinayak Borkar <vb...@yahoo.com> wrote:
>>>> Lexicographical order is text sort order. So:
>>>>
>>>> decimal
>>>> double
>>>> float
>>>> integer
>>>>
>>>> xs:integer is supposed to be infinite precision, but we represent it as a 64
>>>> bit fixed-precision signed-integer which is a long in java.
>>>>
>>>> Vinayak
>>>>
>>>>
>>>>
>>>> On 6/15/12 3:11 PM, Eldon Carman wrote:
>>>>>
>>>>> Thanks for the scaffolding. I have two questions. Is this the correct
>>>>> lexicographical order?
>>>>> 1. double
>>>>> 2. float
>>>>> 3. decimal
>>>>> 4. integer
>>>>>
>>>>> Also do we always referrer to a integer as a long for this implementation?
>>>>>
>>>>> Preston
>>>>>
>>>>> On Fri, Jun 15, 2012 at 7:09 AM, Vinayak Borkar<vb...@yahoo.com> wrote:
>>>>>>
>>>>>> Preston,
>>>>>>
>>>>>>
>>>>>> I have now added some scaffolding so that implementing the arithmetic
>>>>>> functions will be easier.
>>>>>>
>>>>>> I have also added the code for xs:integer + xs:integer which is needed
>>>>>> for
>>>>>> the 1 + 1 example, ant it works end-to-end.
>>>>>>
>>>>>> Look at the AddScalarEvaluatorFactory class. You will be creating a class
>>>>>> like that for each of Subtract, Multiply, and Divide by extending
>>>>>> AbstractArithmeticScalarEvaluatorFactory.
>>>>>>
>>>>>> The only method that you have to implement when you extend
>>>>>> AbstractArithmeticScalarEvaluatorFactory is the
>>>>>> createArithmeticOperation()
>>>>>> method that creates an instance of AbstractArithmeticOperation.
>>>>>>
>>>>>> For example, the one for Add looks like this:
>>>>>>
>>>>>> @Override
>>>>>> protected AbstractArithmeticOperation createArithmeticOperation() {
>>>>>> return new AddOperation();
>>>>>> }
>>>>>>
>>>>>>
>>>>>> The AddOperation implements all the logic for what it means to add two
>>>>>> values of various types.
>>>>>>
>>>>>> The AbstractArithmeticScalarEvaluatorFactory has all the logic to
>>>>>> correctly
>>>>>> dispatch to the correct method in AbstractArithmeticOperation based on
>>>>>> XQuery rules.
>>>>>>
>>>>>> As your next step, please implement all the methods in AddOperation. The
>>>>>> methods in this class look like
>>>>>>
>>>>>> void operateXY(X x, Y y, DataOutput dOut)
>>>>>>
>>>>>> where X and Y are type names.
>>>>>>
>>>>>> For example the method that computes the result for xs:integer and
>>>>>> xs:double
>>>>>> would read:
>>>>>>
>>>>>> void operateIntegerDouble(LongPointable longp, DoublePointable doublep,
>>>>>> DataOutput dOut)
>>>>>>
>>>>>> Since Add is commutative, you can implement about half of the methods by
>>>>>> delegating to the other half (by switching the arguments). The convention
>>>>>> you should follow is have operateXY delegate to operateYX when X is
>>>>>> lexicographically greater than Y.
>>>>>>
>>>>>> So in the above example, operateIntegerDouble will delegate to
>>>>>> operateDoubleInteger in the AddOperation class.
>>>>>>
>>>>>> Note that this trick does not apply to Minus and Divide, but applied to
>>>>>> Multiply.
>>>>>>
>>>>>> Let us know how it goes with implementing the unimplemented methods in
>>>>>> AddOperation and then implemnting the other arithmetic operation classes.
>>>>>>
>>>>>> Vinayak
>>>>>
>>>>>
>>>>
>>
Re: Arithmetic Functions
Posted by Eldon Carman <ec...@ucr.edu>.
I went through add, subtract, divide and multiply. Here is a patch of
my changes. I skipped the date functions, since we have not talked
about the date format and the Pointable classes are just stubbed out.
The XSDecimalPointable has been updated off a copy of DoublePointable
and just renamed. Not sure if this is correct, but now all the
Integer, Float and Double all used the same functions when doing the
operations.
When you have time I would like your feedback.
Thanks
Preston
On Fri, Jun 15, 2012 at 5:24 PM, Till Westmann <ti...@westmann.org> wrote:
>
> On Jun 15, 2012, at 5:06 PM, Eldon Carman wrote:
>
>> Ok. Now for these mixed types that are added together, there is a
>> promotion order. Basically the largest numeric type gets used. I have
>> been trying to find documentation on the promotion order. Is that what
>> I listed before? (size order)
>>
>> 1. double (double-precision 64-bit floating point type) - Java type double
>> 2. float (single-precision 32-bit floating point type) - Java type float
>> 3. decimal (a minimum of 18 decimal digits) - Java type double ???
>> 4. integer (a decimal type with a fixed decimal point) - Java type long
>>
>> Also do you know where that is in the xquery specification?
>
> Here it is:
> http://www.w3.org/TR/xquery/#id-type-promotion-and-operator-mapping
>
>> On Fri, Jun 15, 2012 at 4:39 PM, Vinayak Borkar <vb...@yahoo.com> wrote:
>>> Lexicographical order is text sort order. So:
>>>
>>> decimal
>>> double
>>> float
>>> integer
>>>
>>> xs:integer is supposed to be infinite precision, but we represent it as a 64
>>> bit fixed-precision signed-integer which is a long in java.
>>>
>>> Vinayak
>>>
>>>
>>>
>>> On 6/15/12 3:11 PM, Eldon Carman wrote:
>>>>
>>>> Thanks for the scaffolding. I have two questions. Is this the correct
>>>> lexicographical order?
>>>> 1. double
>>>> 2. float
>>>> 3. decimal
>>>> 4. integer
>>>>
>>>> Also do we always referrer to a integer as a long for this implementation?
>>>>
>>>> Preston
>>>>
>>>> On Fri, Jun 15, 2012 at 7:09 AM, Vinayak Borkar<vb...@yahoo.com> wrote:
>>>>>
>>>>> Preston,
>>>>>
>>>>>
>>>>> I have now added some scaffolding so that implementing the arithmetic
>>>>> functions will be easier.
>>>>>
>>>>> I have also added the code for xs:integer + xs:integer which is needed
>>>>> for
>>>>> the 1 + 1 example, ant it works end-to-end.
>>>>>
>>>>> Look at the AddScalarEvaluatorFactory class. You will be creating a class
>>>>> like that for each of Subtract, Multiply, and Divide by extending
>>>>> AbstractArithmeticScalarEvaluatorFactory.
>>>>>
>>>>> The only method that you have to implement when you extend
>>>>> AbstractArithmeticScalarEvaluatorFactory is the
>>>>> createArithmeticOperation()
>>>>> method that creates an instance of AbstractArithmeticOperation.
>>>>>
>>>>> For example, the one for Add looks like this:
>>>>>
>>>>> @Override
>>>>> protected AbstractArithmeticOperation createArithmeticOperation() {
>>>>> return new AddOperation();
>>>>> }
>>>>>
>>>>>
>>>>> The AddOperation implements all the logic for what it means to add two
>>>>> values of various types.
>>>>>
>>>>> The AbstractArithmeticScalarEvaluatorFactory has all the logic to
>>>>> correctly
>>>>> dispatch to the correct method in AbstractArithmeticOperation based on
>>>>> XQuery rules.
>>>>>
>>>>> As your next step, please implement all the methods in AddOperation. The
>>>>> methods in this class look like
>>>>>
>>>>> void operateXY(X x, Y y, DataOutput dOut)
>>>>>
>>>>> where X and Y are type names.
>>>>>
>>>>> For example the method that computes the result for xs:integer and
>>>>> xs:double
>>>>> would read:
>>>>>
>>>>> void operateIntegerDouble(LongPointable longp, DoublePointable doublep,
>>>>> DataOutput dOut)
>>>>>
>>>>> Since Add is commutative, you can implement about half of the methods by
>>>>> delegating to the other half (by switching the arguments). The convention
>>>>> you should follow is have operateXY delegate to operateYX when X is
>>>>> lexicographically greater than Y.
>>>>>
>>>>> So in the above example, operateIntegerDouble will delegate to
>>>>> operateDoubleInteger in the AddOperation class.
>>>>>
>>>>> Note that this trick does not apply to Minus and Divide, but applied to
>>>>> Multiply.
>>>>>
>>>>> Let us know how it goes with implementing the unimplemented methods in
>>>>> AddOperation and then implemnting the other arithmetic operation classes.
>>>>>
>>>>> Vinayak
>>>>
>>>>
>>>
>
Re: Arithmetic Functions
Posted by Till Westmann <ti...@westmann.org>.
On Jun 15, 2012, at 5:06 PM, Eldon Carman wrote:
> Ok. Now for these mixed types that are added together, there is a
> promotion order. Basically the largest numeric type gets used. I have
> been trying to find documentation on the promotion order. Is that what
> I listed before? (size order)
>
> 1. double (double-precision 64-bit floating point type) - Java type double
> 2. float (single-precision 32-bit floating point type) - Java type float
> 3. decimal (a minimum of 18 decimal digits) - Java type double ???
> 4. integer (a decimal type with a fixed decimal point) - Java type long
>
> Also do you know where that is in the xquery specification?
Here it is:
http://www.w3.org/TR/xquery/#id-type-promotion-and-operator-mapping
> On Fri, Jun 15, 2012 at 4:39 PM, Vinayak Borkar <vb...@yahoo.com> wrote:
>> Lexicographical order is text sort order. So:
>>
>> decimal
>> double
>> float
>> integer
>>
>> xs:integer is supposed to be infinite precision, but we represent it as a 64
>> bit fixed-precision signed-integer which is a long in java.
>>
>> Vinayak
>>
>>
>>
>> On 6/15/12 3:11 PM, Eldon Carman wrote:
>>>
>>> Thanks for the scaffolding. I have two questions. Is this the correct
>>> lexicographical order?
>>> 1. double
>>> 2. float
>>> 3. decimal
>>> 4. integer
>>>
>>> Also do we always referrer to a integer as a long for this implementation?
>>>
>>> Preston
>>>
>>> On Fri, Jun 15, 2012 at 7:09 AM, Vinayak Borkar<vb...@yahoo.com> wrote:
>>>>
>>>> Preston,
>>>>
>>>>
>>>> I have now added some scaffolding so that implementing the arithmetic
>>>> functions will be easier.
>>>>
>>>> I have also added the code for xs:integer + xs:integer which is needed
>>>> for
>>>> the 1 + 1 example, ant it works end-to-end.
>>>>
>>>> Look at the AddScalarEvaluatorFactory class. You will be creating a class
>>>> like that for each of Subtract, Multiply, and Divide by extending
>>>> AbstractArithmeticScalarEvaluatorFactory.
>>>>
>>>> The only method that you have to implement when you extend
>>>> AbstractArithmeticScalarEvaluatorFactory is the
>>>> createArithmeticOperation()
>>>> method that creates an instance of AbstractArithmeticOperation.
>>>>
>>>> For example, the one for Add looks like this:
>>>>
>>>> @Override
>>>> protected AbstractArithmeticOperation createArithmeticOperation() {
>>>> return new AddOperation();
>>>> }
>>>>
>>>>
>>>> The AddOperation implements all the logic for what it means to add two
>>>> values of various types.
>>>>
>>>> The AbstractArithmeticScalarEvaluatorFactory has all the logic to
>>>> correctly
>>>> dispatch to the correct method in AbstractArithmeticOperation based on
>>>> XQuery rules.
>>>>
>>>> As your next step, please implement all the methods in AddOperation. The
>>>> methods in this class look like
>>>>
>>>> void operateXY(X x, Y y, DataOutput dOut)
>>>>
>>>> where X and Y are type names.
>>>>
>>>> For example the method that computes the result for xs:integer and
>>>> xs:double
>>>> would read:
>>>>
>>>> void operateIntegerDouble(LongPointable longp, DoublePointable doublep,
>>>> DataOutput dOut)
>>>>
>>>> Since Add is commutative, you can implement about half of the methods by
>>>> delegating to the other half (by switching the arguments). The convention
>>>> you should follow is have operateXY delegate to operateYX when X is
>>>> lexicographically greater than Y.
>>>>
>>>> So in the above example, operateIntegerDouble will delegate to
>>>> operateDoubleInteger in the AddOperation class.
>>>>
>>>> Note that this trick does not apply to Minus and Divide, but applied to
>>>> Multiply.
>>>>
>>>> Let us know how it goes with implementing the unimplemented methods in
>>>> AddOperation and then implemnting the other arithmetic operation classes.
>>>>
>>>> Vinayak
>>>
>>>
>>
Re: Arithmetic Functions
Posted by Eldon Carman <ec...@ucr.edu>.
Ok. Now for these mixed types that are added together, there is a
promotion order. Basically the largest numeric type gets used. I have
been trying to find documentation on the promotion order. Is that what
I listed before? (size order)
1. double (double-precision 64-bit floating point type) - Java type double
2. float (single-precision 32-bit floating point type) - Java type float
3. decimal (a minimum of 18 decimal digits) - Java type double ???
4. integer (a decimal type with a fixed decimal point) - Java type long
Also do you know where that is in the xquery specification?
On Fri, Jun 15, 2012 at 4:39 PM, Vinayak Borkar <vb...@yahoo.com> wrote:
> Lexicographical order is text sort order. So:
>
> decimal
> double
> float
> integer
>
> xs:integer is supposed to be infinite precision, but we represent it as a 64
> bit fixed-precision signed-integer which is a long in java.
>
> Vinayak
>
>
>
> On 6/15/12 3:11 PM, Eldon Carman wrote:
>>
>> Thanks for the scaffolding. I have two questions. Is this the correct
>> lexicographical order?
>> 1. double
>> 2. float
>> 3. decimal
>> 4. integer
>>
>> Also do we always referrer to a integer as a long for this implementation?
>>
>> Preston
>>
>> On Fri, Jun 15, 2012 at 7:09 AM, Vinayak Borkar<vb...@yahoo.com> wrote:
>>>
>>> Preston,
>>>
>>>
>>> I have now added some scaffolding so that implementing the arithmetic
>>> functions will be easier.
>>>
>>> I have also added the code for xs:integer + xs:integer which is needed
>>> for
>>> the 1 + 1 example, ant it works end-to-end.
>>>
>>> Look at the AddScalarEvaluatorFactory class. You will be creating a class
>>> like that for each of Subtract, Multiply, and Divide by extending
>>> AbstractArithmeticScalarEvaluatorFactory.
>>>
>>> The only method that you have to implement when you extend
>>> AbstractArithmeticScalarEvaluatorFactory is the
>>> createArithmeticOperation()
>>> method that creates an instance of AbstractArithmeticOperation.
>>>
>>> For example, the one for Add looks like this:
>>>
>>> @Override
>>> protected AbstractArithmeticOperation createArithmeticOperation() {
>>> return new AddOperation();
>>> }
>>>
>>>
>>> The AddOperation implements all the logic for what it means to add two
>>> values of various types.
>>>
>>> The AbstractArithmeticScalarEvaluatorFactory has all the logic to
>>> correctly
>>> dispatch to the correct method in AbstractArithmeticOperation based on
>>> XQuery rules.
>>>
>>> As your next step, please implement all the methods in AddOperation. The
>>> methods in this class look like
>>>
>>> void operateXY(X x, Y y, DataOutput dOut)
>>>
>>> where X and Y are type names.
>>>
>>> For example the method that computes the result for xs:integer and
>>> xs:double
>>> would read:
>>>
>>> void operateIntegerDouble(LongPointable longp, DoublePointable doublep,
>>> DataOutput dOut)
>>>
>>> Since Add is commutative, you can implement about half of the methods by
>>> delegating to the other half (by switching the arguments). The convention
>>> you should follow is have operateXY delegate to operateYX when X is
>>> lexicographically greater than Y.
>>>
>>> So in the above example, operateIntegerDouble will delegate to
>>> operateDoubleInteger in the AddOperation class.
>>>
>>> Note that this trick does not apply to Minus and Divide, but applied to
>>> Multiply.
>>>
>>> Let us know how it goes with implementing the unimplemented methods in
>>> AddOperation and then implemnting the other arithmetic operation classes.
>>>
>>> Vinayak
>>
>>
>
Re: Arithmetic Functions
Posted by Vinayak Borkar <vb...@yahoo.com>.
Lexicographical order is text sort order. So:
decimal
double
float
integer
xs:integer is supposed to be infinite precision, but we represent it as
a 64 bit fixed-precision signed-integer which is a long in java.
Vinayak
On 6/15/12 3:11 PM, Eldon Carman wrote:
> Thanks for the scaffolding. I have two questions. Is this the correct
> lexicographical order?
> 1. double
> 2. float
> 3. decimal
> 4. integer
>
> Also do we always referrer to a integer as a long for this implementation?
>
> Preston
>
> On Fri, Jun 15, 2012 at 7:09 AM, Vinayak Borkar<vb...@yahoo.com> wrote:
>> Preston,
>>
>>
>> I have now added some scaffolding so that implementing the arithmetic
>> functions will be easier.
>>
>> I have also added the code for xs:integer + xs:integer which is needed for
>> the 1 + 1 example, ant it works end-to-end.
>>
>> Look at the AddScalarEvaluatorFactory class. You will be creating a class
>> like that for each of Subtract, Multiply, and Divide by extending
>> AbstractArithmeticScalarEvaluatorFactory.
>>
>> The only method that you have to implement when you extend
>> AbstractArithmeticScalarEvaluatorFactory is the createArithmeticOperation()
>> method that creates an instance of AbstractArithmeticOperation.
>>
>> For example, the one for Add looks like this:
>>
>> @Override
>> protected AbstractArithmeticOperation createArithmeticOperation() {
>> return new AddOperation();
>> }
>>
>>
>> The AddOperation implements all the logic for what it means to add two
>> values of various types.
>>
>> The AbstractArithmeticScalarEvaluatorFactory has all the logic to correctly
>> dispatch to the correct method in AbstractArithmeticOperation based on
>> XQuery rules.
>>
>> As your next step, please implement all the methods in AddOperation. The
>> methods in this class look like
>>
>> void operateXY(X x, Y y, DataOutput dOut)
>>
>> where X and Y are type names.
>>
>> For example the method that computes the result for xs:integer and xs:double
>> would read:
>>
>> void operateIntegerDouble(LongPointable longp, DoublePointable doublep,
>> DataOutput dOut)
>>
>> Since Add is commutative, you can implement about half of the methods by
>> delegating to the other half (by switching the arguments). The convention
>> you should follow is have operateXY delegate to operateYX when X is
>> lexicographically greater than Y.
>>
>> So in the above example, operateIntegerDouble will delegate to
>> operateDoubleInteger in the AddOperation class.
>>
>> Note that this trick does not apply to Minus and Divide, but applied to
>> Multiply.
>>
>> Let us know how it goes with implementing the unimplemented methods in
>> AddOperation and then implemnting the other arithmetic operation classes.
>>
>> Vinayak
>
Re: Arithmetic Functions
Posted by Eldon Carman <ec...@ucr.edu>.
Thanks for the scaffolding. I have two questions. Is this the correct
lexicographical order?
1. double
2. float
3. decimal
4. integer
Also do we always referrer to a integer as a long for this implementation?
Preston
On Fri, Jun 15, 2012 at 7:09 AM, Vinayak Borkar <vb...@yahoo.com> wrote:
> Preston,
>
>
> I have now added some scaffolding so that implementing the arithmetic
> functions will be easier.
>
> I have also added the code for xs:integer + xs:integer which is needed for
> the 1 + 1 example, ant it works end-to-end.
>
> Look at the AddScalarEvaluatorFactory class. You will be creating a class
> like that for each of Subtract, Multiply, and Divide by extending
> AbstractArithmeticScalarEvaluatorFactory.
>
> The only method that you have to implement when you extend
> AbstractArithmeticScalarEvaluatorFactory is the createArithmeticOperation()
> method that creates an instance of AbstractArithmeticOperation.
>
> For example, the one for Add looks like this:
>
> @Override
> protected AbstractArithmeticOperation createArithmeticOperation() {
> return new AddOperation();
> }
>
>
> The AddOperation implements all the logic for what it means to add two
> values of various types.
>
> The AbstractArithmeticScalarEvaluatorFactory has all the logic to correctly
> dispatch to the correct method in AbstractArithmeticOperation based on
> XQuery rules.
>
> As your next step, please implement all the methods in AddOperation. The
> methods in this class look like
>
> void operateXY(X x, Y y, DataOutput dOut)
>
> where X and Y are type names.
>
> For example the method that computes the result for xs:integer and xs:double
> would read:
>
> void operateIntegerDouble(LongPointable longp, DoublePointable doublep,
> DataOutput dOut)
>
> Since Add is commutative, you can implement about half of the methods by
> delegating to the other half (by switching the arguments). The convention
> you should follow is have operateXY delegate to operateYX when X is
> lexicographically greater than Y.
>
> So in the above example, operateIntegerDouble will delegate to
> operateDoubleInteger in the AddOperation class.
>
> Note that this trick does not apply to Minus and Divide, but applied to
> Multiply.
>
> Let us know how it goes with implementing the unimplemented methods in
> AddOperation and then implemnting the other arithmetic operation classes.
>
> Vinayak