public static object Div(BinaryOpStorage /*!*/ divideStorage, ConversionStorage <double> /*!*/ tofStorage, object self, object other)
{
var divide = divideStorage.GetCallSite("/");
var tof = tofStorage.GetSite(ConvertToFAction.Make(tofStorage.Context));
return(ClrFloat.Floor(tof.Target(tof, divide.Target(divide, self, other))));
}
public static RubyArray /*!*/ Coerce(ConversionStorage <double> /*!*/ tof1, ConversionStorage <double> /*!*/ tof2,
object self, object other)
{
var context = tof1.Context;
if (context.GetClassOf(self) == context.GetClassOf(other))
{
return(RubyOps.MakeArray2(other, self));
}
var site1 = tof1.GetSite(ConvertToFAction.Make(context));
var site2 = tof2.GetSite(ConvertToFAction.Make(context));
return(RubyOps.MakeArray2(site1.Target(site1, other), site2.Target(site2, self)));
}
public static double CastToFloat(ConversionStorage <double> /*!*/ floatConversion, object value)
{
var site = floatConversion.GetSite(ConvertToFAction.Make(floatConversion.Context));
return(site.Target(site, value));
}
public double CastToDouble(object value)
{
var site = RubyUtils.GetCallSite(ref _tofConversion, ConvertToFAction.Make(Context));
return(site.Target(site, value));
}
public static object Step(
BinaryOpStorage /*!*/ equals,
BinaryOpStorage /*!*/ greaterThanStorage,
BinaryOpStorage /*!*/ lessThanStorage,
BinaryOpStorage /*!*/ addStorage,
ConversionStorage <double> /*!*/ tofStorage,
BlockParam block, object self, object limit, [Optional] object step)
{
if (step == Missing.Value)
{
step = ClrInteger.One;
}
if (self is double || limit is double || step is double)
{
var site = tofStorage.GetSite(ConvertToFAction.Make(tofStorage.Context));
// At least one of the arguments is double so convert all to double and run the Float version of Step
double floatSelf = self is double?(double)self : site.Target(site, self);
double floatLimit = limit is double?(double)self : site.Target(site, limit);
double floatStep = step is double?(double)self : site.Target(site, step);
return(Step(block, floatSelf, floatLimit, floatStep));
}
else
{
#region The generic step algorithm:
// current = self
// if step is postive then
// while current < limit do
// yield(current)
// current = current + step
// end
// else
// while current > limit do
// yield(current)
// current = current + step
// end
// return self
#endregion
bool isStepZero = Protocols.IsEqual(equals, step, 0);
if (isStepZero)
{
throw RubyExceptions.CreateArgumentError("step can't be 0");
}
var greaterThan = greaterThanStorage.GetCallSite(">");
bool isStepPositive = RubyOps.IsTrue(greaterThan.Target(greaterThan, step, 0));
var compare = isStepPositive ? greaterThan : lessThanStorage.GetCallSite("<");
object current = self;
while (!RubyOps.IsTrue(compare.Target(compare, current, limit)))
{
object result;
if (YieldStep(block, current, out result))
{
return(result);
}
var add = addStorage.GetCallSite("+");
current = add.Target(add, current, step);
}
return(self);
}
}
