package jp.ndca.toolkit.cluster.lsh.hash.pstable.data;

import static org.junit.Assert.assertEquals;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import org.junit.Test;

import jp.ndca.toolkit.cluster.lsh.hash.HashProbability;
import jp.ndca.toolkit.cluster.lsh.hash.pstable.NormalHashFunctionHandler;
import jp.ndca.toolkit.cluster.lsh.hash.pstable.NormalHashProbability;
import jp.ndca.toolkit.cluster.lsh.hash.pstable.PstableHandler;
import jp.ndca.toolkit.cluster.lsh.hash.pstable.PstableHandlerWrapper;
import jp.ndca.toolkit.cluster.lsh.hash.pstable.data.PstableHammingDataStore;

public class PstableDataHammingStoreTest {

　　@Test
　　public void testSearch() throws IOException{

　　　　/**
　　　　* ベクトルデータの読み込み
　　　　*/
　　　　InputStream is
　　　　　　= Thread.currentThread().getContextClassLoader().getResourceAsStream("lsh.txt");
　　　　BufferedReader br = new BufferedReader( new InputStreamReader(is) );

　　　　List<int[]> vectorList = new ArrayList<int[]>();

　　　　while( br.ready() ){
　　　　　　String line = br.readLine();
　　　　　　line = line.substring(1); 　　　　　　　　　　//[を除去
　　　　　　line = line.substring(0, line.length()-1); //]を除去
　　　　　　String[] numbers = line.split(",");
　　　　　　if(numbers.length != 0)
　　　　　　　　vectorList.add( StringArrayToIntegerArray(numbers) );
　　　　}

　　　　/**
　　　　* LSHパラメータの取得
　　　　*/
　　　　Properties prop = new Properties();
　　　　InputStream _is
　　　　　　= Thread.currentThread().getContextClassLoader().getResourceAsStream("lsh.properties")
　　　　prop.load( _is );

　　　　double c = Double.valueOf(prop.getProperty("c"));
　　　　double r = Double.valueOf(prop.getProperty("r"));

　　　　HashProbability pp = new NormalHashProbability( c, r );
　　　　double p1 = pp.getGoodHashProb();
　　　　double p2 = pp.getBadHashProb();

　　　　int n = Integer.parseInt(prop.getProperty("n"));
　　　　int dimension = Integer.parseInt(prop.getProperty("dimension"));

　　　　PstableHandler ph = new NormalHashFunctionHandler( p1, p2, n, dimension, r );

　　　　int K = ph.getK();
　　　　int L = ph.getL();

　　　　/**
　　　　* 検索データの変換
　　　　*/
　　　　PstableHandlerWrapper phw
　　　　　　= new PstableHandlerWrapper( ph.generateHashFunctionVectorGeneratorList( K, L ) );
　　　　PstableHammingDataStore pstableDataHammingStore
　　　　　　= new PstableHammingDataStore( vectorList, phw );

　　　　/**
　　　　* 検索の実行
　　　　*/
　　　　int[] query = new int[]{ 1 , 105, 119, 152, 177, 196, 215, 258, 315, 343, 413, 448 };

　　　　long start = System.currentTimeMillis();
　　　　String[] pstableHashes = phw.getPstableHashes(query);
　　　　int[] result = pstableDataHammingStore.search(pstableHashes);
　　　　long end = System.currentTimeMillis();
　　　　long diff = end - start;

　　　　assertEquals( true, classify(result, 9) );
　　　　System.out.println(vectorList.size());
　　　　System.out.println(result.length);
　　　　System.out.println( diff );

　　}

　　private static int[] StringArrayToIntegerArray( String[] array ){
　　　　int[] intArray = new int[ array.length ];
　　　　for( int i = 0 ; i < array.length ; i++){
　　　　　　if(array[i].equals(""))
　　　　　　　　continue;
　　　　　　intArray[i] = Integer.parseInt( array[i].trim() );
　　　　}
　　　　return intArray;
　　}

　　private static boolean classify( int[] candidateIds, int id ){
　　　　for( int candidateId : candidateIds){
　　　　　　if(candidateId==id)
　　　　　　　　return true;
　　　　}
　　　　return false;
　　}

}

package jp.ndca.toolkit.cluster.hierarchiccluster.builder;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

import jp.ndca.toolkit.cluster.hierarchiccluster.node.Member;
import jp.ndca.toolkit.cluster.hierarchiccluster.node.Node;
import jp.ndca.toolkit.cluster.hierarchiccluster.node.distance.impl.WardDistanceMeasure;
import jp.ndca.toolkit.cluster.hierarchiccluster.vector.SparseVector;
import jp.ndca.toolkit.cluster.hierarchiccluster.vector.distance.impl.EuclideanDistanceMeasure;
import jp.ndca.toolkit.cluster.hierarchiccluster.view.TreeDisplaySupport;

