Skip to content

etcart / RIVet

Go to a project
Commit 08c0a7e5 by simetk
Options

updated

parent f258c284
Inline Side-by-side
Showing with 8142 additions and 728 deletions
RIVCompare 0 → 100644
File added
RIVLower.c deleted 100644 → 0
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <math.h>
#include "RIVLower.h"
int* addS2D(int* destination, sparseRIV input){// #TODO fix destination parameter vs calloc of destination
int *locations_slider = input.locations;
int *values_slider = input.values;
int *locations_stop = locations_slider+input.count;
/* apply values at an index based on locations */
while(locations_slider<locations_stop){
destination[*locations_slider] += *values_slider;
locations_slider++;
values_slider++;
}
return destination;
}
int* mapI2D(int *locations, size_t valueCount){// #TODO fix destination parameter vs calloc of destination
int *destination = (int*)calloc(RIVSIZE,sizeof(int));
int *locations_slider = locations;
int *locations_stop = locations_slider+valueCount;
/*apply values +1 or -1 at an index based on locations */
while(locations_slider<locations_stop){
destination[*locations_slider] +=1;
locations_slider++;
destination[*locations_slider] -= 1;
locations_slider++;
}
return destination;
}
int* addI2D(int* destination, int *locations, size_t valueCount){// #TODO fix destination parameter vs calloc of destination
int *locations_slider = locations;
int *locations_stop = locations_slider+valueCount;
/*apply values +1 or -1 at an index based on locations */
while(locations_slider<locations_stop){
destination[*locations_slider] +=1;
locations_slider++;
destination[*locations_slider] -= 1;
locations_slider++;
}
return destination;
}
sparseRIV consolidateI2SIndirect(int *implicit, size_t valueCount){
int *denseTemp = mapI2D(implicit, valueCount);
sparseRIV sparseOut = consolidateD2S(denseTemp);
free(denseTemp);
return sparseOut;
}
sparseRIV consolidateI2SDirect(int *implicit, size_t valueCount){
sparseRIV sparseOut;
int *locationsTemp = RIVKey.h_tempBlock+RIVSIZE;
int *valuesTemp = RIVKey.h_tempBlock+2*RIVSIZE;
sparseOut.count = 0;
int add = 1;
int found;
for(int i=0; i<valueCount; i++){
found = 0;
for(int j=0; j<sparseOut.count; j++){
if(implicit[i] == locationsTemp[j]){
valuesTemp[i] += add;
add *= -1;
found = 1;
}
}
if(!found){
locationsTemp[sparseOut.count] = implicit[i];
valuesTemp[sparseOut.count] = add;
sparseOut.count++;
add*= -1;
}
}
sparseOut.locations = malloc(2*sparseOut.count*sizeof(int));
sparseOut.values = sparseOut.locations+sparseOut.count;
memcpy(sparseOut.locations, locationsTemp, sparseOut.count*sizeof(int));
memcpy(sparseOut.values, valuesTemp, sparseOut.count*sizeof(int));
return sparseOut;
}
sparseRIV consolidateD2S(int *denseInput){
sparseRIV output;
output.count = 0;
/* key/value pairs will be loaded to a worst-case sized temporary slot */
int* locations = RIVKey.h_tempBlock+RIVSIZE;
int* values = locations+RIVSIZE;
int* locations_slider = locations;
int* values_slider = values;
for(int i=0; i<RIVSIZE; i++){
/* act only on non-zeros */
if(denseInput[i]){
/* assign index to locations */
*(locations_slider++) = i;
/* assign value to values */
*(values_slider++) = denseInput[i];
/* track size of forming sparseRIV */
output.count++;
}
}
/* a slot is opened for the locations/values pair */
output.locations = (int*) malloc(output.count*2*sizeof(int));
if(!output.locations){
printf("memory allocation failed"); //*TODO enable fail point knowledge
}
/* copy locations values into opened slot */
memcpy(output.locations, locations, output.count*sizeof(int));
output.values = output.locations + output.count;
/* copy values into opened slot */
memcpy(output.values, values, output.count*sizeof(int));
return output;
}
void RIVInit(){
RIVKey.I2SThreshold = sqrt(RIVSIZE);
/* open a slot at least large enough for worst case handling of
* sparse to dense conversion. may be enlarged by filetoL2 functions */
struct sigaction action;
action.sa_sigaction = signalSecure;
action.sa_flags = SA_SIGINFO;
//for(int i=1; i<27; i++){
sigaction(11,&action,NULL);
//}
RIVKey.h_tempBlock = (int*)malloc(3*RIVSIZE*sizeof(int));
RIVKey.tempSize = 3*RIVSIZE;
RIVKey.thing = 0;
/* open a slot for a cache of dense RIVs, optimized for frequent accesses */
memset(RIVKey.RIVCache, 0, sizeof(denseRIV)*CACHESIZE);
}
void RIVCleanup(){
if(cacheDump()){
puts("cache dump failed, some lexicon data was lost");
}
free(RIVKey.h_tempBlock);
}
int wordtoSeed(unsigned char* word){
int i=0;
int seed = 0;
while(*word){
/* left-shift 5 each time *should* make seeds unique to words
* this means letters are taken as characters couned in base 32, which
* should be large enough to hold all english characters plus a few outliers
* */
seed += (*(word))<<(i*5);
word++;
i++;
}
return seed;
}
void makeSparseLocations(unsigned char* word, int *locations, size_t count){
locations+=count;
srand(wordtoSeed(word));
int *locations_stop = locations+NONZEROS;
while(locations<locations_stop){
/* unrolled for speed, guaranteed to be an even number of steps */
*locations = rand()%RIVSIZE;
locations++;
*locations = rand()%RIVSIZE;
locations++;
}
return;
}
int fLexPush(denseRIV RIVout){
char pathString[200] = {0};
/* word data will be placed in a (new?) file under the lexicon directory
* in a file named after the word itself */
sprintf(pathString, "lexicon/%s", RIVout.name);
FILE *lexWord = fopen(pathString, "wb");
if(!lexWord){
printf("lexicon push has failed for word: %s\nconsider cleaning inputs", pathString);
return 1;
}
sparseRIV temp = consolidateD2S(RIVout.values);
if(temp.count<(RIVSIZE/2)){
/* smaller stored as sparse vector */
fwrite(&temp.count, 1, sizeof(size_t), lexWord);
fwrite(RIVout.frequency, 1, sizeof(int), lexWord);
fwrite(&RIVout.magnitude, 1, sizeof(float), lexWord);
fwrite(temp.locations, temp.count, sizeof(int), lexWord);
fwrite(temp.values, temp.count, sizeof(int), lexWord);
}else{
/* saturation is too high, better to store dense */
/* there's gotta be a better way to do this */
temp.count = 0;
fwrite(&temp.count, 1, sizeof(int), lexWord);
fwrite(RIVout.frequency, 1, sizeof(int), lexWord);
fwrite(&RIVout.magnitude, 1, sizeof(float), lexWord);
fwrite(RIVout.values, RIVSIZE, sizeof(int), lexWord);
}
fclose(lexWord);
free(RIVout.values);
free(temp.locations);
return 0;
}
denseRIV fLexPull(FILE* lexWord){
denseRIV output = denseAllocate();
int typeCheck;
/* get metadata for vector */
fread(&typeCheck, 1, sizeof(unsigned int), lexWord);
fread(output.frequency, 1, sizeof(int), lexWord);
fread(&(output.magnitude), 1, sizeof(int), lexWord);
/* first value stored is the value count if sparse, and 0 if dense */
if (typeCheck){
/* pull as sparseVector */
sparseRIV temp;
/* value was not 0, so it's the value count */
temp.count = typeCheck;
temp.locations = malloc(temp.count*2*sizeof(int));
temp.values = temp.locations+temp.count;
fread(temp.locations, temp.count, sizeof(int), lexWord);
fread(temp.values, temp.count, sizeof(int), lexWord);
addS2D(output.values, temp);
free(temp.locations);
}else{
/* typecheck is thrown away, just a flag in this case */
fread(output.values, RIVSIZE, sizeof(int), lexWord);
}
output.cached = 0;
return output;
}
void signalSecure(int signum, siginfo_t *si, void* arg){
if(cacheDump()){
puts("cache dump failed, some lexicon data lost");
}else{
puts("cache dumped successfully");
}
signal(signum, SIG_DFL);
kill(getpid(), signum);
}
int cacheDump(){
int i=0;
int j=0;
int flag = 0;
denseRIV* cache_slider = RIVKey.RIVCache;
denseRIV* cache_stop = RIVKey.RIVCache+CACHESIZE;
while(cache_slider<cache_stop){
if((*cache_slider).cached){
j++;
flag += fLexPush(*cache_slider);
}
else{
i++;
}
cache_slider++;
}
printf("%d cacheslots unused\n%d, cacheslots used", i, j);
return flag;
}
denseRIV denseAllocate(){
/* allocates a 0 vector */
denseRIV output;
output.values = calloc(RIVSIZE+1, sizeof(int));
/* for compact memory use, frequency is placed immediately after values */
output.frequency = output.values+RIVSIZE;
output.magnitude = 0;
output.cached = 0;
return output;
}
/*TODO add a simplified free function*/
RIVLower.h
...@@ -6,6 +6,8 @@ ...@@ -6,6 +6,8 @@
#include <signal.h> #include <signal.h>
#include <unistd.h> #include <unistd.h>
#include <math.h> #include <math.h>
#include <sys/stat.h>
#include <sys/types.h>
/* RIVSIZE macro defines the dimensionality off the RIVs we will use /* RIVSIZE macro defines the dimensionality off the RIVs we will use
* 25000 is the standard, but can be redefined specifically * 25000 is the standard, but can be redefined specifically
*/ */
...@@ -42,6 +44,8 @@ ...@@ -42,6 +44,8 @@
#error "CACHESIZE cannot be a negative number" #error "CACHESIZE cannot be a negative number"
#endif #endif
/* the size of the tempBlock used in consolidation and implicit RIVs */
#define TEMPSIZE 3*RIVSIZE
/* the sparseRIV is a RIV form optimized for RIVs that will be mostly 0s /* the sparseRIV is a RIV form optimized for RIVs that will be mostly 0s
* as this is often an ideal case, it is adviseable as the default * as this is often an ideal case, it is adviseable as the default
...@@ -56,8 +60,9 @@ typedef struct{ ...@@ -56,8 +60,9 @@ typedef struct{
int *locations; int *locations;
size_t count; size_t count;
int frequency; int frequency;
float magnitude; double magnitude;
int boolean; int boolean;
int contextSize;
}sparseRIV; }sparseRIV;
/* the denseRIV is a RIV form optimized for overwhelmingly non-0 vectors /* the denseRIV is a RIV form optimized for overwhelmingly non-0 vectors
* this is rarely the case, but its primary use is for performing vector * this is rarely the case, but its primary use is for performing vector
...@@ -68,46 +73,42 @@ typedef struct{ ...@@ -68,46 +73,42 @@ typedef struct{
char name[100]; char name[100];
int* values; int* values;
int* frequency; int* frequency;
float magnitude; double magnitude;
int cached; int cached;
int *contextSize;
}denseRIV; }denseRIV;
/*RIVKey, holds globally important data that should not be changed partway through /*RIVKey, holds global variables used under the hood, primarily for the lexicon
* first function call in the program should always be: * it also holds a "temp block" that will be used by the dense to sparse
* RIVinit(); * conversion and implicit RIV aggregation
* this will set these variables, check for incompatible choices, and open up
* memory blocks which the system will use in the background
*/ */
struct RIVData{ struct RIVData{
int I2SThreshold; int h_tempBlock[TEMPSIZE];
int *h_tempBlock;
int tempSize; int tempSize;
int thing; char lexName[255];
denseRIV RIVCache[CACHESIZE]; denseRIV RIVCache[CACHESIZE];
}static RIVKey; }static RIVKey;
/* RIVinit should be the first function called in any usage of this library /* lexOpen is called to "open the lexicon", setting up for later calls to
* it sets global variables that practically all functions will reference, * lexPush and lexPull. if the lexicon has not been opened before calls
* it checks that your base parameters are valid, and allocates memory for * to these functions, their behavior can be unpredictable, most likely crashing
* the functions to use, so that we can move fast with rare allocations.
*/ */
void RIVInit(); void lexOpen();
/* RIVCleanup should always be called to close a RIV program. it frees /* lexClose should always be called after the last lex push or lex pull call
* blocks allocated by RIVinit, and dumps the cached data to appropriate lexicon files * if the lexicon is left open, some vector data may be lost due to
* un-flushed RIV cache
*/ */
void RIVCleanup(); void lexClose();
/*consolidateD2S takes a denseRIV value-set input, and returns a sparse RIV with /*consolidateD2S takes a denseRIV value-set input, and returns a sparse RIV with
* all 0s removed. it does not automatically carry metadata, which must be assigned * all 0s removed. it does not automatically carry metadata, which must be assigned
* to a denseRIV after the fact. often denseRIVs are only temporary, and don't * to a denseRIV after the fact. often denseRIVs are only temporary, and don't
* need to carry metadata * contain any metadata
*/ */
sparseRIV consolidateD2S(int *denseInput); //#TODO fix int*/denseRIV confusion sparseRIV consolidateD2S(int *denseInput); //#TODO fix int*/denseRIV confusion
/* mapS2D expands a sparseRIV out to denseRIV values, filling array locations
* based on location-value pairs
*/
/* makeSparseLocations must be called repeatedly in the processing of a /* makeSparseLocations must be called repeatedly in the processing of a
...@@ -118,12 +119,17 @@ sparseRIV consolidateD2S(int *denseInput); //#TODO fix int*/denseRIV confusion ...@@ -118,12 +119,17 @@ sparseRIV consolidateD2S(int *denseInput); //#TODO fix int*/denseRIV confusion
void makeSparseLocations(unsigned char* word, int *seeds, size_t seedCount); void makeSparseLocations(unsigned char* word, int *seeds, size_t seedCount);
/* fLexPush pushes the data contained in a denseRIV out to a lexicon file, /* fLexPush pushes the data contained in a denseRIV out to a lexicon file,
* saving it for long-term aggregation. function is called by "lexpush", * saving it for long-term aggregation. function is called by "lexPush",
* which is what users should actually use. lexPush, unlike fLexPush, * which is what users should actually use. lexPush, unlike fLexPush,
* has cache logic under the hood for speed and harddrive optimization * has cache logic under the hood for speed and harddrive optimization
*/ */
int fLexPush(denseRIV RIVout); int fLexPush(denseRIV RIVout);
/* flexPull pulls data directly from a file and converts it (if necessary)
* to a denseRIV. function is called by "lexPull" which is what users
* should actually use. lexPull, unlike FlexPull, has cache logic under
* the hood for speed and harddrive optimization
*/
denseRIV fLexPull(FILE* lexWord); denseRIV fLexPull(FILE* lexWord);
/* creates a standard seed from the characters in a word, hopefully unique */ /* creates a standard seed from the characters in a word, hopefully unique */
...@@ -135,13 +141,31 @@ int wordtoSeed(unsigned char* word); ...@@ -135,13 +141,31 @@ int wordtoSeed(unsigned char* word);
*/ */
int* mapI2D(int *locations, size_t seedCount); int* mapI2D(int *locations, size_t seedCount);
/* highly optimized method for adding vectors. there is no method
* included for adding D2D or S2S, as this system is faster-enough
* to be more than worth using
*/
int* addS2D(int* destination, sparseRIV input); int* addS2D(int* destination, sparseRIV input);
/*
sparseRIV consolidateI2SIndirect(int *implicit, size_t valueCount); sparseRIV consolidateI2SIndirect(int *implicit, size_t valueCount);
sparseRIV consolidateI2SDirect(int *implicit, size_t valueCount); sparseRIV consolidateI2SDirect(int *implicit, size_t valueCount);
* consolidate I2S is temporarily deprecated. may be brought back.
* in tandem they are much faster, but less careful with RAM */
/* caheDump flushes the RIV cache out to relevant files, backing up all
* data. this is called by the lexClose and signalSecure functions
*/
int cacheDump(); int cacheDump();
/* adds all elements of an implicit RIV (a sparseRIV represented without values)
* to a denseRIV. used by the file2L2 functions in aggregating a document vector
*/
int* addI2D(int* destination, int* locations, size_t seedCount); int* addI2D(int* destination, int* locations, size_t seedCount);
/* allocates a denseRIV filled with 0s
*/
denseRIV denseAllocate(); denseRIV denseAllocate();
/* redefines signal behavior to protect cached data against seg-faults etc*/
void signalSecure(int signum, siginfo_t *si, void* arg); void signalSecure(int signum, siginfo_t *si, void* arg);
/* begin definitions */ /* begin definitions */
...@@ -196,6 +220,7 @@ int* addI2D(int* destination, int *locations, size_t valueCount){// #TODO fix de ...@@ -196,6 +220,7 @@ int* addI2D(int* destination, int *locations, size_t valueCount){// #TODO fix de
return destination; return destination;
} }
/*
sparseRIV consolidateI2SIndirect(int *implicit, size_t valueCount){ sparseRIV consolidateI2SIndirect(int *implicit, size_t valueCount){
int *denseTemp = mapI2D(implicit, valueCount); int *denseTemp = mapI2D(implicit, valueCount);
...@@ -237,7 +262,8 @@ sparseRIV consolidateI2SDirect(int *implicit, size_t valueCount){ ...@@ -237,7 +262,8 @@ sparseRIV consolidateI2SDirect(int *implicit, size_t valueCount){
memcpy(sparseOut.locations, locationsTemp, sparseOut.count*sizeof(int)); memcpy(sparseOut.locations, locationsTemp, sparseOut.count*sizeof(int));
memcpy(sparseOut.values, valuesTemp, sparseOut.count*sizeof(int)); memcpy(sparseOut.values, valuesTemp, sparseOut.count*sizeof(int));
return sparseOut; return sparseOut;
} }*/
sparseRIV consolidateD2S(int *denseInput){ sparseRIV consolidateD2S(int *denseInput){
sparseRIV output; sparseRIV output;
output.count = 0; output.count = 0;
...@@ -264,7 +290,7 @@ sparseRIV consolidateD2S(int *denseInput){ ...@@ -264,7 +290,7 @@ sparseRIV consolidateD2S(int *denseInput){
/* a slot is opened for the locations/values pair */ /* a slot is opened for the locations/values pair */
output.locations = (int*) malloc(output.count*2*sizeof(int)); output.locations = (int*) malloc(output.count*2*sizeof(int));
if(!output.locations){ if(!output.locations){
printf("memory allocation failed"); //*TODO enable fail point knowledge printf("memory allocation failed"); //*TODO enable fail point knowledge and security
} }
/* copy locations values into opened slot */ /* copy locations values into opened slot */
memcpy(output.locations, locations, output.count*sizeof(int)); memcpy(output.locations, locations, output.count*sizeof(int));
...@@ -278,9 +304,13 @@ sparseRIV consolidateD2S(int *denseInput){ ...@@ -278,9 +304,13 @@ sparseRIV consolidateD2S(int *denseInput){
} }
void RIVInit(){ void lexOpen(char* lexName){
RIVKey.I2SThreshold = sqrt(RIVSIZE); /* RIVKey.I2SThreshold = sqrt(RIVSIZE);*/ //deprecate?
struct stat st;
if (stat(lexName, &st) == -1) {
mkdir(lexName, 0777);
}
strcpy(RIVKey.lexName, lexName);
/* open a slot at least large enough for worst case handling of /* open a slot at least large enough for worst case handling of
* sparse to dense conversion. may be enlarged by filetoL2 functions */ * sparse to dense conversion. may be enlarged by filetoL2 functions */
struct sigaction action; struct sigaction action;
...@@ -290,27 +320,23 @@ void RIVInit(){ ...@@ -290,27 +320,23 @@ void RIVInit(){
sigaction(11,&action,NULL); sigaction(11,&action,NULL);
//} //}
RIVKey.h_tempBlock = (int*)malloc(3*RIVSIZE*sizeof(int));
RIVKey.tempSize = 3*RIVSIZE;
RIVKey.thing = 0;
/* open a slot for a cache of dense RIVs, optimized for frequent accesses */ /* open a slot for a cache of dense RIVs, optimized for frequent accesses */
memset(RIVKey.RIVCache, 0, sizeof(denseRIV)*CACHESIZE); memset(RIVKey.RIVCache, 0, sizeof(denseRIV)*CACHESIZE);
} }
void RIVCleanup(){ void lexClose(){
if(cacheDump()){ if(cacheDump()){
puts("cache dump failed, some lexicon data was lost"); puts("cache dump failed, some lexicon data was lost");
} }
free(RIVKey.h_tempBlock);
} }
int wordtoSeed(unsigned char* word){ int wordtoSeed(unsigned char* word){
int i=0; int i=0;
int seed = 0; int seed = 0;
while(*word){ while(*word){
/* left-shift 5 each time *should* make seeds unique to words /* left-shift 5 each time *should* make seeds unique to words
* this means letters are taken as characters couned in base 32, which * this means letters are taken as characters counted in base 32, which
* should be large enough to hold all english characters plus a few outliers * should be large enough to hold all english characters plus a few outliers
* */ * */
seed += (*(word))<<(i*5); seed += (*(word))<<(i*5);
...@@ -336,41 +362,40 @@ void makeSparseLocations(unsigned char* word, int *locations, size_t count){ ...@@ -336,41 +362,40 @@ void makeSparseLocations(unsigned char* word, int *locations, size_t count){
int fLexPush(denseRIV RIVout){ int fLexPush(denseRIV RIVout){
char pathString[200] = {0}; char pathString[200] = {0};
/* word data will be placed in a (new?) file under the lexicon directory /* word data will be placed in a (new?) file under the lexicon directory
* in a file named after the word itself */ * in a file named after the word itself */
sprintf(pathString, "lexicon/%s", RIVout.name); sprintf(pathString, "%s/%s", RIVKey.lexName, RIVout.name);
FILE *lexWord = fopen(pathString, "wb"); FILE *lexWord = fopen(pathString, "wb");
if(!lexWord){ if(!lexWord){
printf("lexicon push has failed for word: %s\nconsider cleaning inputs", pathString); printf("lexicon push has failed for word: %s\nconsider cleaning inputs", pathString);
return 1; return 1;
} }
sparseRIV temp = consolidateD2S(RIVout.values); sparseRIV temp = consolidateD2S(RIVout.values);
if(temp.count<(RIVSIZE/2)){ if(temp.count<(RIVSIZE/2)){
/* smaller stored as sparse vector */ /* smaller stored as sparse vector */
fwrite(&temp.count, 1, sizeof(size_t), lexWord); fwrite(&temp.count, 1, sizeof(size_t), lexWord);
fwrite(RIVout.frequency, 1, sizeof(int), lexWord); fwrite(RIVout.frequency, 1, sizeof(int), lexWord);
fwrite(RIVout.contextSize, 1, sizeof(int), lexWord);
fwrite(&RIVout.magnitude, 1, sizeof(float), lexWord); fwrite(&RIVout.magnitude, 1, sizeof(float), lexWord);
fwrite(temp.locations, temp.count, sizeof(int), lexWord); fwrite(temp.locations, temp.count, sizeof(int), lexWord);
fwrite(temp.values, temp.count, sizeof(int), lexWord); fwrite(temp.values, temp.count, sizeof(int), lexWord);
// printf("%s, writing as sparse, frequency: %d", RIVout.name, *RIVout.frequency);
}else{ }else{
/* saturation is too high, better to store dense */ /* saturation is too high, better to store dense */
/* there's gotta be a better way to do this */ /* there's gotta be a better way to do this */
temp.count = 0; temp.count = 0;
fwrite(&temp.count, 1, sizeof(int), lexWord); fwrite(&temp.count, 1, sizeof(size_t), lexWord);
fwrite(RIVout.frequency, 1, sizeof(int), lexWord); fwrite(RIVout.frequency, 1, sizeof(int), lexWord);
fwrite(RIVout.contextSize, 1, sizeof(int), lexWord);
fwrite(&RIVout.magnitude, 1, sizeof(float), lexWord); fwrite(&RIVout.magnitude, 1, sizeof(float), lexWord);
fwrite(RIVout.values, RIVSIZE, sizeof(int), lexWord); fwrite(RIVout.values, RIVSIZE, sizeof(int), lexWord);
// printf("%s, writing as dense, frequency: %d", RIVout.name, *RIVout.frequency);
} }
fclose(lexWord); fclose(lexWord);
free(RIVout.values); free(RIVout.values);
free(temp.locations); free(temp.locations);
...@@ -380,37 +405,39 @@ int fLexPush(denseRIV RIVout){ ...@@ -380,37 +405,39 @@ int fLexPush(denseRIV RIVout){
denseRIV fLexPull(FILE* lexWord){ denseRIV fLexPull(FILE* lexWord){
denseRIV output = denseAllocate(); denseRIV output = denseAllocate();
int typeCheck; size_t typeCheck;
int flag = 0;
/* get metadata for vector */ /* get metadata for vector */
fread(&typeCheck, 1, sizeof(unsigned int), lexWord); flag+= fread(&typeCheck, 1, sizeof(size_t), lexWord);
fread(output.frequency, 1, sizeof(int), lexWord); flag+= fread(output.frequency, 1, sizeof(int), lexWord);
fread(&(output.magnitude), 1, sizeof(int), lexWord); flag+= fread(output.contextSize, 1, sizeof(int), lexWord);
flag+= fread(&(output.magnitude), 1, sizeof(float), lexWord);
/* first value stored is the value count if sparse, and 0 if dense */ /* first value stored is the value count if sparse, and 0 if dense */
if (typeCheck){ if (typeCheck){
/* pull as sparseVector */ /* pull as sparseVector */
sparseRIV temp; sparseRIV temp;
/* value was not 0, so it's the value count */ /* value was not 0, so it's the value count */
temp.count = typeCheck; temp.count = typeCheck;
temp.locations = (int*)malloc(temp.count*2*sizeof(int)); temp.locations = (int*)malloc(temp.count*2*sizeof(int));
temp.values = temp.locations+temp.count; temp.values = temp.locations+temp.count;
fread(temp.locations, temp.count, sizeof(int), lexWord); flag+= fread(temp.locations, temp.count, sizeof(int), lexWord);
fread(temp.values, temp.count, sizeof(int), lexWord); flag+=fread(temp.values, temp.count, sizeof(int), lexWord);
addS2D(output.values, temp); addS2D(output.values, temp);
free(temp.locations); free(temp.locations);
}else{ }else{
/* typecheck is thrown away, just a flag in this case */ /* typecheck is thrown away, just a flag in this case */
fread(output.values, RIVSIZE, sizeof(int), lexWord); flag += fread(output.values, RIVSIZE, sizeof(int), lexWord);
} }
output.cached = 0; output.cached = 0;
return output; return output;
} }
void signalSecure(int signum, siginfo_t *si, void* arg){ void signalSecure(int signum, siginfo_t *si, void* arg){
...@@ -424,33 +451,31 @@ void signalSecure(int signum, siginfo_t *si, void* arg){ ...@@ -424,33 +451,31 @@ void signalSecure(int signum, siginfo_t *si, void* arg){
} }
int cacheDump(){ int cacheDump(){
int i=0;
int j=0;
int flag = 0; int flag = 0;
denseRIV* cache_slider = RIVKey.RIVCache; denseRIV* cache_slider = RIVKey.RIVCache;
denseRIV* cache_stop = RIVKey.RIVCache+CACHESIZE; denseRIV* cache_stop = RIVKey.RIVCache+CACHESIZE;
while(cache_slider<cache_stop){ while(cache_slider<cache_stop){
if((*cache_slider).cached){ if((*cache_slider).cached){
j++;
flag += fLexPush(*cache_slider); flag += fLexPush(*cache_slider);
} }
else{ else{
i++;
} }
cache_slider++; cache_slider++;
} }
printf("%d cacheslots unused\n%d, cacheslots used", i, j);
return flag; return flag;
} }
denseRIV denseAllocate(){ denseRIV denseAllocate(){
/* allocates a 0 vector */ /* allocates a 0 vector */
denseRIV output; denseRIV output;
output.values = (int*)calloc(RIVSIZE+1, sizeof(int)); output.values = (int*)calloc(RIVSIZE+2, sizeof(int));
/* for compact memory use, frequency is placed immediately after values */ /* for compact memory use, frequency is placed immediately after values */
output.frequency = output.values+RIVSIZE; output.frequency = output.values+RIVSIZE;
output.magnitude = 0; output.contextSize = output.frequency+1;
output.magnitude = 0;
output.cached = 0; output.cached = 0;
return output; return output;
} }
...@@ -458,3 +483,4 @@ denseRIV denseAllocate(){ ...@@ -458,3 +483,4 @@ denseRIV denseAllocate(){
/*TODO add a simplified free function*/ /*TODO add a simplified free function*/
#endif #endif
RIVLower.h.gch 0 → 100644
File added
RIVaccessories.c deleted 100644 → 0
int isLetter(char c){
if((c>96 && c<123)||(c == 32) || (c == '_')) return 1;
else return 0;
}
int isWordClean(char* word){
char *letter = word;
char *word_stop = word+99;
while(letter<word_stop){
if(!(*letter)) break;
if(!(isLetter(*letter))){
return 0;
}
letter++;
}
return 1;
}
RIVcompare.c 0 → 100644
#include <stdio.h>
#include "RIVtools.h"
#include <dirent.h>
#include <sys/types.h>
#include <time.h>
int main(){
lexOpen("/home/drbob/Documents/lexicon");
FILE *wordList = fopen("wordList.txt", "r");
char word[100];
denseRIV accept;
sparseRIV analyzefloor;
sparseRIV analyzerounded;
sparseRIV other;
while(fscanf(wordList, "%s", word)){
if(!*word) break;
if(feof(wordList))break;
puts(word);
// sleep(1);
accept = lexPull(word);
other = consolidateD2S(accept.values);
//other.magnitude = getMagnitudeSparse(other);
// accept.magnitude = other.magnitude;
// analyzerounded = normalize(accept, 2000);
// analyzefloor = normalizeFloored(accept, 2000);
// if(cosCompare(accept, analyzefloor)>1.00){
// printf("floored: %f rounded: %f\tcontextSize: %d\tfrequency: %d\tsaturationbase %d, saturationFloored %d, saturationRounded %d\n", analyzefloor.magnitude, analyzerounded.magnitude, *(accept.contextSize), *(accept.frequency), other.count, analyzefloor.count, analyzerounded.count);
////}
// free(analyzefloor.locations);
// free(analyzerounded.locations);
free(other.locations);
free(accept.values);
}
lexClose();
}
RIVcull 0 → 100644
File added
RIVcullCPUlinux.c
...@@ -15,7 +15,7 @@ void directoryToL2s(char *rootString, sparseRIV** fileRIVs, int *fileCount); ...@@ -15,7 +15,7 @@ void directoryToL2s(char *rootString, sparseRIV** fileRIVs, int *fileCount);
int main(int argc, char *argv[]){ int main(int argc, char *argv[]){
clock_t begintotal = clock(); clock_t begintotal = clock();
int fileCount = 0; int fileCount = 0;
RIVInit(); //RIVInit();
sparseRIV *fileRIVs = (sparseRIV*) malloc(1*sizeof(sparseRIV)); sparseRIV *fileRIVs = (sparseRIV*) malloc(1*sizeof(sparseRIV));
char rootString[2000]; char rootString[2000];
if(argc <2){ if(argc <2){
...@@ -44,6 +44,7 @@ int main(int argc, char *argv[]){ ...@@ -44,6 +44,7 @@ int main(int argc, char *argv[]){
baseDense.values = malloc(RIVSIZE*sizeof(int)); baseDense.values = malloc(RIVSIZE*sizeof(int));
fileRIVs_slider = fileRIVs; fileRIVs_slider = fileRIVs;
sparseRIV* comparators_slider; sparseRIV* comparators_slider;
int thing = 0;
int count = 0; int count = 0;
while(fileRIVs_slider<fileRIVs_stop){ while(fileRIVs_slider<fileRIVs_stop){
comparators_slider = fileRIVs; comparators_slider = fileRIVs;
...@@ -59,8 +60,8 @@ int main(int argc, char *argv[]){ ...@@ -59,8 +60,8 @@ int main(int argc, char *argv[]){
count++; count++;
if(cosine>THRESHOLD){ if(cosine>THRESHOLD){
printf("%s\t%s\n%f\n", (*fileRIVs_slider).name , (*comparators_slider).name, cosine); printf("%s\t%s\n%f\n", (*fileRIVs_slider).name , (*comparators_slider).name, cosine);
(*comparators_slider).boolean = 0; (*comparators_slider).boolean = 0;
RIVKey.thing++; thing++;
} }
} }
...@@ -75,7 +76,7 @@ int main(int argc, char *argv[]){ ...@@ -75,7 +76,7 @@ int main(int argc, char *argv[]){
double time = (double)(endnsquared - beginnsquared) / CLOCKS_PER_SEC; double time = (double)(endnsquared - beginnsquared) / CLOCKS_PER_SEC;
printf("\nnsquared time:%lf\n\n", time); printf("\nnsquared time:%lf\n\n", time);
printf("\ncosines: %d \n", count); printf("\ncosines: %d \n", count);
printf("\nsims: %d \n", RIVKey.thing); printf("\nsims: %d \n", thing);
clock_t endtotal = clock(); clock_t endtotal = clock();
double time_spent = (double)(endtotal - begintotal) / CLOCKS_PER_SEC; double time_spent = (double)(endtotal - begintotal) / CLOCKS_PER_SEC;
printf("total time:%lf\n\n", time_spent); printf("total time:%lf\n\n", time_spent);
......
RIVcullG deleted 100644 → 0
File deleted
RIVcullbooks.c 0 → 100644
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <time.h>
#define RIVSIZE 25000
#define CACHESIZE 0
#define NONZEROS 2
#define THRESHOLD 0.98
#include "RIVtools.h"
void directoryToL2s(char *rootString, sparseRIV** fileRIVs, int *fileCount);
int main(int argc, char *argv[]){
clock_t begintotal = clock();
int fileCount = 0;
sparseRIV *fileRIVs = (sparseRIV*) malloc(1*sizeof(sparseRIV));
char rootString[2000];
if(argc <2){
printf("give me a directory");
return 1;
}
strcpy(rootString, argv[1]);
strcat(rootString, "/");
directoryToL2s(rootString, &fileRIVs, &fileCount);
printf("fileCount: %d\n", fileCount);
sparseRIV* fileRIVs_slider = fileRIVs;
sparseRIV* fileRIVs_stop = fileRIVs+fileCount;
while(fileRIVs_slider <fileRIVs_stop){
(*fileRIVs_slider).magnitude = getMagnitudeSparse(*fileRIVs_slider);
fileRIVs_slider++;
}
clock_t beginnsquared = clock();
int thing = 0;
float cosine;
float minmag;
float maxmag;
denseRIV baseDense;
baseDense.values = malloc(RIVSIZE*sizeof(int));
fileRIVs_slider = fileRIVs;
sparseRIV* comparators_slider;
int count = 0;
while(fileRIVs_slider<fileRIVs_stop){
comparators_slider = fileRIVs;
memset(baseDense.values, 0, RIVSIZE*sizeof(int));
baseDense.values = addS2D(baseDense.values, *fileRIVs_slider);
baseDense.magnitude = (*fileRIVs_slider).magnitude;
minmag = baseDense.magnitude*.85;
maxmag = baseDense.magnitude*1.15;
while(comparators_slider < fileRIVs_slider){
if((*comparators_slider).magnitude < maxmag && (*comparators_slider).magnitude > minmag && (*comparators_slider).boolean){
cosine = cosCompare(baseDense, *comparators_slider);
count++;
if(cosine>THRESHOLD){
printf("%s\t%f\n",(*comparators_slider).name, cosine);
if(remove((*comparators_slider).name)){
printf(" well shit");
}
(*comparators_slider).boolean = 0;
thing++;
}
}
comparators_slider++;
}
fileRIVs_slider++;
}
clock_t endnsquared = clock();
double time = (double)(endnsquared - beginnsquared) / CLOCKS_PER_SEC;
printf("\nnsquared time:%lf\n\n", time);
printf("\ncosines: %d \n", count);
printf("\nsims: %d \n", thing);
clock_t endtotal = clock();
double time_spent = (double)(endtotal - begintotal) / CLOCKS_PER_SEC;
printf("total time:%lf\n\n", time_spent);
free(fileRIVs);
return 0;
}
void directoryToL2s(char *rootString, sparseRIV** fileRIVs, int *fileCount){
char pathString[2000];
DIR *directory;
struct dirent *files = 0;
if(!(directory = opendir(rootString))){
printf("location not found, %s\n", rootString);
return;
}
while((files=readdir(directory))){
if(*(files->d_name) == '.') continue;
if(files->d_type == DT_DIR){
strcpy(pathString, rootString);
strcat(pathString, files->d_name);
strcat(pathString, "/");
directoryToL2s(pathString, fileRIVs, fileCount);
}
strcpy(pathString, rootString);
strcat(pathString, files->d_name);
FILE *input = fopen(pathString, "r");
puts(pathString);
if(!input){
printf("file %s doesn't seem to exist, breaking out of loop", pathString);
return;
}else{
(*fileRIVs) = (sparseRIV*)realloc((*fileRIVs), ((*fileCount)+1)*sizeof(sparseRIV));
(*fileRIVs)[(*fileCount)] = fileToL2(input);
strcpy((*fileRIVs)[(*fileCount)].name, pathString);
fclose(input);
(*fileCount)++;
}
}
}
RIVlexcompare 0 → 100644
File added
RIVlexcompare.c 0 → 100644
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <time.h>
#define RIVSIZE 25000
#define CACHESIZE 0
#define NONZEROS 2
#define THRESHOLD 0.90
#include "RIVtools.h"
void directoryToL2s(char *rootString, sparseRIV** fileRIVs, int *fileCount);
int main(int argc, char *argv[]){
clock_t begintotal = clock();
int fileCount = 0;
lexOpen("/home/drbob/Documents/lexicon");
sparseRIV *fileRIVs = (sparseRIV*) malloc(1*sizeof(sparseRIV));
char rootString[2000];
if(argc <2){
printf("give me a directory");
return 1;
}
int thing = 0;
strcpy(rootString, argv[1]);
strcat(rootString, "/");
directoryToL2s(rootString, &fileRIVs, &fileCount);
printf("fileCount: %d\n", fileCount);
sparseRIV* fileRIVs_slider = fileRIVs;
sparseRIV* fileRIVs_stop = fileRIVs+fileCount;
while(fileRIVs_slider <fileRIVs_stop){
(*fileRIVs_slider).magnitude = getMagnitudeSparse(*fileRIVs_slider);
fileRIVs_slider++;
}
clock_t beginnsquared = clock();
float cosine;
denseRIV baseDense;
baseDense.values = malloc(RIVSIZE*sizeof(int));
fileRIVs_slider = fileRIVs;
sparseRIV* comparators_slider;
int count = 0;
while(fileRIVs_slider<fileRIVs_stop){
if(!fileRIVs_slider->boolean){
fileRIVs_slider++;
continue;
}
if(fileRIVs_slider->magnitude == 0) continue;
comparators_slider = fileRIVs;
memset(baseDense.values, 0, RIVSIZE*sizeof(int));
baseDense.values = addS2D(baseDense.values, *fileRIVs_slider);
baseDense.magnitude =(*fileRIVs_slider).magnitude;
while(comparators_slider < fileRIVs_stop){
if(!(comparators_slider->boolean&&strcmp(comparators_slider->name, fileRIVs_slider->name))){
comparators_slider++;
continue;
}
if(comparators_slider->magnitude==0) continue;
cosine = cosCompare(baseDense, *comparators_slider);
count++;
if(cosine>THRESHOLD){
printf("%s\t%s\n%f\n", fileRIVs_slider->name , comparators_slider->name, cosine);
comparators_slider->boolean = 0;
thing++;
}
comparators_slider++;
}
fileRIVs_slider++;
}
clock_t endnsquared = clock();
double time = (double)(endnsquared - beginnsquared) / CLOCKS_PER_SEC;
printf("\nnsquared time:%lf\n\n", time);
printf("\ncosines: %d \n", count);
printf("\nsims: %d \n", thing);
clock_t endtotal = clock();
double time_spent = (double)(endtotal - begintotal) / CLOCKS_PER_SEC;
printf("total time:%lf\n\n", time_spent);
free(fileRIVs);
lexClose();
return 0;
}
void directoryToL2s(char *rootString, sparseRIV** fileRIVs, int *fileCount){
DIR *directory;
struct dirent *files = 0;
if(!(directory = opendir(rootString))){
printf("location not found, %s\n", rootString);
return;
}
while((files=readdir(directory))){
if(*(files->d_name) == '.') continue;
denseRIV temp = lexPull(files->d_name);
if(*temp.frequency >2000){
(*fileRIVs) = (sparseRIV*)realloc((*fileRIVs), ((*fileCount)+1)*sizeof(sparseRIV));
(*fileRIVs)[(*fileCount)] = normalize(temp, 500);
strcpy((*fileRIVs)[(*fileCount)].name, files->d_name);
(*fileCount)++;
}
free(temp.values);
}
}
RIVread 0 → 100644
File added
RIVread.c
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#define CACHESIZE 10000 #define CACHESIZE 15000
//#define RIVSIZE 5
#include <setjmp.h> #include <setjmp.h>
#include <signal.h> #include <signal.h>
#include "RIVtoolsCPUlinux.h" #include "RIVtools.h"
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
...@@ -21,33 +20,38 @@ void readdirContingency(int sigNumber); ...@@ -21,33 +20,38 @@ void readdirContingency(int sigNumber);
jmp_buf readdirRecov; jmp_buf readdirRecov;
int main(int argc, char *argv[]){ int main(int argc, char *argv[]){
clock_t begintotal = clock(); clock_t begintotal = clock();
RIVInit(); lexOpen("/home/drbob/Documents/lexicon");
char pathString[1000]; char pathString[1000];
strcpy(pathString, argv[1]); strcpy(pathString, argv[1]);
strcat(pathString, "/"); strcat(pathString, "/");
struct stat st = {0};
if(stat(pathString, &st) == -1) {
return 1;
}
directoryGrind(pathString); directoryGrind(pathString);
clock_t endtotal = clock();
clock_t endtotal = clock();
double time_spent = (double)(endtotal - begintotal) / CLOCKS_PER_SEC; double time_spent = (double)(endtotal - begintotal) / CLOCKS_PER_SEC;
printf("total time:%lf\n\n", time_spent); printf("total time:%lf\n\n", time_spent);
RIVCleanup(); lexClose();
return 0; return 0;
} }
void addS2Ds(denseRIV *denseSet, sparseRIV additive, int RIVCount){ void addS2Ds(denseRIV *denseSet, sparseRIV additive, int RIVCount){
denseRIV *denseSet_slider = denseSet; denseRIV *denseSet_slider = denseSet;
denseRIV *dense_stop = denseSet+RIVCount; denseRIV *dense_stop = denseSet+RIVCount;
//int *target;
while(denseSet_slider<dense_stop){ while(denseSet_slider<dense_stop){
addS2D((*denseSet_slider).values, additive); addS2D((*denseSet_slider).values, additive);
*(denseSet_slider->contextSize) += additive.frequency;
denseSet_slider++; denseSet_slider++;
} }
}
}
int checkDupe(denseRIV* RIVSet, char* word, int wordCount){ int checkDupe(denseRIV* RIVSet, char* word, int wordCount){
denseRIV* RIVStop = RIVSet+wordCount; denseRIV* RIVStop = RIVSet+wordCount;
while(RIVSet<RIVStop){ while(RIVSet<RIVStop){
...@@ -62,8 +66,8 @@ void directoryGrind(char *rootString){ ...@@ -62,8 +66,8 @@ void directoryGrind(char *rootString){
char pathString[2000]; char pathString[2000];
DIR *directory; DIR *directory;
struct dirent *files = 0; struct dirent *files = 0;
if(!(directory = opendir(rootString))){ if(!(directory = opendir(rootString))){
printf("location not found, %s\n", rootString); printf("location not found, %s\n", rootString);
return; return;
...@@ -73,16 +77,16 @@ void directoryGrind(char *rootString){ ...@@ -73,16 +77,16 @@ void directoryGrind(char *rootString){
if(setjmp(readdirRecov)){ if(setjmp(readdirRecov)){
continue; continue;
} }
signal(SIGSEGV, readdirContingency);
//printf("reclen: %d, d_name pointer: %p, firstDigit, %d", files->d_reclen,files->d_name,*(files->d_name)); //printf("reclen: %d, d_name pointer: %p, firstDigit, %d", files->d_reclen,files->d_name,*(files->d_name));
while(*(files->d_name)=='.'){ while(*(files->d_name)=='.'){
files = readdir(directory); files = readdir(directory);
} }
//signal(SIGSEGV, SIG_DFL); //signal(SIGSEGV, signalSecure);
if(files->d_type == DT_DIR){ if(files->d_type == DT_DIR){
strcpy(pathString, rootString); strcpy(pathString, rootString);
strcat(pathString, files->d_name); strcat(pathString, files->d_name);
strcat(pathString, "/"); strcat(pathString, "/");
directoryGrind(pathString); directoryGrind(pathString);
...@@ -107,10 +111,10 @@ void fileGrind(FILE* textFile){ ...@@ -107,10 +111,10 @@ void fileGrind(FILE* textFile){
char word[200]; char word[200];
while(fscanf(textFile, "%99s", word)){ while(fscanf(textFile, "%99s", word)){
if(feof(textFile)) break; if(feof(textFile)) break;
if(!(*word))continue; if(!(*word))continue;
if(!isWordClean((char*)word)){ if(!isWordClean((char*)word)){
continue; continue;
} }
...@@ -118,32 +122,31 @@ void fileGrind(FILE* textFile){ ...@@ -118,32 +122,31 @@ void fileGrind(FILE* textFile){
continue; continue;
} }
RIVArray[wordCount] = lexPull(word); RIVArray[wordCount] = lexPull(word);
if(!*((RIVArray[wordCount].name))) break; if(!*((RIVArray[wordCount].name))) break;
int* thing = RIVArray[wordCount].frequency; *(RIVArray[wordCount].frequency)+= 1;;
*thing = *thing + 1;
//printf("%s, %d, %d\n", RIVArray[wordCount].name, *(RIVArray[wordCount].frequency), *thing); //printf("%s, %d, %d\n", RIVArray[wordCount].name, *(RIVArray[wordCount].frequency), *thing);
wordCount++; wordCount++;
} }
//printf("%d\n", wordCount); //printf("%d\n", wordCount);
addS2Ds(RIVArray, aggregateRIV, wordCount); addS2Ds(RIVArray, aggregateRIV, wordCount);
denseRIV* RIVArray_slider = RIVArray; denseRIV* RIVArray_slider = RIVArray;
denseRIV* RIVArray_stop = RIVArray+wordCount; denseRIV* RIVArray_stop = RIVArray+wordCount;
while(RIVArray_slider<RIVArray_stop){ while(RIVArray_slider<RIVArray_stop){
lexPush(*RIVArray_slider); lexPush(*RIVArray_slider);
RIVArray_slider++; RIVArray_slider++;
} }
free(RIVArray); free(RIVArray);
free(aggregateRIV.locations); free(aggregateRIV.locations);
} }
void readdirContingency(int sigNumber){ void readdirContingency(int sigNumber){
("readdir segfaulted, trying to recover"); ("readdir segfaulted, trying to recover");
longjmp(readdirRecov, 1); longjmp(readdirRecov, 1);
} }
RIVtools.h
...@@ -33,119 +33,123 @@ sparseRIV fileToL2Clean(FILE *data); ...@@ -33,119 +33,123 @@ sparseRIV fileToL2Clean(FILE *data);
sparseRIV fileToL2direct(FILE *data); sparseRIV fileToL2direct(FILE *data);
/*cosine determines the "similarity" between two RIVs. */ /*cosine determines the "similarity" between two RIVs. */
float cosCompare(denseRIV baseRIV, sparseRIV comparator); double cosCompare(denseRIV baseRIV, sparseRIV comparator);
/*currently unused */ /*currently unused */
sparseRIV wordtoL2(char* word); sparseRIV wordtoL2(char* word);
/* converts an implicit RIV (a set of unvalued locations) into a formal /* converts an implicit RIV (a set of unvalued locations) into a formal
* sparse RIV. this chooses the best method to perform the consolidation * sparse RIV. this chooses the best method to perform the consolidation
* and launches that function */ * and launches that function defunct right now for memory usage reasons*/
sparseRIV consolidateI2S(int *implicit, size_t valueCount); sparseRIV consolidateI2S(int *implicit, size_t valueCount);
sparseRIV normalizeFloored(denseRIV input, int factor);
sparseRIV normalize(denseRIV input, int factor);
int roundMultiply(int base, float divisor);
/* like fileToL2 but takes a block of text */ /* like fileToL2 but takes a block of text */
sparseRIV text2L2(char *text); sparseRIV text2L2(char *text);
float getMagnitudeSparse(sparseRIV input);
/* calculates the magnitude of a sparseVector */ //TODO contain integer overflow in square process
double getMagnitudeSparse(sparseRIV input);
sparseRIV text2L2(char *text){ sparseRIV text2L2(char *text){
unsigned int blockSize; int wordCount = 0;
char word[100] = {0}; unsigned char word[100] = {0};
int denseTemp[RIVSIZE] = {0};
/* locations (implicit RIV) are temp stored in temp block, and moved /* locations (implicit RIV) are temp stored in temp block, and moved
* to permanent home in consolidation */ * to permanent home in consolidation */
int *locations = RIVKey.h_tempBlock; int *locations = RIVKey.h_tempBlock;
int locationCount = 0; int locationCount = 0;
int displacement; int displacement;
while(sscanf(text, "%99s%n", word, &displacement)){ while(sscanf(text, "%99s%n", word, &displacement)){
text += displacement+1; text += displacement+1;
if(!displacement){ if(!displacement){
break; break;
} }
if(!(*word)){ if(!(*word)){
break; break;
} }
blockSize = locationCount+NONZEROS; /* if this word would overflow the locations block, map it to the denseVector */
/* if this word would overflow the locations block, grow it */ if((locationCount+NONZEROS)>TEMPSIZE){
if(blockSize>RIVKey.tempSize){ addI2D(denseTemp, locations, locationCount);
RIVKey.h_tempBlock = (int*) realloc(RIVKey.h_tempBlock, blockSize*sizeof(int)); locationCount = 0;
locations = RIVKey.h_tempBlock;
RIVKey.tempSize+=NONZEROS;
} }
/* add word's L1 RIV to the accumulating implicit RIV */ /* add word's L1 RIV to the accumulating implicit RIV */
makeSparseLocations((unsigned char*)word, locations, locationCount); makeSparseLocations(word, locations, locationCount);
locationCount+= NONZEROS; locationCount+= NONZEROS;
wordCount++;
} }
sparseRIV output = consolidateI2S(locations, locationCount); /* map remaining locations to the denseTemp */
addI2D(denseTemp, locations, locationCount);
sparseRIV output = consolidateD2S(denseTemp);
/* frequency records the number of words in this file, untill frequency /* frequency records the number of words in this file, untill frequency
* is needed to hold some more useful data point */ * is needed to hold some more useful data point */
output.frequency = locationCount/NONZEROS; output.frequency = wordCount;
output.boolean = 1; output.boolean = 1;
return output; return output;
} }
sparseRIV fileToL2(FILE *data){ sparseRIV fileToL2(FILE *data){
unsigned int blockSize;
unsigned char word[100] = {0}; unsigned char word[100] = {0};
/* locations (implicit RIV) are temp stored in temp block, and moved /* locations (implicit RIV) are temp stored in temp block, and moved
* to permanent home in consolidation */ * to permanent home in consolidation */
int *locations = RIVKey.h_tempBlock; int *locations = RIVKey.h_tempBlock;
int locationCount = 0; int locationCount = 0;
int denseTemp[RIVSIZE] = {0};
int wordCount = 0;
while(fscanf(data, "%99s", word)){ while(fscanf(data, "%99s", word)){
if(feof(data)){ if(feof(data)){
break; break;
} }
if(!(*word)){ if(!(*word)){
break; break;
} }
blockSize = locationCount+NONZEROS; /* if this word would overflow the locations block, map it to the denseVector */
/* if this word would overflow the locations block, grow it */ if((locationCount+NONZEROS)>TEMPSIZE){
if(blockSize>RIVKey.tempSize){ addI2D(denseTemp, locations, locationCount);
RIVKey.h_tempBlock = (int*) realloc(RIVKey.h_tempBlock, blockSize*sizeof(int)); locationCount = 0;
locations = RIVKey.h_tempBlock;
RIVKey.tempSize+=NONZEROS;
} }
/* add word's L1 RIV to the accumulating implicit RIV */ /* add word's L1 RIV to the accumulating implicit RIV */
makeSparseLocations(word, locations, locationCount); makeSparseLocations(word, locations, locationCount);
locationCount+= NONZEROS; locationCount+= NONZEROS;
wordCount++;
} }
/* map remaining locations to the denseTemp */
sparseRIV output = consolidateI2S(locations, locationCount); addI2D(denseTemp, locations, locationCount);
sparseRIV output = consolidateD2S(denseTemp);
/* frequency records the number of words in this file */ /* frequency records the number of words in this file */
output.frequency = locationCount/NONZEROS; output.frequency = wordCount;
output.boolean = 1; output.boolean = 1;
return output; return output;
} }
sparseRIV fileToL2Clean(FILE *data){ sparseRIV fileToL2Clean(FILE *data){
int denseTemp[RIVSIZE] = {0};
unsigned char word[100] = {0}; unsigned char word[100] = {0};
int *locations = RIVKey.h_tempBlock; int *locations = RIVKey.h_tempBlock;
unsigned int blockSize; unsigned int wordCount = 0;
int locationCount = 0; int locationCount = 0;
while(fscanf(data, "%99s", word)){ while(fscanf(data, "%99s", word)){
if(feof(data)){ if(feof(data)){
break; break;
} }
if(!(*word)){ if(!(*word)){
break; break;
} }
...@@ -153,49 +157,49 @@ sparseRIV fileToL2Clean(FILE *data){ ...@@ -153,49 +157,49 @@ sparseRIV fileToL2Clean(FILE *data){
if(!isWordClean((char*)word)){ if(!isWordClean((char*)word)){
continue; continue;
} }
blockSize = locationCount+NONZEROS; /* if this word would overflow the locations block, map it to the denseVector */
if(blockSize>RIVKey.tempSize){ if((locationCount+NONZEROS)>TEMPSIZE){
RIVKey.h_tempBlock = (int*)realloc(RIVKey.h_tempBlock, blockSize*sizeof(int)); addI2D(denseTemp, locations, locationCount);
locations = RIVKey.h_tempBlock; locationCount = 0;
RIVKey.tempSize+=NONZEROS;
} }
/* add word's L1 RIV to the accumulating implicit RIV */
makeSparseLocations(word, locations, locationCount); makeSparseLocations(word, locations, locationCount);
locationCount+= NONZEROS; locationCount+= NONZEROS;
wordCount++;
} }
/* map remaining locations to the denseTemp */
sparseRIV output = consolidateI2S(locations, locationCount); addI2D(denseTemp, locations, locationCount);
sparseRIV output = consolidateD2S(denseTemp);
/* frequency records the number of words in this file */ /* frequency records the number of words in this file */
output.frequency = locationCount/NONZEROS; output.frequency = locationCount/NONZEROS;
output.boolean = 1; output.boolean = 1;
return output; return output;
} }
//defunct temporarily, might make a return
sparseRIV consolidateI2S(int *implicit, size_t valueCount){ /*sparseRIV consolidateI2S(int *implicit, size_t valueCount){
if(valueCount<RIVKey.I2SThreshold){ if(valueCount<RIVKey.I2SThreshold){
/*direct method is faster on small datasets, but has geometric scaling on large datasets */ //direct method is faster on small datasets, but has geometric scaling on large datasets
return consolidateI2SDirect(implicit, valueCount); return consolidateI2SDirect(implicit, valueCount);
}else{ }else{
/* optimized for large datasets */ // optimized for large datasets
return consolidateI2SIndirect(implicit, valueCount); return consolidateI2SIndirect(implicit, valueCount);
} }
} }*/
void aggregateWord2D(denseRIV destination, char* word){ void aggregateWord2D(denseRIV destination, char* word){
srand(wordtoSeed((unsigned char*)word)); srand(wordtoSeed((unsigned char*)word));
for(int i=0; i<NONZEROS; i++){ for(int i=0; i<NONZEROS; i++){
destination.values[(rand()%RIVSIZE)] +=1; destination.values[(rand()%RIVSIZE)] +=1;
destination.values[(rand()%RIVSIZE)] -= 1; destination.values[(rand()%RIVSIZE)] -= 1;
} }
} }
float cosCompare(denseRIV baseRIV, sparseRIV comparator){ double cosCompare(denseRIV baseRIV, sparseRIV comparator){
int dot = 0; int dot = 0;
int n = comparator.count; int n = comparator.count;
while(n){ while(n){
...@@ -204,50 +208,48 @@ float cosCompare(denseRIV baseRIV, sparseRIV comparator){ ...@@ -204,50 +208,48 @@ float cosCompare(denseRIV baseRIV, sparseRIV comparator){
* comparing sparse to dense by index*/ * comparing sparse to dense by index*/
//dot += values[i]*baseRIV.values[locations[i]]; //dot += values[i]*baseRIV.values[locations[i]];
dot += comparator.values[n] * baseRIV.values[comparator.locations[n]]; dot += comparator.values[n] * baseRIV.values[comparator.locations[n]];
//printf("%d, %d, %d\n",baseRIV.values[comparator.locations[n]],comparator.values[n] , n); //printf("%d, %d, %d\n",baseRIV.values[comparator.locations[n]],comparator.values[n] , n);
} }
/*dot divided by product of magnitudes */ /*dot divided by product of magnitudes */
float cosine = dot/(baseRIV.magnitude*comparator.magnitude);
return cosine; return dot/(baseRIV.magnitude*comparator.magnitude);
} }
float getMagnitudeSparse(sparseRIV input){ double getMagnitudeSparse(sparseRIV input){
unsigned long long int temp = 0; size_t temp = 0;
int *values = input.values; int *values = input.values;
int *values_stop = values+input.count; int *values_stop = values+input.count;
while(values<values_stop){ while(values<values_stop){
temp += (*values)*(*values); temp += (*values)*(*values);
//if(temp> 0x0AFFFFFFFFFFFFFF) printf("%s, fuuuuuuuuuuuuck*****************************************",input.name );
values++; values++;
} }
return sqrt(temp);
input.magnitude = sqrt(temp);
return input.magnitude;
} }
denseRIV lexPull(char* word){ denseRIV lexPull(char* word){
#if CACHESIZE > 0 #if CACHESIZE > 0
/* if there is a cache, first check if the word is cached */ /* if there is a cache, first check if the word is cached */
srand(wordtoSeed((unsigned char*)word)); srand(wordtoSeed((unsigned char*)word));
int hash = rand()%CACHESIZE; int hash = rand()%CACHESIZE;
if(!strcmp(word, RIVKey.RIVCache[hash].name)){ if(!strcmp(word, RIVKey.RIVCache[hash].name)){
/* if word is cached, pull from cache and exit */ /* if word is cached, pull from cache and exit */
return RIVKey.RIVCache[hash]; return RIVKey.RIVCache[hash];
} }
#endif /* CACHESIZE > 0 */ #endif /* CACHESIZE > 0 */
/* if not, attempt to pull the word data from lexicon file */ /* if not, attempt to pull the word data from lexicon file */
denseRIV output; denseRIV output;
char pathString[200]; char pathString[200];
sprintf(pathString, "lexicon/%s", word); sprintf(pathString, "%s/%s", RIVKey.lexName, word);
FILE *lexWord = fopen(pathString, "rb"); FILE *lexWord = fopen(pathString, "rb");
/* if this lexicon file already exists */ /* if this lexicon file already exists */
if(lexWord){ if(lexWord){
/* pull data from file */ /* pull data from file */
...@@ -257,7 +259,7 @@ denseRIV lexPull(char* word){ ...@@ -257,7 +259,7 @@ denseRIV lexPull(char* word){
/*if file does not exist, return a 0 vector (word is new to the lexicon */ //#TODO enable NO-NEW features to protect mature lexicons? /*if file does not exist, return a 0 vector (word is new to the lexicon */ //#TODO enable NO-NEW features to protect mature lexicons?
output = denseAllocate(); output = denseAllocate();
} }
strcpy(output.name, word); strcpy(output.name, word);
return output; return output;
} }
...@@ -267,31 +269,30 @@ int lexPush(denseRIV RIVout){ ...@@ -267,31 +269,30 @@ int lexPush(denseRIV RIVout){
fLexPush(RIVout); fLexPush(RIVout);
return 0; return 0;
#else /* CACHESIZE != 0 */ #else /* CACHESIZE != 0 */
/* if our RIV was cached, there are two options (hopefully) /* if our RIV was cached, there are two options (hopefully)
* either the RIV is still cached, and the data has been updated * either the RIV is still cached, and the data has been updated
* to the cache or the RIV was pushed out from under it, * to the cache or the RIV was pushed out from under it,
* in which case it has already been pushed! move on*/ * in which case it has already been pushed! move on*/
if(RIVout.cached){ if(RIVout.cached){
return 0; return 0;
} }
srand(wordtoSeed((unsigned char*)RIVout.name)); srand(wordtoSeed((unsigned char*)RIVout.name));
int hash = rand()%CACHESIZE; int hash = rand()%CACHESIZE;
if(!RIVKey.RIVCache[hash].cached){ if(!RIVKey.RIVCache[hash].cached){
/* if there is no word in this cache slot, push to cache instead of file */ /* if there is no word in this cache slot, push to cache instead of file */
RIVKey.RIVCache[hash] = RIVout; RIVKey.RIVCache[hash] = RIVout;
RIVKey.RIVCache[hash].cached = 1; RIVKey.RIVCache[hash].cached = 1;
return 0; return 0;
/*if the current RIV is more frequent than the RIV holding its slot */ /*if the current RIV is more frequent than the RIV holding its slot */
}else if(*(RIVout.frequency) > *(RIVKey.RIVCache[hash].frequency) ){ }else if(*(RIVout.frequency) > *(RIVKey.RIVCache[hash].frequency) ){
/* push the current cache entry to a file */ /* push the current cache entry to a file */
int diag = fLexPush(RIVKey.RIVCache[hash]); int diag = fLexPush(RIVKey.RIVCache[hash]);
/* push the current RIV to cache */ /* push the current RIV to cache */
RIVKey.RIVCache[hash] = RIVout; RIVKey.RIVCache[hash] = RIVout;
RIVKey.RIVCache[hash].cached = 1; RIVKey.RIVCache[hash].cached = 1;
return diag; return diag;
...@@ -332,4 +333,70 @@ sparseRIV fileToL2direct(FILE *data){; ...@@ -332,4 +333,70 @@ sparseRIV fileToL2direct(FILE *data){;
return output; return output;
} }
sparseRIV normalizeFloored(denseRIV input, int factor){
float divisor = (float)factor/(*input.contextSize);
// printf("in norm: %d, %d, %f\n", *input.contextSize, factor, divisor);
int* locations = RIVKey.h_tempBlock;
int* values = locations+RIVSIZE;
int count = 0;
for(int i=0; i<RIVSIZE; i++){
if(!input.values[i]) continue;
locations[count] = i;
values[count]= input.values[i]*divisor;
if(values[count])count++;
}
sparseRIV output;
output.locations = (int*) malloc(count*2*sizeof(int));
output.values = output.locations+count;
memcpy(output.locations, locations, count*sizeof(int));
memcpy(output.values, values, count*sizeof(int));
strcpy(output.name, input.name);
output.count = count;
output.magnitude = getMagnitudeSparse(output);
output.contextSize = *input.contextSize;
output.frequency = *input.frequency;
return output;
}
sparseRIV normalize(denseRIV input, int factor){
float divisor = (float)factor/(*input.contextSize);
// printf("in norm: %d, %d, %f\n", *input.contextSize, factor, divisor);
int* locations = RIVKey.h_tempBlock;
int* values = locations+RIVSIZE;
int count = 0;
for(int i=0; i<RIVSIZE; i++){
if(!input.values[i]) continue;
locations[count] = i;
values[count]= roundMultiply(input.values[i], divisor);
if(values[count])count++;
}
sparseRIV output;
output.locations = (int*) malloc(count*2*sizeof(int));
output.values = output.locations+count;
memcpy(output.locations, locations, count*sizeof(int));
memcpy(output.values, values, count*sizeof(int));
strcpy(output.name, input.name);
output.count = count;
output.magnitude = getMagnitudeSparse(output);
output.contextSize = *input.contextSize;
output.frequency = *input.frequency;
return output;
}
int roundMultiply(int base, float divisor){
float temp = base*divisor;
int output = temp*2;
if (output%2){
output/=2;
output+=1;
}else{
output/=2;
}
return output;
}
#endif #endif
RIVtools.c → RIVtools.h.save
#ifndef RIVTOOLS_H_
#define RIVTOOLS_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "RIVLower.h"
#include "RIVaccessories.h" #include "RIVaccessories.h"
#include "RIVtools.h"
/* lexPush writes a denseRIV to a file for permanent storage */
int lexPush(denseRIV RIVout);
/* lexPull reads an existing lexicon entry (under directory "lexicon")
* and creates a denseRIV with those attributes.
* if the file does not exist, it creates a 0 vector with the name of word
*/
denseRIV lexPull(char* word);
/* fileToL2 takes an input file, reads words (delimiting on " " and "\n")
* and returns a sparse RIV which is the vector sum of the base RIVs of each
* word contained
*/
sparseRIV fileToL2(FILE *input);
/* fileToL2Clean operates the same as fileToL2 butkeeps only words
* containing lowercase letters and the '_' symbol
* this is important if you will be lexPush-ing those words later
*/
sparseRIV fileToL2Clean(FILE *data);
/*filetoL2direct is an experiment in simplifying the process. it's slow */
sparseRIV fileToL2direct(FILE *data);
/*cosine determines the "similarity" between two RIVs. */
double cosCompare(denseRIV baseRIV, sparseRIV comparator);
/*currently unused */
sparseRIV wordtoL2(char* word);
/* converts an implicit RIV (a set of unvalued locations) into a formal
* sparse RIV. this chooses the best method to perform the consolidation
* and launches that function defunct right now for memory usage reasons*/
sparseRIV consolidateI2S(int *implicit, size_t valueCount);
sparseRIV normalizeFloored(denseRIV input, int factor);
sparseRIV normalize(denseRIV input, int factor);
int roundMultiply(int base, float divisor);
/* like fileToL2 but takes a block of text */
sparseRIV text2L2(char *text);
/* calculates the magnitude of a sparseVector */ //TODO contain integer overflow in square process
double getMagnitudeSparse(sparseRIV input);
sparseRIV text2L2(char *text){ sparseRIV text2L2(char *text){
unsigned int blockSize; int wordCount = 0;
char word[100] = {0}; unsigned char word[100] = {0};
int denseTemp[RIVSIZE] = {0};
/* locations (implicit RIV) are temp stored in temp block, and moved /* locations (implicit RIV) are temp stored in temp block, and moved
* to permanent home in consolidation */ * to permanent home in consolidation */
int *locations = RIVKey.h_tempBlock; int *locations = RIVKey.h_tempBlock;
int locationCount = 0; int locationCount = 0;
int displacement; int displacement;
while(sscanf(text, "%99s%n", word, &displacement)){ while(sscanf(text, "%99s%n", word, &displacement)){
text += displacement+1; text += displacement+1;
if(!displacement){ if(!displacement){
break; break;
} }
if(!(*word)){ if(!(*word)){
break; break;
} }
blockSize = locationCount+NONZEROS; /* if this word would overflow the locations block, map it to the denseVector */
/* if this word would overflow the locations block, grow it */ if((locationCount+NONZEROS)>TEMPSIZE){
if(blockSize>RIVKey.tempSize){ addI2D(denseTemp, locations, locationCount);
RIVKey.h_tempBlock = (int*) realloc(RIVKey.h_tempBlock, blockSize*sizeof(int)); locationCount = 0;
locations = RIVKey.h_tempBlock;
RIVKey.tempSize+=NONZEROS;
} }
/* add word's L1 RIV to the accumulating implicit RIV */ /* add word's L1 RIV to the accumulating implicit RIV */
makeSparseLocations((unsigned char*)word, locations, locationCount); makeSparseLocations(word, locations, locationCount);
locationCount+= NONZEROS; locationCount+= NONZEROS;
wordCount++;
} }
sparseRIV output = consolidateI2S(locations, locationCount); /* map remaining locations to the denseTemp */
addI2D(denseTemp, locations, locationCount);
sparseRIV output = consolidateD2S(denseTemp);
/* frequency records the number of words in this file, untill frequency /* frequency records the number of words in this file, untill frequency
* is needed to hold some more useful data point */ * is needed to hold some more useful data point */
output.frequency = locationCount/NONZEROS; output.frequency = wordCount;
output.boolean = 1; output.boolean = 1;
return output; return output;
} }
sparseRIV fileToL2(FILE *data){ sparseRIV fileToL2(FILE *data){
unsigned int blockSize;
unsigned char word[100] = {0}; unsigned char word[100] = {0};
/* locations (implicit RIV) are temp stored in temp block, and moved /* locations (implicit RIV) are temp stored in temp block, and moved
* to permanent home in consolidation */ * to permanent home in consolidation */
int *locations = RIVKey.h_tempBlock; int *locations = RIVKey.h_tempBlock;
int locationCount = 0; int locationCount = 0;
int denseTemp[RIVSIZE] = {0};
int wordCount = 0;
while(fscanf(data, "%99s", word)){ while(fscanf(data, "%99s", word)){
if(feof(data)){ if(feof(data)){
break; break;
} }
if(!(*word)){ if(!(*word)){
break; break;
} }
blockSize = locationCount+NONZEROS; /* if this word would overflow the locations block, map it to the denseVector */
/* if this word would overflow the locations block, grow it */ if((locationCount+NONZEROS)>TEMPSIZE){
if(blockSize>RIVKey.tempSize){ addI2D(denseTemp, locations, locationCount);
RIVKey.h_tempBlock = (int*) realloc(RIVKey.h_tempBlock, blockSize*sizeof(int)); locationCount = 0;
locations = RIVKey.h_tempBlock;
RIVKey.tempSize+=NONZEROS;
} }
/* add word's L1 RIV to the accumulating implicit RIV */ /* add word's L1 RIV to the accumulating implicit RIV */
makeSparseLocations(word, locations, locationCount); makeSparseLocations(word, locations, locationCount);
locationCount+= NONZEROS; locationCount+= NONZEROS;
wordCount++;
} }
/* map remaining locations to the denseTemp */
sparseRIV output = consolidateI2S(locations, locationCount); addI2D(denseTemp, locations, locationCount);
sparseRIV output = consolidateD2S(denseTemp);
/* frequency records the number of words in this file */ /* frequency records the number of words in this file */
output.frequency = locationCount/NONZEROS; output.frequency = wordCount;
output.boolean = 1; output.boolean = 1;
return output; return output;
} }
sparseRIV fileToL2Clean(FILE *data){ sparseRIV fileToL2Clean(FILE *data){
int denseTemp[RIVSIZE] = {0};
unsigned char word[100] = {0}; unsigned char word[100] = {0};
int *locations = RIVKey.h_tempBlock; int *locations = RIVKey.h_tempBlock;
unsigned int blockSize; unsigned int wordCount = 0;
int locationCount = 0; int locationCount = 0;
while(fscanf(data, "%99s", word)){ while(fscanf(data, "%99s", word)){
if(feof(data)){ if(feof(data)){
break; break;
} }
if(!(*word)){ if(!(*word)){
break; break;
} }
...@@ -107,49 +157,49 @@ sparseRIV fileToL2Clean(FILE *data){ ...@@ -107,49 +157,49 @@ sparseRIV fileToL2Clean(FILE *data){
if(!isWordClean((char*)word)){ if(!isWordClean((char*)word)){
continue; continue;
} }
blockSize = locationCount+NONZEROS; /* if this word would overflow the locations block, map it to the denseVector */
if(blockSize>RIVKey.tempSize){ if((locationCount+NONZEROS)>TEMPSIZE){
RIVKey.h_tempBlock = (int*)realloc(RIVKey.h_tempBlock, blockSize*sizeof(int)); addI2D(denseTemp, locations, locationCount);
locations = RIVKey.h_tempBlock; locationCount = 0;
RIVKey.tempSize+=NONZEROS;
} }
/* add word's L1 RIV to the accumulating implicit RIV */
makeSparseLocations(word, locations, locationCount); makeSparseLocations(word, locations, locationCount);
locationCount+= NONZEROS; locationCount+= NONZEROS;
wordCount++;
} }
/* map remaining locations to the denseTemp */
sparseRIV output = consolidateI2S(locations, locationCount); addI2D(denseTemp, locations, locationCount);
sparseRIV output = consolidateD2S(denseTemp);
/* frequency records the number of words in this file */ /* frequency records the number of words in this file */
output.frequency = locationCount/NONZEROS; output.frequency = locationCount/NONZEROS;
output.boolean = 1; output.boolean = 1;
return output; return output;
} }
//defunct temporarily, might make a return
sparseRIV consolidateI2S(int *implicit, size_t valueCount){ /*sparseRIV consolidateI2S(int *implicit, size_t valueCount){
if(valueCount<RIVKey.I2SThreshold){ if(valueCount<RIVKey.I2SThreshold){
/*direct method is faster on small datasets, but has geometric scaling on large datasets */ //direct method is faster on small datasets, but has geometric scaling on large datasets
return consolidateI2SDirect(implicit, valueCount); return consolidateI2SDirect(implicit, valueCount);
}else{ }else{
/* optimized for large datasets */ // optimized for large datasets
return consolidateI2SIndirect(implicit, valueCount); return consolidateI2SIndirect(implicit, valueCount);
} }
} }*/
void aggregateWord2D(denseRIV destination, char* word){ void aggregateWord2D(denseRIV destination, char* word){
srand(wordtoSeed((unsigned char*)word)); srand(wordtoSeed((unsigned char*)word));
for(int i=0; i<NONZEROS; i++){ for(int i=0; i<NONZEROS; i++){
destination.values[(rand()%RIVSIZE)] +=1; destination.values[(rand()%RIVSIZE)] +=1;
destination.values[(rand()%RIVSIZE)] -= 1; destination.values[(rand()%RIVSIZE)] -= 1;
} }
} }
float cosCompare(denseRIV baseRIV, sparseRIV comparator){ double cosCompare(denseRIV baseRIV, sparseRIV comparator){
int dot = 0; int dot = 0;
int n = comparator.count; int n = comparator.count;
while(n){ while(n){
...@@ -158,50 +208,48 @@ float cosCompare(denseRIV baseRIV, sparseRIV comparator){ ...@@ -158,50 +208,48 @@ float cosCompare(denseRIV baseRIV, sparseRIV comparator){
* comparing sparse to dense by index*/ * comparing sparse to dense by index*/
//dot += values[i]*baseRIV.values[locations[i]]; //dot += values[i]*baseRIV.values[locations[i]];
dot += comparator.values[n] * baseRIV.values[comparator.locations[n]]; dot += comparator.values[n] * baseRIV.values[comparator.locations[n]];
//printf("%d, %d, %d\n",baseRIV.values[comparator.locations[n]],comparator.values[n] , n); //printf("%d, %d, %d\n",baseRIV.values[comparator.locations[n]],comparator.values[n] , n);
} }
/*dot divided by product of magnitudes */ /*dot divided by product of magnitudes */
float cosine = dot/(baseRIV.magnitude*comparator.magnitude);
return cosine; return dot/(baseRIV.magnitude*comparator.magnitude);
} }
float getMagnitudeSparse(sparseRIV input){ double getMagnitudeSparse(sparseRIV input){
unsigned long long int temp = 0; size_t temp = 0;
int *values = input.values; int *values = input.values;
int *values_stop = values+input.count; int *values_stop = values+input.count;
while(values<values_stop){ while(values<values_stop){
temp += (*values)*(*values); temp += (*values)*(*values);
if(temp> 0x0AFFFFFFFFFFFFFF) printf("%s, fuuuuuuuuuuuuck****
values++; values++;
} }
return sqrt(temp);
input.magnitude = sqrt(temp);
return input.magnitude;
} }
denseRIV lexPull(char* word){ denseRIV lexPull(char* word){
#if CACHESIZE > 0 #if CACHESIZE > 0
/* if there is a cache, first check if the word is cached */ /* if there is a cache, first check if the word is cached */
srand(wordtoSeed((unsigned char*)word)); srand(wordtoSeed((unsigned char*)word));
int hash = rand()%CACHESIZE; int hash = rand()%CACHESIZE;
if(!strcmp(word, RIVKey.RIVCache[hash].name)){ if(!strcmp(word, RIVKey.RIVCache[hash].name)){
/* if word is cached, pull from cache and exit */ /* if word is cached, pull from cache and exit */
return RIVKey.RIVCache[hash]; return RIVKey.RIVCache[hash];
} }
#endif /* CACHESIZE > 0 */ #endif /* CACHESIZE > 0 */
/* if not, attempt to pull the word data from lexicon file */ /* if not, attempt to pull the word data from lexicon file */
denseRIV output; denseRIV output;
char pathString[200]; char pathString[200];
sprintf(pathString, "lexicon/%s", word); sprintf(pathString, "%s/%s", RIVKey.lexName, word);
FILE *lexWord = fopen(pathString, "rb"); FILE *lexWord = fopen(pathString, "rb");
/* if this lexicon file already exists */ /* if this lexicon file already exists */
if(lexWord){ if(lexWord){
/* pull data from file */ /* pull data from file */
...@@ -211,7 +259,7 @@ denseRIV lexPull(char* word){ ...@@ -211,7 +259,7 @@ denseRIV lexPull(char* word){
/*if file does not exist, return a 0 vector (word is new to the lexicon */ //#TODO enable NO-NEW features to protect mature lexicons? /*if file does not exist, return a 0 vector (word is new to the lexicon */ //#TODO enable NO-NEW features to protect mature lexicons?
output = denseAllocate(); output = denseAllocate();
} }
strcpy(output.name, word); strcpy(output.name, word);
return output; return output;
} }
...@@ -221,31 +269,30 @@ int lexPush(denseRIV RIVout){ ...@@ -221,31 +269,30 @@ int lexPush(denseRIV RIVout){
fLexPush(RIVout); fLexPush(RIVout);
return 0; return 0;
#else /* CACHESIZE != 0 */ #else /* CACHESIZE != 0 */
/* if our RIV was cached, there are two options (hopefully) /* if our RIV was cached, there are two options (hopefully)
* either the RIV is still cached, and the data has been updated * either the RIV is still cached, and the data has been updated
* to the cache or the RIV was pushed out from under it, * to the cache or the RIV was pushed out from under it,
* in which case it has already been pushed! move on*/ * in which case it has already been pushed! move on*/
if(RIVout.cached){ if(RIVout.cached){
return 0; return 0;
} }
srand(wordtoSeed((unsigned char*)RIVout.name)); srand(wordtoSeed((unsigned char*)RIVout.name));
int hash = rand()%CACHESIZE; int hash = rand()%CACHESIZE;
if(!RIVKey.RIVCache[hash].cached){ if(!RIVKey.RIVCache[hash].cached){
/* if there is no word in this cache slot, push to cache instead of file */ /* if there is no word in this cache slot, push to cache instead of file */
RIVKey.RIVCache[hash] = RIVout; RIVKey.RIVCache[hash] = RIVout;
RIVKey.RIVCache[hash].cached = 1; RIVKey.RIVCache[hash].cached = 1;
return 0; return 0;
/*if the current RIV is more frequent than the RIV holding its slot */ /*if the current RIV is more frequent than the RIV holding its slot */
}else if(*(RIVout.frequency) > *(RIVKey.RIVCache[hash].frequency) ){ }else if(*(RIVout.frequency) > *(RIVKey.RIVCache[hash].frequency) ){
/* push the current cache entry to a file */ /* push the current cache entry to a file */
int diag = fLexPush(RIVKey.RIVCache[hash]); int diag = fLexPush(RIVKey.RIVCache[hash]);
/* push the current RIV to cache */ /* push the current RIV to cache */
RIVKey.RIVCache[hash] = RIVout; RIVKey.RIVCache[hash] = RIVout;
RIVKey.RIVCache[hash].cached = 1; RIVKey.RIVCache[hash].cached = 1;
return diag; return diag;
...@@ -286,3 +333,70 @@ sparseRIV fileToL2direct(FILE *data){; ...@@ -286,3 +333,70 @@ sparseRIV fileToL2direct(FILE *data){;
return output; return output;
} }
sparseRIV normalizeFloored(denseRIV input, int factor){
float divisor = (float)factor/(*input.contextSize);
// printf("in norm: %d, %d, %f\n", *input.contextSize, factor, divisor);
int* locations = RIVKey.h_tempBlock;
int* values = locations+RIVSIZE;
int count = 0;
for(int i=0; i<RIVSIZE; i++){
if(!input.values[i]) continue;
locations[count] = i;
values[count]= input.values[i]*divisor;
if(values[count])count++;
}
sparseRIV output;
output.locations = (int*) malloc(count*2*sizeof(int));
output.values = output.locations+count;
memcpy(output.locations, locations, count*sizeof(int));
memcpy(output.values, values, count*sizeof(int));
strcpy(output.name, input.name);
output.count = count;
output.magnitude = getMagnitudeSparse(output);
output.contextSize = *input.contextSize;
output.frequency = *input.frequency;
return output;
}
sparseRIV normalize(denseRIV input, int factor){
float divisor = (float)factor/(*input.contextSize);
// printf("in norm: %d, %d, %f\n", *input.contextSize, factor, divisor);
int* locations = RIVKey.h_tempBlock;
int* values = locations+RIVSIZE;
int count = 0;
for(int i=0; i<RIVSIZE; i++){
if(!input.values[i]) continue;
locations[count] = i;
values[count]= roundMultiply(input.values[i], divisor);
if(values[count])count++;
}
sparseRIV output;
output.locations = (int*) malloc(count*2*sizeof(int));
output.values = output.locations+count;
memcpy(output.locations, locations, count*sizeof(int));
memcpy(output.values, values, count*sizeof(int));
strcpy(output.name, input.name);
output.count = count;
output.magnitude = getMagnitudeSparse(output);
output.contextSize = *input.contextSize;
output.frequency = *input.frequency;
return output;
}
int roundMultiply(int base, float divisor){
float temp = base*divisor;
int output = temp*2;
if (output%2){
output/=2;
output+=1;
}else{
output/=2;
}
return output;
}
#endif
new 0 → 100644
File added
new.c 0 → 100644
#include <stdio.h>
#include "RIVtools.h"
int main(){
lexOpen("/home/drbob/Documents/lexicon");
lexPull("unseemli");
}
output.txt 0 → 100644
fileCount: 6264
rattl dash
0.902735
rattl howl
0.907285
few fresh
0.911250
few actor
0.903736
few relax
0.908174
few arriv
0.903417
few persuas
0.900377
few imposs
0.905686
few gradual
0.913572
few favorit
0.903885
few useless
0.905217
few incid
0.913623
few refresh
0.901153
few peril
0.900388
few between
0.910486
few high
0.904163
few posit
0.916543
few day
0.901561
few show
0.911159
few pretend
0.905087
few urgent
0.908557
few altogeth
0.916462
few deliber
0.912095
few guard
0.903756
few vigor
0.903973
few extravag
0.905679
few sentenc
0.900128
few charg
0.907086
few quarter
0.903887
few awar
0.906083
few prevail
0.904464
few visit
0.902345
few rival
0.909845
few except
0.915179
few eccentr
0.903887
few bear
0.900751
few schoolmast
0.900320
few time
0.910193
few unlik
0.908011
few dispos
0.912868
few absenc
0.917454
few ceremoni
0.910448
few approach
0.906881
few prodigi
0.910678
few hitherto
0.907315
few strongli
0.917586
few insist
0.910896
few extrem
0.918341
few voyag
0.901305
few eight
0.900199
few notwithstand
0.916680
few abat
0.907976
few instead
0.916307
few afford
0.906443
few twenti
0.917917
few past
0.907399
few entrust
0.907013
few precis
0.905116
few determin
0.904153
few attend
0.919429
few longer
0.907376
few partli
0.918724
few explor
0.901397
few splendid
0.901089
few temporari
0.905585
few particularli
0.916444
few point
0.901528
few proprietor
0.903065
few person
0.905122
few reput
0.912810
few expert
0.906985
few seriou
0.913767
few threaten
0.907114
few interv
0.915775
few carri
0.922690
few insignific
0.910985
few favour
0.900882
few pursuit
0.915431
few stage
0.903833
few labori
0.903648
few notori
0.912753
few uncertainti
0.908667
few freeli
0.907401
few might
0.902401
few attent
0.921943
few occupi
0.909108
few calcul
0.911416
few flourish
0.906963
few openli
0.903129
few allus
0.904563
few month
0.905253
few three
0.902140
few forti
0.920729
few impress
0.909066
few presum
0.908198
few precaut
0.906039
few fulli
0.909560
few agit
0.905223
few beyond
0.902534
few vent
0.902240
few reviv
0.904464
few eventu
0.901092
few alreadi
0.922223
few escap
0.915010
few short
0.916966
few unreason
0.900701
few discov
0.925662
few compel
0.916023
few unusu
0.917167
few certain
0.906033
few everywher
0.903157
few convinc
0.905240
few fail
0.904012
few greatli
0.923992
few miracul
0.904338
few firm
0.900567
few annoy
0.902022
few account
0.910591
few constantli
0.910995
few twice
0.908639
few presenc
0.900795
few intercours
0.902711
few intox
0.903732
few fatigu
0.913393
few distract
0.903641
few proceed
0.910959
few latter
0.901389
few ampl
0.900861
few everi
0.903084
few studi
0.902229
few tenth
0.902473
few patron
0.914209
few unfortun
0.921956
few careless
0.907021
few elabor
0.900833
few mark
0.913869
few sum
0.903129
few imagin
0.905180
few check
0.910130
few least
0.905952
few expend
0.900099
few endeavour
0.908733
few final
0.922187
few delay
0.902365
few eighti
0.905841
few orderli
0.905182
few boldli
0.906143
few manner
0.910116
few third
0.903035
few trace
0.900136
few wholli
0.907924
few rude
0.903673
few seldom
0.904662
few belong
0.901782
few part
0.912096
few besid
0.905821
few directli
0.911555
few famou
0.907538
few fact
0.905077
few prevent
0.905184
few admir
0.905590
few uncertain
0.918536
few great
0.914866
few clergyman
0.901564
few utmost
0.910756
few offens
0.902925
few suffici
0.904833
few fortnight
0.902710
few pretens
0.910442
few drive
0.903507
few disgust
0.902774
few somewhat
0.924013
few opposit
0.906765
few unpleas
0.903650
few exactli
0.911173
few firmli
0.901783
few brief
0.905446
few suggest
0.913113
few vener
0.902365
few scanti
0.909625
few danger
0.907615
few distinguish
0.905848
few liter
0.911945
few clear
0.910569
few obvious
0.910379
few whole
0.926445
few found
0.926101
few intens
0.905663
few scene
0.902559
few occur
0.907667
few mention
0.910196
few nearli
0.921986
few abandon
0.903713
few mani
0.916967
few apart
0.908442
few custom
0.911450
few forese
0.907489
few disguis
0.900906
few tast
0.900565
few perceiv
0.906679
few nevertheless
0.914206
few subsid
0.906417
few difficulti
0.919999
few receiv
0.912795
few project
0.904620
few intim
0.909273
few absorb
0.915752
few englishman
0.908473
few remain
0.925881
few undertak
0.915157
few reconcil
0.904307
few certainti
0.907306
few overlook
0.923585
few struggl
0.900087
few detail
0.907032
few fashion
0.902945
few talent
0.902379
few accid
0.909412
few inde
0.903711
few agre
0.904822
few both
0.913594
few elsewher
0.912523
few abroad
0.902582
few interest
0.904756
few allow
0.919490
few there
0.902378
few accordingli
0.914981
few explain
0.900979
few complain
0.906888
few suspect
0.902637
few perfectli
0.912994
few releas
0.903705
few settl
0.907092
few defenc
0.901211
few narr
0.902423
few conceal
0.913924
few whenc
0.900724
few usual
0.917143
few place
0.925348
few lead
0.906765
few ingenu
0.903099
few much
0.904452
few recept
0.916752
few incred
0.920119
few hardli
0.908291
few notic
0.902246
few repeat
0.907605
few failur
0.904539
few especi
0.904790
few distinctli
0.917853
few encourag
0.914152
few confin
0.905060
few disagre
0.905260
few inform
0.908481
few compromis
0.903034
few far
0.910421
few violent
0.923747
few plan
0.901631
few easili
0.913815
few celebr
0.905982
few veri
0.902340
few later
0.904312
few arous
0.900805
few fifteen
0.907717
few invari
0.906326
few allud
0.908536
few while
0.910387
few suspens
0.904031
few consider
0.905688
few exhaust
0.914914
few disclos
0.907324
few satisfact
0.909449
few accustom
0.913575
few pursu
0.903160
few caution
0.912584
few introduc
0.905735
few neither
0.904421
few success
0.912022
few circumst
0.908729
few invit
0.900571
few one
0.914105
few entertain
0.906376
few rapidli
0.911802
few fifti
0.905812
few detect
0.906856
few curiou
0.909439
few accompani
0.908124
few pronounc
0.918319
few howev
0.931216
few convey
0.908151
few opportun
0.908655
few intoler
0.904248
few infam
0.901995
few express
0.902512
few enthusiast
0.905567
few more
0.906612
few disast
0.903151
few concert
0.906191
few fairli
0.922584
few cours
0.903286
few set
0.903973
few elaps
0.915785
few lost
0.905550
few pass
0.915169
few present
0.920995
few surround
0.907663
few permit
0.903411
few fortun
0.900463
few resort
0.906867
few observ
0.902358
few regular
0.919533
few draw
0.903807
few famili
0.904554
few extraordinari
0.919240
few attract
0.908029
few remind
0.905545
few abov
0.904727
few stamp
0.902165
few procur
0.905693
few pretenc
0.901729
few imprison
0.910425
few retain
0.902521
few conjectur
0.911883
few thoroughli
0.902645
few unabl
0.917140
few prompt
0.905460
few inquiri
0.901681
few occup
0.902900
few upright
0.900690
few greatest
0.901819
few familiar
0.907783
few indulg
0.902043
few owner
0.909440
few persist
0.906975
few secur
0.902944
few favourit
0.915287
few dissip
0.907063
few festiv
0.900539
few withdraw
0.909535
few thorough
0.901540
few nowher
0.901172
few enorm
0.911841
few regularli
0.919351
few twelv
0.910072
few energet
0.912718
few becom
0.916750
few conspicu
0.908247
few consciou
0.901220
few unnecessari
0.910096
few weigh
0.903771
few luxuri
0.903326
few scheme
0.908290
few suppress
0.906258
few arrang
0.908511
few novelti
0.908179
few leisur
0.912441
few occasion
0.915211
few previou
0.913580
few depress
0.912763
few catastroph
0.907492
few abl
0.908693
few meantim
0.908750
few earli
0.908168
few superstiti
0.900879
few absent
0.911689
few disord
0.917571
few whatev
0.901316
few profession
0.902473
few be
0.919807
few clearli
0.901775
few under
0.911823
few also
0.907180
few five
0.903240
few anticip
0.922169
few sixteen
0.913592
few possibl
0.909310
few hint
0.904402
few tragedi
0.902652
few appar
0.920860
few obstin
0.913287
few recognis
0.915804
few chosen
0.900381
few exagger
0.900102
few mischiev
0.904896
few repair
0.907243
few credit
0.901152
few visitor
0.901348
few remark
0.914633
few advanc
0.906666
few rough
0.911264
few likewis
0.902402
few decid
0.910577
few earliest
0.904120
few difficult
0.907894
few enter
0.909815
few full
0.903258
few eleg
0.905652
few afterward
0.913385
few disadvantag
0.903955
few deplor
0.902998
few inquisit
0.903555
few unsuccess
0.912503
few seemingli
0.905423
few irishman
0.903272
few discard
0.901388
few at
0.916495
few slight
0.921328
few rich
0.902875
few overflow
0.900441
few often
0.900907
few premis
0.902201
few seventeen
0.908973
few daili
0.914854
few beforehand
0.903072
few follow
0.910825
few strong
0.905052
few score
0.907660
few recollect
0.906260
few other
0.909504
few ventur
0.913951
few frenchman
0.918808
few sever
0.919217
few describ
0.902532
few robberi
0.902368
few obstacl
0.907052
few length
0.907021
few excit
0.922478
few enthusiasm
0.900744
few fit
0.902712
few publicli
0.902865
few singular
0.906204
few frequent
0.904955
few prove
0.905475
few divert
0.911299
few loss
0.912987
few conclud
0.903630
few discourag
0.909882
few accomplish
0.903644
few induc
0.911747
few assist
0.908591
few oblig
0.908014
few continu
0.911172
few bring
0.900637
few aggrav
0.901687
few ascertain
0.902525
few owe
0.900781
few event
0.912584
few neighbour
0.915257
few moreov
0.913121
few inspect
0.909339
few dignifi
0.906120
few entir
0.911719
few relief
0.920002
few momentari
0.912336
few manag
0.912876
few onli
0.905532
few prefer
0.904187
few soon
0.905137
few fourteen
0.908365
few arrest
0.907489
few succeed
0.917770
few given
0.905119
few explan
0.902401
few all
0.901280
few not
0.903627
few partial
0.904223
few easi
0.904214
few order
0.917562
few though
0.906153
few compani
0.902640
few display
0.902963
few magnific
0.905091
few prolong
0.906133
few purpos
0.901973
few suffic
0.900437
few befor
0.909978
few earlier
0.905485
few uncommon
0.912143
few modest
0.900030
few probabl
0.918843
few urg
0.903606
few prematur
0.904437
few apprehens
0.908714
few disturb
0.918595
few eighteen
0.920491
few abrupt
0.900258
few convers
0.905195
few some
0.908995
few career
0.906215
few same
0.902774
few complaint
0.908758
few confirm
0.908432
few inclin
0.907666
few complet
0.910338
few ingeni
0.907226
few serious
0.900460
few wherev
0.906525
few rais
0.904205
few insens
0.901186
few travel
0.912603
few farther
0.911519
few rest
0.905724
few expect
0.900233
few second
0.909450
few prospect
0.900601
few further
0.910015
few situat
0.913623
few gain
0.906742
few intend
0.909939
few discomfort
0.906765
few two
0.916062
few mistak
0.900444
few accommod
0.916018
few customari
0.906689
few neighbourhood
0.917067
few overpow
0.908110
few inquir
0.905556
few prison
0.900429
few immedi
0.920663
few privat
0.904514
few effort
0.905207
few join
0.900934
few toler
0.909293
few task
0.903385
few promptli
0.909271
few fatal
0.904243
few confus
0.926212
few discoveri
0.903550
few ceas
0.905765
few after
0.916847
few call
0.906740
few evid
0.915586
few even
0.907406
few within
0.900365
few invalid
0.903770
few brutal
0.902489
few theatr
0.907278
few undoubtedli
0.902007
few trifl
0.902958
few appear
0.926405
few ten
0.912601
few press
0.909381
few utterli
0.918208
few doubt
0.900097
few revolt
0.900779
few charit
0.903513
few remov
0.900743
few direct
0.910109
few scarc
0.918594
few emin
0.901263
few attempt
0.920532
few happili
0.903979
few six
0.902808
few outrag
0.901822
few irrit
0.904320
few admit
0.900186
few expos
0.904955
few interven
0.904444
few ground
0.908311
few anoth
0.906621
few intent
0.916318
few inconveni
0.906820
few habit
0.912638
few search
0.901233
few erect
0.901503
few recov
0.902900
few discharg
0.905463
few immens
0.919123
few simpli
0.901539
few thirti
0.915784
few year
0.900857
few most
0.914409
few latest
0.903773
few on
0.912726
few actual
0.903895
few prepar
0.910889
few suspicion
0.903091
few personag
0.909001
few larg
0.901591
few accident
0.900045
few satisfi
0.908044
few reliev
0.919294
few doubtless
0.916321
few spectat
0.902581
few occas
0.916802
few visibl
0.901617
few grievanc
0.901755
few fix
0.908548
few cautiou
0.906343
few avoid
0.907926
few rather
0.906343
few spectacl
0.903348
few offer
0.906079
few first
0.921010
few hardship
0.900463
few still
0.905493
few commenc
0.903347
few make
0.903515
few sundri
0.905446
few discuss
0.900436
few end
0.906909
few relic
0.905189
few engag
0.918894
few indiffer
0.910040
few destin
0.906263
few such
0.902956
few plot
0.905250
few oppos
0.900658
few examin
0.912291
few contriv
0.915267
few almost
0.927738
proclam disabl
0.911109
proclam revolut
0.904854
proclam restor
0.901893
proclam magistr
0.902273
proclam assign
0.901291
proclam dispatch
0.900259
proclam allegi
0.904362
proclam pretext
0.901846
proclam prosecut
0.908727
proclam penalti
0.900736
proclam breach
0.901586
proclam sanction
0.902360
proclam surrend
0.913800
proclam expedit
0.900372
proclam augment
0.900728
proclam impos
0.901216
proclam submit
0.912912
proclam issu
0.901588
proclam massacr
0.902134
proclam discret
0.902886
proclam conquest
0.909840
proclam agent
0.903635
proclam oppon
0.903790
proclam effectu
0.906012
proclam conspiraci
0.913413
proclam propos
0.905898
proclam transact
0.911650
proclam recruit
0.901944
proclam debat
0.905920
proclam colleagu
0.909204
proclam sieg
0.900186
proclam denounc
0.905277
proclam preliminari
0.908517
proclam expir
0.901829
proclam behalf
0.901981
proclam alleg
0.906631
proclam plunder
0.907872
proclam remonstr
0.908979
proclam unanim
0.918653
proclam commiss
0.915334
proclam neutral
0.901915
proclam resolut
0.908282
proclam decis
0.901981
proclam embark
0.905665
proclam declar
0.902072
proclam expedi
0.912749
proclam war
0.900770
proclam truce
0.904238
proclam compli
0.905704
proclam spaniard
0.905385
proclam vindic
0.913095
proclam confer
0.907254
proclam conspir
0.905134
proclam rebellion
0.908227
proclam clergi
0.900633
proclam defend
0.903717
everyday sensit
0.904620
everyday annihil
0.902284
everyday perhap
0.906103
everyday impart
0.905978
everyday assuredli
0.903392
everyday mean
0.903267
everyday selfish
0.902137
everyday reflect
0.901647
everyday justli
0.900631
everyday intellect
0.901310
everyday temptat
0.902445
everyday content
0.909447
everyday share
0.901151
everyday motiv
0.906341
everyday wholesom
0.905199
everyday aspir
0.910435
everyday conceiv
0.908946
everyday treat
0.901649
everyday degrad
0.908737
everyday exact
0.900901
everyday restraint
0.903107
everyday perfect
0.908927
everyday apt
0.915245
everyday comprehend
0.902887
everyday misunderstand
0.900331
everyday conscienc
0.905266
everyday folli
0.900872
everyday idl
0.913519
everyday presumpt
0.906714
everyday disposit
0.903392
everyday mental
0.906695
everyday alon
0.904793
everyday cruelti
0.906648
everyday imparti
0.902490
everyday error
0.902467
everyday tediou
0.902501
everyday harmless
0.904339
everyday yet
0.912168
everyday own
0.904633
everyday sort
0.903999
everyday delus
0.908526
everyday physic
0.901939
everyday infinit
0.909139
everyday pride
0.903768
everyday absurd
0.916146
everyday worth
0.900039
everyday usag
0.900901
everyday worthi
0.905811
everyday regard
0.901712
everyday fantast
0.905569
everyday concern
0.904898
everyday endow
0.911037
everyday prejudic
0.908757
everyday indol
0.906158
everyday infanc
0.903828
everyday weak
0.903817
everyday knowledg
0.905030
everyday frivol
0.903718
everyday philosoph
0.900596
everyday true
0.912546
everyday real
0.913863
everyday arrog
0.903594
everyday inspir
0.900941
everyday chariti
0.905447
everyday sensibl
0.918507
everyday barbar
0.910707
everyday commonplac
0.908915
everyday contempl
0.908769
everyday worldli
0.903542
everyday affect
0.909202
everyday taint
0.900182
everyday trivial
0.915643
everyday comprehens
0.908181
everyday unfit
0.914240
everyday burden
0.900097
everyday forbid
0.902302
everyday cherish
0.900920
everyday hatr
0.907987
everyday distrust
0.904999
everyday need
0.907231
everyday proprieti
0.906992
everyday ordinari
0.912059
everyday truth
0.902635
everyday viciou
0.905194
everyday geniu
0.905851
everyday worst
0.908375
everyday superflu
0.904131
everyday attach
0.901583
everyday greedi
0.900824
everyday subtl
0.902564
everyday discern
0.904749
everyday ambiti
0.905131
everyday tyranni
0.906933
everyday kind
0.908266
everyday preserv
0.904350
everyday truli
0.906274
everyday unjust
0.900130
everyday solv
0.901231
everyday deni
0.908976
everyday enjoy
0.904838
everyday acknowledg
0.900306
everyday maxim
0.904904
everyday faculti
0.902125
everyday artist
0.901333
everyday specul
0.915026
everyday alik
0.909467
everyday suscept
0.901496
everyday ambit
0.906395
everyday life
0.914038
everyday envi
0.906381
everyday peculiarli
0.910037
everyday improb
0.900653
everyday peopl
0.901610
everyday contradict
0.903649
everyday feebl
0.901114
everyday confound
0.904838
everyday eas
0.900800
everyday vulgar
0.917027
everyday despis
0.903544
everyday teach
0.900952
everyday degener
0.902154
everyday partak
0.900103
everyday relish
0.906279
everyday unknown
0.908396
everyday remot
0.910298
everyday realis
0.904154
everyday lessen
0.904865
everyday capabl
0.900525
everyday duti
0.900241
everyday ani
0.903133
everyday lack
0.917584
everyday abus
0.907426
everyday genuin
0.913327
everyday exist
0.901490
everyday perpetu
0.918975
everyday mere
0.913718
everyday critic
0.906648
everyday sphere
0.902417
everyday natur
0.906082
everyday privileg
0.901080
everyday therefor
0.900634
everyday notion
0.911275
everyday conscienti
0.903954
everyday sometim
0.907867
everyday benevol
0.904484
everyday odiou
0.902601
everyday superstit
0.906001
everyday magnifi
0.900052
everyday learn
0.905120
everyday evad
0.907737
everyday unworthi
0.904728
everyday wise
0.907426
everyday habitu
0.915774
everyday finer
0.905361
everyday condemn
0.903111
everyday oppress
0.902008
everyday simpl
0.914418
everyday charact
0.906803
everyday immor
0.904284
everyday exercis
0.900151
everyday discrimin
0.900246
everyday none
0.903281
everyday belief
0.910321
everyday abomin
0.901624
everyday miseri
0.904392
everyday honesti
0.906941
everyday rare
0.917774
everyday justifi
0.900244
everyday suffer
0.903293
everyday world
0.912890
everyday profit
0.902218
everyday intellig
0.901050
everyday obscur
0.913745
everyday mislead
0.906053
everyday inconsist
0.906766
everyday ignor
0.914787
everyday breed
0.905248
everyday human
0.903910
everyday higher
0.900721
everyday spirit
0.908238
everyday labour
0.912633
everyday injustic
0.904546
everyday profess
0.906951
everyday gross
0.909819
everyday must
0.904153
everyday inevit
0.909860
everyday infirm
0.903220
everyday detest
0.900789
everyday lose
0.906884
everyday disciplin
0.902353
everyday borrow
0.902620
everyday cure
0.901171
everyday fault
0.903733
everyday contempt
0.905936
everyday offenc
0.901979
everyday free
0.900254
everyday dispens
0.900613
everyday contrari
0.902803
everyday inflict
0.900781
everyday understand
0.902931
everyday fiction
0.911303
everyday proof
0.910917
everyday desir
0.905888
everyday ridicul
0.914804
everyday ideal
0.906530
everyday agreeabl
0.903604
everyday sens
0.913143
everyday fals
0.905387
everyday repos
0.900522
everyday conceit
0.907412
everyday alway
0.904196
everyday sentiment
0.904214
everyday particular
0.900462
everyday constant
0.910706
everyday sympathi
0.905683
everyday nourish
0.904639
everyday futur
0.904999
everyday disgrac
0.905869
everyday certainli
0.909610
everyday strict
0.908659
everyday temper
0.904315
everyday choic
0.916468
everyday neglect
0.916751
everyday avers
0.906082
everyday vaniti
0.905222
everyday choos
0.906951
everyday tempt
0.912692
everyday enlighten
0.907921
everyday idea
0.909620
everyday appetit
0.908901
everyday legitim
0.902338
everyday pure
0.904602
everyday absolut
0.912868
everyday imaginari
0.912757
everyday reason
0.910370
everyday worthless
0.907583
everyday practis
0.900424
everyday liberti
0.904464
everyday deserv
0.902824
everyday no
0.901341
everyday simplic
0.915413
everyday modesti
0.901293
everyday denial
0.902856
everyday bodili
0.911381
everyday hypocrit
0.903280
everyday revel
0.900991
everyday imit
0.906682
everyday appreci
0.910685
everyday pervers
0.900781
everyday injur
0.902882
everyday realiti
0.906835
everyday invent
0.910673
everyday healthi
0.904288
everyday best
0.912202
everyday judgment
0.904033
everyday sole
0.904019
everyday humbl
0.901461
everyday freedom
0.905605
everyday humil
0.901721
everyday pleasur
0.907418
everyday better
0.901294
everyday outward
0.907266
everyday otherwis
0.910331
everyday unnatur
0.907567
everyday greater
0.901954
everyday ordinarili
0.903529
everyday infidel
0.904215
everyday rightli
0.909283
everyday necess
0.904790
everyday phrase
0.913261
mainten oper
0.905359
mainten compet
0.917102
mainten author
0.909809
mainten render
0.908067
mainten zealou
0.903457
mainten basi
0.903932
mainten appropri
0.907711
mainten affirm
0.900310
mainten controversi
0.902258
mainten extent
0.914644
mainten necessari
0.903292
mainten incorpor
0.907116
mainten limit
0.908043
mainten efficaci
0.912912
mainten foundat
0.905062
mainten necessarili
0.911553
mainten mode
0.902212
mainten deriv
0.911750
mainten consist
0.906053
mainten abolish
0.906937
mainten liabl
0.907478
mainten infer
0.910374
mainten repres
0.906831
mainten technic
0.902013
mainten obtain
0.906398
mainten qualif
0.912465
mainten violat
0.904002
mainten measur
0.902033
mainten apprehend
0.904923
mainten benefit
0.904433
mainten defici
0.901320
mainten regul
0.913793
mainten impair
0.912086
mainten commun
0.902616
mainten effici
0.908008
mainten enumer
0.912579
mainten corpor
0.906819
mainten exclud
0.919531
mainten tend
0.901159
mainten allot
0.902400
mainten establish
0.907968
mainten commonli
0.900485
mainten denomin
0.919041
mainten ensur
0.918792
mainten compens
0.913379
mainten adequ
0.915586
mainten transmit
0.905940
mainten consequ
0.909636
mainten integr
0.902776
mainten obviou
0.902986
mainten secondli
0.905066
mainten subject
0.902428
mainten reduc
0.909531
mainten demonstr
0.900465
mainten recours
0.908281
mainten arbitrari
0.910061
mainten unquestion
0.913200
mainten indispens
0.911617
mainten readili
0.901024
mainten involv
0.909423
mainten incur
0.900788
mainten enlarg
0.901910
mainten access
0.900314
mainten benefici
0.900721
mainten tendenc
0.912056
mainten exceed
0.905855
mainten provis
0.906270
mainten conform
0.909746
mainten subsist
0.905984
mainten ascrib
0.900184
mainten maintain
0.923632
mainten guarante
0.900140
mainten attribut
0.901175
mainten properti
0.908284
mainten appli
0.907504
mainten promot
0.910535
mainten proport
0.904549
mainten restrict
0.918472
mainten principl
0.909486
mainten perman
0.900854
mainten adher
0.924976
mainten forego
0.902035
mainten convert
0.908008
mainten diminut
0.903212
mainten applic
0.906963
mainten enforc
0.908922
mainten due
0.900737
mainten inferior
0.911178
mainten commerc
0.906827
mainten injuri
0.907223
mainten therebi
0.907992
mainten adapt
0.903850
mainten substitut
0.916577
mainten depend
0.905854
mainten function
0.900601
mainten circul
0.902192
mainten defect
0.901860
mainten requisit
0.926690
mainten contribut
0.907161
mainten extens
0.909684
mainten addit
0.906042
mainten util
0.915723
mainten chiefli
0.902372
mainten individu
0.905955
mainten capac
0.901957
mainten conced
0.906739
mainten proper
0.904066
mainten equival
0.908002
mainten adopt
0.910325
mainten unequ
0.900991
mainten obstruct
0.908339
mainten equal
0.907988
mainten requir
0.904469
mainten expressli
0.904447
mainten tax
0.915305
mainten essenti
0.910460
mainten diminish
0.910316
mainten voluntari
0.909947
mainten institut
0.906803
mainten enabl
0.903664
mainten expel
0.901506
mainten reciproc
0.903373
mainten support
0.904367
mainten amount
0.900641
side underneath
0.903920
side reach
0.907852
side below
0.913465
side round
0.903371
side spot
0.913986
side through
0.904086
side stone
0.900238
side cross
0.907149
side distanc
0.900468
side front
0.900982
side entranc
0.917213
side heap
0.912269
side forward
0.904158
side wooden
0.904614
side fasten
0.910576
side open
0.903571
side along
0.907904
side upward
0.906155
side row
0.908133
side straw
0.903690
side spread
0.900861
side cover
0.900150
side heavi
0.913594
side shelter
0.900481
side lay
0.904805
side squar
0.900223
side bottom
0.903406
side loos
0.900874
side strike
0.903180
side pole
0.903476
side disappear
0.901549
side block
0.900796
side bare
0.905318
side spur
0.900897
side wall
0.906040
side blow
0.900999
side near
0.903054
side scatter
0.902873
side throw
0.906593
side centr
0.904601
side move
0.903093
side pile
0.905414
side canva
0.904145
side close
0.913126
guilt jealou
0.903832
guilt fellowship
0.917513
guilt rejoic
0.901368
guilt bold
0.902719
guilt flesh
0.905744
guilt bestow
0.924140
guilt confid
0.900808
guilt aloof
0.903759
guilt testifi
0.910517
guilt earthli
0.920386
guilt martyr
0.905312
guilt harsh
0.915216
guilt consid
0.904884
guilt subdu
0.921548
guilt triumph
0.900118
guilt enjoin
0.910543
guilt tranquil
0.920624
guilt scourg
0.909852
guilt boast
0.922030
guilt blind
0.909381
guilt sacrific
0.919030
guilt divin
0.919416
guilt persuad
0.901300
guilt tempor
0.902863
guilt imag
0.900164
guilt behaviour
0.912489
guilt ancestor
0.907593
guilt unwil
0.901255
guilt conjur
0.907424
guilt obey
0.914704
guilt consol
0.902543
guilt reject
0.917550
guilt safe
0.900639
guilt wicked
0.926488
guilt sacr
0.907144
guilt stain
0.901216
guilt poster
0.917021
guilt testimoni
0.910429
guilt eloqu
0.907625
guilt uphold
0.921222
guilt act
0.914904
guilt common
0.901474
guilt allur
0.920277
guilt matter
0.903460
guilt acquir
0.902782
guilt falsehood
0.934338
guilt displeasur
0.906232
guilt lend
0.907655
guilt willingli
0.916268
guilt fame
0.909162
guilt weaken
0.907965
guilt pieti
0.923466
guilt countryman
0.900687
guilt guardian
0.910443
guilt spoil
0.900064
guilt mortal
0.902686
guilt oracl
0.915757
guilt reli
0.911863
guilt miser
0.905532
guilt mankind
0.908447
guilt stubborn
0.900159
guilt esteem
0.915823
guilt crime
0.929603
guilt destini
0.925546
guilt poison
0.913063
guilt solicit
0.915137
guilt peac
0.908161
guilt passion
0.902456
guilt opinion
0.905449
guilt err
0.930765
guilt withstand
0.906809
guilt capric
0.900295
guilt cun
0.900968
guilt forsak
0.910409
guilt wors
0.906057
guilt skill
0.903114
guilt scandal
0.901038
guilt childhood
0.901555
guilt honor
0.907951
guilt insol
0.900523
guilt profound
0.905921
guilt barbarian
0.901376
guilt patern
0.901572
guilt pledg
0.906998
guilt thu
0.906456
guilt judg
0.908204
guilt unfold
0.900671
guilt violenc
0.909472
guilt reap
0.919932
guilt villain
0.907707
guilt tame
0.907800
guilt furthermor
0.903809
guilt predict
0.902593
guilt everlast
0.903712
guilt thirst
0.915322
guilt abid
0.916628
guilt prudenc
0.923436
guilt fate
0.916196
guilt chast
0.905215
guilt wealth
0.909874
guilt worship
0.901791
guilt rack
0.903027
guilt prudent
0.905107
guilt offend
0.929902
guilt respect
0.917553
guilt forbear
0.922208
guilt inact
0.901780
guilt fidel
0.902104
guilt honour
0.909333
guilt lament
0.910418
guilt griev
0.903678
guilt skil
0.904141
guilt rebelli
0.910396
guilt troublesom
0.901603
guilt destroy
0.906146
guilt hope
0.901413
guilt imput
0.917741
guilt sooner
0.903188
guilt guilti
0.948114
guilt miracl
0.910522
guilt slander
0.912652
guilt idol
0.901382
guilt contend
0.914885
guilt whatsoev
0.906631
guilt preciou
0.903990
guilt rob
0.905489
guilt maladi
0.902141
guilt digniti
0.912433
guilt obedi
0.928312
guilt fear
0.901711
guilt virtu
0.918052
guilt merit
0.919934
guilt reward
0.921676
guilt improp
0.902979
guilt wretch
0.912173
guilt rebuk
0.914698
guilt adversari
0.906262
guilt scrupl
0.910824
guilt convict
0.915637
guilt man
0.901923
guilt speech
0.901457
guilt devout
0.904081
guilt deliv
0.906609
guilt assum
0.901519
guilt foul
0.905990
guilt voluntarili
0.905434
guilt betray
0.904895
guilt yield
0.919033
guilt puriti
0.909751
guilt sustain
0.911220
guilt benefactor
0.913808
guilt nobl
0.917198
guilt blame
0.912174
guilt cruel
0.909062
guilt soul
0.907816
guilt tortur
0.904094
guilt persecut
0.915844
guilt henceforth
0.917066
guilt precept
0.907625
guilt undergo
0.900497
guilt sinner
0.903045
guilt insult
0.901390
guilt repent
0.918852
guilt gloriou
0.902034
guilt fulfil
0.927759
guilt traitor
0.912773
guilt poss
0.905934
guilt rever
0.920890
guilt treason
0.912838
guilt impot
0.926326
guilt wisdom
0.913553
guilt heir
0.901733
guilt repugn
0.901274
guilt deliver
0.909343
guilt forfeit
0.915285
guilt dilig
0.906771
guilt provok
0.910453
guilt compass
0.912973
guilt belov
0.900465
guilt death
0.902683
guilt withhold
0.929365
guilt devoid
0.906231
guilt nobli
0.907108
guilt rash
0.929611
guilt deaf
0.904425
guilt overcom
0.910373
guilt plead
0.905777
guilt sovereign
0.903077
guilt superior
0.906292
guilt aton
0.929829
guilt overwhelm
0.903724
guilt evil
0.931657
guilt accord
0.905491
guilt deem
0.912602
guilt sake
0.903771
guilt resist
0.900863
guilt abil
0.903692
guilt discord
0.910971
guilt commend
0.908591
guilt religion
0.901792
guilt covet
0.917406
guilt felic
0.901891
guilt mischief
0.908278
guilt guidanc
0.905335
guilt oath
0.900064
guilt remembr
0.908539
guilt seek
0.921834
guilt consecr
0.906709
guilt discont
0.900739
guilt caus
0.909243
guilt accept
0.908605
guilt crimin
0.909496
guilt gall
0.902673
guilt spiritu
0.905424
guilt bribe
0.912756
guilt etern
0.913435
guilt flatter
0.904251
guilt repay
0.909333
guilt abstain
0.910456
guilt strength
0.911987
guilt prophesi
0.912091
guilt dictat
0.916479
guilt rule
0.901395
guilt disdain
0.916475
guilt patienc
0.915144
guilt revers
0.900113
guilt doubli
0.905116
guilt argument
0.909678
guilt prais
0.911452
guilt gift
0.918853
guilt medit
0.909998
guilt wick
0.906246
guilt renounc
0.935774
guilt doom
0.903880
guilt vile
0.930205
guilt neglig
0.902223
guilt grievou
0.924843
guilt advantag
0.902279
guilt shame
0.908565
guilt wrong
0.902979
guilt possess
0.905138
guilt manifest
0.912171
guilt perish
0.915297
guilt sincer
0.916246
guilt exalt
0.919181
guilt alien
0.909316
guilt plea
0.910377
guilt iniqu
0.906794
guilt perplex
0.900091
guilt gratif
0.908957
guilt reproach
0.916399
guilt malic
0.930031
guilt lust
0.913874
guilt censur
0.923841
guilt devis
0.922749
guilt spare
0.905383
guilt reveng
0.907001
guilt scorn
0.908444
guilt theft
0.922692
guilt treacheri
0.904580
guilt glori
0.911111
guilt wanton
0.909659
guilt forev
0.902275
guilt argu
0.918312
guilt withal
0.911040
guilt endur
0.923439
guilt deform
0.901210
guilt faith
0.925381
guilt conclus
0.900451
guilt wherefor
0.909350
guilt holi
0.902285
guilt punish
0.928079
guilt ungrat
0.914485
guilt consumm
0.917164
guilt magnanim
0.924150
guilt glorifi
0.900602
guilt benefic
0.903899
guilt bound
0.905754
guilt guid
0.912206
guilt trust
0.913279
guilt zeal
0.908846
guilt thief
0.902058
guilt extinguish
0.904124
guilt defer
0.902769
guilt shun
0.920562
guilt wil
0.935386
guilt pain
0.905650
guilt singl
0.905902
guilt save
0.903781
guilt salvat
0.913925
guilt deceit
0.928241
guilt importun
0.904751
guilt lustr
0.906280
guilt sublim
0.904003
guilt self
0.907317
guilt bondag
0.922573
guilt who
0.902437
guilt redeem
0.929676
guilt crave
0.914783
guilt hereaft
0.922352
guilt foretel
0.905701
guilt aliv
0.904836
guilt profan
0.913032
guilt dishonour
0.926709
guilt lowli
0.901564
guilt victim
0.909442
guilt restrain
0.919681
guilt hearer
0.906626
guilt prosper
0.905968
guilt goodwil
0.904680
guilt fraud
0.935096
guilt commit
0.928022
guilt health
0.906271
guilt brethren
0.904372
guilt multitud
0.914936
guilt monstrou
0.903913
guilt recompens
0.925221
guilt assur
0.904654
guilt misfortun
0.915266
guilt religi
0.907141
guilt nobil
0.905064
guilt justif
0.910248
guilt vengeanc
0.910698
guilt regardless
0.904731
guilt devot
0.906647
guilt homag
0.900912
guilt manli
0.904579
guilt deed
0.921457
guilt bind
0.921920
guilt strengthen
0.909381
guilt communion
0.904774
guilt trial
0.900854
guilt creatur
0.903203
guilt excus
0.900273
guilt believ
0.902862
guilt advers
0.927253
guilt blot
0.902386
guilt interpos
0.903376
guilt torment
0.908674
guilt merci
0.921536
guilt surpass
0.902893
guilt demon
0.905301
guilt offspr
0.901205
guilt vain
0.919990
guilt justic
0.911607
guilt endeavor
0.902356
guilt inward
0.900589
guilt tyrant
0.937199
guilt malici
0.902259
guilt earnest
0.900879
guilt fetter
0.927468
guilt bodi
0.901364
guilt counsel
0.912855
guilt heal
0.905968
guilt exert
0.912969
guilt conquer
0.916457
guilt decay
0.901653
guilt constrain
0.915574
guilt suicid
0.907464
guilt saviour
0.902549
guilt foolish
0.900637
guilt orat
0.904080
guilt satan
0.905286
guilt repress
0.902761
guilt inherit
0.909258
guilt potent
0.911641
guilt perform
0.907325
guilt persever
0.914269
guilt calam
0.915113
guilt suppos
0.902278
guilt betwixt
0.907632
guilt refus
0.901850
guilt immort
0.918183
guilt usurp
0.908317
guilt corrupt
0.902313
guilt live
0.900180
guilt accus
0.916247
guilt strive
0.917083
guilt defi
0.912920
guilt alter
0.905937
guilt exil
0.904154
guilt despond
0.906691
guilt quarrel
0.903395
guilt henc
0.901807
guilt impuls
0.900898
guilt transgress
0.903013
guilt deceiv
0.922960
guilt submiss
0.916669
guilt banish
0.926612
guilt object
0.900614
guilt bewar
0.907728
guilt grant
0.909962
guilt disregard
0.900251
guilt mild
0.901107
guilt artific
0.913834
guilt honest
0.903275
guilt slave
0.911036
guilt assert
0.905635
guilt feign
0.920582
guilt nay
0.922633
guilt writ
0.903025
guilt conduct
0.911649
guilt destitut
0.912080
guilt consent
0.902770
guilt distress
0.903130
guilt god
0.904621
guilt innoc
0.908614
guilt piou
0.919243
guilt hinder
0.906225
guilt power
0.917743
guilt void
0.930975
guilt wit
0.916867
guilt avow
0.902717
guilt flatteri
0.912563
guilt manhood
0.910999
guilt propheci
0.906406
guilt plainli
0.901249
guilt confess
0.903687
guilt ruin
0.904005
guilt aris
0.908727
guilt remedi
0.903463
curios condescend
0.902566
curios futil
0.902383
curios deepli
0.901931
curios servant
0.901499
curios amus
0.916547
curios refrain
0.910233
curios rumour
0.908883
curios puzzl
0.903940
curios excurs
0.911177
curios brilliant
0.904117
curios bustl
0.903319
curios disapprov
0.905782
curios wa
0.911748
curios tragic
0.911179
curios shock
0.910935
curios unlucki
0.904208
curios indign
0.908575
curios sober
0.901959
curios courteou
0.905729
curios hesit
0.911654
curios vagu
0.913900
curios unexpect
0.917417
curios humor
0.905273
curios spite
0.915936
curios hopeless
0.907712
curios timid
0.918018
curios appal
0.904060
curios dislik
0.903422
curios generos
0.902565
curios blank
0.901406
curios astound
0.903289
curios secreci
0.902066
curios unexpectedli
0.904902
curios intimaci
0.915453
curios retir
0.900460
curios awkward
0.907187
curios gaieti
0.900951
curios companion
0.914772
curios lavish
0.900675
curios pictur
0.902297
curios secretli
0.918312
curios apolog
0.912770
curios complac
0.907362
curios liveri
0.900873
curios unmistak
0.904218
curios childish
0.902239
curios comic
0.901456
curios stranger
0.903162
curios adventur
0.913567
curios romant
0.903901
curios acquaint
0.910065
curios uneasi
0.922293
curios suspici
0.919198
curios solemnli
0.907489
curios counten
0.906016
curios vexat
0.905068
curios ardent
0.900592
curios resent
0.919080
curios dismiss
0.905071
curios commot
0.903042
curios recal
0.912986
curios compliment
0.904333
curios astonish
0.922753
curios embarrass
0.915830
curios undisturb
0.900289
curios humili
0.909945
curios imprud
0.902851
curios mortifi
0.904841
curios unconsci
0.913283
curios rambl
0.900214
curios amaz
0.900926
curios unawar
0.912015
curios friend
0.900465
curios menac
0.901613
curios thought
0.902780
curios handsom
0.901701
curios mood
0.901969
curios regret
0.906455
curios fanci
0.907884
curios pathet
0.913459
curios bewild
0.901719
curios shrewd
0.914194
curios blunder
0.902473
curios cordial
0.910971
curios delight
0.905101
curios anxiou
0.909107
curios amiabl
0.910448
curios comment
0.900533
curios impati
0.903315
curios disappoint
0.915810
curios surmis
0.902076
curios odd
0.910981
curios intrud
0.907898
curios episod
0.908655
curios vividli
0.900162
curios bitterli
0.901002
curios fascin
0.913597
curios quit
0.906452
curios surpris
0.922346
curios confront
0.906870
curios strang
0.905479
curios powerless
0.903833
curios anxieti
0.910264
curios eager
0.906995
curios reappear
0.902850
curios awaken
0.903878
curios alert
0.903193
curios monk
0.903366
curios confidenti
0.908273
curios reluct
0.911135
curios cynic
0.903099
curios profoundli
0.911515
curios gossip
0.905291
curios melancholi
0.917767
curios affair
0.900600
curios tact
0.900747
curios attitud
0.904683
curios exasper
0.910167
curios jealousi
0.902968
curios seem
0.914004
curios alarm
0.907001
curios aristocrat
0.902146
curios warmli
0.906312
curios interview
0.901848
curios casual
0.918126
curios badli
0.900743
curios vehement
0.901118
curios discreet
0.904805
curios treacher
0.900462
curios lawyer
0.903347
curios engross
0.900998
curios mysteri
0.904317
curios repel
0.900163
soldier victori
0.906379
soldier veteran
0.914196
soldier attack
0.913937
soldier conqueror
0.900356
soldier forthwith
0.902661
soldier retreat
0.910799
soldier enemi
0.917709
soldier safeti
0.903135
soldier mob
0.904547
soldier command
0.904335
soldier braveri
0.902491
soldier assault
0.907030
soldier seiz
0.910897
soldier sent
0.900970
soldier defeat
0.904080
soldier led
0.901462
soldier rebel
0.915620
soldier dispers
0.914685
soldier repuls
0.908273
soldier formid
0.903965
mate pluck
0.911410
mate drunken
0.908421
mate then
0.903579
mate shed
0.902879
mate pitch
0.903487
mate kill
0.900598
mate dead
0.902728
mate drown
0.912723
mate drunk
0.900630
mate spit
0.904750
mate fast
0.902162
mate lame
0.901982
mate break
0.901031
mate shift
0.900575
mate rotten
0.902760
mate infern
0.900084
mate up
0.901774
mate spill
0.900590
greec austria
0.903234
greec netherland
0.902788
rusti piazza
0.910103
rusti litter
0.900688
rusti blacken
0.908083
rusti patch
0.900173
rusti loung
0.908904
rusti lookout
0.904309
level portion
0.901801
level height
0.919358
level elev
0.902712
level narrow
0.910995
level space
0.909236
level divid
0.900310
level frame
0.902914
level rapid
0.900738
level widen
0.911948
level flow
0.900944
level expans
0.900703
level extend
0.903688
level mass
0.905884
level shallow
0.912388
level irregular
0.903117
level sceneri
0.901016
level distant
0.909910
level depth
0.900001
level surmount
0.912349
level solid
0.910500
level recess
0.909717
level interior
0.902233
level unbroken
0.900201
level wide
0.907966
level scale
0.912976
level lighter
0.906212
level small
0.901354
level lower
0.915426
level main
0.904864
dog whip
0.904132
dog shut
0.907925
dog run
0.900555
dog hunt
0.904896
dog dirti
0.900132
cling dreari
0.905002
cling stifl
0.916954
cling solitari
0.901089
cling hover
0.901383
cling solitud
0.903599
cling horror
0.921747
cling calm
0.900792
cling ach
0.901116
cling stray
0.907064
cling desper
0.907820
cling touch
0.902505
cling ecstasi
0.905821
cling sudden
0.902408
cling horribl
0.909851
cling warmth
0.901550
cling sunshin
0.902302
cling agoni
0.908690
cling sicken
0.910602
cling ghastli
0.904730
cling helpless
0.907192
cling despair
0.904031
cling vanish
0.908259
cling abyss
0.902166
cling fade
0.905287
cling lone
0.901386
cling hideou
0.904038
cling ici
0.902373
cling lurk
0.913907
cling shrink
0.905364
cling fright
0.903953
cling dream
0.901175
cling seren
0.902751
cling placid
0.907986
cling haunt
0.909755
cling eyelid
0.900628
cling snatch
0.905453
steed shaft
0.909577
steed warrior
0.905136
steed eleph
0.901856
lump scrape
0.908527
lump fat
0.901558
lump wash
0.917051
lump piec
0.915061
lump dirt
0.901225
lump handl
0.906320
lump hot
0.902280
lump clean
0.919660
lump squeez
0.902162
descend vast
0.914780
descend nake
0.902901
descend burn
0.901788
descend forcibl
0.901303
descend throughout
0.901950
descend herd
0.902074
descend crush
0.901248
descend furiou
0.905330
descend limb
0.909504
descend blood
0.902012
descend simultan
0.902669
descend depart
0.907990
descend profus
0.907556
descend spring
0.909843
descend incess
0.912948
descend costli
0.912758
descend monster
0.902481
descend swell
0.909473
descend ascend
0.937941
descend preced
0.901898
descend emerg
0.908284
descend fall
0.900437
descend prey
0.908693
descend fragment
0.908189
descend devic
0.901523
descend embrac
0.906927
descend entangl
0.902770
descend reign
0.913907
descend gather
0.902733
descend doubl
0.900504
descend fed
0.902358
descend rank
0.912192
descend dungeon
0.901196
descend rigid
0.907108
descend shape
0.904033
descend circl
0.921001
descend backward
0.907035
descend appeas
0.903222
descend nine
0.902836
descend featur
0.900029
descend imperi
0.902452
descend chain
0.901613
descend suspend
0.901674
descend exhibit
0.905666
descend remnant
0.915080
descend endless
0.902691
descend forth
0.908073
descend ensu
0.916811
descend each
0.902218
descend former
0.903658
descend steadi
0.900461
descend flight
0.927095
descend reced
0.904696
descend innumer
0.916633
descend flock
0.900574
descend blast
0.904785
descend crown
0.904472
descend prostrat
0.902262
descend barren
0.908518
descend conflict
0.905350
descend fugit
0.907247
descend barrier
0.911595
descend ancient
0.908263
descend penetr
0.910563
descend field
0.924257
descend path
0.903524
descend stake
0.901841
descend descent
0.956750
descend disastr
0.907408
descend renew
0.903337
descend lofti
0.915136
descend slow
0.906101
descend invad
0.907130
descend contest
0.908760
descend forc
0.905107
descend cast
0.904089
descend rise
0.918347
descend fratern
0.905075
descend passag
0.906088
descend laps
0.909405
descend captiv
0.906763
descend midst
0.906124
descend furi
0.910164
descend assail
0.908938
wish mine
0.912634
wish mad
0.909885
wish ask
0.903492
wish busi
0.903839
wish help
0.911457
wish cowardli
0.904181
wish ever
0.925124
wish kindli
0.909360
wish forget
0.921310
wish beg
0.910107
wish cruelli
0.914063
wish happen
0.916708
wish rascal
0.900279
wish entreat
0.907606
wish suit
0.907511
wish starv
0.911099
wish us
0.901928
wish astray
0.900603
wish proud
0.901150
wish tell
0.900353
wish angri
0.901160
wish promis
0.917660
wish about
0.905173
wish decent
0.913605
wish delicaci
0.903596
wish idiot
0.912987
wish match
0.902471
wish keep
0.910979
wish way
0.913942
wish frankli
0.908158
wish good
0.928490
wish secret
0.910725
wish mind
0.930735
wish sick
0.907068
wish insinu
0.902988
wish bad
0.917726
wish pay
0.908461
wish advic
0.916614
wish think
0.918649
wish happi
0.923735
wish whi
0.900280
wish well
0.921094
wish courtesi
0.907727
wish find
0.923982
wish impertin
0.915906
wish gratitud
0.912434
wish lifetim
0.908720
wish husband
0.903199
wish marriag
0.901835
wish comfort
0.933060
wish chanc
0.914989
wish deal
0.922982
wish sympath
0.903530
wish hard
0.905739
wish heartili
0.914784
wish grudg
0.920856
wish child
0.904552
wish trick
0.914012
wish undo
0.911144
wish today
0.916738
wish never
0.931449
wish advis
0.914546
wish dull
0.907226
wish gladli
0.908537
wish horrid
0.913726
wish read
0.904147
wish humour
0.911381
wish hate
0.910585
wish friendship
0.908482
wish memori
0.904353
wish leav
0.914031
wish lie
0.902642
wish parent
0.901083
wish will
0.904144
wish cheat
0.924883
wish pardon
0.909159
wish thing
0.922851
wish acquiesc
0.901151
wish forgiv
0.915127
wish dare
0.920877
wish dumb
0.901589
wish see
0.915112
wish feel
0.926327
wish courag
0.900214
wish gentleman
0.905078
wish take
0.904035
wish hurt
0.904126
wish prize
0.905793
wish swear
0.902771
wish fret
0.906350
wish here
0.901810
wish bargain
0.909042
wish master
0.906176
wish mend
0.912292
wish resolv
0.903239
wish do
0.935844
wish warn
0.904180
wish know
0.932419
wish behav
0.928108
wish ugli
0.901454
wish pleas
0.926980
wish lesson
0.911345
wish displeas
0.918742
wish realiz
0.900332
wish dearli
0.900028
wish noth
0.935164
wish harm
0.923871
wish steal
0.901828
wish graciou
0.903247
wish write
0.904440
wish meddl
0.909723
wish purs
0.907884
wish send
0.903840
wish liar
0.901795
wish fool
0.904065
wish loath
0.904077
wish asham
0.911507
wish realli
0.920957
wish fond
0.918024
wish impud
0.914710
wish enough
0.916430
wish give
0.927469
wish treasur
0.900496
wish stupid
0.918857
wish word
0.903509
wish piti
0.910628
wish unkind
0.911937
wish poor
0.916970
wish lazi
0.902802
wish clever
0.909287
wish say
0.903484
wish care
0.919721
wish rememb
0.924323
wish too
0.927067
wish readi
0.904800
wish honestli
0.923735
wish tiresom
0.906776
wish earnestli
0.920433
wish nurs
0.902697
wish beggar
0.915241
wish rid
0.929271
wish plenti
0.903154
wish risk
0.907586
wish thank
0.912695
wish like
0.906713
wish troubl
0.920874
wish answer
0.916746
wish ass
0.907702
wish brute
0.900667
wish witti
0.912924
wish unhappi
0.920398
wish speak
0.929745
wish now
0.920990
wish sure
0.925226
next left
0.903539
next last
0.908335
recogn statement
0.901386
recogn formal
0.900030
recogn peculiar
0.910408
recogn complic
0.911592
recogn differ
0.901549
recogn identifi
0.910614
recogn instinct
0.908058
recogn authent
0.903040
recogn relationship
0.905961
recogn contemporari
0.900058
recogn politician
0.900560
recogn virtual
0.902008
recogn ultim
0.908980
recogn claim
0.900688
recogn recognit
0.921619
recogn balanc
0.904360
recogn societi
0.902211
recogn relat
0.906216
recogn uniform
0.901409
recogn interpret
0.902550
recogn origin
0.900819
recogn signific
0.907936
recogn demand
0.900464
recogn strictli
0.908140
recogn view
0.913369
recogn record
0.901670
recogn connect
0.902409
recogn uniqu
0.906663
recogn predecessor
0.901249
recogn experi
0.908177
recogn conscious
0.906404
recogn singularli
0.905394
recogn aim
0.900254
recogn indefinit
0.900492
recogn rel
0.903225
recogn aspect
0.902443
recogn outset
0.900040
recogn respons
0.916049
recogn verdict
0.901901
recogn insan
0.907633
recogn occurr
0.900174
recogn unlimit
0.909189
recogn supposit
0.900716
recogn coincid
0.901981
recogn model
0.903754
recogn briefli
0.900381
recogn passiv
0.900734
recogn correct
0.905061
recogn reveal
0.904490
recogn correctli
0.903166
recogn verifi
0.904735
recogn contrast
0.906471
recogn question
0.913246
recogn compar
0.908353
recogn import
0.903554
recogn favor
0.902058
recogn appeal
0.914351
recogn le
0.900154
recogn delic
0.900264
recogn admiss
0.903898
recogn discu
0.905491
recogn assent
0.900492
recogn sensat
0.903564
recogn interfer
0.907704
recogn influenc
0.906844
chronic symptom
0.907471
easter dublin
0.906202
easter petersburg
0.902042
sell shill
0.902317
sell cost
0.915883
sell expens
0.910429
sell or
0.908108
sell hire
0.903048
sell stock
0.909069
sell purchas
0.910334
sell conveni
0.906598
sell money
0.903459
sell landlord
0.904823
sell work
0.901839
sell farmer
0.902584
sell cheap
0.907404
sell use
0.900786
sell tradesman
0.905849
sell buy
0.917461
sell warrant
0.901410
sell tenant
0.901949
develop artifici
0.902210
develop characterist
0.909068
develop multipl
0.902815
develop materi
0.905656
develop typic
0.901445
develop mainli
0.906307
develop factor
0.911518
contemptu demur
0.901593
contemptu noisi
0.901668
contemptu inwardli
0.921530
contemptu carelessli
0.911213
contemptu coldli
0.907423
contemptu matrimoni
0.905395
contemptu ironi
0.926360
contemptu mockeri
0.906675
contemptu disconcert
0.901361
contemptu avert
0.903296
contemptu sympathet
0.901910
contemptu overhear
0.900290
contemptu incomprehens
0.903207
contemptu boyhood
0.902037
contemptu indescrib
0.907198
contemptu betroth
0.905794
contemptu sane
0.904921
contemptu madman
0.918654
contemptu scrupul
0.905455
contemptu masculin
0.911205
contemptu incredul
0.922488
contemptu rave
0.900572
contemptu triumphantli
0.903696
contemptu boyish
0.900029
contemptu smother
0.908009
contemptu sli
0.910933
contemptu clamour
0.902866
contemptu ruffian
0.906351
contemptu sickli
0.904925
contemptu thwart
0.911804
contemptu ardour
0.903546
contemptu penit
0.901278
contemptu impend
0.900162
contemptu beset
0.907444
contemptu misgiv
0.905291
contemptu feverish
0.901747
contemptu reminisc
0.901275
contemptu hopelessli
0.918913
contemptu recoil
0.903102
contemptu calmli
0.900365
contemptu client
0.901475
contemptu harass
0.907957
contemptu sneer
0.909845
wealthi intrigu
0.906132
wealthi pension
0.906151
wealthi guis
0.901000
wealthi banquet
0.900459
wealthi companionship
0.902777
wealthi elder
0.912992
wealthi age
0.901212
wealthi older
0.909037
wealthi narrat
0.900710
wealthi sojourn
0.908261
wealthi complexion
0.910729
wealthi scholar
0.910566
wealthi tribut
0.919029
wealthi estat
0.915783
wealthi memor
0.908267
wealthi courtier
0.911128
wealthi novel
0.900241
wealthi tender
0.901311
wealthi surviv
0.915350
wealthi highli
0.901268
wealthi preacher
0.902958
wealthi refug
0.904001
wealthi marvel
0.900465
wealthi puritan
0.909927
wealthi inmat
0.913052
wealthi antiqu
0.906577
wealthi household
0.927168
wealthi younger
0.911735
wealthi tutor
0.909999
wealthi vigil
0.907050
wealthi furnish
0.900486
wealthi grandeur
0.901982
wealthi reckless
0.902873
wealthi titl
0.901131
wealthi murder
0.904266
wealthi vigour
0.910242
wealthi nobleman
0.905745
wealthi resid
0.900987
wealthi statur
0.905948
wealthi excel
0.900156
wealthi men
0.910685
wealthi rome
0.900139
wealthi physician
0.900525
wealthi won
0.904115
wealthi born
0.919610
wealthi irresist
0.903946
wealthi filthi
0.902587
wealthi aristocraci
0.910903
wealthi consult
0.903418
wealthi reconcili
0.904703
steep rocki
0.903865
steep rock
0.907583
steep stream
0.903373
stagger stumbl
0.903469
maid sad
0.905914
infect topic
0.903891
infect valuabl
0.901420
infect moder
0.907993
infect form
0.903701
infect abstract
0.901482
infect infus
0.901771
infect preval
0.901207
infect diseas
0.922947
infect accumul
0.914895
infect medium
0.905126
infect stimul
0.902554
infect collect
0.902787
infect predomin
0.900831
infect diet
0.904834
infect compos
0.912968
infect instanc
0.910635
infect instrument
0.907750
infect effect
0.916144
infect abund
0.907434
infect treatment
0.919404
infect weight
0.901330
infect implic
0.902982
infect case
0.915605
infect distinct
0.911740
infect special
0.903604
infect fabric
0.915181
infect gener
0.902323
infect design
0.907129
infect exampl
0.908500
infect diffus
0.922020
infect lastli
0.908638
infect prescrib
0.901722
infect process
0.902533
infect numer
0.908302
infect combin
0.902278
infect activ
0.900812
infect attain
0.903169
infect element
0.911887
infect durat
0.902230
infect practic
0.901282
infect employ
0.908134
infect ident
0.905361
infect method
0.906900
infect sourc
0.918784
infect excess
0.925405
infect cleanli
0.903084
infect transform
0.902931
infect superfici
0.912806
infect indic
0.906363
infect elast
0.906494
infect provid
0.908041
infect properli
0.917994
infect multipli
0.903010
infect isol
0.900192
infect harmoni
0.902619
infect matur
0.905958
infect action
0.912050
infect increas
0.904949
infect spontan
0.909318
infect compact
0.901412
infect condit
0.911681
infect thrive
0.903317
infect enrich
0.900755
infect ration
0.908757
infect mechan
0.900374
infect may
0.916361
infect abnorm
0.908003
infect instruct
0.902086
infect larger
0.903975
infect composit
0.900024
infect impli
0.903974
infect produc
0.905680
infect fewer
0.905792
infect separ
0.912654
infect satisfactori
0.906878
infect variou
0.913340
infect medicin
0.902916
infect suppli
0.903107
infect modern
0.904311
infect scope
0.902766
infect contact
0.900409
infect vari
0.909745
infect defin
0.901679
infect dimens
0.900558
infect contract
0.902983
infect qualiti
0.905376
infect either
0.910027
infect insuffici
0.905916
infect substanc
0.902867
infect omit
0.902778
infect imperfect
0.903684
infect degre
0.917500
infect suitabl
0.913853
infect proce
0.901273
infect philosophi
0.901971
infect digest
0.906752
infect comparison
0.903101
dive tumbl
0.913729
dive hem
0.903910
dive swim
0.901257
hitch bucket
0.911108
audibl perspir
0.906910
audibl deepen
0.911419
audibl faintli
0.901923
audibl clumsi
0.905011
audibl exclam
0.900955
audibl dismay
0.903336
audibl shabbi
0.905175
audibl gait
0.908400
audibl sombr
0.901162
audibl weird
0.902213
audibl dimli
0.903588
audibl sinist
0.918874
audibl grotesqu
0.904465
audibl brink
0.905085
audibl totter
0.908160
audibl sturdi
0.902922
audibl muffl
0.908986
audibl feebli
0.914555
audibl impass
0.912625
audibl curious
0.905208
audibl monoton
0.904374
audibl involuntarili
0.902906
audibl jet
0.900322
audibl omin
0.927953
audibl startl
0.904495
privi duke
0.912763
privi chancellor
0.915861
privi lordship
0.903999
astronom comput
0.905849
astronom accur
0.905670
astronom magnitud
0.904001
astronom contain
0.907146
astronom similar
0.908841
alp skeleton
0.901522
alp survey
0.901815
alp depict
0.910983
alp rustic
0.900419
sniff thump
0.902220
sniff bump
0.900548
prof connexion
0.908532
prof valu
0.914208
prof supernatur
0.916202
prof aristotl
0.915453
prof signifi
0.907573
prof graviti
0.907268
prof deduct
0.920006
prof exterior
0.911922
prof intellectu
0.917738
prof abundantli
0.919032
prof reproduc
0.916373
prof reaction
0.905832
prof socrat
0.906889
prof theme
0.902001
prof refer
0.915519
prof scienc
0.913555
prof scientif
0.915766
prof quot
0.911041
prof phenomenon
0.905111
prof test
0.904116
prof fundament
0.909888
prof thereto
0.903978
prof unchang
0.904634
prof psycholog
0.908386
prof percept
0.919510
prof definit
0.915376
prof procedur
0.910158
prof doctrin
0.928071
prof correspond
0.904746
prof stress
0.908622
prof accuraci
0.922725
prof logic
0.924237
prof subordin
0.917481
prof moral
0.913761
prof languag
0.907018
prof modifi
0.901595
prof neg
0.915673
prof poetic
0.903511
prof plato
0.913069
prof writer
0.911785
prof doe
0.913453
prof repetit
0.920215
prof can
0.901382
prof theori
0.933471
prof primit
0.901927
prof histori
0.902404
prof fabl
0.905689
prof reader
0.913202
prof evolv
0.909832
prof analysi
0.912871
prof civilis
0.903369
prof inher
0.926057
prof qualifi
0.918302
prof indirectli
0.901002
prof approb
0.900420
prof ethic
0.917762
prof sect
0.913236
prof systemat
0.910073
prof formula
0.919507
prof concept
0.919982
prof mathemat
0.921279
prof incident
0.908740
prof ha
0.922435
prof extinct
0.905899
prof class
0.913444
prof essenc
0.913483
prof proposit
0.920920
biodivers protocol
0.945774
biodivers environment
0.925179
biodivers wetland
0.988621
biodivers desertif
0.968683
biodivers ozon
0.994381
trait character
0.902836
trait literatur
0.901932
swarm plung
0.908498
swarm tremend
0.902169
swarm trampl
0.903989
swarm midday
0.903246
swarm crumbl
0.907393
swarm gorgeou
0.907811
swarm sway
0.907166
swarm empti
0.906578
swarm mingl
0.904079
experiment investig
0.910225
court servic
0.903252
wheel huge
0.906288
victoria graham
0.907323
victoria moscow
0.917578
victoria alexandria
0.906130
gdp overview
0.916187
steadfast snare
0.911932
steadfast pilgrimag
0.912416
steadfast triumphant
0.913392
steadfast verg
0.918056
steadfast proudli
0.914842
steadfast heed
0.912433
steadfast prop
0.907330
steadfast sting
0.916898
steadfast joy
0.906470
steadfast sooth
0.906684
steadfast deject
0.923902
steadfast chao
0.913631
steadfast joyou
0.910718
steadfast robber
0.904568
steadfast awe
0.912674
steadfast dismal
0.901658
steadfast cradl
0.903442
steadfast incens
0.903801
steadfast wither
0.906227
steadfast unseen
0.903436
steadfast wilder
0.903027
steadfast supplic
0.912504
steadfast pomp
0.906149
steadfast phantom
0.913297
steadfast curs
0.904508
steadfast sweetli
0.911000
steadfast pang
0.905673
steadfast enchant
0.905219
steadfast battlefield
0.900108
steadfast ponder
0.910888
steadfast befal
0.906300
steadfast wring
0.912236
steadfast naught
0.911192
steadfast exult
0.912302
steadfast wrestl
0.933059
steadfast sweat
0.901317
steadfast deadli
0.903809
steadfast mock
0.909360
steadfast hunger
0.906953
steadfast clip
0.904419
steadfast quench
0.918166
steadfast haughti
0.908408
steadfast toil
0.902583
steadfast remors
0.903425
steadfast defil
0.905217
steadfast kindl
0.907533
steadfast senseless
0.904061
steadfast frail
0.912674
steadfast eve
0.902132
steadfast postur
0.901248
steadfast quest
0.905847
steadfast amor
0.901970
steadfast thirsti
0.906942
radic social
0.904999
radic polit
0.905667
radic progress
0.907394
cheer heart
0.902574
cheer tongu
0.902462
cheer terribl
0.919840
cheer lighten
0.906080
cheer win
0.905335
cheer sore
0.912788
cheer token
0.906311
cheer wonder
0.901516
cheer die
0.905088
cheer buri
0.901775
cheer stricken
0.905277
cheer bore
0.905789
cheer asid
0.907806
cheer mourn
0.901169
cheer gentl
0.909391
cheer comrad
0.901828
cheer togeth
0.900485
cheer hear
0.903643
cheer grave
0.906806
cheer dread
0.927365
cheer play
0.903397
cheer grief
0.900090
cheer littl
0.901452
cheer swallow
0.903637
cheer affection
0.902942
cheer spi
0.911907
cheer friendli
0.905874
cheer smell
0.900060
cheer ear
0.900933
cheer brave
0.913313
cheer weari
0.912390
cheer old
0.910909
cheer guest
0.901084
cheer fair
0.906189
cheer coupl
0.907890
cheer afresh
0.911960
cheer pleasant
0.907439
cheer await
0.903315
cheer long
0.902955
cheer brother
0.916151
cheer wed
0.908112
cheer funer
0.900922
cheer utter
0.909237
cheer hearti
0.912479
cheer grace
0.902695
cheer hand
0.904573
cheer begin
0.902251
cheer meet
0.902396
cheer quiet
0.903865
cheer sight
0.912457
cheer wander
0.906053
cheer sport
0.909389
cheer welcom
0.913002
cheer overtak
0.905118
cheer sorrow
0.900930
cheer onc
0.907516
parcel stuff
0.904046
parcel amateur
0.907249
parcel ink
0.902519
parcel pit
0.901334
parcel neat
0.901040
parcel breech
0.908421
parcel duplic
0.900309
parcel parad
0.904279
parcel draught
0.907644
parcel put
0.907866
parcel explod
0.901581
parcel sack
0.902382
parcel rot
0.901871
parcel finish
0.901469
parcel till
0.901062
parcel chew
0.902512
parcel anywher
0.904492
parcel label
0.911186
parcel scrap
0.909362
parcel rubbish
0.904801
assess satellit
0.923236
twitch haggard
0.902712
twitch furtiv
0.905768
twitch blink
0.900661
twitch daze
0.907562
grim lash
0.902812
grim writh
0.907059
grim lap
0.901473
grim sheer
0.902968
grim bent
0.900069
grim glare
0.901542
grim tangl
0.900155
linen cloth
0.901585
linen mat
0.900366
linen wax
0.903485
linen fine
0.902314
face forehead
0.904389
face flush
0.910257
face eye
0.913804
stole stoop
0.906321
stole creep
0.903870
stole awak
0.900647
stole cloak
0.900989
conjunct specif
0.906808
conjunct denot
0.903571
conjunct impur
0.905795
conjunct varieti
0.906364
conjunct treatis
0.904146
conjunct ie
0.904597
conjunct scriptur
0.900002
conjunct number
0.901223
conjunct embodi
0.900380
conjunct decreas
0.900771
conjunct previous
0.901421
conjunct creation
0.901365
conjunct motion
0.902164
conjunct similarli
0.909568
conjunct intermedi
0.906144
conjunct creat
0.903400
conjunct insert
0.900881
conjunct analog
0.906544
conjunct hypothesi
0.904453
conjunct valid
0.906173
conjunct textur
0.903453
conjunct acquisit
0.904031
conjunct particl
0.905270
summer winter
0.921110
summer autumn
0.916484
outbreak reserv
0.902570
outbreak declin
0.901957
outbreak successor
0.901056
outbreak campaign
0.908504
outbreak subsequ
0.908990
go fetch
0.911694
go just
0.900182
go away
0.914081
go fellow
0.906719
go luck
0.906751
go stay
0.918489
go come
0.915645
go somewher
0.902456
muse forlorn
0.900897
muse fondli
0.914024
rail cart
0.911858
rail trap
0.900999
rail load
0.904932
rail drag
0.901996
rail knot
0.903579
rail pavement
0.900818
rail stand
0.907908
rail hedg
0.905257
rail push
0.909687
rail sailor
0.902159
rail bench
0.913341
rail mouth
0.900507
rail behind
0.905462
rail stout
0.902327
rail outsid
0.900924
rail mud
0.904062
rail strand
0.911432
rail down
0.901830
rail drop
0.907485
rail over
0.903587
rail hang
0.913292
rail pilot
0.900423
rail bolt
0.900578
rail smoke
0.900850
rail heel
0.910434
carv brass
0.901359
carv richli
0.914104
carv carpet
0.902484
carv vault
0.902956
carv picturesqu
0.910231
carv figur
0.900105
carv galleri
0.901159
carv marbl
0.912486
carv gild
0.904828
carv decor
0.915113
carv brick
0.907138
carv polish
0.902391
carv pillar
0.910527
carv roof
0.910501
carv loom
0.901757
carv damp
0.900338
sour harden
0.901104
sour stale
0.911001
ripe season
0.908869
ripe sow
0.900281
ripe fruit
0.905852
ripe root
0.902163
ripe sap
0.905704
ripe ripen
0.901206
ripe feed
0.914117
ripe plough
0.905452
ripe sharpen
0.901214
ripe worm
0.916351
ripe tool
0.902666
dozen half
0.914036
dozen off
0.902991
dozen pick
0.900526
symbol statu
0.900734
iron furnac
0.900317
iron middl
0.902466
edinburgh lincoln
0.907030
edinburgh hamilton
0.905698
edinburgh wale
0.910668
clerk lodg
0.907396
clerk late
0.901243
clerk offic
0.913245
midnight sunris
0.909831
midnight eleven
0.901530
midnight hour
0.912940
midnight corps
0.900358
midnight daylight
0.916944
midnight night
0.912729
pinch bite
0.901724
pinch prick
0.909536
pinch tie
0.908985
pinch bigger
0.901886
pinch scratch
0.911329
pinch shave
0.902639
pinch stiff
0.900316
hungari denmark
0.931341
hungari singapor
0.957127
hungari dominican
0.955183
hungari costa
0.946988
hungari iran
0.944659
hungari leon
0.947133
hungari vietnam
0.939947
hungari lebanon
0.960327
hungari czech
0.949243
hungari korea
0.946091
hungari malaysia
0.938634
hungari norway
0.930955
hungari morocco
0.963133
hungari algeria
0.942243
hungari cypru
0.957969
hungari iceland
0.978077
hungari bolivia
0.938354
hungari bulgaria
0.951259
hungari chad
0.948713
hungari guatemala
0.944568
hungari trinidad
0.941614
hungari ethiopia
0.948548
hungari poland
0.952632
hungari malta
0.969479
hungari liberia
0.933471
hungari georgia
0.946272
hungari saudi
0.946171
hungari madagascar
0.936976
hungari peru
0.966461
hungari uruguay
0.945853
hungari jamaica
0.965485
hungari syria
0.956576
hungari sweden
0.954918
hungari venezuela
0.946646
hungari chile
0.962252
hungari argentina
0.954916
hungari philippin
0.963415
hungari colombia
0.948153
hungari finland
0.959440
hungari indonesia
0.939182
hungari switzerland
0.945655
hungari armenia
0.965919
hungari brazil
0.962481
hungari romania
0.942988
hungari nigeria
0.939150
hungari panama
0.951849
hungari sudan
0.939632
hungari thailand
0.940045
hungari hondura
0.941891
hungari zealand
0.908785
hungari jordan
0.937604
hungari sierra
0.945398
hungari arabia
0.963938
hungari cote
0.946930
hungari portug
0.913461
hungari ukrain
0.958872
hungari pakistan
0.939032
hungari belgium
0.964139
hungari cuba
0.970915
hungari congo
0.946314
hungari japan
0.904508
hungari luxembourg
0.981260
reel sling
0.904774
reel tore
0.903448
reel gust
0.902566
wake sleep
0.913758
altern formerli
0.907851
altern inner
0.902961
altern temporarili
0.902825
mist sky
0.905510
mist horizon
0.900127
anxious reassur
0.903649
helmet armor
0.906385
strain stir
0.908808
strain smooth
0.904504
strain cool
0.910580
strain bruis
0.904730
muscl fibr
0.901457
quick stroke
0.902325
quick lightli
0.905340
quick shake
0.912315
pillow asleep
0.901456
yesterday nobodi
0.900826
yesterday sorri
0.907309
yesterday pen
0.900312
yesterday glad
0.903830
yesterday home
0.901563
yesterday rogu
0.910056
yesterday vex
0.913944
applaud adorn
0.904945
applaud afflict
0.927038
applaud invinc
0.901540
applaud antagonist
0.900248
applaud enrag
0.912674
applaud hero
0.911777
applaud rescu
0.914744
applaud combat
0.905986
applaud speedili
0.905041
applaud hostil
0.901403
applaud battl
0.904105
applaud exceedingli
0.931369
applaud dispel
0.914517
applaud array
0.905406
applaud vow
0.906787
applaud impel
0.903846
applaud duli
0.921758
applaud incap
0.935866
applaud valour
0.915051
applaud gratifi
0.929208
applaud verili
0.903365
applaud counsellor
0.918033
applaud abod
0.917962
applaud auster
0.909578
applaud destruct
0.904835
applaud achiev
0.911987
applaud divers
0.925063
applaud encount
0.904418
applaud incessantli
0.922294
applaud inflam
0.923564
applaud heroic
0.906366
applaud repeatedli
0.926093
applaud virtuou
0.911349
applaud depriv
0.930954
applaud recit
0.912226
applaud dissolut
0.909635
applaud energi
0.910710
wound threat
0.902012
wound summon
0.902323
wound stab
0.904457
wound fight
0.904074
wound signal
0.902133
dedic notabl
0.900562
dedic deceas
0.902807
dedic style
0.900179
earth maker
0.907196
earth dwell
0.903241
earth race
0.904966
earth heaven
0.917066
earth invis
0.904756
earth lengthen
0.904959
earth planet
0.903032
debt creditor
0.915008
leg neck
0.900150
leg head
0.903838
leg nose
0.900934
leg crack
0.906751
leg stick
0.911890
leg shirt
0.902868
leg toe
0.903972
leg pair
0.902890
garment wear
0.903856
garment fill
0.902581
garment terror
0.900856
garment sink
0.900044
garment jewel
0.902289
garment fare
0.900335
garment mask
0.902161
garment fire
0.902421
garment beast
0.901761
garment lock
0.901111
garment light
0.904340
garment beauti
0.900868
garment taper
0.900108
garment string
0.901713
garment wild
0.902688
garment garb
0.902876
garment peasant
0.909215
garment mantl
0.901299
garment devour
0.900149
garment perfum
0.905287
garment hide
0.901123
bubbl hatch
0.900145
bubbl odour
0.909284
bubbl suck
0.913154
bubbl soft
0.900337
uncov stool
0.902961
uncov hip
0.905155
uncov sheath
0.903808
uncov revolv
0.901104
uncov distort
0.902666
uncov scar
0.911665
uncov brillianc
0.900453
uncov partit
0.901340
uncov nail
0.904187
uncov blunt
0.900006
uncov wrap
0.903302
uncov lumin
0.904500
speedi harbour
0.902819
speedi workman
0.903719
speedi victor
0.907629
speedi scotch
0.908709
speedi travers
0.906046
dreami loneli
0.903796
dreami reveri
0.914183
deiti penanc
0.906218
deiti ordin
0.904746
deiti ordain
0.922811
deiti rite
0.919291
deiti cleans
0.908201
deiti creator
0.915496
deiti purifi
0.903000
deiti righteou
0.913384
deiti righteous
0.913544
deiti beget
0.901161
deiti chastis
0.902551
reckon nowaday
0.908641
reckon lucki
0.906492
reckon eat
0.906071
back slip
0.906155
back turn
0.911381
back stop
0.914093
back catch
0.904784
back knock
0.905037
back around
0.901243
back again
0.909085
back pocket
0.901756
associ period
0.903467
associ public
0.901313
associ tradit
0.901856
nineteen parisian
0.909805
nineteen sixti
0.906274
nineteen suburb
0.903634
nineteen seventi
0.906143
nineteen senior
0.900689
nineteen nineti
0.919978
nineteen theatric
0.900995
nineteen bachelor
0.900269
nineteen decidedli
0.903193
nineteen thirteen
0.911072
overhang slope
0.904543
clash tempest
0.901215
eighth fifth
0.932335
eighth inhabit
0.908856
eighth twelfth
0.917292
eighth seventh
0.928717
eighth articl
0.903067
eighth enclos
0.907322
eighth breadth
0.912018
eighth ninth
0.924281
eighth sixth
0.943583
eighth fourth
0.930731
tribe abound
0.907728
moonlight glimmer
0.903968
vii viii
0.943678
vii ix
0.902321
vii iv
0.904017
step pace
0.907465
step instantli
0.907430
step instant
0.903162
woman mistress
0.904714
woman young
0.901955
thunder lightn
0.921549
wharf ashor
0.902535
wharf barg
0.914859
wharf alongsid
0.911805
wharf ladder
0.901517
wharf haul
0.900933
wharf ditch
0.909588
wharf yacht
0.903588
wharf steamer
0.904779
wharf dock
0.923956
jove nought
0.903811
impetu baffl
0.914057
impetu feat
0.902828
impetu slaughter
0.909545
elderli blond
0.900588
elderli restaur
0.900623
elderli uncomfort
0.903703
frighten upset
0.903439
frighten look
0.909429
frighten quietli
0.902449
petticoat comb
0.903575
petticoat mess
0.900901
petticoat wink
0.902018
petticoat sneak
0.902858
petticoat sip
0.902782
petticoat rip
0.902793
petticoat waistcoat
0.906409
petticoat nap
0.907399
petticoat bust
0.902499
petticoat hug
0.906362
gape dust
0.902618
gape groan
0.900289
gape gnaw
0.906234
choir cloister
0.900704
westminst victual
0.902766
westminst coach
0.901699
westminst thenc
0.922752
law prohibit
0.901307
law statut
0.904588
law entitl
0.903118
law commonwealth
0.906116
law enact
0.903150
law exempt
0.916291
law slaveri
0.914151
law civil
0.915558
law despot
0.900375
germ evolut
0.904935
strangl frenzi
0.903054
strangl regain
0.900792
thick water
0.902785
thick wet
0.905037
thick cut
0.916461
thick downward
0.903696
thick hole
0.910291
thick skin
0.900293
thick thin
0.920583
thick turf
0.900222
thick flat
0.901802
constern escort
0.904205
constern entreati
0.908938
constern terrifi
0.919131
constern panic
0.912064
constern raid
0.901981
constern musket
0.904525
sing song
0.900303
liquid distil
0.901160
liquid dissolv
0.910348
darken gloomi
0.900342
darken shine
0.903399
darken veil
0.903335
darken gloom
0.908496
darken shadowi
0.915997
float hollow
0.900869
float pebbl
0.902437
silenc silent
0.917897
silenc moment
0.906738
ape art
0.902507
ape cupid
0.901839
tablespoon teaspoon
0.903228
noon dine
0.920467
noon supper
0.929170
noon dinner
0.924011
noon staid
0.909383
noon bed
0.910342
noon sup
0.917325
lamp dark
0.905229
fervent solemn
0.905280
fervent unspeak
0.904048
news hous
0.900199
news return
0.907740
news messag
0.908778
news shortli
0.907441
news spend
0.901106
rush shot
0.907192
rush fell
0.902626
portugues peninsula
0.917777
portugues hudson
0.901640
text descript
0.900324
text cite
0.901472
lift thrust
0.902464
lift throat
0.900033
delici deep
0.901302
delici exquisit
0.900634
delici dainti
0.906238
apostl christ
0.930930
apostl testament
0.907188
apostl discipl
0.906603
apostl gospel
0.924538
singer magic
0.903131
singer accent
0.900439
fuller quarri
0.900345
feast belli
0.902047
feast goodli
0.901720
feast templ
0.907836
feast bid
0.901679
feast oxen
0.909455
feast trumpet
0.908923
feast mirth
0.903924
feast prayer
0.906857
feast anew
0.905833
feast thither
0.902211
feast bloodi
0.905454
feast hast
0.908325
feast stead
0.918008
feast hail
0.904374
feast sung
0.909937
approxim aggreg
0.901023
format facilit
0.900140
format termin
0.909383
format construct
0.900605
moan shiver
0.900197
baggag ammunit
0.914475
baggag horseback
0.900056
keeper hospit
0.901346
keeper store
0.901565
keeper newli
0.911420
keeper steward
0.901184
keeper surgeon
0.903456
stomach food
0.904171
stomach bait
0.907468
stomach pore
0.902751
stomach soften
0.904494
stomach coars
0.907783
stomach patient
0.908813
stomach colour
0.900794
exposur smaller
0.904426
exposur flavour
0.900195
exposur merg
0.907312
exposur collector
0.906072
exposur item
0.904712
exposur outcom
0.910115
exposur damag
0.904834
exposur explos
0.900910
exposur sampl
0.905974
exposur heat
0.908273
exposur shorten
0.911635
exposur improv
0.901788
exposur imper
0.908629
exposur inabl
0.903594
exposur replac
0.904323
exposur acut
0.915066
exposur plaster
0.902712
exposur precipit
0.905543
exposur radiat
0.900835
exposur specimen
0.903372
exposur drill
0.901144
exposur atmospher
0.909833
teacher pupil
0.927271
teacher school
0.900338
monasteri abbey
0.906764
monasteri build
0.902118
monasteri fortifi
0.903059
joint adjust
0.910966
theolog historian
0.908041
theolog orthodox
0.902372
theolog univers
0.904749
christoph gilbert
0.907078
christoph bass
0.919024
christoph matthew
0.901470
christoph patrick
0.912545
christoph carolin
0.906267
christoph robinson
0.906175
christoph harvey
0.904696
christoph lawrenc
0.904629
sale dealer
0.906974
sale patent
0.902764
bloom bud
0.910371
bloom blossom
0.909483
ship board
0.907044
ship sail
0.910928
ship crew
0.900186
cock cellar
0.905599
cock trim
0.904926
warm cold
0.932205
warm brisk
0.908634
warm smoothli
0.906433
warm weather
0.913699
warm grate
0.900684
poet masterpiec
0.909067
poet vers
0.923055
poet poetri
0.929243
poet refin
0.900038
poet satir
0.900627
poet poem
0.901742
poet prose
0.902855
boundless serpent
0.905796
boundless realm
0.911851
boundless kindr
0.900177
boundless thrice
0.901918
boundless shrine
0.906094
boundless strife
0.905373
boundless dire
0.900101
rim thickli
0.900655
guinea australia
0.900342
guinea turkey
0.912302
guinea mexico
0.920074
heathen christian
0.905081
heathen prophet
0.912659
heathen resurrect
0.903161
heathen bibl
0.903750
heathen preach
0.914453
heathen proverb
0.915401
heathen insight
0.902601
heathen plagu
0.904957
brahmana ascet
0.945262
brahmana endu
0.909948
iaea ibrd
0.983096
iaea ilo
0.984496
iaea imf
0.908800
iaea imo
0.986509
iaea icao
0.980916
iaea oa
0.962379
iaea opcw
0.973770
iaea ifc
0.985259
iaea wto
0.967321
iaea interpol
0.972360
iaea unesco
0.979095
iaea wmo
0.985902
iaea fao
0.984695
pamphlet publish
0.916942
pamphlet sketch
0.902968
pamphlet magazin
0.901473
pamphlet copi
0.911333
pamphlet advoc
0.900053
pamphlet epoch
0.907019
pamphlet signatur
0.906046
pamphlet england
0.902760
pamphlet perus
0.914863
pamphlet nineteenth
0.913018
pamphlet introduct
0.906480
pamphlet summari
0.912861
pamphlet paragraph
0.902678
pamphlet print
0.903567
pamphlet aggress
0.902530
insid tight
0.900611
insid neatli
0.900688
insid pack
0.900723
vanquish slay
0.934453
vanquish tiger
0.923991
vanquish slain
0.927917
vanquish bull
0.915392
vanquish foremost
0.929100
vanquish prowess
0.907077
vanquish wrath
0.912995
vanquish foe
0.941156
vanquish sire
0.916217
twine nostril
0.900021
twine enclosur
0.901900
conting disput
0.900122
conting transfer
0.910756
conting deliveri
0.909720
conting administ
0.900376
conting contin
0.900013
conting concess
0.909947
conting organis
0.915797
conting concentr
0.905259
conting recommend
0.913906
conting select
0.902233
conting state
0.910224
conting evinc
0.905257
conting approv
0.900790
thousand four
0.901142
thousand seven
0.913075
thousand rent
0.905068
thousand citi
0.901320
thousand hundr
0.939273
thousand overthrow
0.900070
thousand nativ
0.900567
girdl silken
0.907910
diver heretofor
0.906016
diver dominion
0.901075
diver therein
0.920854
diver shew
0.911204
diver thereof
0.913905
diver jupit
0.902401
xii xi
0.936019
lord enquir
0.904241
recur relaps
0.907207
recur phase
0.902077
recur chang
0.900597
recur tempera
0.901946
recur crisi
0.900577
landladi parlour
0.910108
rain wind
0.915613
genial grow
0.902165
genial charm
0.900282
genial defianc
0.900883
closet wardrob
0.912739
report request
0.911191
report detain
0.901473
report permiss
0.905336
report postpon
0.905629
report speaker
0.900422
bearer address
0.903192
bearer salut
0.903134
slant flap
0.901752
slant tilt
0.903646
slant squat
0.909053
daughter sister
0.900727
daughter widow
0.912164
daughter marri
0.912150
daughter nephew
0.901038
daughter wife
0.905133
airport runway
0.992511
paint painter
0.913561
pastor church
0.903319
wondrou perchanc
0.905859
wondrou fiend
0.906257
wondrou harp
0.903354
wondrou aught
0.905357
wondrou babe
0.904319
broad fring
0.904606
germani itali
0.900964
white black
0.919662
gigant ornament
0.901440
gigant edific
0.911339
gigant resembl
0.900566
weed rake
0.901191
scotland holland
0.912555
scotland settlement
0.900757
rustl flutter
0.905823
se en
0.916667
muster galley
0.902675
gap ascent
0.900331
sanctifi sin
0.925693
moist dri
0.910396
moist moistur
0.913871
tumult clamor
0.905568
tumult stormi
0.901175
tumult sullen
0.900778
mighti behold
0.904951
campbel davi
0.906371
indebt recent
0.900547
indebt statesman
0.903255
turk arab
0.911446
northeast southwest
0.904390
shop pleasantli
0.904543
shop inn
0.903132
friday thursday
0.927820
friday morn
0.904913
friday monday
0.945966
friday saturday
0.927192
friday wednesday
0.941032
friday tuesday
0.934651
friday sunday
0.918737
fain ala
0.902487
fain bless
0.903619
fain discours
0.908792
fain knave
0.914932
fain pray
0.913093
candid term
0.905487
candid nomin
0.908064
candid provinci
0.901787
grass tree
0.905349
ribbon lace
0.916311
ribbon embroid
0.903456
ribbon dress
0.906632
ribbon velvet
0.901874
troop armi
0.928699
troop garrison
0.903060
troop detach
0.910887
troop fortress
0.900311
troop despatch
0.914525
invas frontier
0.900767
invas alli
0.902825
speck misti
0.903665
harrison walker
0.911348
harrison watson
0.909582
harrison roger
0.912757
woe bliss
0.902578
ware lent
0.903229
bedroom room
0.909325
athlet routin
0.910079
athlet musician
0.901237
athlet riddl
0.900232
baptism baptiz
0.911037
gallop saddl
0.906339
beer butcher
0.910016
haven elm
0.903409
town constabl
0.900609
town villag
0.900898
town neighborhood
0.903789
reluctantli departur
0.900261
shakespear homer
0.900774
player game
0.905939
domain vital
0.901480
domain aid
0.903516
domain protect
0.901798
rag pin
0.900185
furious terrif
0.910429
pulpit roman
0.904885
pulpit congreg
0.912348
breakfast afternoon
0.901524
niec cousin
0.901164
niec gover
0.902163
classic histor
0.911406
classic chronicl
0.904733
classic literari
0.908008
classic recreat
0.900560
classic centuri
0.906722
danc dancer
0.911593
monarchi royalti
0.907203
monarchi citizen
0.901996
monarchi patriot
0.920090
monarchi warfar
0.900267
monarchi empir
0.900861
anyhow anyway
0.910245
earn wage
0.901480
eastward westward
0.914016
eastward northward
0.905824
eastward southward
0.907709
chest sharp
0.903770
resign relinquish
0.919359
resign applaus
0.902020
north west
0.921223
north south
0.924610
north east
0.914968
committe session
0.902469
spear shield
0.908371
assassin regent
0.905722
assassin jesuit
0.902162
assassin emperor
0.903460
assassin heret
0.900386
bride bridegroom
0.926540
negoti stipul
0.902179
captur besieg
0.909433
captur headquart
0.900846
proclaim riot
0.902020
proclaim famin
0.903301
proclaim savag
0.904783
proclaim challeng
0.907527
proclaim decre
0.901851
sixteenth eighteenth
0.911070
sixteenth fifteenth
0.926594
sixteenth seventeenth
0.929096
sixteenth founder
0.904484
tread roam
0.900649
tread fearless
0.905254
tread fieri
0.913897
tread bosom
0.906036
toy tune
0.902727
drink barber
0.900950
ingredi mixtur
0.904105
unicamer percent
0.906738
decept lesser
0.919256
decept bounti
0.917672
decept assumpt
0.918670
decept loyalti
0.921164
northern southern
0.906250
son eldest
0.914756
thereaft rumor
0.907055
tailor tavern
0.903694
fleet laden
0.901044
stabl cattl
0.905611
stabl meal
0.902781
stabl hors
0.907327
independ liber
0.908326
independ result
0.902936
independ nation
0.903917
dazzl splendor
0.902012
dazzl illumin
0.907000
dazzl sparkl
0.901575
dazzl glitter
0.906502
dazzl stern
0.903610
dazzl majest
0.903078
dazzl radiant
0.901057
dazzl vision
0.903788
adjac circular
0.900383
nonsens afraid
0.903329
nonsens talk
0.900456
nonsens silli
0.920362
hog oat
0.900607
huddl drowsi
0.902624
huddl flare
0.904089
huddl crouch
0.908009
curtain ceil
0.900508
helena solomon
0.924083
estim countri
0.906402
estim avail
0.901411
estim cultiv
0.910858
ruler illustri
0.905077
oxford cambridg
0.912845
fuss grumbl
0.903037
fuss nasti
0.910116
council appoint
0.913110
desert plain
0.900881
dramat comedi
0.905983
dramat drama
0.912217
salon valet
0.900011
uneasili timidli
0.905920
glimps peep
0.900047
artilleri cavalri
0.912047
artilleri infantri
0.912658
bleed fountain
0.905983
initi seri
0.902316
initi base
0.901109
initi foreign
0.902894
coax youngster
0.902774
caress tenderli
0.915756
dear dearest
0.903237
fierc flee
0.905208
fierc speed
0.900860
fierc host
0.908615
fierc blaze
0.905986
fierc rage
0.919626
fierc uplift
0.900823
plane parallel
0.903407
enterpris sterl
0.900727
member assembl
0.901190
cardin princ
0.900361
hither tarri
0.904620
signor queri
0.901704
joke bulli
0.903917
physiolog secondari
0.905394
radio microwav
0.936998
radio relay
0.949525
needl thread
0.902291
meanwhil keen
0.901250
eagerli greet
0.901067
eagerli hungri
0.901759
hiss headlong
0.900619
jame thoma
0.907235
congratul announc
0.902196
transpar outlin
0.900388
wrinkl bald
0.913736
loaf brandi
0.906033
emphat emphasi
0.931626
emphat morbid
0.907253
waist skirt
0.907078
mix liquor
0.905209
wine ale
0.901472
sadli scold
0.905212
spanish french
0.904054
wing beam
0.903918
gleam glisten
0.900756
constitut govern
0.902749
snowi glide
0.900725
audienc lectur
0.902988
collar boot
0.903928
collar button
0.904988
collar sleev
0.901465
fli chase
0.903933
tub pot
0.908523
curl hair
0.917430
gold silver
0.909378
latin english
0.901891
hook hammer
0.900059
toss fling
0.905271
jaw teeth
0.902245
petti bond
0.907054
petti malign
0.904574
petti loyal
0.921875
petti whim
0.902242
variat variabl
0.902246
dug shovel
0.910606
quantiti palat
0.913523
quantiti ferment
0.917214
quantiti size
0.901696
ador pervad
0.901456
ador goddess
0.901998
ador illus
0.907809
persia arabian
0.927111
vapor ether
0.900024
nerv brain
0.912043
chat shi
0.907400
receipt payment
0.906975
shadow dim
0.906229
primari extern
0.902789
nile laurel
0.901759
hearken beseech
0.904827
uproar shower
0.902391
gem hue
0.903569
gem garland
0.919846
gem splendour
0.910720
pr imp
0.978490
europ america
0.902299
vessel remaind
0.903384
tooth flute
0.901426
tooth rib
0.900448
tanker refriger
0.926312
jew gentil
0.904113
jew hebrew
0.908228
manufactur product
0.901683
coventri batten
0.916445
coventri mightili
0.910812
plant seed
0.901643
xv xvi
0.908051
vainli hasten
0.904117
vainli linger
0.902774
upstair downstair
0.909083
thrill felt
0.901141
noun adject
0.900396
acid dilut
0.917949
acid carbon
0.906454
acid sulphur
0.912651
reform polici
0.901431
protest cathol
0.909126
mother father
0.922352
coward scoundrel
0.906772
coward damn
0.901169
mountain forest
0.902769
emphas problem
0.900842
reliabl normal
0.901654
reliabl grade
0.900172
treasuri commission
0.903463
promin vicin
0.900398
nois crowd
0.900912
florida danish
0.905514
inadequ facil
0.906753
shutter window
0.903026
shutter pane
0.921989
blade stalk
0.911680
blade cord
0.901034
herald renown
0.903652
oar steer
0.902433
angel heavenli
0.905206
angel almighti
0.900065
thou wilt
0.961323
foam aloft
0.901270
battalion regiment
0.914559
coron royal
0.901335
curli moustach
0.902654
ghost witch
0.902708
arjuna kuru
0.945089
love lover
0.907573
spencer thompson
0.900014
spencer webster
0.900999
parker anderson
0.907238
parker owen
0.911155
hurl pierc
0.901908
surfac compress
0.905678
sweep storm
0.901881
sweep beneath
0.905400
sweep shatter
0.913696
eden primros
0.909434
execut minist
0.900593
tack fore
0.903039
scorch snake
0.905358
brussel vienna
0.912106
salari weekli
0.901925
xiv xiii
0.903635
restless keenli
0.900855
restless brood
0.906331
stump strap
0.904063
italian grand
0.903532
alley saloon
0.900124
reef coral
0.916120
altar tomb
0.903026
get want
0.900281
get tri
0.900733
get somebodi
0.912431
get bit
0.900649
evapor solut
0.912901
architectur sculptur
0.902682
substanti expand
0.905653
tale stori
0.902768
cloud sun
0.900911
male femal
0.911058
scan shuffl
0.902501
martial warlik
0.919553
blend globe
0.900319
youth bitter
0.911820
nook shadi
0.905369
au par
0.912117
prone apollo
0.905242
underground laboratori
0.905211
vote elect
0.926560
vest canon
0.900123
onlin proofread
0.983049
stoni hillsid
0.902736
chanceri nw
0.912185
nsquared time:3.703720
cosines: 7327255
sims: 3664
total time:5.044032
runscriptUb.sh 0 → 100644
clean(){
while [ "$1" ]; do
./RIVread "$1"
shift
done
}
clean ../bookCleaner/cleanbooks/*
speedtest.c deleted 100644 → 0
#include <stdio.h>
#define RIVSIZE 25000
#include "RIVtoolsCPUlinux.h"
#include <time.h>
#define iterations 500
int main(){
RIVInit();
FILE* numba1 = fopen("testfolder/numba1.txt", "r");
FILE* numba2 = fopen("testfolder/numba2.txt", "r");
if(numba1){
puts("numba1 opened successfully");
}if(numba1){
puts("numba1 opened successfully");
}
sparseRIV first = fileToL2(numba1);
sparseRIV second = fileToL2(numba2);
first.magnitude = getMagnitudeSparse(first);
denseRIV second2 = denseAllocate();
second2.values = addS2D(second2.values, second);
second2.magnitude = getMagnitudeSparse(second);
clock_t begintotal = clock();
for(int i=0; i<iterations; i++){
cosCompare(second2, first);
}
clock_t endtotal = clock();
double time_spent = (double)(endtotal - begintotal) / CLOCKS_PER_SEC;
}
testfolder/numba1.txt deleted 100644 → 0
rabi_noun s._noun de_noun rabide@yahoo.com prospect_noun place_noun home_noun bellaire_noun tx_noun work_noun
objective_noun financial_adjective engineering_noun position_noun energy_noun trading_noun finance_noun
profile_noun over_other ten_noun year_noun diverse_adjective experience_noun risk_noun analysis_noun management_noun energy_noun sector_noun last_adjective four_noun which_other be_verb trading_noun finance_noun
analytical_noun quantitative_adjective skill_noun structuring_noun pricing_noun energy_noun derivative_noun
expertise_noun trading_noun derivative_noun development_noun trade_noun analytic_noun exposure_noun management_noun risk_verb structure_verb e&p_noun project_noun finance_noun transaction_noun
experience_noun shell_noun capital_noun inc._noun houston_noun tx_noun
present_adjective vice_noun president_noun reports_noun chief_noun financial_noun officer_noun responsible_adjective devise_verb strategy_noun manage_verb price_verb market_noun credit_noun risk_noun within_other structured_adjective transaction_noun
design_verb execute_verb oil_noun gas_noun hedge_noun eight_noun domestic_adjective two_noun international_adjective transaction_noun involve_verb over_other million_noun capital_noun risk_noun
develop_verb implement_verb framework_noun identification_noun mitigation_noun pricing_noun risk_noun producer_noun finance_noun transaction_noun
provide_verb sophisticated_adjective simulation_noun modeling_noun support_noun financial_adjective engineering_noun solution_noun e&p_noun finance_noun leasing_noun small_adjective business_noun finance_noun
led_verb development_noun computational_adjective infrastructure_noun risk_noun modeling_noun pricing_noun
shell_noun oil_noun products_noun company_noun houston_noun tx_noun
trade_noun analytics_noun developer_noun derivatives_noun trader_noun traded_noun future_noun option_noun otc_noun derivative_noun crude_adjective oil_noun heating_noun oil_noun gasoline_noun
manage_verb net_adjective hydrocarbon_noun exposure_noun company_noun
develop_verb analytic_noun identify_verb speculative_adjective program_noun trading_noun opportunity_noun e.g._other refinery_noun margin_noun protection_noun
carry_verb out_adverb simulation_noun back_adverb testing_noun risk_noun adjusted_adjective performance_noun measurement_noun trading_noun strategy_noun
price_verb embedded_adjective cap_noun devise_verb strategy_noun option_noun replication_noun dynamic_adjective hedging_noun
shell_noun e&p_noun technology_noun company_noun houston_noun tx_noun
senior_noun research_noun engineer_noun research_noun engineer_noun use_verb reliability_noun analysis_noun solve_verb wide_adjective variety_noun engineering_noun problem_noun
model_verb environmental_adjective structural_adjective response_noun develop_verb design_noun code_noun criterion_noun carry_verb out_adverb decision_noun analysis_noun under_other uncertainty_noun surface_noun system_noun selection_noun etc._other
deliver_verb enable_verb technology_noun risk-based_adjective design_noun recipe_noun development_noun complex_adjective engineering_noun system_noun range_verb billion-dollar_adjective tension_noun leg_noun platform_noun requalification_noun aging_noun fleet_noun offshore_adjective jacket_noun structure_noun
brown_adjective root_noun inc._noun houston_noun tx_noun
naval_noun architect_noun software_noun troubleshooter_noun carry_verb out_adverb naval_noun architectural_noun design_noun motion_noun response_noun modeling_noun downtime_noun analysis_noun environmental_adjective datum_noun base_noun management_noun software_noun development_noun maintenance_noun support_noun offshore_adjective structure_noun design_noun construction_noun
education_noun university_noun california_noun berkeley_noun ca_noun
ph.d._noun naval_noun architecture_noun offshore_noun engineering_noun minor_noun statistics_noun structure_noun thesis_noun offshore_noun structural_noun system_noun reliability_noun wave-load_noun modeling_noun system_noun behavior_noun analysis_noun
probabilistically_adverb model_verb multidimensional_adjective hazard_noun effect_noun performance_noun complicated_adjective system_noun develop_verb methodology_noun characterize_verb system_noun failure_noun risk_noun
work_verb research_noun associate_noun reliability_noun marine_noun structures_noun center_noun stanford_noun university_noun consultant_noun offshore_adjective oil_noun gas_noun industry_noun
university_noun california_noun berkeley_noun ca_noun
m.s._noun naval_noun architecture_noun offshore_noun engineering_noun minor_noun statistics_noun structure_noun thesis_noun simulation_noun random_noun seaway_noun towing_noun tank_noun random_noun walk_verb frequency_noun method_noun
work_verb research_noun assistant_noun develop_verb software_noun time_noun series_noun analysis_noun model_noun testing_noun calibration_noun
indian_noun institute_noun technology_noun kharagpur_noun india_noun
b.tech._noun naval_noun architecture_noun graduate_verb first_adjective class_noun honor_noun rank_verb first_adverb class_noun
relevant_adjective training_noun credit_noun risk_noun modeling_noun stanford_noun university_noun stanford_noun ca_noun
october_noun finance_noun accounting_noun executive_noun rice_noun university_noun houston_noun tx_noun
august_noun training_noun modules_noun product_noun knowledge_noun structured_noun project_noun finance_noun securitization_noun credit_noun strategy_noun in-house_noun training_noun dc_noun gardener_noun euromoney_noun
january_noun april_noun risk_noun risk_noun conference_noun washington_noun d.c._noun june_noun economics_noun supply_noun refining_noun marketing_noun stone_noun bond_noun corp._noun houston_noun tx_noun
april_noun understand_verb apply_verb financial_adjective mathematics_noun energy_noun derivative_noun efficient_adjective pricing_noun trading_noun risk_noun management_noun risk_noun conferences_noun new_noun york_noun ny_noun
march_noun practical_noun strategic_noun application_noun var_noun energy_noun industries_noun risk_noun conferences_noun houston_noun tx_noun
december_noun financial_noun modeling_noun s-plus_noun mathsoft_noun new_noun york_noun ny_noun
october_noun option_noun analytic_noun pricing_noun option_noun exotic_noun options_noun cibc_noun school_noun financial_noun products_noun houston_noun tx_noun
september_noun fundamental_noun energy_noun basis_noun trading_noun princeton_noun energy_noun houston_noun tx_noun
feb_noun energy_noun derivatives_noun price_noun risk_noun management_noun energy_noun institute_noun univ._noun houston_noun houston_noun tx_noun
january_noun april_noun latest_adjective development_noun advanced_noun mathematics_noun derivative_noun risk_noun conference_noun new_noun york_noun ny_noun
december_noun options_noun seminar_noun nymex_noun houston_noun tx_noun
october_noun
select_verb honors_noun activities_noun present_verb seminar_noun credit_noun risk_noun e&p_noun mezzanine_noun finance_noun global_noun association_noun risk_noun professional_noun houston_noun chapter_noun tx_noun
june_noun special_adjective recognition_noun award_noun shell_noun oil_noun products_noun company_noun
committee_noun membership_noun panelist_noun author_noun lecturer_noun publication_noun reviewer_noun etc._other
asce_noun api_noun otc_noun asme_noun omae_noun etc._other
receive_verb omae_noun award_noun american_noun society_noun mechanical_adjective engineering_noun recognition_noun outstanding_adjective originality_noun significance_noun paper_noun title_verb development_noun reliability-based_adjective global_adjective design_noun equation_noun tension_noun leg_noun platforms_noun
short_adjective course_noun instructor_noun seminar_noun speaker_noun university_noun texas_noun austin_noun rice_noun university_noun university_noun houston_noun
sea_noun grant_noun association_noun award_noun excellence_noun research_noun sea_noun grant_noun association_noun usa_noun
institute_noun silver_noun medal_noun indian_noun institute_noun technology_noun kharagpur_noun india_noun
national_noun science_noun talent_noun search_verb scholarship_noun government_noun india_noun
personal_adjective data_noun date_noun birth_noun september_noun us_noun citizen_noun marry_verb one_noun child_noun
reference_noun available_adjective upon_other request_noun
document_noun properties_noun title_noun rabi_noun s_noun author_noun shell_noun chemical_noun company_noun template_noun normal_adjective last_adjective save_verb grady_adjective revision_noun number_noun application_noun microsoft_noun word_noun
total_adjective editing_noun time_noun last_adjective print_verb create_verb last_adjective save_verb company_noun shell_noun chemical_noun company_noun
testfolder/numba2.txt deleted 100644 → 0
meet_verb discuss_verb non-grid_adjective am_noun process_verb attendee_noun julia_noun lynn_noun steve_noun sheila_noun
calendar_noun entry_noun appointment_noun
description_noun meet_verb discuss_verb non-grid_adjective am_noun process_verb attendee_noun julia_noun lynn_noun steve_noun sheila_noun jerry_noun conference_noun room_noun
date_noun time_noun pm_noun pm_noun central_noun standard_noun time_noun
detailed_adjective description_noun united_noun states_noun license_noun
wordList.txt 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment