public class Weight
extends java.lang.Object
| Modifier and Type | Class and Description |
|---|---|
static class |
Weight.WeightingScheme |
| Modifier and Type | Field and Description |
|---|---|
static double |
pmiAlphaAlpha |
static double |
pmiDiscDiscount |
static double |
spmiK |
static Weight.WeightingScheme |
weightingScheme |
| Constructor and Description |
|---|
Weight() |
| Modifier and Type | Method and Description |
|---|---|
static double |
addedValue(double fxy,
double fx,
double fy,
double N)
This method computes the Added value weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
allr(double fxy,
double fx,
double fy,
double N)
This method computes the Additive log-likelihood ratio based (allr) weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static void |
applyWeightingScheme()
This function calculates all the necessary weights for the word vectors.
|
static <T,V> void |
applyWeightingScheme(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap,
java.util.HashMap<V,java.lang.Long> tuplesMap2,
java.util.HashMap<T,java.lang.Double> frequency1Map,
java.util.HashMap<V,java.lang.Double> frequency2Map,
java.util.HashMap<T,java.lang.Double> frequency1MapOfGivenPOS,
java.util.HashMap<V,java.lang.Double> informationMap,
java.util.HashMap<V,java.lang.Double> entropyMap,
java.util.HashMap<V,java.lang.Double> grefFeatureWeightMap,
java.util.HashMap<V,java.lang.Double> atcFeatureWeightMap,
double allRelationCountOfGivenType,
double allRelationCountOfGivenTypeAlpha,
double allRelationCount,
java.util.HashMap<T,java.lang.Double> vectorElementSumMap,
java.lang.Double avgWordVectorElementSum,
java.lang.Double maxWordFeaturePairFrequency,
long allWordTypeCount,
long allFeatureDocFreqCount)
This function calculates the weight for (word, feature) pairs stored in @param tuplesMap.
|
static double |
binLH(double fxy,
double fx,
double fy,
double N)
This method computes the binomial-likelihood weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
certainty(double fxy,
double fx,
double fy,
double N)
This method computes the Certainty factor weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
chiSquare(double fxy,
double fx,
double fy,
double N)
This method computes the chi-square weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
chiSquareWYCC(double fxy,
double fx,
double fy,
double N)
This method computes the chi-square with Yates' continuity correction weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
cohenKappa(double fxy,
double fx,
double fy,
double N)
This method computes the Cohen's Kappa weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static void |
computeAllFeatureDocFreqCounts()
This method computes sum of the feature document frequencies for all types of features.
|
static <V> long |
computeAllFeatureDocFreqCounts(java.util.HashMap<V,java.lang.Long> frequencyMap)
This function calculates the sum of the feature document frequencies in @param frequencyMap.
|
static void |
computeAllRelationCountOfGivenTypeAlphas()
This method calculates the sum of the feature frequencies rasied to the power pmiAlphaAlpha for all types of features.
|
static <V> java.lang.Double |
computeAllRelationCountOfGivenTypeAlphas(java.util.HashMap<V,java.lang.Double> frequencyMap)
This function calculates the sum of the feature frequencies rasied to the power pmiAlphaAlpha in @param frequencyMap.
|
static void |
computeAtcFeatureWeightForFeatures()
This method computes the ATC feature weight of features for all types of features.
|
static <T,V> void |
computeAtcFeatureWeightForFeatures(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap,
java.util.HashMap<V,java.lang.Long> tuplesMap2,
double allCount,
java.lang.Double maxWordFeaturePairFrequency,
java.util.HashMap<V,java.lang.Double> atcFeatureWeightMap)
This function calculates ATC feature weight of features stored in @param frequency2Map.
|
static void |
computeAvgWordVectorElementSums()
This method computes the average word vector length.
|
static void |
computeEntropyForFeatures()
This method computes the entropy of features as defined in "Rapp, 2003, Word Sense Discovery Based on Sense Descriptor Dissimilarity" for all types of features.
|
static <T,V> void |
computeEntropyForFeatures(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap,
java.util.HashMap<V,java.lang.Double> frequency2Map,
java.util.HashMap<V,java.lang.Double> entropyMap)
This method computes the entropy of features as defined in "Rapp, 2003, Word Sense Discovery Based on Sense Descriptor Dissimilarity" for a given type of features.
|
static void |
computeGrefFeatureWeightForFeatures()
This method computes Grefenstette's feature weight of features as defined in "Curran, 2004, From distributional to semantic similarity" for all types of features.
|
static <T,V> void |
computeGrefFeatureWeightForFeatures(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap,
java.util.HashMap<V,java.lang.Double> frequency2Map,
java.util.HashMap<V,java.lang.Double> grefFeatureWeightMap)
This function calculates Grefenstette's feature weight of features stored in @param frequency2Map.
|
static void |
computeInformationForFeatures()
This method computes the information content of features as defined in "Lin, 1998, An information-theoretic definition of similarity" for all types of features.
|
static <T> void |
computeInformationForFeatures(java.util.HashMap<T,java.lang.Long> tuplesMap,
java.util.HashMap<T,java.lang.Double> informationMap,
long allCount)
This function calculates the information content of features stored in @param tuplesMap.
|
static void |
computeMaxWordFeaturePairFrequencies()
This method computes the maximum word-feature pair frequencies for all types of features.
|
static <T,V> java.lang.Double |
computeMaxWordFeaturePairFrequencies(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap)
This function calculates the maximum word-feature pair frequency in @param tuplesMap.
|
static <T,V> double |
computeWeight(T word1,
V word2,
java.util.HashMap<V,java.lang.Double> word1Table,
java.util.HashMap<V,java.lang.Long> tuplesMap2,
java.util.HashMap<T,java.lang.Double> frequency1Map,
java.util.HashMap<V,java.lang.Double> frequency2Map,
java.util.HashMap<T,java.lang.Double> frequency1MapOfGivenPOS,
java.util.HashMap<V,java.lang.Double> informationMap,
java.util.HashMap<V,java.lang.Double> entropyMap,
java.util.HashMap<V,java.lang.Double> grefFeatureWeightMap,
java.util.HashMap<V,java.lang.Double> atcFeatureWeightMap,
double allRelationCountOfGivenType,
double allRelationCountOfGivenTypeAlpha,
double allRelationCount,
java.util.HashMap<T,java.lang.Double> vectorElementSumMap,
java.lang.Double avgWordVectorElementSum,
java.lang.Double maxWordFeaturePairFrequency,
long allWordTypeCount,
long allFeatureDocFreqCount)
This function calculates the weight for a (word, feature) pair.
|
static double |
confidence(double fxy,
double fx,
double fy,
double N)
This method computes the confidence weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
driverKroeber(double fxy,
double fx,
double fy,
double N)
This method computes the Driver-Kroeber weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
fager(double fxy,
double fx,
double fy,
double N)
This method computes the Fager weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
gini(double fxy,
double fx,
double fy,
double N)
This method computes the Gini index weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
gMean(double fxy,
double fx,
double fy,
double N)
This method computes the geometric mean weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
hamann(double fxy,
double fx,
double fy,
double N)
This method computes the Hamann weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
hypLH(double fxy,
double fx,
double fy,
double N)
This method computes the hypergeometric-likelihood weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
jaccard(double fxy,
double fx,
double fy,
double N)
This method computes the Jaccard weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
jMeasure(double fxy,
double fx,
double fy,
double N)
This method computes the J measure weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
kappa(double fxy,
double fx,
double fy,
double N)
This method computes the Kappa weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
krippendorffAlpha(double fxy,
double fx,
double fy,
double N)
This method computes the Krippendorff's alpha weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
kulczynski1(double fxy,
double fx,
double fy,
double N)
This method computes the Kulczynski weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
kulczynski2(double fxy,
double fx,
double fy,
double N)
This method computes the Kulczynski weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
laplace(double fxy,
double fx,
double fy,
double N)
This method computes the Laplace weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
liddell(double fxy,
double fx,
double fy,
double N)
This method computes the Liddell weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
logLFunctionInsideLogLikelihood(double k,
double n,
double x)
This is the logL function used inside the logLikelihood function as described in "Manning and Schütze, 2000, Foundations of Statistical Natural Language Processing, p. 173"
|
static double |
logLikelihood(double c1,
double c2,
double c12,
double N)
This function computes the log likelihood ratio of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
ltu(double fij,
double vectorElementSum,
double avgWordVectorElementSum,
double nj,
double N)
This method computes the LTU weight of a (word, feature) pair.
|
static double |
minPmiTTest1(double fxy,
double fx,
double fy,
double N)
This method computes the min(Pmi,T-test1) weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
minPmiTTest2(double fxy,
double fx,
double fy,
double N)
This method computes the min(Pmi,T-test2) weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
minSens(double fxy,
double fx,
double fy,
double N)
This method computes the minimum sensitivity weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
mutualInformation(double fxy,
double fx,
double fy,
double N)
This method computes the mutual information of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
ngd(double fxy,
double fx,
double fy,
double N)
This method computes the NgdMOD weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
oddsRatio1(double fxy,
double fx,
double fy,
double N)
This method computes the odds-ratio1 weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
oddsRatio2(double fxy,
double fx,
double fy,
double N)
This method computes the odds-ratio2 weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
okapi1(double fij,
double vectorElementSum,
double avgWordVectorElementSum,
double nj,
double N)
This method computes the Okapi BM25 weight of a (word, feature) pair.
|
static double |
okapi2(double fij,
double vectorElementSum,
double avgWordVectorElementSum,
double nj,
double N)
This method computes the Okapi BM25 weight of a (word, feature) pair.
|
static double |
okapi3(double fij,
double vectorElementSum,
double avgWordVectorElementSum,
double nj,
double N)
This method computes the Okapi BM25 weight of a (word, feature) pair.
|
static double |
pearson(double fxy,
double fx,
double fy,
double N)
This method computes the Pearson weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
phi(double fxy,
double fx,
double fy,
double N)
This method computes the phi weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
piaterskyShapiro(double fxy,
double fx,
double fy,
double N)
This method computes the Piatersky-Shapiro weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
pmiWdfDisc(double fxy,
double fx,
double fy)
This method computes the PmiWdf discounting factor of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
poissonLH(double fxy,
double fx,
double fy,
double N)
This method computes the poisson-likelihood weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
poissonSig(double fxy,
double fx,
double fy,
double N)
This method computes the poisson significance weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
poissonStirlingLH(double fxy,
double fx,
double fy,
double N)
This method computes the poisson-stirling-likelihood weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
relRisk(double fxy,
double fx,
double fy,
double N)
This method computes the relative risk weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
rogersTanimoto(double fxy,
double fx,
double fy,
double N)
This method computes the Rogers-Tanimoto weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
scottPi(double fxy,
double fx,
double fy,
double N)
This method computes the Scott's Pi weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
simpleLL(double fxy,
double fx,
double fy,
double N)
This method computes the simple log likelihood weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
sokalMichiner(double fxy,
double fx,
double fy,
double N)
This method computes the Sokal-Michiner weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
sokalSneath1(double fxy,
double fx,
double fy,
double N)
This method computes the Sokal-Sneath weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
sokalSneath2(double fxy,
double fx,
double fy,
double N)
This method computes the Sokal-Sneath weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
sokalSneath3(double fxy,
double fx,
double fy,
double N)
This method computes the Sokal-Sneath weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
sqLogLikelihood(double fxy,
double fx,
double fy,
double N)
This method computes the squared log likelihood ratio weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
tCombCost(double fxy,
double fx,
double fy,
double N)
This method computes the T combined cost weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
tTest1(double fxy,
double fx,
double fy,
double N)
This method computes the t-test weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
tTest2(double fxy,
double fx,
double fy,
double N)
This method computes the t-test weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
tTest3(double fxy,
double fx,
double fy,
double N)
This method computes the t-test weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
uniSubtuples(double fxy,
double fx,
double fy,
double N)
This method computes the Unigram subtuples weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
yulleQ(double fxy,
double fx,
double fy,
double N)
This method computes the Yulle's Q weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
yulleW(double fxy,
double fx,
double fy,
double N)
This method computes the Yulle's W weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
zTest1(double fxy,
double fx,
double fy,
double N)
This method computes the z-test weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
zTest2(double fxy,
double fx,
double fy,
double N)
This method computes the z-test weight of a (word, feature) pair based on the frequencies given as input parameters.
|
static double |
zTest3(double fxy,
double fx,
double fy,
double N)
This method computes the z-test weight of a (word, feature) pair based on the frequencies given as input parameters.
|
public static Weight.WeightingScheme weightingScheme
public static double pmiAlphaAlpha
public static double spmiK
public static double pmiDiscDiscount
public static void applyWeightingScheme()
public static <T,V> void applyWeightingScheme(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap, java.util.HashMap<V,java.lang.Long> tuplesMap2, java.util.HashMap<T,java.lang.Double> frequency1Map, java.util.HashMap<V,java.lang.Double> frequency2Map, java.util.HashMap<T,java.lang.Double> frequency1MapOfGivenPOS, java.util.HashMap<V,java.lang.Double> informationMap, java.util.HashMap<V,java.lang.Double> entropyMap, java.util.HashMap<V,java.lang.Double> grefFeatureWeightMap, java.util.HashMap<V,java.lang.Double> atcFeatureWeightMap, double allRelationCountOfGivenType, double allRelationCountOfGivenTypeAlpha, double allRelationCount, java.util.HashMap<T,java.lang.Double> vectorElementSumMap, java.lang.Double avgWordVectorElementSum, java.lang.Double maxWordFeaturePairFrequency, long allWordTypeCount, long allFeatureDocFreqCount)
T
- the type of keys in @param tuplesMapV
- the type of values in @param tuplesMaptuplesMap
- the map containing the (word, feature) pairstuplesMap2
- the map containing the number of words with which the features occurfrequency1Map
- the map containing the frequency of words in the given type of relationfrequency2Map
- the map containing the frequency of features in the given type of relationfrequency1MapOfGivenPOS
- the map containing the frequency of words of a given POSinformationMap
- the map containing the information content of the featuresentropyMap
- the map containing the entropy of featuresgrefFeatureWeightMap
- the map containing Grefenstette's feature weight of the featuresatcFeatureWeightMap
- the map containing ATC feature weight of the featuresallRelationCountOfGivenType
- the count of all the relations of the given typeallRelationCountOfGivenTypeAlpha
- the sum of the feature frequencies rasied to the power pmiAlphaAlpha of the given typeallRelationCount
- the count of all the relations of all types for the given POSvectorElementSumMap
- a map containing the vector element sums of words for a given POSavgWordVectorElementSum
- the average word vector element sum of a given POSmaxWordFeaturePairFrequency
- the maximum word-feature pair frequencyallWordTypeCount
- the count of all the word types of the given POSallFeatureDocFreqCount
- the sum of the feature document frequencies of a given typepublic static <T,V> double computeWeight(T word1, V word2, java.util.HashMap<V,java.lang.Double> word1Table, java.util.HashMap<V,java.lang.Long> tuplesMap2, java.util.HashMap<T,java.lang.Double> frequency1Map, java.util.HashMap<V,java.lang.Double> frequency2Map, java.util.HashMap<T,java.lang.Double> frequency1MapOfGivenPOS, java.util.HashMap<V,java.lang.Double> informationMap, java.util.HashMap<V,java.lang.Double> entropyMap, java.util.HashMap<V,java.lang.Double> grefFeatureWeightMap, java.util.HashMap<V,java.lang.Double> atcFeatureWeightMap, double allRelationCountOfGivenType, double allRelationCountOfGivenTypeAlpha, double allRelationCount, java.util.HashMap<T,java.lang.Double> vectorElementSumMap, java.lang.Double avgWordVectorElementSum, java.lang.Double maxWordFeaturePairFrequency, long allWordTypeCount, long allFeatureDocFreqCount)
T
- the type of keys in @param tuplesMapV
- the type of values in @param tuplesMapword1
- the wordword2
- the featureword1Table
- the map containing the features with frequencies for wordtuplesMap2
- the map containing the number of words with which the features occurfrequency1Map
- the map containing the frequency of words in the given type of relationfrequency2Map
- the map containing the frequency of features in the given type of relationfrequency1MapOfGivenPOS
- the map containing the frequency of words of a given POSinformationMap
- the map containing the information content of the featuresentropyMap
- the map containing the entropy of featuresgrefFeatureWeightMap
- that map that will contain Grefenstette's feature weight of the featuresallRelationCountOfGivenType
- the count of all the relations of the given typeallRelationCountOfGivenTypeAlpha
- the sum of the feature frequencies rasied to the power pmiAlphaAlpha of the given typeallRelationCount
- the count of all the relations of all types for the given POSatcFeatureWeightMap
- the map containing ATC feature weight of the featuresvectorElementSumMap
- a map containing the vector element sumps of words for a given POSavgWordVectorElementSum
- the average word vector element sum of a given POSmaxWordFeaturePairFrequency
- the maximum word-feature pair frequencyallWordTypeCount
- the count of all the word types of the given POSallFeatureDocFreqCount
- the sum of the feature document frequencies of a given typepublic static double mutualInformation(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double pmiWdfDisc(double fxy, double fx, double fy)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature ypublic static double logLikelihood(double c1, double c2, double c12, double N)
c1
- the frequency of word xc2
- the frequency of feature yc12
- the frequency with which word x and feature y co-occurN
- the count of all the relations of the given typepublic static double logLFunctionInsideLogLikelihood(double k, double n, double x)
k
- kn
- nx
- xpublic static double hypLH(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double binLH(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double poissonLH(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double poissonStirlingLH(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double poissonSig(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double sqLogLikelihood(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double sokalMichiner(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double rogersTanimoto(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double hamann(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double sokalSneath1(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double sokalSneath2(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double sokalSneath3(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double kulczynski1(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double kulczynski2(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double yulleW(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double yulleQ(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double driverKroeber(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double pearson(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double fager(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double uniSubtuples(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double tCombCost(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double phi(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double kappa(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double jMeasure(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double gini(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double confidence(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double laplace(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double piaterskyShapiro(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double certainty(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double addedValue(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double tTest1(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double tTest2(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double tTest3(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double zTest1(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double zTest2(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double zTest3(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double simpleLL(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double allr(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double chiSquare(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double chiSquareWYCC(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double okapi1(double fij, double vectorElementSum, double avgWordVectorElementSum, double nj, double N)
fij
- the frequency with which word i and feature j co-occurvectorElementSum
- the element sum of the current word vectoravgWordVectorElementSum
- the average word vector element sum of a given POSnj
- the type frequency of feature jN
- the count of all the relations of the given typepublic static double okapi2(double fij, double vectorElementSum, double avgWordVectorElementSum, double nj, double N)
fij
- the frequency with which word i and feature j co-occurvectorElementSum
- the element sum of the current word vectoravgWordVectorElementSum
- the average word vector element sum of a given POSnj
- the type frequency of feature jN
- the count of all the relations of the given typepublic static double okapi3(double fij, double vectorElementSum, double avgWordVectorElementSum, double nj, double N)
fij
- the frequency with which word i and feature j co-occurvectorElementSum
- the element sum of the current word vectoravgWordVectorElementSum
- the average word vector element sum of a given POSnj
- the type frequency of feature jN
- the count of all the relations of the given typepublic static double ltu(double fij, double vectorElementSum, double avgWordVectorElementSum, double nj, double N)
fij
- the frequency with which word i and feature j co-occurvectorElementSum
- the element sum of the current word vectoravgWordVectorElementSum
- the average word vector element sum of a given POSnj
- the type frequency of feature jN
- the count of all the relations of the given typepublic static double relRisk(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double liddell(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double jaccard(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double gMean(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double minSens(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double oddsRatio1(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double oddsRatio2(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double minPmiTTest1(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double minPmiTTest2(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double krippendorffAlpha(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double scottPi(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double cohenKappa(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static double ngd(double fxy, double fx, double fy, double N)
fxy
- the frequency with which word x and feature y co-occurfx
- the frequency of word xfy
- the frequency of feature yN
- the count of all the relations of the given typepublic static void computeInformationForFeatures()
public static <T> void computeInformationForFeatures(java.util.HashMap<T,java.lang.Long> tuplesMap, java.util.HashMap<T,java.lang.Double> informationMap, long allCount)
T
- the type of keys in @param tuplesMap and @param informationMaptuplesMap
- the map containing the featuresinformationMap
- that map that will contain the information content of the featuresallCount
- the count of all the word types of the given POSpublic static void computeEntropyForFeatures()
public static <T,V> void computeEntropyForFeatures(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap, java.util.HashMap<V,java.lang.Double> frequency2Map, java.util.HashMap<V,java.lang.Double> entropyMap)
T
- the type of keys in @param tuplesMapV
- the type of keys in @param frequency2Map and @param EntropyMaptuplesMap
- the map containing the (word, feature) pairsfrequency2Map
- the map containing the frequency of featuresentropyMap
- that map that will contain entropy of the featurespublic static void computeGrefFeatureWeightForFeatures()
public static <T,V> void computeGrefFeatureWeightForFeatures(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap, java.util.HashMap<V,java.lang.Double> frequency2Map, java.util.HashMap<V,java.lang.Double> grefFeatureWeightMap)
T
- the type of keys in @param tuplesMapV
- the type of keys in @param frequency2Map and @param GrefFeatureWeightMaptuplesMap
- the map containing the (word, feature) pairsfrequency2Map
- the map containing the frequency of featuresgrefFeatureWeightMap
- that map that will contain Grefenstette's feature weight of the featurespublic static void computeAtcFeatureWeightForFeatures()
public static <T,V> void computeAtcFeatureWeightForFeatures(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap, java.util.HashMap<V,java.lang.Long> tuplesMap2, double allCount, java.lang.Double maxWordFeaturePairFrequency, java.util.HashMap<V,java.lang.Double> atcFeatureWeightMap)
T
- the type of keys in @param tuplesMapV
- the type of keys in @param tuplesMap2 and @param ATCFeatureWeightMaptuplesMap
- the map containing the (word, feature) pairstuplesMap2
- the map containing the number of words with which the features occurallCount
- the count of all the relations of the given typemaxWordFeaturePairFrequency
- the maximum word-feature pair frequencyatcFeatureWeightMap
- that map that will contain ATC feature weight of the featurespublic static void computeAvgWordVectorElementSums()
public static void computeMaxWordFeaturePairFrequencies()
public static <T,V> java.lang.Double computeMaxWordFeaturePairFrequencies(java.util.HashMap<T,java.util.HashMap<V,java.lang.Double>> tuplesMap)
T
- the type of keys in @param tuplesMapV
- the type of values in @param tuplesMaptuplesMap
- the map containing the (word, feature) pairspublic static void computeAllRelationCountOfGivenTypeAlphas()
public static <V> java.lang.Double computeAllRelationCountOfGivenTypeAlphas(java.util.HashMap<V,java.lang.Double> frequencyMap)
V
- the type of keys in @param frequencyMapfrequencyMap
- the map containing the features with their frequencypublic static void computeAllFeatureDocFreqCounts()
public static <V> long computeAllFeatureDocFreqCounts(java.util.HashMap<V,java.lang.Long> frequencyMap)
V
- the type of keys in @param frequencyMapfrequencyMap
- the map containing the features with their document frequency


137 The project ﬁle will be opened, and Snap ! will start in edit mode (with the program visible). Using #run: instead of #open: will start in presentation mode (with only the stage visible) and will “start” the project by clicking the green ﬂag. (“Start” is in quotation marks because there is no guarantee that the project includes any scripts triggered by the green ﬂag. Some projects are started by typing on the keyboard or by clicking a sprite.) If the verb is run, then you can also use any subset of the following ﬂags: &editMode Start in edit mode, not presentation mode. &noRun Don’t click the green ﬂag. &hideControls Don’t show the row of buttons above the stage (edit mode, green ﬂag, pause, stop). &lang=fr Set language to (in this example) French. &noCloud Don’t allow cloud operations from this project (for running projects from unknown sources that include JavaScript code) &noExitWarning When closing the window or loading a different URL, don’t show the browser “are you sure you want to leave this page” message. &blocksZoom=n Like the Zoom blocks option in the Settings menu. The last of these ﬂags is intended for use on a web page in which a Snap ! window is embedded. Here’s an example that loads a shared (public) project from the Snap ! cloud: http://snap.berkeley.edu/run#present:Username=jens&ProjectName=tree%20animation (Note that “Username” and “ProjectName” are TitleCased, even though the ﬂags such as “noRun” are camelCased. Note also that a space in the project name must be represented in Unicode as %20.) The verb present behaves like run: it ordinarily starts the project in presentation mode, but its behavior can be modiﬁed with the same four ﬂags as for run. The verb cloud (yes, we know it’s not a verb in its ordinary use) behaves like open except that it loads from the Snap ! cloud rather than from the Internet in general. The verb dl (short for “download”) does not start Snap ! but just downloads a cloud-saved project to your computer as an .xml ﬁle. This is useful for debugging; sometimes a defective project that Snap ! won’t run can be downloaded, edited, and then re-saved to the cloud. H. Mirror Sites If the site snap.berkeley.edu is ever unavailable, you can load Snap ! at the following mirror sites: ● http://bjc.edc.org/snapsource/snap.html ● http://cs10.org/snap


MY PROFILE
HOME
PERSONAL DETAILS
EDUCATION
EXPERIENCE
TRAINING
FACEBOOK
Personal Deatails
----------------
Date of Birth: 26 July, 1993
Age: 23
Marital Status: single
Military Status: Exempted
Design by Koraivit


Chittagong Women Chamber of Commerce & Industry-CWCCI is one of the leading Chambers involved in the economic empowerment of women in Bangladesh. It was formed by a group of innovative women entrepreneurs in 2003. Currently the Chamber is working as a common platform for Women Entrepreneurs & Business women in Chittagong region.
Main aim of CWCCI is to protect, develop, support and promote all measures towards ensuring a favorable environment for the business enterprises owned by the Women. The members of the Chamber include individual enterprises, cooperatives, private companies, NGOs, and institutions either owned or operated by women, working for entrepreneurship development amongst women. Our objectives are far-reaching and increasing number of women are being able to transform their latent potentiality into reality. CWCCI provides to the members overall technological and business solutions for sustainability of women entrepreneurships.


Source code for admit.xmlio.Parser
""" .. _Parser-api:
Parser --- Converts an ADMIT project on disk to in-memory objects.
------------------------------------------------------------------
This module is for parsing the input xml files, both admit.xml and the
general bdp xml files.
"""
# system imports
from xml import sax
import copy
import os
# ADMIT imports
from admit.xmlio.AdmitParser import AdmitParser
from admit.xmlio.ErrorHandler import ErrorHandler
from admit.xmlio.BDPReader import BDPReader
from admit.AT import AT
from admit.util.AdmitLogging import AdmitLogging as logging
from admit.util import utils
[docs]class Parser(object):
""" Main XML parsing class.
This class parses the main xml file (usually admit.xml) and reads in all
AT and ADMIT data. It then searches for all BDP's in the working
directory and subdirectories. These BDP files are then parsed and added
to their parent ATs.
Parameters
----------
base : ADMIT
Instance of the base ADMIT class to add everything to.
No Default.
baseDir : str
The root directory of the admit tree.
Default: "" (current dirctory).
xmlFile : str
The root admit xml file to parse.
Default: "".
Attributes
----------
xmlFile : str
String for the xml file to parse.
parser : SAX parser
The parser to use.
admit : ADMIT
The instance of the ADMIT class to add everything to.
baseDir : str
The root directory for working.
tasks : List
A list of all AT's found.
userData : dict
Dictionary for user data.
summaryData : dict
Summary data.
flowmanager : FlowManager
Temporary FM for reading in the data.
projmanager: dict
Project ID to base directory map.
"""
def __init__(self, base, baseDir="", xmlFile=""):
self.xmlFile = xmlFile
self.parser = sax.make_parser() # initialize the parser
self.admit = base
self.baseDir = baseDir
self.tasks = None
self.userData = None
self.summaryData = None
self.flowmanager = None
self.projmanager = None
[docs] def getTasks(self):
""" Return the list of AT's that have been read in
Parameters
----------
None
Returns
-------
List
List of the AT's from the xml file
"""
return self.tasks
[docs] def getflowmanager(self):
""" Return the local copy of the FlowManager
Parameters
----------
None
Returns
-------
FlowManager
Copy of the local FlowManager that was read in from XML.
"""
return self.flowmanager
[docs] def getSummary(self):
""" Return the local copy of the summaryData
Parameters
----------
None
Returns
-------
summaryData
Copy of the local summaryData that was read in from XML.
"""
return self.summaryData
[docs] def addBDPtoAT(self, bdp):
""" Method to add a BDP to an AT. The AT is not specified, but the
_taskid attribute of the BDP is used to identify the necessary AT.
Parameters
----------
bdp : BDP
Any valid BDP, to be added to an existing AT.
Returns
-------
None
"""
found = False
cp = copy.deepcopy(bdp)
# find the AT we need
for at in self.tasks:
# see if the ID's match
if at._taskid == bdp._taskid:
found = True
# set the base directory of the BDP
cp.baseDir(at.baseDir())
# add it to the correct slot
at._bdp_out[at._bdp_out_map.index(cp._uid)] = cp
break
if not found:
logging.info("##### Found orphaned BDP with type %s in file %s" % \
(bdp._type, bdp.xmlFile))
[docs] def parse(self, doParse=True):
""" Method that controls the parsing flow. First reads in the root xml
file and then any BDP files that were found.
Parameters
----------
doParse : Boolean
Whether or not to actually parse the XML
Default: True
Returns
-------
None
"""
if self.xmlFile is not None:
# set up the parser, error handler,a nd content handler
contentHandler = AdmitParser(self.baseDir, self.baseDir + self.xmlFile)
contentHandler.setadmit(self.admit)
errorHandler = ErrorHandler()
self.parser.setContentHandler(contentHandler)
self.parser.setErrorHandler(errorHandler)
if doParse:
# parse admit.xml
self.parser.parse(open(self.baseDir + self.xmlFile))
# get all of the bits and assemble the admit class content
self.tasks = contentHandler.getAT()
self.flowmanager = contentHandler.getflowmanager()
self.projmanager = contentHandler.projmanager
self.summaryData = contentHandler.summaryData
files = utils.getFiles(self.baseDir)
for fl in files:
# search for all BDP's and load them
BDPreader = BDPReader(fl)
# return the generated BDP class
self.addBDPtoAT(BDPreader.read())
for at in self.tasks:
if not at.getProject():
at.baseDir(self.baseDir)
at.checkfiles()


Hi there! After a lot of work, Autoplaylists is switching to an improved set of Google apis.
After the switch, you'll see faster and more accurate syncing.
Read the announcement email for all the details.
The new apis require that you approve access to your library (for syncing) and extensions (to check if you're a paid user).
This only needs to happen once. Hit the button below to bring up the prompt, then hit "allow" on the next screen.
This page will automatically close once when you're done.


Please open console to see logs (Neglect if already opened)
Listener Div (id : listener)
Nested Div (id : div1)
Div on which click operation is to be performed (id : div2)


A powerful and complete implementation of the uTorrent Web API. It is compatible with both Javascript and TypeScript!
Note: This library is a work in progress, so not all features may be available.
npm i utorrent-web-api
Some neat examples to show the simplicity and power of the API.
Creating a new uTorrent client instance is easy!
import { uTorrent } from "utorrent-web-api";
// Create an instance of the client
let utorrent = new uTorrent(host, port, username, password);
Torrents can be added by .torrent URL, magnet link, or file upload.
// Add a torrent via .torrent URL or magnet link
utorrent.addUrl(url).then((infoHash) => {
console.log("Success! Info hash:", infoHash);
}).catch((err) => {
console.error("Failed to add the torrent:", err);
});
// Add a torrent via .torrent file upload
[WORK IN PROGRESS]
It's easy to get the list of torrents currently in uTorrent!
let myAddedTorrent;
utorrent.list().then((result) => {
// Find the added torrent and save it
myAddedTorrent = result.torrents[infoHash];
// Iterate over all torrents
for (let hash in result.torrents) {
// Do something with the torrent
}
}).catch((err) => {
console.error("Failed to list torrents", err);
});
Once you have a torrent object, you can use that object to work with the torrent directly. Each time an action is performed, it will update all of its attributes with the latest information from the server. View the full Torrent documentation here: Torrent Docs
// Check if the torrent status indicates it's paused
if (myAddedTorrent.status & TorrentStatus.Paused) {
console.log("It is paused!");
}
// Refresh the torrent
myAddedTorrent.refresh().then(() => {
console.log("Torrent refreshed successfully");
});
// Pause the torrent
myAddedTorrent.pause().then(() => {
console.log("Paused successfully");
});
// Start the torrent
myAddedTorrent.start().then(() => {
console.log("Started successfully");
});
// Delete the torrent with its data
myAddedTorrent.remove(RemoveFlag.WithTorrent | RemoveFlag.WithData).then(() => {
console.log("Removed successfully");
});
It's a peace of cake to manage downloading or downloaded files with the API! You can check on their progress and manage their priority.
// Fetch the files
myTorrent.files().then((fileArray) => {
for (let file of fileArray) {
console.log("Name:", file.name, "; Progress:", file.progress * 100);
}
});
// Set a file's download priority
file.setPriority(Priority.Skip).then(() => {
console.log("This file will not be downloaded...");
});
// Set the priority of multiple files at once
myTorrent.setFilePriority(myTorrentFiles, Priority.High).then(() => {
console.log("The files specified have been set");
});
Full Documention can be found here
Generated using TypeDoc


Begin your day with Lamsbeg Group
Insanity: doing the same thing over and over again and expecting different results.


Welcome to Indivisible Denver
This is a group working in Colorado's Congressional District 1 promoting and fighting for progressive values by engaging with our elected representatives.
{% block css %}{% endblock %}
This is a group working in Colorado's Congressional District 1 promoting and fighting for progressive values by engaging with our elected representatives.


Mess Management System is designed for better interaction between Management and Members. Mess Management System handles all the requirements for easy Mess Management. This WebPage will help the Mess Center to structuralize the activities and maintain data transparecy where needed and properly store data for regular operations and future analysis.
“The main aim of the mess is to provide clean and fresh food to the employees of the organization.
Thus, there arises a need to create entire Mess Management an automated system."
Ganesh Bandal“The main aim of the mess is to provide clean and fresh food to the employees of the organization.
Thus, there arises a need to create entire Mess Management an automated system."
Smita-Suhita“The main aim of the mess is to provide clean and fresh food to the employees of the organization.
Thus, there arises a need to create entire Mess Management an automated system."
Jyoti-Shubhangi


Finite States to Petri Nets with NTL
This tutorial shows how to transform finite state machines to Petri Nets using NTL.
Setting up the environment
Create a new project in your IDE. Download the metamodels (zip, 804 Bytes) and add the two files contained in there to your project. They contain very simple implementations of the finite state machine and Petri Net metamodels.
Note: See that both of these metamodels do not hold any reference to NMF. In fact, their implementation is super-straight-forward. The implementation of the models is also not reflected, so you can use arbitrary CLR objects within NMF Transformations.
Adding a reference to NMF Transformations
We will need to add a reference to NMF Transformations in order to use it. Thus, add a reference to the assemblies NMF.Transformations.Core.dll (this is NMF Transformations Core) and NMF.Transformations.dll (the NMF Transformations Language).
Create a transformation file
Create a new file and name FSM2PN.cs (or any other name if you wish). Inside the file, we will work with NTL. Thus, add the following using statements on top of the transformation file:
using NMF.Transformations;
using NMF.Transformations.Core;
Create a new transformation class
Our transformation will use the default behavior and simply inherit from ReflectiveTransformation. As a consequence, NTL will infere the rules of our transformation by the public nested classes. So, add the following class:
public class FSM2PN : ReflectiveTransformation
{
}
Of course, you can embrace the transformation class in a namespace as you wish. It is also perfectly legal to make the transformation class itself internal.
Transforming Finite State Machines to Petri Nets
We start by adding a rule to transform finite state machines to Petri Nets. Add the following code as nested class inside the previous FSM2PN class:
public class AutomataToNet : TransformationRule<FSM.FiniteStateMachine, PN.PetriNet>
{
public override void Transform(FSM.FiniteStateMachine input, PN.PetriNet output, ITransformationContext context)
{
output.ID = input.ID;
}
}
This tells NTL how to transform finite state machines to Petri Nets. By inheriting from TransformationRule, we tell NTL that this class is a transformation rule and what this rule takes as input and output. In the Transform method, we specify what shall be done, if a state machine is transformed to a Petri Net. Here, we only copy the ID. However, this is not really suprising and would be better done without NTL, so far. Thus, we go ahead and add rules to transform places and transitions.
Transforming states
To transform states to places, just add the following lines of code as another nested class of FSM2PN:
public class StateToPlace : TransformationRule<FSM.State, PN.Place>
{
public override void Transform(FSM.State input, PN.Place output, ITransformationContext context)
{
output.ID = input.Name;
if (input.IsStartState)
{
output.TokenCount = 1;
}
else
{
output.TokenCount = 0;
}
}
}
In the Transform method, we again just copy the very simplest data from the finite state machine to the Petri Net.
Adding dependencies
However, if we called our new transformation to transform a finite state machine to a Petri Net, NTL would not know when to use the new rule State2Place. Thus, we need to add a dependency. We can do so on two spots: Either in Automata2Net to specify what other rules should be called (forward dependency) or in State2Place to specify when it will be called (reversed dependency). In this tutorial, we will use a reversed dependency. In that way, the code belonging to the transformation of states is all stored in State2Place. Dependencies are generally specified in the RegisterDependencies method. Thus, add the following method in the State2Place rule:
public override void RegisterDependencies()
{
CallForEach(Rule<AutomataToNet>(),
selector: fsm => fsm.States,
persistor: (pn, places) => pn.Places.AddRange(places));
}
The method Rule<> simply gets the instance of the rule with the specified rule type. As a consequence, the compiler is aware of the input type and can provide IntelliSense support for specifying the lambda predicates.
As you can see, dependencies can have a row of lambda expressions, specifying their behavior. The names are according to their functionality. If a finite state machine is transformed into a Petri Net using Automata2Net, then the selector specifies which states the current rule (State2Place) should be called. If all states of the finite state machine are transformed, the persistor specifies how the transformed elements should be persisted. Here, we just add the places to the places collection of the Petri Net.
Transforming Transitions
Now, we have transformed the places of our state machine. However, we still need to transform the transitions. Thus, add the following code as a new nested class of FSM2PN:
public class TransitionToTransition : TransformationRule<FSM.Transition, PN.Transition>
{
public override void Transform(FSM.Transition input, PN.Transition output, ITransformationContext context)
{
output.Input = input.Input;
}
public override void RegisterDependencies()
{
CallForEach(Rule<AutomataToNet>(),
(fsm => fsm.Transitions,
(pn, transitions) => pn.Transitions.AddRange(transitions));
}
}
Again, we have a rule how transistions are transformed to transitions of the Petri Net. We copy the inputs and create a reversed dependency to let NTL know which transitions to transform and add the transformed transitions to the Transitions collection of the Petri Net.
What is left is to fill the transitions start and end places. So if a state machine transition has had a start state, we want the Petri Net transition to have exactly the output of the State2Place added to the From collection. The same holds for the target state and the To collection.
To do this, just add the following code next to the existing reversed dependency in Transition2Transition:
Require(Rule<StateToPlace>(),
t => t.StartState, (t, p) =>
{
t.From.Add(p);
p.Outgoing.Add(t);
});
Require(Rule<StateToPlace>(),
t => t.EndState, (t, p) =>
{
t.To.Add(p);
p.Incoming.Add(t);
});
This will do. We specify that Transition2Transition needs the start state eventually transformed to a place (using State2Place). We already triggered this transformation elsewhere, thus the states are already transformed and NTL just takes the already transformed places.
Note: We assume here that the model representation has no direct support for opposite references. We made this assumption for brevity of the example. In reality, the To reference of transitions and the Incoming reference would better be true opposite references and thus, only one of the two statements in the dependencies would be required.
End states
Finally, we still need to transform the information that some states are end states. Thus, we add a new transformation rule that transforms end states to transitions.
public class EndStateToTransition : TransformationRule<FSM.State, PN.Transition>
{
public override void Transform(FSM.State input, PN.Transition output, ITransformationContext context)
{
output.Input = "";
}
public override void RegisterDependencies()
{
CallForEach(Rule<AutomataToNet>(),
selector: fsm => fsm.States.Where(s => s.IsEndState),
persistor: (pn, endTransitions) => pn.Transitions.AddRange(endTransitions));
}
}
Now, the created transition currently is not starting from the place corresponding to our end state. We could of course solve this problem by adding a new dependency (if you want to practice, just try that!). However, in some cases, these persistors eventually get very complex.
For such circumstances, NTL provides a trace. The trace allows to look up the corresponding model elements for certain elements directly. The trace is exposed through the Trace property of the transformation context that comes as argument to the Transform method. Thus, in the Transform method of the EndState2Transition rule, add the following lines:
var from = context.Trace.ResolveIn(Rule<StateToPlace>(), input);
output.From.Add(from);
from.Outgoing.Add(output);
Triggering the transformation
We are done with our transformation, so let's try it out! The simplest way to do this is by using the TransformationEngine class. Anywhere in your client, just call add the following line:
var pn = TransformationEngine.Transform<FSM.FiniteStateMachine, PN.PetriNet>(fsm, new FSM2PN());
This tells NTL to call the transformation with the finite state machine of the variable fsm. In this example, we created a new transformation just for this call. If you want to make frequent calls to use the transformation, you can also reuse the transformation initialization by using the same transformation instance several times. Transformations are even thread-safe, once they are initialized, as the data of a transformation run is only saved in the transformation context.
So start create some finite state machines and see how they are transformed to Petri Nets!


Phi Sigma Pi National Honor Fraternity is a gender-inclusive academic fraternity open to undergraduate students attending colleges and universities throughout the United States. The Gamma Xi Chapter is Drexel University's Chapter. Our purpose is to bring together some of the brightest and most motivated students on campus and work together in a spirit of excellence to encourage three ideals:
Collectively, these three ideals are known as "The Tripod" of Phi Sigma Pi. Joining Phi Sigma Pi is the first step in a lifelong journey of increased awareness, improved capabilities, greater opportunities and a network of friendships. Phi Sigma Pi is open for membership to any student who possess the following credentials:
Our members tend to be some of the most involved students on campus. We routinely have members who are also involved in social fraternities or sororities, honor societies, university athletics, student government, and many other organizations. We are not part of the social Greek system. We support involvement in other organizations and membership in Phi Sigma Pi is designed to work well with heavily involved students.
Scholarship in our organization expands outside the classroom and is a part of a larger “always learning” philosophy. Like other chapters, Gamma Xi holds scholarship events that result in the acquisition and dissemination of information and knowledge among our members.
Leadership exercises the application of professional skills and the fostering of leadership qualities by promoting and advancing the welfare of humanity. Along with holding nationally award-winning Leadership in Action modules, we also support our national and local philantrophies through service. Our local philatrophy is the American Foundation for Suicide Prevention.
Fellowship fosters non-discriminatory, fraternal fellowship within our ranks that is crucial in planning successful events and activities. Fellowship provides the passion and stability to fully remain involved with Phi Sigma Pi long after you cross the graduation stage. In Phi Sigma Pi, you're part of a family, a member for life.


Python Docs¶
-
class
river.
StreamReader
¶ The main entry point for River for reading an existing stream. This class is initialized with a stream name corresponding to an existing stream, and allows for batch consumption of the stream. Reads requesting more data than is present in the stream will block.
After constructing a StreamReader, you must call initialize with the name of the stream you wish to read.
-
good
¶ Whether this stream is “good” for reading (similar to std::ifstream’s #good()). Synonymous with casting to bool. Indicates whether more samples can be read from this stream via this StreamReader.
-
initialize
(self, unicode stream_name: str, timeout_ms: int = -1)¶ Initialize this reader to a particular stream. If timeout_ms is positive, this call will wait for up to timeout_ms milliseconds for the stream to be created. When the timeout is exceeded or if no timeout was given and the stream does not exist, a StreamReaderException will be raised.
-
initialized_at_us
¶
-
metadata
¶
-
new_buffer
(self, n: int) → np.ndarray¶ Returns an empty NumPy buffer of size n with a dtype matching the stream’s schema. Note that the returned buffer is simply allocated and not also zeroed, so there’s likely to be “junk” seen in the returned array.
-
read
(self: StreamReader, ndarray arr: np.ndarray, timeout_ms: int = -1) → int¶ Read from the stream from where was last consumed. This call blocks until the desired number of samples is available in the underlying stream. The return value indicates how many samples were written to the buffer. If EOF has been reached, then #good() will return false, and any attempts to #read() will return -1.
- Parameters
arr – The buffer into which data will be read from the stream. At most arr.size samples will be read from the stream and written into arr. The return value of this call (if nonnegative) tells how many samples, each of sample_size bytes as told by the schema, were written into the buffer. For VARIABLE_WIDTH_BYTES fields, ensure this buffer is large enough to capture the maximum possible read size.
timeout_ms – If positive, the maximum length of time this entire call can block while waiting for samples. After the timeout, the stream can be partially read, and the return value is needed to determine samples read.
- Returns
the number of elements read. This will always be less than or equal to arr.size. For example, if there is a timeout, this could be a partially read buffer and so can be less than arr.size; this number can be less than arr.size even if there is no timeout given, in the case of an EOF on the stream. Returns -1 if EOF is encountered; if -1 is returned, buffer is guaranteed to not have been touched.
-
schema
¶
-
stop
(self) → None¶ Stops this reader from being used in the future. Redis connections are freed; read() will no longer work; good() will return false.
-
stream_name
¶
-
tail
(self, ndarray arr, int timeout_ms=-1) → int¶ Returns the last element in the stream after the previously seen elements. Blocks until there’s at least one element available in the stream after the current cursor if no timeout is given; else, waits for the timeout.
- Parameters
timeout_ms – If positive, the maximum length of time this entire call can block while waiting for a sample. After the timeout there will be 0 or 1 elements read, and so the return value is needed to determine samples read.
- Returns
the number of elements skipped and/or read, including the last element that might be written into the buffer. Thus, this will return 0 in the event of a timeout; this will return >= 1 iff buffer is changed. Returns -1 if there is an EOF in the stream.
-
total_samples_read
¶
-
-
class
river.
StreamWriter
¶ The main entry point for River for writing a new stream. Streams are defined by a schema and a stream name, both of which are given in the initialize() call. All samples written to this stream must belong to the same schema. Once there are no more elements in this stream, call stop(); this will signal to any other readers that the stream has ended.
-
initialize
(self: StreamWriter, unicode stream_name: str, StreamSchema schema: StreamSchema, dict user_metadata: dict = None)¶ Initialize this stream for writing. The given stream name must be unique within the Redis used. This initialization puts necessary information (e.g. schemas and timestamps) into redis. Optionally, it can accept a dict of user metadata to put in to Redis atomically.
-
initialized_at_us
¶
-
metadata
¶ this does a call to Redis under-the-hood and so can incur a little bit of overhead.
- Type
Returns all metadata set for this stream. Implementation note
-
new_buffer
(self, n: int) → np.ndarray¶ Returns an empty NumPy buffer of size n with a dtype matching the stream’s schema. Note that the returned buffer is simply allocated and not also zeroed, so there’s likely to be “junk” seen in the returned array.
-
schema
¶
-
stop
(self) → None¶ Stops this stream permanently. This method must be called once the stream is finished in order to notify readers that the stream has terminated.
-
stream_name
¶
-
total_samples_written
¶
-
write
(self, ndarray arr: np.ndarray) → None¶ Writes data to the stream. Assumes that each element of the array arr is of the correct sample size (as defined by the stream’s schema’s sample size), and will write bytes in order of the schema fields. arr.size samples will be written to the stream.
-
-
class
river.
StreamSchema
¶ The schema for a particular stream. A stream has exactly one schema over its lifetime; this schema defines both the writing and reading structure of the stream (and, if in use, the on-disk representation of the stream).
-
dtype
(self) → np.dtype¶ Returns the equivalent NumPy dtype for this schema instance.
-
field_definitions
¶
-
static
from_dtype
(dtype dtype: np.dtype)¶ Creates a StreamSchema from a given NumPy dtype. This dtype should be a “structured array” dtype, where the dtype is a collection of named fields. See https://numpy.org/doc/stable/user/basics.rec.html for more details.
-
-
class
river.
FieldDefinition
¶ One or more fields that are present in each sample of a particular stream. This definition governs how this will be serialized to Redis and the columns in the persisted file. A collection of field definitions are housed within a StreamSchema.
While most field definitions are fixed-width( e.g. doubles, floats, etc.), the VARIABLE_WIDTH_BYTES field is a bit different. If you want to use a variable-width bytes (e.g. a dynamic-length string or byte array), then specify VARIABLE_WIDTH_BYTES but this must be your only field; this is for simplicity for handling serialization/deserialization. In this case, the size should correspond to the MAX size possible for this field, which is needed when serializing/deserializing.
-
name
¶
-
type
¶
-
-
class
river.
FieldType
(value)¶ An enumeration.
-
DOUBLE
= 0¶
-
FIXED_WIDTH_BYTES
= 4¶
-
FLOAT
= 1¶
-
INT32
= 2¶
-
INT64
= 3¶
-
VARIABLE_WIDTH_BYTES
= 5¶
-
-
class
river.
RedisException
¶
-
class
river.
StreamReaderException
¶
-
class
river.
StreamWriterException
¶
-
class
river.
StreamDoesNotExistException
¶
-
class
river.
StreamExistsException
¶


{% include 'header.html' %} {% block content %}
We've emailed you instructions for setting your password, if an account exists with the email you entered.
You should receive them shortly.
If you don't receive an email, please make sure you've entered the
address you registered with, and check your spam folder.


[gecode-users] Gecode 4.0.0
Christian Schulte
cschulte at kth.se
Mon Nov 7 10:31:54 CET 2011
Dear all,
I also support Guido's proposal. For 4.0.0 I think we will aim at getting the FloatVars in with the functionality described by Vincent. This will be enough work: testing, support in minimodel, documenting it in MPG, ...
In a second step one then can start thinking how to get the remaining stuff in. I expect that this will also change how we build and package Gecode and for that reason postponing it is a good idea so that we do not have a new major release and at the same time a change of the build infrastructure.
Best
Christian
--
Christian Schulte, KTH, web.it.kth.se/~cschulte/
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf Of Guido Tack
Sent: Sunday, November 06, 2011 10:52 AM
To: Filip Konvička
Cc: Vincent Barichard; users at gecode.org
Subject: Re: [gecode-users] Gecode 4.0.0
--
Guido Tack, http://people.cs.kuleuven.be/~guido.tack/
Hi guys,
we wouldn't be worried at all about having code that uses an LGPL library within Gecode - actually, we already have, as Gist uses Qt. This doesn't mean Gecode, or any part of it, needs to be LGPL.
As far as I can see, it's possible to build MPIR and MPFR using Visual Studio. I haven't checked how easy it is, though. What we'd really need is someone to build Windows binary packages for these two libraries (or a combined one), which install all the libraries and header files somewhere ready to compile and link against. We'd be very happy to help with the packaging, we have enough experience with the wix toolkit, e.g.
Vincent, as far as I can see, a core version of FloatVars could be an integral part of Gecode without linking to MPFR. Then a separate DLL could provide the constraints for trigonometric and transcendental functions, and link to MPFR.
Cheers,
Guido
On 6 Nov 2011, at 08:41, Filip Konvička wrote:
> Hi Vincent,
>
> I agree. Regarding LGPL - I should have said that it would make the Gecode package include LGPL code, which might be problematic for some. But it's still OK for many. I was briefly looking at the Internet on Friday and I haven't seen a usable math library that is not LGPL.
>
> Best,
> Filip
>
>> Hi Filip,
>>
>> I don't know smathlib, but as you said, it seems to be not maintained anymore.
>> Elisa is based on Gaol which is based on the IBM mathematical library, so it also relies on
>> another external library.
>>
>> I agree to not start a new implementation, it will be painfull. I don't think that Gecode will
>> become LGPL if it links with a LGPL library. But users should have the choice to not embed such a dependency.
>> I didn't find a mathematical library which fit all our needs (license, multi platforms, small, reliable).
>> So I see no choice but to use an external dependency which will be LGPL. Up to now, I retained two possibilities which
>> are MPFR or CRlibm. Maybe CRLibm is easier to build under windows than MPFR? (I am not a Windows user so I have no feedback on this)
>>
>> I also think that a build-option should be used to decide if transcendental constraints must be included. But we still have
>> to provide a fully functional implementation of FloatVar, and to achieve it, we must choose a library. I prefer a library
>> which works on Linux and Windows. I think it's up to Gecode maintainers to decide which choice has to be made, I will follow
>> their conlusions. But in the meantime, I will continue to dig the topic, so thank you very much for all your remarks and
>> advices :) If a Windows user has ever used an exact mathematical library, feel free to share your comments.
>>
>> Best,
>> Vincent
>>
>> Filip Konvi?ka <filip.konvicka at logis.cz> a écrit :
>>
>>>> Maybe you can have a look at Gaol:
>>>> http://sourceforge.net/projects/gaol/
>>>>
>>>> You can also write to the author Frederic Goualard to talk about the
>>>> subject.
>>>>
>>>
>>> One issue will probably be the license - both Gaol and MPFR are LGPL, so including them in a Gecode distribution would make that Gecode package also LGPL, I guess. Again, if a user decides to build their own Gecode with this included, it's fine, so it's great to have the option. But for a standard Gecode release my understanding was that the ideal license would be MIT-style.
>>>
>>> Best,
>>> Filip
>>>
>>>
>>> _______________________________________________
>>> Gecode users mailing list
>>> users at gecode.org
>>> https://www.gecode.org/mailman/listinfo/gecode-users
>>>
>>
>>
>>
>
>
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
_______________________________________________
Gecode users mailing list
users at gecode.org
https://www.gecode.org/mailman/listinfo/gecode-users
More information about the users
mailing list


I recently bought a lb of wild dagga leaves from a well known vendor. I was looking for a cannabis like high that they promise. I tried smoking the leaves but they were horrible tasting like molasses and rubber. Smoking the leaves didn't give me any effects, except a gross green dagga phlem, and a sore throat.
So I decided that I would put the leaves in a bowl and let them soak for a day. I strained the leaves out and boiled the water down till it was resin/tar on the bottom of the pan. I was excited, and was looking forward to a buzz. I smoke cigarettes daily, and had smoked cannabis (4 hits) about 3 hours prior to trying out my dagga resin. I was in a positive mood and upbeat about the experience to come. I had sampled dagga resin from an online vendor before and liked the experience. So I anticipated a nice high.
I collected all the sticky resin and ended up with about 5 or 6 grams. I packed about 2 to 3 bowls of this dagga resin (about a gram each) and smoked it with my girlfriend 'Daisy'. It seemed to come on very slow, every thing seemed a little off-kilter, I was watching tv and everything seemed stranger than normal reality. About 20 minutes after smoking a strong sedation started taking effect. 10 minutes later I felt dizzy and my stomach was starting to be upset. I tried falling asleep, but I was so nauseated I couldn't, I started getting chills although I was under a heavy blanket. I jumped in a hot shower, I felt very disorientated, and couldn't focus on anything.  Every thought made me want to puke. Well I puked about an hour and a half after the initial smoking.
This was definitely not fun, not recreational and not something I ever wanted to experience again. I never want to hear the word dagga again. The following morning I felt almost normal, and the first thing I did was throw the resin away.
I do not know what caused this horrible reaction. Maybe it was the large amount I smoked. Maybe it was how I prepared it. Maybe it was the amount of tar that my lungs endured. What I do know is that it was one of the worst experiences I have ever had.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


You need JavaScript enabled for this to work
Compare Bible Passages
Compare
American Standard Version
The Emphasized Bible
King James Version
The Lexham English Bible
Young's Literal Translation
Darby Bible
There was an error
Verse will be here...
words.
characters.
American Standard Version
The Emphasized Bible
King James Version
The Lexham English Bible
Young's Literal Translation
Darby Bible
There was an error
Verse will be here...
words.
characters.


Action snippets (click to execute)
-
-
Remove all 2+ spaces on a single line
-
Center all dialogs
GLSL snippets (click to copy)
-
PI (define)
-
float array initializer
-
vec2 array initializer
-
vec3 array initializer
-
vec4 array initializer
-
2D texture from imports
-
to_uv coordinates (cartesian)
-
to_polar coordinates
-
rand
Fragment snippets (click to copy)
-
Previous synth frame texture
-
Previous frame texture
-
portamento (MIDI keyboard)
-
ADSR function
-
ADSR usage
-
Simple Exp. low-pass filter
-
Filters argument - frequency as cutoff
-
LPF (low-pass filter)
-
HPF (high-pass filter, require LPF)
-
BPF (band-pass filter, require LPF and HPF)
-
2 channels MIDI/Multitimbrality


{Front End Developer | Mechanical Engineer}
Hey, I'm Jovaun. I'm a 4th year studying Mechanical Engineering at Northeastern University, and I'm interested in web development and product design. I like creating cool looking stuff, and seeing people enjoy it. Take a look around and feel free to contact me.


continue
artifacts = []
for source in sources:
artifacts.extend(classes_by_source.get(source, []))
vt = vt_by_target.get(target)
if vt is not None:
// NOTE: analysis_file doesn"t exist yet.
vts_artifactfiles_pairs.append(
continue
artifacts = []
if resources_by_target is not None:
for _, paths in resources_by_target.get(target).abs_paths():
artifacts.extend(paths)
for source in sources:
classes = classes_by_source.get(source, [])
artifacts.extend(classes)


This simple app works on so-called 360 degree photos, created by devices such as the Ricoh Theta. Such cameras produce equirectangular stills. This app allows you to rotate these photos along any axis and save the result as a new equirectangular image. You can also apply zoom effects and do a few other interesting transformations.
Select an image by clicking on the Upload button above. Then once the image is loaded, click on the '?' icon for more instructions.
This app does all of its processing in javascript and WebGL on the client. It does not load your image to a server.
Copyright 2017 - Robert Woodley
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.


Storyteller will track the changes in a single open directory. Tracking changes can be turned on and off at any time as long as there is an open directory is VS Code.
Whenever VS Code is started with the Storyteller plugin and a directory is NOT open a warning message like the one above will be displayed. If the user is not interested in using Storyteller this warning can be dismissed and no changes will be tracked.
Tip: An open directory is required because Storyteller stores all of the changes it
records in a special directory called .storyteller
. The open directory is where this special one will be stored.
To open a directory in VS Code go to the File
menu and select Open a Folder...
To start a brand new project:
(File -> Open Folder...)
.Opening the directory alone does not begin tracking. A user must explicitly start the recording process.
There are two ways to do this:
Open VS Code's command pallette (ctrl/cmd + shift + p
) and type in "Storyteller: Start Tracking This Project".
Click the "Start Storyteller" button in the status bar on the bottom left corner in VS Code (this will only be present if the plugin is installed).
With the user's permission to start tracking changes Storyteller is now active and all changes inside the project directory will be tracked. Storyteller attributes all changes to one or more developers. Storyteller will prompt for the first developer's information. Enter in a name and email (or hit 'escape' to remain anonymous). All changes will be attributed to this 'active' developer. More developers can be added at any time. Look here for more information.
.storyteller
, will be
created in the Storyteller project directory to hold the changes. You should not edit anything in this special directory.
If Storyteller has tracked a directory in the past there will be a hidden directory named .storyteller
that holds the
project's historical data. Whenever a directory is opened (using VS Code and the Storyteller plugin) that has this special sub-directory,
Storyteller automatically continues to track changes in the directory. There is no need to log in again. On subsequent startups, VS Code
opens the last used folder by default so working over multiple programming sessions is automatic. A message will be displayed that shows
the current active developer.
The user can stop Storyteller from tracking changes by opening the command pallette and typing in "Storyteller: Stop Tracking This Project". No new data will be recorded after that point.
Later, if the user would like to start tracking changes again they can open the command pallette and type in "Storyteller: Start Tracking This Project" or hit the "Start Storyteller" button in the status bar. The system will reconcile the changes since stopping when it is started up again.
Tip: If at anytime a user would like to delete the entire recorded Storyteller history all they have to
do is delete the .storyteller
directory.
On start up, Storyteller will reconcile any changes made to the file system outside of VS Code. If one or more files or directories are added outside of VS Code they will be added to the Storyteller data in one large block with a single timestamp. A diff is run against each existing file on start up to check for changes made outside of VS Code. If any changes are found then they will be added to the Storyteller data in a single block with a single timestamp.
If any files or directories are removed outside of VS Code, Storyteller will prompt to see if the user wants to add them back. If so, the existing Storyteller data will be used to recreate them on the file system. This prevents accidental deletion or deletions by other tools.


| 1 |
Zheng_2016 |
Src siRNA prevents corticosteroid-associated osteoporosis in a rabbit model |
Zheng, Li-Zhen; Wang, Xin-Luan; Cao, Hui-Juan; Chen, Shi-Hui; Huang, Le; Qin, Ling |
2016 |
2016-02-29 |
PMC |
N |
|
26597781.0 |
10.1016/j.bone.2015.11.010 |
cxt824rp |
0.992608 |
Zhang_2012 |
Zheng_2020, He_Y_2015, Zheng_2018, WEN_Q_2008 |
| 2 |
Qin_L_2015 |
Phytomolecule icaritin incorporated PLGA/TCP scaffold for steroid-associated osteonecrosis: Proof-of-concept for prevention of hip joint collapse in bipedal emus and mechanistic study in quadrupedal rabbits |
Qin, Ling; Yao, Dong; Zheng, Lizhen; Liu, Wai-Ching; Liu, Zhong; Lei, Ming; Huang, Le; Xie, Xinhui; Wang, Xinluan; Chen, Yang; Yao, Xinsheng; Peng, Jiang; Gong, He; Griffith, James F.; Huang, Yanping; Zheng, Yongping; Feng, Jian Q.; Liu, Ying; Chen, Shihui; Xiao, Deming; Wang, Daping; Xiong, Jiangyi; Pei, Duanqing; Zhang, Peng; Pan, Xiaohua; Wang, Xiaohong; Lee, Kwong-Man; Cheng, Chun-Yiu |
2015 |
2015-08-31 |
PMC |
N |
PMC7111223 |
25968462.0 |
10.1016/j.biomaterials.2015.04.038 |
2lxab3u2 |
0.958771 |
|
Zheng_2020, Zheng_2016, Zhang_2009 |
| 3 |
He_Y_2015 |
Src inhibitor reduces permeability without disturbing vascularization and prevents bone destruction in steroid-associated osteonecrotic lesions in rabbits |
He, Yi-Xin; Liu, Jin; Guo, Baosheng; Wang, Yi-Xiang; Pan, Xiaohua; Li, Defang; Tang, Tao; Chen, Yang; Peng, Songlin; Bian, Zhaoxiang; Liang, Zicai; Zhang, Bao-Ting; Lu, Aiping; Zhang, Ge |
2015 |
2015-03-09 |
COMM-USE |
N |
PMC4352921 |
25748225.0 |
10.1038/srep08856 |
racjw15b |
0.929807 |
|
Zheng_2020, Zheng_2016 |
| 4 |
Zhang_2012 |
Additive Effects of Mechanical Marrow Ablation and PTH Treatment on de Novo Bone Formation in Mature Adult Rats |
Zhang, Qing; Miller, Christopher; Bible, Jesse; Li, Jiliang; Xu, Xiaoqing; Mehta, Nozer; Gilligan, James; Vignery, Agnès; Scholz, Jodi A Carlson |
2012 |
2012-12-05 |
COMM-USE |
N |
PMC3901151 |
24710549.0 |
10.3390/cells1041168 |
md0bcflu |
0.925095 |
Zheng_2016 |
Zheng_2020, Zheng_2016, Zhou_2017, WEN_Q_2008 |
| 5 |
Sheng_2007 |
Elevated adipogenesis of marrow mesenchymal stem cells during early steroid-associated osteonecrosis development |
Sheng, Hui H; Zhang, Ge G; Cheung, Wing Hoi WH; Chan, Chun Wai CW; Wang, Yi Xiang YX; Lee, Kwong Man KM; Wang, Hong Fu HF; Leung, Kwok Sui KS; Qin, Ling L |
2007 |
2007-10-15 |
COMM-USE |
N |
PMC2146995 |
17937789.0 |
10.1186/1749-799x-2-15 |
v5glur2c |
0.921388 |
|
Zheng_2020 |
| 6 |
Zheng_2020 |
Magnesium and vitamin C supplementation attenuates steroid-associated osteonecrosis in a rat model |
Zheng, Li-Zhen; Wang, Jia-Li; Xu, Jian-Kun; Zhang, Xiao-Tian; Liu, Bao-Yi; Huang, Le; Zhang, Ri; Zu, Hai-Yue; He, Xuan; Mi, Jie; Pang, Qian-Qian; Wang, Xin-Luan; Ruan, Ye-Chun; Zhao, De-Wei; Qin, Ling |
2020 |
2020-04-30 |
PMC |
N |
|
32045781.0 |
10.1016/j.biomaterials.2020.119828 |
mxtk0xmk |
0.917697 |
|
Zheng_2018, Zheng_2016 |
| 7 |
Zheng_2018 |
Steroid-associated osteonecrosis animal model in rats |
Zheng, Li-Zhen; Wang, Jia-Li; Kong, Ling; Huang, Le; Tian, Li; Pang, Qian-Qian; Wang, Xin-Luan; Qin, Ling |
2018 |
2018-02-06 |
None |
N |
PMC5892381 |
29662787.0 |
10.1016/j.jot.2018.01.003 |
tad9jmfp |
0.894473 |
|
Zheng_2020 |
| 8 |
Pu_R_2017 |
11β-hydroxysteroid dehydrogenases as targets in the treatment of steroid-associated femoral head necrosis using antler extract |
Pu, Ribusurong; Peng, Hao |
2017 |
2017-11-07 |
PMC |
N |
PMC5772940 |
29434691.0 |
10.3892/etm.2017.5459 |
9unop8z4 |
0.890375 |
|
Zheng_2020 |
| 9 |
Zhu_Z_2016 |
Dimethyloxaloylglycine increases bone repair capacity of adipose-derived stem cells in the treatment of osteonecrosis of the femoral head |
Zhu, Zhen-Hong; Song, Wen-Qi; Zhang, Chang-Qing; Yin, Ji-Min |
2016 |
2016-09-13 |
NONCOMM |
N |
PMC5103711 |
27882083.0 |
10.3892/etm.2016.3698 |
kjvy2c2k |
0.880489 |
|
Zheng_2020 |
| 10 |
Zhou_2017 |
PTH[1-34] improves the effects of core decompression in early-stage steroid-associated osteonecrosis model by enhancing bone repair and revascularization |
Zhou, Chen-he; Meng, Jia-hong; Zhao, Chen-chen; Ye, Chen-yi; Zhu, Han-xiao; Hu, Bin; Heng, Boon Chin; Shen, Yue; Lin, Tiao; Yang, Xiao-bo; Shi, Zhong-li; Shen, Wei-liang; Yan, Shi-gui |
2017 |
2017-05-31 |
COMM-USE |
N |
PMC5451136 |
28562696.0 |
10.1371/journal.pone.0178781 |
jrmfl3te |
0.874754 |
Zheng_2016, Zhang_2012 |
Zheng_2020, Zheng_2016 |
| 11 |
Zheng_2013 |
Steroid-Associated Hip Joint Collapse in Bipedal Emus |
Zheng, Li-Zhen; Liu, Zhong; Lei, Ming; Peng, Jiang; He, Yi-Xin; Xie, Xin-Hui; Man, Chi-Wai; Huang, Le; Wang, Xin-Luan; Fong, Daniel Tik-Pui; Xiao, De-Ming; Wang, Da-Ping; Chen, Yang; Feng, Jian Q.; Liu, Ying; Zhang, Ge; Qin, Ling |
2013 |
2013-10-21 |
COMM-USE |
N |
PMC3804596 |
24204675.0 |
10.1371/journal.pone.0076797 |
efb10j3u |
0.870655 |
Zheng_2016, Taniguchi_2019 |
Kianmehr_2015, Chan_2006 |
| 12 |
Zhang_2009 |
A novel semisynthesized small molecule icaritin reduces incidence of steroid-associated osteonecrosis with inhibition of both thrombosis and lipid-deposition in a dose-dependent manner |
Zhang, Ge; Qin, Ling; Sheng, Hui; Wang, Xin-Luan; Wang, Yi-Xiang; Yeung, David Ka-Wai; Griffith, James F.; Yao, Xin-Sheng; Xie, Xin-Hui; Li, Zi-Rong; Lee, Kwong-Man; Leung, Kwok-Sui |
2009 |
2009-02-28 |
PMC |
N |
|
|
10.1016/j.bone.2008.10.035 |
jssovqb0 |
0.868477 |
|
Zhang_2009, Zhang_2007 |
| 13 |
Zhang_2007 |
Epimedium-derived phytoestrogen exert beneficial effect on preventing steroid-associated osteonecrosis in rabbits with inhibition of both thrombosis and lipid-deposition |
Zhang, G.; Qin, L.; Sheng, H.; Yeung, K.W.; Yeung, H.Y.; Cheung, W.H.; Griffith, J.; Chan, C.W.; Lee, K.M.; Leung, K.S. |
2007 |
2007-03-31 |
PMC |
N |
|
17188589.0 |
10.1016/j.bone.2006.10.026 |
8gocv5kl |
0.859785 |
|
Zheng_2020, Zhang_2009 |
| 14 |
Qin_L_2006 |
Multiple bioimaging modalities in evaluation of an experimental osteonecrosis induced by a combination of lipopolysaccharide and methylprednisolone |
Qin, L.; Zhang, G.; Sheng, H.; Yeung, K.W.; Yeung, H.Y.; Chan, C.W.; Cheung, W.H.; Griffith, J.; Chiu, K.H.; Leung, K.S. |
2006 |
2006-10-31 |
PMC |
N |
PMC7103395 |
16765664.0 |
10.1016/j.bone.2006.04.018 |
a14tc4kf |
0.851328 |
|
Zheng_2018, Zheng_2020, WEN_Q_2008 |
| 15 |
Xi_H_2016 |
Levodopa attenuates cellular apoptosis in steroid-associated necrosis of the femoral head |
Xi, Hongbo; Tao, Weijian; Jian, Zhengguang; Sun, Xuefeng; Gong, Xiaohong; Huang, Lixin; Dong, Tianhua |
2016 |
2016-12-07 |
NONCOMM |
N |
PMC5245153 |
28123470.0 |
10.3892/etm.2016.3964 |
z105jy9g |
0.816272 |
|
Zheng_2020 |
| 16 |
Zhang_2009 |
Constitutional Flavonoids Derived from Epimedium Dose-Dependently Reduce Incidence of Steroid-Associated Osteonecrosis Not via Direct Action by Themselves on Potential Cellular Targets |
Zhang, Ge; Wang, Xin-Luan; Sheng, Hui; Xie, Xin-Hui; He, Yi-Xin; Yao, Xin-Sheng; Li, Zi-Rong; Lee, Kwong-Man; He, Wei; Leung, Kwok-Sui; Qin, Ling |
2009 |
2009-07-29 |
COMM-USE |
N |
PMC2713419 |
19641620.0 |
10.1371/journal.pone.0006419 |
vnh9eb00 |
0.811427 |
|
Zhang_2009 |
| 17 |
Qin_L_2007 |
Contrast-Enhanced MRI and Micro-CT Adopted for Evaluation of a Lipid-Lowering and Anticoagulant Herbal Epimedium-Derived Phytoestrogenic Extract for Prevention of Steroid-Associated Osteonecrosis |
Qin, Ling; Zhang, Ge; Sheng, Hui; Griffth, James F.; Yeung, Ka Wai; Leung, Kwok-Sui |
2007 |
2007-01-01 |
PMC |
N |
PMC7120779 |
|
10.1007/978-3-540-45456-4_38 |
47wk5g0h |
0.804274 |
|
Zheng_2020, Zhang_2007, Zhang_2009 |
| 18 |
WEN_Q_2008 |
A Rabbit Model of Hormone-induced Early Avascular Necrosis of the Femoral Head |
WEN, Qian; MA, Li; CHEN, Yan-Ping; YANG, Lin; LUO, Wei; WANG, Xiao-Ning |
2008 |
2008-10-31 |
PMC |
N |
PMC7134729 |
19133613.0 |
10.1016/s0895-3988(08)60060-4 |
z9ge3a9s |
0.773338 |
Zheng_2016 |
Zheng_2020, Zheng_2016 |
| 19 |
Li_P_2017 |
Differential expression of miR-195-5p in collapse of steroid-induced osteonecrosis of the femoral head |
Li, Pengfei; Zhai, Pei; Ye, Zengjie; Deng, Peng; Fan, Yueguang; Zeng, Yirong; Pang, Zhihui; Zeng, Jianchun; Li, Jie; Feng, Wenjun |
2017 |
2017-04-21 |
COMM-USE |
N |
PMC5522094 |
28498798.0 |
10.18632/oncotarget.17333 |
zvu9ww8j |
0.735582 |
|
|
| 20 |
Xie_X_2015 |
Steroid-associated osteonecrosis: Epidemiology, pathophysiology, animal model, prevention, and potential treatments (an overview) |
Xie, Xin-Hui; Wang, Xin-Luan; Yang, Hui-Lin; Zhao, De-Wei; Qin, Ling |
2015 |
2015-01-13 |
None |
N |
PMC5982361 |
30035041.0 |
10.1016/j.jot.2014.12.002 |
y6y235hw |
0.555451 |
|
Zheng_2020, Zheng_2018, Chan_2006 |


Raycast-CCD manager.
Raycast-CCD is a simple and potentially cheaper alternative to the SDK's built-in continuous collision detection algorithm.
This implementation has some limitations:
Also, since it is raycast-based, the solution is not perfect. In particular:
- small dynamic objects can still go through the static world if the ray goes through a crack between edges, or a small hole in the world (like the keyhole from a door).
- dynamic-vs-dynamic CCD is very approximate. It only works well for fast-moving dynamic objects colliding against slow-moving dynamic objects.
Finally, since it is using the SDK's scene queries under the hood, it only works provided the simulation shapes also have scene-query shapes associated with them. That is, if the objects in the scene only use PxShapeFlag::eSIMULATION_SHAPE (and no PxShapeFlag::eSCENE_QUERY_SHAPE), then the raycast-CCD system will not work.


NOTE: Set the gAgendaMask options to -1 to enable all agenda effects.
NOTE: In this theme demo, we passed in a dynamic range constraint to the second date-picker (start from 2004.6.8 to 2004.8.8).
Copyright© 2003-2007 Idemfactor Solutions,
Inc. All rights reserved.


--- ---
Because of the way this form works (the form data is not sumbitted, as forms usually do), your browser may not ask you to remember the username/password. If you'd like to save them to your password manager, fill them in and click this button. This will not create a new post!
Drag this link to your bookmarks, to post from any webpage: post to {{ site.title }}


The following disclaimer covers all the content on www.tedfelix.com. It supersedes any other disclaimers that may appear on individual pages.
The information on www.tedfelix.com ("this site") is a collection of information and opinions that has been gathered while researching various topics. This site is independent and not affiliated with any other company or website in any way other than as a customer. Any advertising that may appear on the site is for the sole purpose of paying Internet service fees and will be managed in a way that maintains the independent nature of the site.
All trademarks are owned by their respective owners.
Use this information at your own risk. The authors of content appearing on this site shall not be held responsible for anything that happens to you as a result of reading this.
The information contained on this site and from any communication related to this site is for information purposes only. The material on this site does not constitute advice and you should not rely on any material in this site to make (or refrain from making) any decision or take (or refrain from taking) any action. Discussion of financial topics on this site is not financial advice.
The entire contents of this site are Copyright 1994-2012, Ted Felix, All Rights Reserved.
By accessing information on this site, you agree to the above terms.


Tabs inside the editor are spans with the class cm-tab, and can be styled. This demo uses an :after pseudo-class CSS hack that will not work on old browsers. You can use a more conservative technique like a background image as an alternative.
cm-tab
:after