classify a list of observation.

@param data contains a list of cps
@return the list
195448
public List classify(List data) {
		List list = new ArrayList();
		
		for (int i = 0; i < data.size(); i++) {
		    list.add(classify((String)data.get(i)));
		}
		
		return list;
    }
606616
public List<List<IN>> classifyFile(String filename) {
    ObjectBank<List<IN>> documents =
      makeObjectBankFromFile(filename, plainTextReaderAndWriter);
    List<List<IN>> result = new ArrayList<List<IN>>();

    for (List<IN> document : documents) {
      // System.err.println(document);
      classify(document);

      List<IN> sentence = new ArrayList<IN>();
      for (IN wi : document) {
        sentence.add(wi);
        // System.err.println(wi);
      }
      result.add(sentence);
    }
    return result;
  }
77450
public <T extends ROCMultiClass> T evaluateROCMultiClass(JavaRDD<DataSet> data) {
        return evaluateROCMultiClass(data, DEFAULT_ROC_THRESHOLD_STEPS, DEFAULT_EVAL_SCORE_BATCH_SIZE);
    }
245060
protected List<String> getTypeNames(CmsGalleryDataBean data) {

        List<String> types = new ArrayList<String>();
        for (CmsResourceTypeBean info : data.getTypes()) {
            types.add(info.getType());
        }
        return types;
    }
1046670
public PmiDataInfo[] listLevelData(int level) {
        ArrayList levelData = new ArrayList();

        Iterator allData = perfData.values().iterator();
        while (allData.hasNext()) {
            PmiDataInfo dataInfo = (PmiDataInfo) allData.next();
            if (dataInfo.getLevel() <= level) {
                levelData.add(dataInfo);
            }

        }

        // get the array
        PmiDataInfo[] ret = new PmiDataInfo[levelData.size()];
        for (int i = 0; i < ret.length; i++)
            ret[i] = (PmiDataInfo) levelData.get(i);
        return ret;
    }
1134754
private List<Integer> extractRgroups(String data){
	  Pattern pattern = Pattern.compile("R[1-9]\\d*");
	  Matcher matcher = pattern.matcher(data);
	  List<Integer> listValues = new ArrayList<Integer>();
	  
	  while(matcher.find()){
		listValues.add(Integer.parseInt(matcher.group().split("R")[1]));  
	  }
	  return listValues;
  }
96569
private List<Integer>[] getRobustPointList(double[][] spectrogramData) {

        int numX = spectrogramData.length;
        int numY = spectrogramData[0].length;

        double[][] allBanksIntensities = new double[numX][numY];
        int bandwidthPerBank = numY / numFilterBanks;

        for (int b = 0; b < numFilterBanks; b++) {

            double[][] bankIntensities = new double[numX][bandwidthPerBank];

            for (int i = 0; i < numX; i++) {
                System.arraycopy(spectrogramData[i], b * bandwidthPerBank, bankIntensities[i], 0, bandwidthPerBank);
            }

            // get the most robust point in each filter bank
            TopManyPointsProcessorChain processorChain = new TopManyPointsProcessorChain(bankIntensities, 1);
            double[][] processedIntensities = processorChain.getIntensities();

            for (int i = 0; i < numX; i++) {
                System.arraycopy(processedIntensities[i], 0, allBanksIntensities[i], b * bandwidthPerBank,
                                bandwidthPerBank);
            }
        }

        List<int[]> robustPointList = new LinkedList<int[]>();

        // find robust points
        for (int i = 0; i < allBanksIntensities.length; i++) {
            for (int j = 0; j < allBanksIntensities[i].length; j++) {
                if (allBanksIntensities[i][j] > 0) {

                    int[] point = new int[] {i, j};
                    //System.out.println(i+","+frequency);
                    robustPointList.add(point);
                }
            }
        }
        // end find robust points

        List<Integer>[] robustLists = new LinkedList[spectrogramData.length];
        for (int i = 0; i < robustLists.length; i++) {
            robustLists[i] = new LinkedList<>();
        }

        // 
        for (int[] coor : robustPointList) {
            robustLists[coor[0]].add(coor[1]);
        }

        // return the list per frame
        return robustLists;
    }
847671
public Object[] getGroupData(Object[] data) {

        if (isSimpleAggregate) {
            if (simpleAggregateData == null) {
                simpleAggregateData = data;

                return null;
            }

            return simpleAggregateData;
        }

        RowIterator it = groupIndex.findFirstRow(session, store, data);

        if (it.hasNext()) {
            Row row = it.getNextRow();

            if (isAggregate) {
                row.setChanged();
            }

            return row.getData();
        }

        return null;
    }
