Evaluate the (single output layer only) network for regression performance

@param iterator    Data to evaluate on
@param columnNames Column names for the regression evaluation. May be null.
@return Regression evaluation
761776
public <T extends RegressionEvaluation> T evaluateRegression(DataSetIterator iterator, List<String> columnNames) {
        return (T)doEvaluation(iterator, new org.deeplearning4j.eval.RegressionEvaluation(columnNames))[0];
    }
280499
public VectorIterator iteratorOfRow(int i) {
        final int ii = i;
        return new VectorIterator(columns) {
            private int j = -1;

            @Override
            public int index() {
                return j;
            }

            @Override
            public double get() {
                return Matrix.this.get(ii, j);
            }

            @Override
            public void set(double value) {
                Matrix.this.set(ii, j, value);
            }

            @Override
            public boolean hasNext() {
                return j + 1 < columns;
            }

            @Override
            public Double next() {
                if(!hasNext()) {
                    throw new NoSuchElementException();
                }
                j++;
                return get();
            }
        };
    }
143813
public VectorIterator nonZeroIteratorOfColumn(int j) {
        final int jj = j;
        return new VectorIterator(rows) {
            private int i = -1;

            @Override
            public int index() {
                return i;
            }

            @Override
            public double get() {
                return SparseMatrix.this.get(i, jj);
            }

            @Override
            public void set(double value) {
                SparseMatrix.this.set(i, jj, value);
            }

            @Override
            public boolean hasNext() {
                while (i + 1 < rows && SparseMatrix.this.isZeroAt(i + 1, jj)) {
                    i++;
                }

                return i + 1 < rows;
            }

            @Override
            public Double next() {
                if(!hasNext()) {
                    throw new NoSuchElementException();
                }
                i++;
                return get();
            }
        };
    }
437216
Iterator<Row> data(IteratorType type) {
    Iterator<Row> itr;
    switch(type) {
      case EXPECTED_DATA:
        itr = data.getRows().iterator();
        break;
      case ERRORS_EXPECTED:
        itr = delta.deleted();
        break;
      case ERRORS_ACTUAL:
        itr = delta.inserted();
        break;
      default:
        throw new InternalErrorException("Unexpected case!");      
    }
    return itr;
  }
449333
public Column getColumn(String columnName) {
    if (columnName == null) {
      return null;
    }
    for (Column column : columns) {
      if (columnName.equals(column.getData())) {
        return column;
      }
    }
    return null;
  }
756559
public final Object getColumnValue(final String columnName) {
        SQLExpression sqlExpression = values[getColumnIndex(columnName)];
        if (sqlExpression instanceof SQLParameterMarkerExpression) {
            return parameters[getParameterIndex(sqlExpression)];
        } else if (sqlExpression instanceof SQLTextExpression) {
            return ((SQLTextExpression) sqlExpression).getText();
        } else {
            return ((SQLNumberExpression) sqlExpression).getNumber();
        }
    }
1215049
public VectorIterator nonZeroIteratorOfRow(int i) {
        final int ii = i;
        return new VectorIterator(columns) {
            private int j = -1;

            @Override
            public int index() {
                return j;
            }

            @Override
            public double get() {
                return SparseMatrix.this.get(ii, j);
            }

            @Override
            public void set(double value) {
                SparseMatrix.this.set(ii, j, value);
            }

            @Override
            public boolean hasNext() {
                while (j + 1 < columns && SparseMatrix.this.isZeroAt(ii, j + 1)) {
                    j++;
                }

                return j + 1 < columns;
            }

            @Override
            public Double next() {
                if(!hasNext()) {
                    throw new NoSuchElementException();
                }
                j++;
                return get();
            }
        };
    }
499622
protected List<Map<String, ResultColumn>> processResultIterator(ResultIterator it) throws DatabaseEngineException {
        List<Map<String, ResultColumn>> res = new ArrayList<>();

        Map<String, ResultColumn> temp;
        while ((temp = it.next()) != null) {
            res.add(temp);
        }

        return res;
    }
287939
public HSlicePredicate<N> setColumnNames(Collection<N> columnNames) {
    this.columnNames = columnNames;
    predicateType = PredicateType.ColumnNames;
    return this;
  }
609316
@SafeVarargs
  public final TableBuilder columns(String... columns) {
    if (columns == null || columns.length == 0) {
      throw new InvalidOperationException("Columns array is null or empty.");
    }
    if (tableColumns != null) {
      throw new InvalidOperationException("The table columns are already defined.");
    }
    tableColumns = columns.clone();
    return this;
  }
263113
public boolean hasColumns(Collection<String> columns) {
        return columns != null && this.columns.equals(new TreeSet<String>(columns));
    }
1275443
public static Double[] getColumnDoubleValues(CSTable t, String columnName) {
        int col = columnIndex(t, columnName);
        if (col == -1) {
            throw new IllegalArgumentException("No such column: " + columnName);
        }
        List<Double> l = new ArrayList<Double>();
        for (String[] s : t.rows()) {
            l.add(new Double(s[col]));
        }
        return l.toArray(new Double[0]);
    }
346837
public static <T> String join(Iterator<T> iterator) {
        return new JoinStrings<T>().apply(iterator);
    }
361753
public boolean isInsertableColumn(final String columnName)
   {
      // Use index iteration to avoid generating an Iterator as side-effect
      final FieldColumnInfo[] fcInfos = getInsertableFcInfos();
      for (int i = 0; i < fcInfos.length; i++) {
        if (fcInfos[i].getCaseSensitiveColumnName().equals(columnName)) {
           return true;
        }
      }
      return false;
   }
503846
@Override
    public Iterator<Cell> iterator()
    {
        if (cells != null)
        {
            return cells.iterator();
        }
        else // if (pbRow != null)
        {
            assert pbRow != null;

            return ConvertibleIteratorUtils.iterateAsCell(pbRow.getCellsList().iterator(),
                    // if there is no ColumnDescription what else we could do with that?
                    pbColumnDescriptions == null ?  Collections.emptyIterator() : pbColumnDescriptions.iterator());
        }
    }
640383
protected static boolean isIgnoredColumn(final Set<String> ignoredColumns, final String columnName) {
      return ignoredColumns.stream().anyMatch(s -> s.equalsIgnoreCase(columnName));
   }
1327873
public ColumnFunctionBuilder getColumn(final String columnName) {
    Preconditions.checkNotNull(columnName);

    return new ColumnFunctionBuilder() {
      @SuppressWarnings("unchecked")
      @Override
      public <T> Function<Cursor, T> as(Class<T> klass) {
        Preconditions.checkArgument(mTypeAdapters.containsKey(klass));

        final TypeAdapter<T> adapter = (TypeAdapter<T>) mTypeAdapters.get(klass);

        return new Function<Cursor, T>() {
          @Override
          public T apply(Cursor c) {
            return adapter.fromCursor(c, columnName);
          }
        };
      }
    };
  }