public class ClusterBuilderTest {

　　public static void main(String[] args){

　　　　List<Node> nodes = new ArrayList<Node>();

　　　　nodes.add( new Member( 0, colorToVector(Color.BLUE)) );
　　　　nodes.add( new Member( 1, colorToVector(Color.MAGENTA)) );
　　　　nodes.add( new Member( 2, colorToVector(Color.CYAN)) );
　　　　nodes.add( new Member( 3, colorToVector(Color.ORANGE)) );
　　　　nodes.add( new Member( 4, colorToVector(Color.PINK)) );
　　　　nodes.add( new Member( 5, colorToVector(Color.RED)) );

　　　　ClusterBuilder builder = new ClusterBuilder(
　　　　　　　　　　　　　　　　　　　　　new WardDistanceMeasure(
　　　　　　　　　　　　　　　　　　　　　　　new EuclideanDistanceMeasure() ));
　　　　Node rootNode = builder.build(nodes);
　　　　TreeDisplaySupport tree = new TreeDisplaySupport();
　　　　tree.makeTreeDiagram(rootNode);

　　}

　　private static SparseVector colorToVector(Color color){
　　　　SparseVector resultVector = new SparseVector();
　　　　resultVector.setQuick( 0, color.getRed() );
　　　　resultVector.setQuick( 1, color.getGreen() );
　　　　resultVector.setQuick( 2, color.getBlue() );
　　　　return resultVector;
　　}

}

+
　　+
　　　　5 (RED)
　　　　+
　　　　　　4 (PINK)
　　　　　　3 (ORANGE)
　　+
　　　　2　（CYAN）
　　　　+
　　　　　　1　（MAGENDA）
　　　　　　0　（BLUE）

package jp.ndca.toolkit.cluster.lsh.hash.simHash.data;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import jp.ndca.toolkit.cluster.lsh.hash.simHash.SimHashHandlerWrapperLong;

public class SimHashedLongDataStoreTest {

　　@Test
　　public void testSearchWithinThreshold() throws Exception{

　　　　List<Map<Integer,Short>> vectorList = makeSortData();

　　　　//検索対象データの元次元数
　　　　int demension = 500;

　　　　//検索ベクトルデータをsimHashした後のlongデータ
　　　　long[] resultList = new long[ vectorList.size() ];


　　　　/**
　　　　* simHashの実行
　　　　*/
　　　　SimHashHandlerWrapperLong simHash = new SimHashHandlerWrapperLong( demension );
　　　　for( int i=0 ; i < resultList.length ; i++ ){
　　　　　　Map<Integer,Short> vectorX = vectorList.get(i);
　　　　　　resultList[i] = simHash.getSimHashByLong( vectorX );
　　　　}
　　　　SimHashedLongDataStore data = new SimHashedLongDataStore(resultList);


　　　　//テストクエリを作成
　　　　String[] strQuery
　　　　　　= new String[]{ "1" , "105", "119", "152", "177", "196", "215", "258", "315", "343", "413", "448" };
　　　　long query = simHash.getSimHashByLong( StringArrayToIntegerArray(strQuery) );


　　　　/**
　　　　*　検索
　　　　*/
　　　　int threshold = 15;
　　　　long start = System.currentTimeMillis();
　　　　int[] candidateIds = data.searchWithinThreshold( query, threshold );
　　　　long end = System.currentTimeMillis();
　　　　long diff = end - start;


　　　　/**
　　　　* 結果の表示
　　　　*/
　　　　System.out.println( candidateIds.length );
　　　　for(int candidate :candidateIds)
　　　　　　System.out.println(candidate);
　　　　System.out.println( diff + "ms" );

　　}


　　/**
　　* 検索データを作成
　　* @return
　　* @throws IOException
　　*/
　　private List<Map<Integer,Short>> makeSortData() throws IOException{

　　　　List< Map<Integer,Short> > vectorList = new ArrayList< Map<Integer,Short> >();

　　　　InputStream is =
　　　　　　Thread.currentThread().getContextClassLoader().getResourceAsStream("lsh.txt");
　　　　BufferedReader br = new BufferedReader( new InputStreamReader( is ) );

　　　　while( br.ready() ){
　　　　　　String line = br.readLine();
　　　　　　line = line.substring(1); 　　　　　　　　　　　　//[を除去
　　　　　　line = line.substring(0, line.length()-1); 　　//]を除去
　　　　　　String[] numbers = line.split(",");
　　　　　　if( numbers.length != 0 )
　　　　　　　　vectorList.add( StringArrayToIntegerArray(numbers) );
　　　　}
　　　　return vectorList;

　　}


　　/**
　　* Stringデータをベクトルデータに変換。
　　* @param array
　　* @return
　　*/
　　private static Map<Integer, Short> StringArrayToIntegerArray( String[] array ){

　　　　Map<Integer, Short> resultMap = new HashMap<Integer, Short>();
　　　　for( int i = 0 ; i < array.length ; i++){
　　　　　　Integer key = null;
　　　　　　if(array[i].equals(""))
　　　　　　　　continue;
　　　　　　key = Integer.parseInt( array[i].trim() );
　　　　　　short num = resultMap.get(key) == null ? 0 : (short)(resultMap.get(key));
　　　　　　resultMap.put(key, ++num);
　　　　}
　　　　return resultMap;

　　}

}