//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); 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); }
//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) { 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); }
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 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, 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))); }