//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertMinArgCount(paramArrayOfExpr, 2);
ExprArray exprArray1 = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
int? integer1;
int? integer2 = (integer2 = (integer1 = Convert.ToInt32(paramArrayOfExpr.Length - 1)).valueOf(exprArray1.rows() * exprArray1.columns() / integer1.Value)).valueOf(integer2.Value + 1);
ExprArray exprArray2 = new ExprArray(integer2.Value, integer1.Value);
try
{
sbyte b;
for (b = 0; b < integer1.Value; b++)
{
exprArray2.set(0, b, paramArrayOfExpr[b + true]);
}
for (b = 1; b < integer2.Value; b++)
{
for (sbyte b1 = 0; b1 < integer1.Value; b1++)
{
if (b - 1 < exprArray1.rows() && b1 < exprArray1.columns())
{
Expr expr = exprArray1.get(b - 1, b1);
exprArray2.set(b, b1, expr);
}
}
}
}
catch (Exception exception)
{
Console.WriteLine(exception.ToString());
Console.Write(exception.StackTrace);
}
return(exprArray2);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertArgCount(paramArrayOfExpr, 3);
ExprArray exprArray = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
string str = asString(paramIEvaluationContext, paramArrayOfExpr[1], true);
int? integer = (integer = Convert.ToInt32(asInteger(paramIEvaluationContext, paramArrayOfExpr[2], true))).valueOf(integer.Value - 1);
if (integer.Value >= exprArray.columns() || integer.Value < 0)
{
integer = Convert.ToInt32(0);
}
if (exprArray.columns() == 0)
{
return(new ExprInteger(0));
}
sbyte b1 = 0;
int i = exprArray.rows();
for (sbyte b2 = 0; b2 < i; b2++)
{
string str1 = asString(paramIEvaluationContext, exprArray.get(b2, integer.Value), false);
if (str1.Equals(str, StringComparison.OrdinalIgnoreCase))
{
b1 = b2 + 1;
break;
}
}
return(new ExprInteger(b1));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertMinArgCount(paramArrayOfExpr, 2);
assertMaxArgCount(paramArrayOfExpr, 2);
ExprArray exprArray = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
double d = asDouble(paramIEvaluationContext, paramArrayOfExpr[1], true);
int i = asInteger(paramIEvaluationContext, paramArrayOfExpr[1], true);
int j = exprArray.rows();
int k = exprArray.columns();
for (sbyte b = 0; b < j; b++)
{
for (sbyte b1 = 0; b1 < k; b1++)
{
Expr expr = exprArray.get(b, b1);
if (expr is ExprDouble)
{
exprArray.set(b, b1, new ExprDouble(Math.Abs(((ExprDouble)expr).doubleValue()) * d));
}
else if (expr is ExprInteger)
{
exprArray.set(b, b1, new ExprInteger(Math.Abs(((ExprInteger)expr).intValue()) * i));
}
}
}
return(exprArray);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertMinArgCount(paramArrayOfExpr, 2);
ExprArray exprArray1 = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
int?[] arrayOfInteger = new int?[paramArrayOfExpr.Length - 1];
for (sbyte b1 = 1; b1 < paramArrayOfExpr.Length; b1++)
{
arrayOfInteger[b1 - true] = Convert.ToInt32(paramIEvaluationContext, paramArrayOfExpr[b1], true);
}
ExprArray exprArray2 = new ExprArray(arrayOfInteger.Length, exprArray1.columns());
for (sbyte b2 = 0; b2 < exprArray1.columns(); b2++)
{
for (sbyte b = 0; b < arrayOfInteger.Length; b++)
{
int i = arrayOfInteger[b].Value - 1;
if (i < 0 || i >= exprArray1.rows())
{
ExprInteger exprInteger = new ExprInteger(1);
exprArray2.set(b, b2, exprInteger);
}
else
{
Expr expr = exprArray1.get(i, b2);
exprArray2.set(b, b2, expr);
}
}
}
return(exprArray2);
}
public static object[][] toObjectArray(ExprArray paramExprArray)
{
//JAVA TO C# CONVERTER NOTE: The following call to the 'RectangularArrays' helper class reproduces the rectangular array initialization that is automatic in Java:
//ORIGINAL LINE: object[][] arrayOfObject = new object[paramExprArray.rows()][paramExprArray.columns()];
object[][] arrayOfObject = RectangularArrays.RectangularObjectArray(paramExprArray.rows(), paramExprArray.columns());
for (sbyte b = 0; b < paramExprArray.rows(); b++)
{
for (sbyte b1 = 0; b1 < paramExprArray.columns(); b1++)
{
Expr expr = paramExprArray.get(b, b1);
if (expr is org.boris.expr.ExprBoolean)
{
arrayOfObject[b][b1] = Convert.ToDouble(((ExprNumber)expr).doubleValue());
}
else if (expr is ExprInteger)
{
arrayOfObject[b][b1] = Convert.ToInt32(((ExprNumber)expr).intValue());
}
else if (expr is ExprNumber)
{
arrayOfObject[b][b1] = Convert.ToDouble(((ExprNumber)expr).doubleValue());
}
else if (expr == null)
{
arrayOfObject[b][b1] = "";
}
else
{
arrayOfObject[b][b1] = expr.ToString();
}
}
}
return(arrayOfObject);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertArgCount(paramArrayOfExpr, 1);
Expr expr = evalArg(paramIEvaluationContext, paramArrayOfExpr[0]);
if (expr is ExprArray)
{
ExprArray exprArray = (ExprArray)expr;
if (exprArray.length() == 0)
{
return(ExprDouble.ZERO);
}
expr = exprArray.get(0);
}
return((expr is ExprNumber) ? new ExprDouble(((ExprNumber)expr).doubleValue()) : ExprDouble.ZERO);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static org.boris.expr.ExprArray toCalculatedEpxrArray(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.ExprArray paramExprArray) throws org.boris.expr.ExprException
public static ExprArray toCalculatedEpxrArray(IEvaluationContext paramIEvaluationContext, ExprArray paramExprArray)
{
ExprArray exprArray = new ExprArray(paramExprArray.rows(), paramExprArray.columns());
for (sbyte b = 0; b < paramExprArray.rows(); b++)
{
for (sbyte b1 = 0; b1 < paramExprArray.columns(); b1++)
{
Expr expr = paramExprArray.get(b, b1);
if (expr is ExprEvaluatable)
{
expr = ((ExprEvaluatable)expr).evaluate(paramIEvaluationContext);
}
exprArray.set(b, b1, expr);
}
}
return(exprArray);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertArgCount(paramArrayOfExpr, 2);
ExprArray exprArray = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
string str = asString(paramIEvaluationContext, paramArrayOfExpr[1], true);
sbyte b1 = 0;
if (exprArray is ExprArrayWithHeader)
{
ExprArrayWithHeader exprArrayWithHeader = (ExprArrayWithHeader)exprArray;
int j = exprArrayWithHeader.Columns.Length;
for (sbyte b = 0; b < j; b++)
{
string str1 = exprArrayWithHeader.Columns[b];
if (str1.Equals(str, StringComparison.OrdinalIgnoreCase))
{
b1 = b + true;
break;
}
}
return(new ExprInteger(b1));
}
if (exprArray.rows() == 0)
{
return(new ExprInteger(b1));
}
int i = exprArray.columns();
for (sbyte b2 = 0; b2 < i; b2++)
{
string str1 = asString(paramIEvaluationContext, exprArray.get(0, b2), false);
if (str1.Equals(str, StringComparison.OrdinalIgnoreCase))
{
b1 = b2 + 1;
break;
}
}
return(new ExprInteger(b1));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertArgCount(paramArrayOfExpr, 10);
ExprArray exprArray1 = null;
Expr expr1 = evalArg(paramIEvaluationContext, paramArrayOfExpr[0]);
Expr expr2 = evalArg(paramIEvaluationContext, paramArrayOfExpr[1]);
Expr expr3 = evalArg(paramIEvaluationContext, paramArrayOfExpr[2]);
Expr expr4 = evalArg(paramIEvaluationContext, paramArrayOfExpr[3]);
Expr expr5 = evalArg(paramIEvaluationContext, paramArrayOfExpr[4]);
Expr expr6 = evalArg(paramIEvaluationContext, paramArrayOfExpr[5]);
Expr expr7 = evalArg(paramIEvaluationContext, paramArrayOfExpr[6]);
Expr expr8 = evalArg(paramIEvaluationContext, paramArrayOfExpr[7]);
Expr expr9 = evalArg(paramIEvaluationContext, paramArrayOfExpr[8]);
Expr expr10 = evalArg(paramIEvaluationContext, paramArrayOfExpr[9]);
ExprArray exprArray2 = asArray(paramIEvaluationContext, expr1, false);
string str = asString(paramIEvaluationContext, expr2, false);
int i = asInteger(paramIEvaluationContext, expr3, false);
double d1 = asDouble(paramIEvaluationContext, expr4, false);
int j = asInteger(paramIEvaluationContext, expr5, false);
int k = asInteger(paramIEvaluationContext, expr6, false);
double d2 = asDouble(paramIEvaluationContext, expr7, false);
int m = asInteger(paramIEvaluationContext, expr8, false);
int n = asInteger(paramIEvaluationContext, expr9, false);
int i1 = asInteger(paramIEvaluationContext, expr10, false);
if (exprArray2 is DummyExprArray)
{
return(new ExprArray(0, 0));
}
if (i <= 0)
{
throw new ExprException("Column to search text (3rd argument) cannot be less than or equal to zero.");
}
if (i > exprArray2.length())
{
throw new ExprException("Column to search text (3rd argument) is greater than the array lenght.");
}
if (j <= 0)
{
throw new ExprException("Begin column index in range 1 (5th argument) cannot be less than or equal to zero.");
}
if (j > exprArray2.length())
{
throw new ExprException("Begin column index in range 1 (5th argument) is greater than the array lenght.");
}
if (k <= 0)
{
throw new ExprException("End column index in range 1 (6th argument) cannot be less than or equal to zero.");
}
if (k > exprArray2.length())
{
throw new ExprException("End column index in range 1 (6th argument) is greater than the array lenght.");
}
if (m < 0)
{
throw new ExprException("Begin column index in range 2 (8th argument) cannot be less than zero.");
}
if (m > exprArray2.length())
{
throw new ExprException("Begin column index in range 2 (8th argument) is greater than the array lenght.");
}
if (n < 0)
{
throw new ExprException("End column index in range 2 (9th argument) cannot be less than zero.");
}
if (n > exprArray2.length())
{
throw new ExprException("End column index in range 2 (9th argument) is greater than the array lenght.");
}
if (i1 <= 0)
{
throw new ExprException("Column index to return values (10th argument) cannot be less than or equal to zero.");
}
if (i1 > exprArray2.length())
{
throw new ExprException("Column index to return values (10th argument) is greater than the array lenght.");
}
List <object> arrayList = new List <object>();
sbyte b;
for (b = 0; b < exprArray2.rows(); b++)
{
string str1 = asString(paramIEvaluationContext, exprArray2.get(b, i - 1), false);
double d3 = asDouble(paramIEvaluationContext, exprArray2.get(b, j - 1), false);
double d4 = asDouble(paramIEvaluationContext, exprArray2.get(b, k - 1), false);
if (m == 0 || n == 0)
{
if (str.Equals(str1, StringComparison.OrdinalIgnoreCase) && d1 >= d3 && d1 <= d4)
{
string str2 = asString(paramIEvaluationContext, exprArray2.get(b, i1 - 1), false);
arrayList.Add(str2);
}
}
else if (m > 0 && n > 0)
{
double d5 = asDouble(paramIEvaluationContext, exprArray2.get(b, m - 1), false);
double d6 = asDouble(paramIEvaluationContext, exprArray2.get(b, n - 1), false);
if (str.Equals(str1, StringComparison.OrdinalIgnoreCase) && d1 >= d3 && d1 <= d4 && d2 >= d5 && d2 <= d6)
{
string str2 = asString(paramIEvaluationContext, exprArray2.get(b, i1 - 1), false);
arrayList.Add(str2);
}
}
}
if (arrayList.Count == 0)
{
exprArray1 = new ExprArray(0, 1);
}
else
{
exprArray1 = new ExprArray(arrayList.Count, 1);
for (b = 0; b < arrayList.Count; b++)
{
exprArray1.set(b, 0, new ExprString((string)arrayList[b]));
}
}
return(exprArray1);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.boris.expr.Expr evaluate(org.boris.expr.IEvaluationContext paramIEvaluationContext, org.boris.expr.Expr[] paramArrayOfExpr) throws org.boris.expr.ExprException
public virtual Expr evaluate(IEvaluationContext paramIEvaluationContext, Expr[] paramArrayOfExpr)
{
assertArgCount(paramArrayOfExpr, 3);
ExprArray exprArray = asArray(paramIEvaluationContext, paramArrayOfExpr[0], true);
double? double1;
double? double2 = (double1 = Convert.ToDouble(asDouble(paramIEvaluationContext, paramArrayOfExpr[1], true) - 1.0D)).valueOf(asDouble(paramIEvaluationContext, paramArrayOfExpr[2], true) - 1.0D);
return((double2.Value < 0.0D || double2.Value >= exprArray.rows()) ? new ExprDouble(1.0D) : ((double1.Value < 0.0D || double1.Value >= exprArray.columns()) ? new ExprDouble(1.0D) : exprArray.get(double2.Value, double1.Value)));
}
