import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
protected void map(LongWritable key, Text value, Mapper.Context context) throws IOException, InterruptedException {
    int sid = 0;
    for (String sentence : value.toString().split("\n")) {

        // do nothing, if maximum number of documents has been seen
        if (--maxdocs < 0) {
            return;
        }

        IntArrayList tids = new IntArrayList();
        for (String term : sentence.split("\\s+")) {
            tids.add(termTIdMap.get(term));
        }

        long did = key.hashCode() * 10000L + (long) sid++;

        outKey.set(did);
        outValue.setContents(tids.toArray(new int[0]));
        context.write(outKey, outValue);
    }
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
@Override
public void readFields(DataInput in) throws IOException {
  super.readFields(in);
  this.mass = in.readInt();
  int numpoints = in.readInt();
  this.boundPoints = new IntArrayList();
  for (int i = 0; i < numpoints; i++) {
    this.boundPoints.add(in.readInt());
  }
  this.mass = boundPoints.size();
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
@Override
public void readFields(DataInput in) throws IOException {
  int len = in.readInt();
  tuple = new IntArrayList(len);
  IntWritable value = new IntWritable();
  for (int i = 0; i < len; i++) {
    value.readFields(in);
    tuple.add(value.get());
  }
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

	String[] items = value.toString().split(itemSeparator);

	IntArrayList itemIds = new IntArrayList();

	String sequenceId = items[0];

	long id = 0;

	try {
		id = Long.parseLong(sequenceId);
	} catch (NumberFormatException e) {
		// if this is not a number, hash it
		id = sequenceId.hashCode();
	}

	// ignore pos 0 which contains a sequence identifier
	for (int i = 1; i < items.length; i++) {
		// System.out.println(itemTIdMap.get(items[i]));
		itemIds.add(itemTIdMap.get(items[i]));
	}

	if (itemIds.size() > 0) {

		outKey.set(id);
		outValue.setContents(itemIds.toArray(new int[0]));
		// System.out.println(itemIds.toString());

		context.write(outKey, outValue);
	}

}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
public static IntArrayList getGroupMembers(int groupId, int maxPerGroup,
        int numFeatures) {
    IntArrayList ret = new IntArrayList();
    int start = groupId * maxPerGroup;
    int end = start + maxPerGroup;
    if (end > numFeatures) {
        end = numFeatures;
    }
    for (int i = start; i < end; i++) {
        ret.add(i);
    }
    return ret;
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
@Override
protected void reduce(IntWritable key, Iterable<TransactionTree> values,
        Context context) throws IOException {
    TransactionTree cTree = new TransactionTree();
    for (TransactionTree tr : values) {
        for (Pair<IntArrayList, Long> p : tr) {
            cTree.addPattern(p.getFirst(), p.getSecond());
        }
    }

    List<Pair<Integer, Long>> localFList = Lists.newArrayList();
    for (Entry<Integer, org.apache.commons.lang3.mutable.MutableLong> fItem : cTree
            .generateFList().entrySet()) {
        localFList.add(new Pair<Integer, Long>(fItem.getKey(), fItem
                .getValue().toLong()));
    }

    Collections.sort(localFList,
            new CountDescendingPairComparator<Integer, Long>());

    FPGrowth<Integer> fpGrowth = new FPGrowth<Integer>();
    fpGrowth.generateTopKFrequentPatterns(
            new IteratorAdapter(cTree.iterator()),
            localFList,
            minSupport,
            maxHeapSize,
            new HashSet<Integer>(ARM.getGroupMembers(key.get(),
                    maxPerGroup, numFeatures).toList()),
            new IntegerStringOutputConverter(
                    new ContextWriteOutputCollector<IntWritable, TransactionTree, Text, TopKStringPatterns>(
                            context), featureReverseMap),
            new ContextStatusUpdater<IntWritable, TransactionTree, Text, TopKStringPatterns>(
                    context));
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
@Override
protected void reduce(IntWritable key, Iterable<TransactionTree> values,
        Context context) throws IOException, InterruptedException {
    TransactionTree cTree = new TransactionTree();
    for (TransactionTree tr : values) {
        for (Pair<IntArrayList, Long> p : tr) {
            cTree.addPattern(p.getFirst(), p.getSecond());
        }
    }
    context.write(key, cTree.getCompressedTree());
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
public IntArrayList getBoundPoints() {
  return boundPoints;
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
public void setBoundPoints(IntArrayList boundPoints) {
  this.boundPoints = boundPoints;
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
public void load(Configuration conf, String fileName, int minSupport) throws IOException {
	
	BufferedReader br = null;
	if (conf == null) {
		@SuppressWarnings("resource")
		FileInputStream fstream = new FileInputStream(fileName);
		// Get the object of DataInputStream
		DataInputStream in = new DataInputStream(fstream);
		br = new BufferedReader(new InputStreamReader(in));
	} else {
		FileSystem fs = FileSystem.get(conf);
		FSDataInputStream dis = fs.open(new Path(fileName));
		br = new BufferedReader(new InputStreamReader(dis));
	}
	
	OpenIntIntHashMap parentMap = new OpenIntIntHashMap();
	
	String line = null;

	while ((line = br.readLine()) != null) {
		String[] splits = line.split("\t");
		int itemId = Integer.parseInt(splits[3]);
		int itemSupport = Integer.parseInt(splits[2]);
		
		int parentId = Integer.parseInt(splits[4]);
		
		parentMap.put(itemId, parentId);

		if (itemSupport >= minSupport) {
			items.add(PrimitiveUtils.combine(itemId, itemSupport));
		}
		itemIdToItemMap.put(itemId, splits[0]);
	}
	
	Collections.sort(items, new MyComparator());
	
	parentIds = new int[parentMap.size() + 1];
	IntArrayList keyList = parentMap.keys();
	for(int i = 0; i < keyList.size(); ++i) {
		int item = keyList.get(i); 
		parentIds[item] = parentMap.get(item);
	}
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

			String[] terms = value.toString().split(itemSeparator);

			IntArrayList tids = new IntArrayList();

			for (int i = 1; i < terms.length; ++i) {

				tids.add(termTIdMap.get(terms[i]));
			}

			if (tids.size() > 0) {

				outValue.setContents(tids.toArray(new int[0]));
				context.write(outKey, outValue);
			}
		}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
private IteratorAdapter(
        Iterator<Pair<IntArrayList, Long>> transactionIter) {
    innerIter = transactionIter;
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
public Pair<List<Integer>, Long> next() {
    Pair<IntArrayList, Long> innerNext = innerIter.next();
    return new Pair<List<Integer>, Long>(innerNext.getFirst().toList(),
            innerNext.getSecond());
}
 

import org.apache.mahout.math.list.IntArrayList; //导入依赖的package包/类
/**
 * Fetch the list of entries from the tuple
 * 
 * @return a List containing the strings in the order of insertion
 */
public IntArrayList getEntries() {
  return new IntArrayList(this.tuple.elements());
}