public override DateTime ToTime()
{
int year = (int)arg0.ToNumber();
TimeValidator.ValidateYear(year);
return(Easter(year));
}
public override DateTime ToTime()
{
int year = (int)arg0.ToNumber();
TimeValidator.ValidateYear(year);
return(new DateTime(year, 1, 1, 0, 0, 0));
}
public override DateTime ToTime()
{
int day = (int)arg0.ToNumber();
int month = (int)arg1.ToNumber();
int year = (int)arg2.ToNumber();
TimeValidator.ValidateDate(day, month, year);
return(new DateTime(year, month, day, 0, 0, 0));
}
public override DateTime ToTime()
{
int hour = (int)arg0.ToNumber();
int minute = (int)arg1.ToNumber();
TimeValidator.ValidateHour(hour);
TimeValidator.ValidateMinute(minute);
DateTime s = DateTime.Now.AddDays(1);
TimeSpan ts = new TimeSpan(hour, minute, 0);
s = s.Date + ts;
return(s);
}
public override decimal ToNumber()
{
decimal basis = arg0.ToNumber();
decimal power = arg1.ToNumber();
if (power == 0)
{
return(1);
}
if (basis == 0)
{
return(0);
}
if (power == 1)
{
return(basis);
}
if (IsInteger(power))
{
if (basis > 0)
{
if (power > 0)
{
return(PowerDecimalToInt(basis, (uint)power));
}
else
{
return(1 / PowerDecimalToInt(basis, (uint)-power));
}
}
else
{
decimal sign = power % 2 == 0 ? 1M : -1M;
if (power > 0)
{
return(sign * PowerDecimalToInt(-basis, (uint)power));
}
else
{
return(sign / PowerDecimalToInt(-basis, (uint)-power));
}
}
}
else
{
if (basis < 0)
{
throw new RuntimeException("RUNTIME ERROR! Exponentiation of a negative number resulted in complex number.");
}
else
{
return((decimal)Math.Pow((double)basis, (double)power));
}
}
}
public override bool ToBool()
{
decimal leftValue = leftSide.ToNumber();
decimal rightValue = rightSide.ToNumber();
switch (type)
{
case ComparisonType.Equals:
return(leftValue == rightValue ? true : false);
case ComparisonType.NotEquals:
return(leftValue != rightValue ? true : false);
case ComparisonType.Bigger:
return(leftValue > rightValue ? true : false);
case ComparisonType.Smaller:
return(leftValue < rightValue ? true : false);
case ComparisonType.BiggerOrEquals:
return(leftValue >= rightValue ? true : false);
case ComparisonType.SmallerOrEquals:
return(leftValue <= rightValue ? true : false);
}
return(false);
}
public override DateTime ToTime()
{
int hour = (int)arg0.ToNumber();
int minute = (int)arg1.ToNumber();
int second = (int)arg2.ToNumber();
TimeValidator.ValidateHour(hour);
TimeValidator.ValidateMinute(minute);
TimeValidator.ValidateSecond(second);
DateTime s = DateTime.Now;
TimeSpan ts = new TimeSpan(hour, minute, second);
s = s.Date + ts;
return(s);
}
public override string ToString()
{
string source = arg0.ToString();
int arg1v = (int)arg1.ToNumber();
if (arg1v >= source.Length)
{
return("");
}
int arg2v = (int)arg2.ToNumber();
if (arg2v < 1)
{
return("");
}
if (arg1v + arg2v > source.Length)
{
arg2v -= arg1v + arg2v - source.Length;
}
return(source.Substring(arg1v, arg2v));
}
public override string ToString()
{
string value;
int number = (int)arg1.ToNumber();
if (arg0 is INumerable)
{
if ((arg0 as INumerable).ToNumber() % 1 == 0)
{
value = ((int)(arg0 as INumerable).ToNumber()).ToString();
}
else
{
value = (arg0 as INumerable).ToNumber().ToString();
}
}
else
{
value = arg0.ToString();
}
if (value.Length >= number)
{
return(value);
}
return(string.Concat(Enumerable.Repeat("0", number - value.Length)) + value);
}
public void Run()
{
int howlong = (int)(time.ToNumber() * 1000);
if (howlong > 0)
{
Thread.Sleep(howlong);
}
}
public override string ToString()
{
string source = arg0.ToString();
int arg1v = (int)arg1.ToNumber();
if (arg1v >= source.Length)
{
return(base.ToString());
}
return(source.Substring(arg1v));
}
public override string ToString()
{
int repeats = (int)arg1.ToNumber();
if (repeats <= 0)
{
return("");
}
else
{
return(string.Concat(Enumerable.Repeat(arg0.ToString(), repeats)));
}
}
public override string ToString()
{
int number = (int)arg0.ToNumber();
if (number > 0)
{
return(Convert.ToString(number, 16));
}
else
{
number *= -1;
}
return("-" + Convert.ToString(number, 16));
}
public override decimal ToNumber()
{
decimal number = arg0.ToNumber();
if (number == 0)
{
throw new RuntimeException("RUNTIME ERROR! Decimal logarithm of zero happened.");
}
else if (number < 0)
{
throw new RuntimeException("RUNTIME ERROR! Decimal logarithm of negative number happened.");
}
else
{
return((decimal)Math.Log10(Decimal.ToDouble(number)));
}
}
public override decimal ToNumber()
{
decimal value = arg0.ToNumber();
if (value < 0)
{
throw new RuntimeException("RUNTIME ERROR! Factorial of negative number happened.");
}
if (value % 1 == 0)
{
return(ArrayedFactorials((int)value));
}
else
{
return(StirlingApproximation((double)value));
}
}
public override bool ToBool()
{
decimal left = leftBound.ToNumber();
decimal right = rightBound.ToNumber();
decimal v = value.ToNumber();
if (left < right)
{
return((v > left) && (v < right));
}
else if (left > right)
{
return((v < left) && (v > right));
}
else
{
return(false);
}
}
public override decimal ToNumber()
{
decimal number = arg0.ToNumber();
if (number < 0)
{
throw new RuntimeException("RUNTIME ERROR! Square root of negative number happened.");
}
else if (number == 0)
{
return(0);
}
else
{
if (number % 1 == 0 && IsPerfectSquare((int)number))
{
return((decimal)Math.Sqrt((int)number));
}
else
{
return(SquareRoot(number));
}
}
}
public override decimal ToNumber()
{
return(condition.ToBool() ? leftValue.ToNumber() : rightValue.ToNumber());
}
public override string ToString()
{
return(DateExtractor.WeekDay(arg0.ToNumber()));
}
private static ITimeable BuildFromDate(List <Token> tokens)
{
decimal month = 1;
List <Token> leftPart = new List <Token>();
List <Token> rightPart = new List <Token>();
bool pastMonth = false;
foreach (Token tok in tokens)
{
if (IsMonth(tok))
{
pastMonth = true;
month = StringToMonth(tok.GetContent());
}
else
{
if (pastMonth)
{
rightPart.Add(tok);
}
else
{
leftPart.Add(tok);
}
}
}
if (leftPart.Count == 0)
{
return(null);
}
INumerable day = NumerableBuilder.Build(leftPart);
if (day.IsNull())
{
return(null);
}
// try to build date without year
if (rightPart.Count == 0)
{
if (day is NumericConstant)
{
return(new Time(new ClockEmpty(), new DayConstant(day.ToNumber()), month, new YearNow()));
}
else
{
return(new Time(new ClockEmpty(), new DayNumerable(day), month, new YearNow()));
}
}
INumerable year = NumerableBuilder.Build(rightPart);
if (year.IsNull())
{
return(null);
}
if (day is NumericConstant)
{
if (year is NumericConstant)
{
return(new Time(new ClockEmpty(), new DayConstant(day.ToNumber()), month, new YearConstant(year.ToNumber())));
}
else
{
return(new Time(new ClockEmpty(), new DayConstant(day.ToNumber()), month, new YearNumerable(year)));
}
}
else
{
if (year is NumericConstant)
{
return(new Time(new ClockEmpty(), new DayNumerable(day), month, new YearConstant(year.ToNumber())));
}
else
{
return(new Time(new ClockEmpty(), new DayNumerable(day), month, new YearNumerable(year)));
}
}
}
private static IClock BuildClock(List <Token> tokens)
{
int semicolons = NumberOfColonsOutsideOfBrackets(tokens);
if (semicolons == 1)
{
List <Token> leftPart = new List <Token>();
List <Token> rightPart = new List <Token>();
int level = 0;
bool pastSemicolon = false;
foreach (Token tok in tokens)
{
if (tok.GetTokenType().Equals(TokenType.BracketOn))
{
level++;
}
if (tok.GetTokenType().Equals(TokenType.BracketOff))
{
level--;
}
if (tok.GetTokenType().Equals(TokenType.Colon) && level == 0)
{
pastSemicolon = true;
}
else
{
if (pastSemicolon)
{
rightPart.Add(tok);
}
else
{
leftPart.Add(tok);
}
}
}
INumerable inumLeft = NumerableBuilder.Build(leftPart);
if (inumLeft.IsNull())
{
return(null);
}
INumerable inumRight = NumerableBuilder.Build(rightPart);
if (inumRight.IsNull())
{
return(null);
}
if (inumLeft is NumericConstant && inumRight is NumericConstant)
{
return(new ClockConstant(inumLeft.ToNumber(), inumRight.ToNumber(), 0));
}
return(new ClockWithoutSeconds(inumLeft, inumRight));
}
else
{
List <Token> leftPart = new List <Token>();
List <Token> middlePart = new List <Token>();
List <Token> rightPart = new List <Token>();
int level = 0;
int currentPart = 1;
foreach (Token tok in tokens)
{
if (tok.GetTokenType().Equals(TokenType.BracketOn))
{
level++;
}
if (tok.GetTokenType().Equals(TokenType.BracketOff))
{
level--;
}
if (tok.GetTokenType().Equals(TokenType.Colon) && level == 0)
{
currentPart++;
}
else
{
if (currentPart == 1)
{
leftPart.Add(tok);
}
else if (currentPart == 2)
{
middlePart.Add(tok);
}
else
{
rightPart.Add(tok);
}
}
}
INumerable inumLeft = NumerableBuilder.Build(leftPart);
if (inumLeft.IsNull())
{
return(null);
}
INumerable inumMiddle = NumerableBuilder.Build(middlePart);
if (inumMiddle.IsNull())
{
return(null);
}
INumerable inumRight = NumerableBuilder.Build(rightPart);
if (inumRight.IsNull())
{
return(null);
}
if (inumLeft is NumericConstant && inumMiddle is NumericConstant && inumRight is NumericConstant)
{
return(new ClockConstant(inumLeft.ToNumber(), inumMiddle.ToNumber(), inumRight.ToNumber()));
}
return(new ClockNumerables(inumLeft, inumMiddle, inumRight));
}
}
public decimal ToMinute()
{
return(minute.ToNumber());
}
public void Run()
{
RuntimeVariables.GetInstance().DecrementBy(variable, value.ToNumber());
}
public decimal ToYear()
{
return(year.ToNumber());
}
public void Run()
{
RuntimeVariables.GetInstance().SetElementOfTime(name, value.ToNumber(), type);
}
public decimal ToSecond()
{
return(second.ToNumber());
}
public void Run()
{
RuntimeVariables.GetInstance().MultiplyBy(variable, value.ToNumber());
}
public int GetValue()
{
return((int)value.ToNumber());
}
public override decimal ToNumber()
{
return(-content.ToNumber());
}
public decimal ToDay()
{
return(day.ToNumber());
}