270382
function(data) {
        if (data === null) {
            return [];
        } else if (Array.isArray(data)) {
            return data.map(this.validateItem, this);
        } else {
            throw new Error('Data for MultiSelectivity instance should be an array');
        }
    }
826442
@Override
	public List<IN> classify(List<IN> tokens) {
		if (baseClassifiers.isEmpty()) {
			return tokens;
		}
		List<List<IN>> baseOutputs = new ArrayList<List<IN>>();

		// the first base model works in place, modifying the original tokens
		List<IN> output = baseClassifiers.get(0).classifySentence(tokens);
		// classify(List<IN>) is supposed to work in place, so add AnswerAnnotation to tokens!
		for (int i = 0, sz = output.size(); i < sz; i++) {
			tokens.get(i).set(AnswerAnnotation.class, output.get(i).get(AnswerAnnotation.class));
		}
		baseOutputs.add(tokens);

		for (int i = 1, sz = baseClassifiers.size(); i < sz; i ++) {
			//List<CoreLabel> copy = deepCopy(tokens);
			// no need for deep copy: classifySentence creates a copy of the input anyway
			// List<CoreLabel> copy = tokens;
			output = baseClassifiers.get(i).classifySentence(tokens);
			baseOutputs.add(output);
		}
		assert(baseOutputs.size() == baseClassifiers.size());
		List<IN> finalAnswer = mergeDocuments(baseOutputs);

		return finalAnswer;
	}
155061
@SuppressWarnings("unchecked")
	private List labeling(List<Sentence> obsvSeqs){
		List labelSeqs = new ArrayList();
		
		for (int i = 0; i < obsvSeqs.size(); ++i){//ith sentence
			List sequence = new ArrayList();
			Sentence sentence = obsvSeqs.get(i);
			
			for (int j = 0; j < sentence.size(); ++j){//jth observation
				Observation obsv = new Observation();
				obsv.originalData = sentence.getWordAt(j);
				
				String [] strCps = dataTagger.getContext(sentence, j);
				
				ArrayList<Integer> tempCpsInt = new ArrayList<Integer>();

				for (int k = 0; k < strCps.length; k++) {
					Integer cpInt = (Integer) taggerMaps.cpStr2Int.get(strCps[k]);
					if (cpInt == null) {
						continue;
					}
					tempCpsInt.add(cpInt);
				}
				
				obsv.cps = new int[tempCpsInt.size()];
				for (int k = 0; k < tempCpsInt.size(); ++k){
					obsv.cps[k] = tempCpsInt.get(k).intValue();
				}
				sequence.add(obsv);
			}
			
			labelSeqs.add(sequence);
		}
		
		taggerModel.inferenceAll(labelSeqs);	
		
		//assign labels to list of sentences
		for (int i = 0; i < obsvSeqs.size(); ++i){
			Sentence sent = obsvSeqs.get(i);
			List seq = (List) labelSeqs.get(i);
			
			for (int j = 0; j < sent.size(); ++j){
				Observation obsrv = (Observation) seq.get(j);			
				String label = (String) taggerMaps.lbInt2Str.get(obsrv.modelLabel);
				
				sent.getTWordAt(j).setTag(label);
			}
		}
		
		return obsvSeqs;
	}
171873
private List<?> convertDataToList(final Object data) {
		if (data == null) {
			return null;
		} else if (data instanceof List) {
			return (List<?>) data;
		} else if (data instanceof Object[]) {
			return Arrays.asList((Object[]) data);
		} else {
			return Arrays.asList(new Object[]{data});
		}
	}
682158
private Collection<MetricDatum> filterOSMetrics(Collection<MetricDatum> data) {
        Collection<MetricDatum> output = new ArrayList<MetricDatum>(data.size());
        for (MetricDatum datum: data) {
            if (!OS_METRIC_NAME.equals(datum.getMetricName()))
                output.add(datum);
        }
        return output;
    }
961848
public LinearClassifier<L, F> trainClassifier(Collection<Datum<L, F>> examples) {
    Dataset<L, F> dataset = new Dataset<L, F>();
    dataset.addAll(examples);
    return trainClassifier(dataset);
  }
870673
@Override
	public List<CPDefinition> findAll() {
		return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
	}
981340
function(data){
			var rows = this.calculateScheduleRowsNumber();
			var datas = [];
			for(var i = 0; i < data.length; i += rows){
				datas.push(data.slice(i, i+rows));
			}
			return datas;
		}
1060324
public static List<Example<String, String>> exampleArrayToList(String[][] data) {
    List<Example<String, String>> pairs = Lists.newArrayList();
    for (int i = 0; i < data.length; i++) {
      pairs.add(new Example<String, String>(data[i][0], data[i][1]));
    }
    return pairs;
  }