Welcome to the third project of the Machine Learning Engineer Nanodegree! In this notebook, some template code has already been provided for you, and it will be your job to implement the additional functionality necessary to successfully complete this project. Sections that begin with 'Implementation' in the header indicate that the following block of code will require additional functionality which you must provide. Instructions will be provided for each section and the specifics of the implementation are marked in the code block with a 'TODO'
statement. Please be sure to read the instructions carefully!
In addition to implementing code, there will be questions that you must answer which relate to the project and your implementation. Each section where you will answer a question is preceded by a 'Question X' header. Carefully read each question and provide thorough answers in the following text boxes that begin with 'Answer:'. Your project submission will be evaluated based on your answers to each of the questions and the implementation you provide.
Note: Code and Markdown cells can be executed using the Shift + Enter keyboard shortcut. In addition, Markdown cells can be edited by typically double-clicking the cell to enter edit mode.
In this project, you will analyze a dataset containing data on various customers' annual spending amounts (reported in monetary units) of diverse product categories for internal structure. One goal of this project is to best describe the variation in the different types of customers that a wholesale distributor interacts with. Doing so would equip the distributor with insight into how to best structure their delivery service to meet the needs of each customer.
The dataset for this project can be found on the UCI Machine Learning Repository. For the purposes of this project, the features 'Channel'
and 'Region'
will be excluded in the analysis — with focus instead on the six product categories recorded for customers.
Run the code block below to load the wholesale customers dataset, along with a few of the necessary Python libraries required for this project. You will know the dataset loaded successfully if the size of the dataset is reported.
# Import libraries necessary for this project
import numpy as np
import pandas as pd
from IPython.display import display # Allows the use of display() for DataFrames
# Import supplementary visualizations code visuals.py
import visuals as vs
# Pretty display for notebooks
%matplotlib inline
# Load the wholesale customers dataset
try:
data = pd.read_csv("customers.csv")
data.drop(['Region', 'Channel'], axis = 1, inplace = True)
print "Wholesale customers dataset has {} samples with {} features each.".format(*data.shape)
except:
print "Dataset could not be loaded. Is the dataset missing?"
In this section, you will begin exploring the data through visualizations and code to understand how each feature is related to the others. You will observe a statistical description of the dataset, consider the relevance of each feature, and select a few sample data points from the dataset which you will track through the course of this project.
Run the code block below to observe a statistical description of the dataset. Note that the dataset is composed of six important product categories: 'Fresh', 'Milk', 'Grocery', 'Frozen', 'Detergents_Paper', and 'Delicatessen'. Consider what each category represents in terms of products you could purchase.
# Display a description of the dataset
display(data.describe())
To get a better understanding of the customers and how their data will transform through the analysis, it would be best to select a few sample data points and explore them in more detail. In the code block below, add three indices of your choice to the indices
list which will represent the customers to track. It is suggested to try different sets of samples until you obtain customers that vary significantly from one another.
# TODO: Select three indices of your choice you wish to sample from the dataset
indices = [9,37,225]
# Create a DataFrame of the chosen samples
samples = pd.DataFrame(data.loc[indices], columns = data.keys()).reset_index(drop = True)
print "Chosen samples of wholesale customers dataset:"
display(samples)
Consider the total purchase cost of each product category and the statistical description of the dataset above for your sample customers.
What kind of establishment (customer) could each of the three samples you've chosen represent?
Hint: Examples of establishments include places like markets, cafes, and retailers, among many others. Avoid using names for establishments, such as saying "McDonalds" when describing a sample customer as a restaurant.
Answer:
One interesting thought to consider is if one (or more) of the six product categories is actually relevant for understanding customer purchasing. That is to say, is it possible to determine whether customers purchasing some amount of one category of products will necessarily purchase some proportional amount of another category of products? We can make this determination quite easily by training a supervised regression learner on a subset of the data with one feature removed, and then score how well that model can predict the removed feature.
In the code block below, you will need to implement the following:
new_data
a copy of the data by removing a feature of your choice using the DataFrame.drop
function.sklearn.cross_validation.train_test_split
to split the dataset into training and testing sets.test_size
of 0.25
and set a random_state
.random_state
, and fit the learner to the training data.score
function.from sklearn.cross_validation import train_test_split
from sklearn.tree import DecisionTreeRegressor
# TODO: Make a copy of the DataFrame, using the 'drop' function to drop the given feature
new_data = data.copy()
new_data_X = new_data.drop('Delicatessen',axis = 1)
new_data_y = new_data['Delicatessen']
# TODO: Split the data into training and testing sets using the given feature as the target
X_train, X_test, y_train, y_test = train_test_split(new_data_X, new_data_y, test_size = 0.25, random_state = 101)
# TODO: Create a decision tree regressor and fit it to the training set
regressor = DecisionTreeRegressor()
regressor.fit(X_train,y_train)
# TODO: Report the score of the prediction using the testing set
score = regressor.score(X_test, y_test)
print "Test R^2 Score: {}".format(score)
Which feature did you attempt to predict? What was the reported prediction score? Is this feature is necessary for identifying customers' spending habits?
Hint: The coefficient of determination, R^2
, is scored between 0 and 1, with 1 being a perfect fit. A negative R^2
implies the model fails to fit the data.
Answer: I chose 'Delicatessen' as the label, and the regressor reported R^2 of 0.0877, which means that other features are not highly relevant to 'Delicatessen'. It could possibly provide some different information from the others about the spending habits. Therefore, it's necessary for identifying customers' spending habits.
To get a better understanding of the dataset, we can construct a scatter matrix of each of the six product features present in the data. If you found that the feature you attempted to predict above is relevant for identifying a specific customer, then the scatter matrix below may not show any correlation between that feature and the others. Conversely, if you believe that feature is not relevant for identifying a specific customer, the scatter matrix might show a correlation between that feature and another feature in the data. Run the code block below to produce a scatter matrix.
# Produce a scatter matrix for each pair of features in the data
pd.scatter_matrix(data, alpha = 0.3, figsize = (14,8), diagonal = 'kde');
data.corr()
Are there any pairs of features which exhibit some degree of correlation? Does this confirm or deny your suspicions about the relevance of the feature you attempted to predict? How is the data for those features distributed?
Hint: Is the data normally distributed? Where do most of the data points lie?
Answer:
Yes, it seems two pairs: Detergents_Paper and Grocery, Detergent_Paper and Milk have certain linear relationship, the correlations reach as much as 0.92 and 0.66 respectively in terms of Pearson test. This confirms my suspicions about the relevance of the feature Detergent_Paper that I attempted to predict.
From the plot above, the data is not normally distributed, it looks each product cost is right skewed.
In this section, you will preprocess the data to create a better representation of customers by performing a scaling on the data and detecting (and optionally removing) outliers. Preprocessing data is often times a critical step in assuring that results you obtain from your analysis are significant and meaningful.
If data is not normally distributed, especially if the mean and median vary significantly (indicating a large skew), it is most often appropriate to apply a non-linear scaling — particularly for financial data. One way to achieve this scaling is by using a Box-Cox test, which calculates the best power transformation of the data that reduces skewness. A simpler approach which can work in most cases would be applying the natural logarithm.
In the code block below, you will need to implement the following:
log_data
after applying logarithmic scaling. Use the np.log
function for this.log_samples
after applying logarithmic scaling. Again, use np.log
.# TODO: Scale the data using the natural logarithm
log_data = np.log(data.copy())
# TODO: Scale the sample data using the natural logarithm
log_samples = np.log(samples.copy())
# Produce a scatter matrix for each pair of newly-transformed features
pd.scatter_matrix(log_data, alpha = 0.3, figsize = (14,8), diagonal = 'kde');
After applying a natural logarithm scaling to the data, the distribution of each feature should appear much more normal. For any pairs of features you may have identified earlier as being correlated, observe here whether that correlation is still present (and whether it is now stronger or weaker than before).
Run the code below to see how the sample data has changed after having the natural logarithm applied to it.
# Display the log-transformed sample data
display(log_samples)
Detecting outliers in the data is extremely important in the data preprocessing step of any analysis. The presence of outliers can often skew results which take into consideration these data points. There are many "rules of thumb" for what constitutes an outlier in a dataset. Here, we will use Tukey's Method for identfying outliers: An outlier step is calculated as 1.5 times the interquartile range (IQR). A data point with a feature that is beyond an outlier step outside of the IQR for that feature is considered abnormal.
In the code block below, you will need to implement the following:
Q1
. Use np.percentile
for this.Q3
. Again, use np.percentile
.step
.outliers
list.NOTE: If you choose to remove any outliers, ensure that the sample data does not contain any of these points!
Once you have performed this implementation, the dataset will be stored in the variable good_data
.
outliers = []
# For each feature find the data points with extreme high or low values
for feature in log_data.keys():
# TODO: Calculate Q1 (25th percentile of the data) for the given feature
Q1 = np.percentile(log_data[feature], 25)
# TODO: Calculate Q3 (75th percentile of the data) for the given feature
Q3 = np.percentile(log_data[feature], 75)
# TODO: Use the interquartile range to calculate an outlier step (1.5 times the interquartile range)
step = 1.5*(Q3-Q1)
# Display the outliers
print "Data points considered outliers for the feature '{}':".format(feature)
outlier = log_data[~((log_data[feature] >= Q1 - step) & (log_data[feature] <= Q3 + step))]
outliers.append(outlier.index.values)
display(outlier)
# # OPTIONAL: Select the indices for data points you wish to remove
# outliers = []
# # Remove the outliers, if any were specified
#good_data = log_data.drop(log_data.index[outliers]).reset_index(drop = True)
outliers_counts = pd.Series(np.concatenate(outliers)).value_counts()
print "Outliers for more than one feature"
print outliers_counts[outliers_counts > 1]
outliers_index = outliers_counts.index
# Remove the outliers, if any were specified
good_data = log_data.drop(log_data.index[outliers_index]).reset_index(drop = True)
Are there any data points considered outliers for more than one feature based on the definition above? Should these data points be removed from the dataset? If any data points were added to the outliers
list to be removed, explain why.
Answer:
Outliers for more than one feature
The data will be more normally distributed if we remove all outliers rather than removing the points which are outliers of more than one feature
In this section you will use principal component analysis (PCA) to draw conclusions about the underlying structure of the wholesale customer data. Since using PCA on a dataset calculates the dimensions which best maximize variance, we will find which compound combinations of features best describe customers.
Now that the data has been scaled to a more normal distribution and has had any necessary outliers removed, we can now apply PCA to the good_data
to discover which dimensions about the data best maximize the variance of features involved. In addition to finding these dimensions, PCA will also report the explained variance ratio of each dimension — how much variance within the data is explained by that dimension alone. Note that a component (dimension) from PCA can be considered a new "feature" of the space, however it is a composition of the original features present in the data.
In the code block below, you will need to implement the following:
sklearn.decomposition.PCA
and assign the results of fitting PCA in six dimensions with good_data
to pca
.log_samples
using pca.transform
, and assign the results to pca_samples
.from sklearn.decomposition import PCA
#import renders as rs
# TODO: Apply PCA to the good data with the same number of dimensions as features
pca = PCA(n_components=6).fit(good_data)
# TODO: Apply a PCA transformation to the sample log-data
pca_samples = pca.transform(log_samples)
# Generate PCA results plot
pca_results = vs.pca_results(good_data, pca)
print pca_results['Explained Variance'].cumsum()
import matplotlib.pyplot as plt
x= np.arange(6)
plt.plot(x,np.cumsum(pca.explained_variance_ratio_),'-o')
How much variance in the data is explained in total by the first and second principal component? What about the first four principal components? Using the visualization provided above, discuss what the first four dimensions best represent in terms of customer spending.
Hint: A positive increase in a specific dimension corresponds with an increase of the positive-weighted features and a decrease of the negative-weighted features. The rate of increase or decrease is based on the indivdual feature weights.
Answer:
Run the code below to see how the log-transformed sample data has changed after having a PCA transformation applied to it in six dimensions. Observe the numerical value for the first four dimensions of the sample points. Consider if this is consistent with your initial interpretation of the sample points.
display(log_samples)
# Display sample log-data after having a PCA transformation applied
display(pd.DataFrame(np.round(pca_samples, 4), columns = pca_results.index.values))
When using principal component analysis, one of the main goals is to reduce the dimensionality of the data — in effect, reducing the complexity of the problem. Dimensionality reduction comes at a cost: Fewer dimensions used implies less of the total variance in the data is being explained. Because of this, the cumulative explained variance ratio is extremely important for knowing how many dimensions are necessary for the problem. Additionally, if a signifiant amount of variance is explained by only two or three dimensions, the reduced data can be visualized afterwards.
In the code block below, you will need to implement the following:
good_data
to pca
.good_data
using pca.transform
, and assign the results to reduced_data
.log_samples
using pca.transform
, and assign the results to pca_samples
.# TODO: Apply PCA by fitting the good data with only two dimensions
pca = PCA(n_components=2).fit(good_data)
# TODO: Transform the good data using the PCA fit above
reduced_data = pca.transform(good_data)
# TODO: Transform log_samples using the PCA fit above
pca_samples = pca.transform(log_samples)
# Create a DataFrame for the reduced data
reduced_data = pd.DataFrame(reduced_data, columns = ['Dimension 1', 'Dimension 2'])
Run the code below to see how the log-transformed sample data has changed after having a PCA transformation applied to it using only two dimensions. Observe how the values for the first two dimensions remains unchanged when compared to a PCA transformation in six dimensions.
# Display sample log-data after applying PCA transformation in two dimensions
display(pd.DataFrame(np.round(pca_samples, 4), columns = ['Dimension 1', 'Dimension 2']))
A biplot is a scatterplot where each data point is represented by its scores along the principal components. The axes are the principal components (in this case Dimension 1
and Dimension 2
). In addition, the biplot shows the projection of the original features along the components. A biplot can help us interpret the reduced dimensions of the data, and discover relationships between the principal components and original features.
Run the code cell below to produce a biplot of the reduced-dimension data.
# Create a biplot
vs.biplot(good_data, reduced_data, pca)
Once we have the original feature projections (in red), it is easier to interpret the relative position of each data point in the scatterplot. For instance, a point the lower right corner of the figure will likely correspond to a customer that spends a lot on 'Milk'
, 'Grocery'
and 'Detergents_Paper'
, but not so much on the other product categories.
From the biplot, which of the original features are most strongly correlated with the first component? What about those that are associated with the second component? Do these observations agree with the pca_results plot you obtained earlier?
In this section, you will choose to use either a K-Means clustering algorithm or a Gaussian Mixture Model clustering algorithm to identify the various customer segments hidden in the data. You will then recover specific data points from the clusters to understand their significance by transforming them back into their original dimension and scale.
What are the advantages to using a K-Means clustering algorithm? What are the advantages to using a Gaussian Mixture Model clustering algorithm? Given your observations about the wholesale customer data so far, which of the two algorithms will you use and why?
Answer:
K-Means
Gaussian Mixture Model
In this case, I prefer to use GMM since we aren't sure that clustering shape is circular. And, we have transformed the data to be normal distributed, which is requried by GMM. Besides, the dataset is small, we don't need worry about the complexity and computation cost.
Depending on the problem, the number of clusters that you expect to be in the data may already be known. When the number of clusters is not known a priori, there is no guarantee that a given number of clusters best segments the data, since it is unclear what structure exists in the data — if any. However, we can quantify the "goodness" of a clustering by calculating each data point's silhouette coefficient. The silhouette coefficient for a data point measures how similar it is to its assigned cluster from -1 (dissimilar) to 1 (similar). Calculating the mean silhouette coefficient provides for a simple scoring method of a given clustering.
In the code block below, you will need to implement the following:
reduced_data
and assign it to clusterer
.reduced_data
using clusterer.predict
and assign them to preds
.centers
.pca_samples
and assign them sample_preds
.sklearn.metrics.silhouette_score
and calculate the silhouette score of reduced_data
against preds
.score
and print the result.from sklearn.mixture import GMM
from sklearn.metrics import silhouette_score
# TODO: Apply your clustering algorithm of choice to the reduced data
clusterer = GMM(n_components=6, random_state=101).fit(reduced_data)
# TODO: Predict the cluster for each data point
preds = clusterer.predict(reduced_data)
print preds
# TODO: Find the cluster centers
centers = clusterer.means_
print centers
# TODO: Predict the cluster for each transformed sample data point
sample_preds = clusterer.predict(pca_samples)
print sample_preds
# TODO: Calculate the mean silhouette coefficient for the number of clusters chosen
score = silhouette_score(reduced_data, preds)
score
for n in xrange(2, 10):
# TODO: Apply your clustering algorithm of choice to the reduced data
clusterer = GMM(n_components=n, random_state=101).fit(reduced_data)
# TODO: Predict the cluster for each data point
preds = clusterer.predict(reduced_data)
# print preds
# TODO: Find the cluster centers
centers = clusterer.means_
# print centers
# TODO: Predict the cluster for each transformed sample data point
sample_preds = clusterer.predict(pca_samples)
# print sample_preds
# TODO: Calculate the mean silhouette coefficient for the number of clusters chosen
score = silhouette_score(reduced_data, preds)
print "{} components' score: {}".format(n, score)
Report the silhouette score for several cluster numbers you tried. Of these, which number of clusters has the best silhouette score?
Answer: Two clusters have the best silhouette score of approximately 0.444
Once you've chosen the optimal number of clusters for your clustering algorithm using the scoring metric above, you can now visualize the results by executing the code block below. Note that, for experimentation purposes, you are welcome to adjust the number of clusters for your clustering algorithm to see various visualizations. The final visualization provided should, however, correspond with the optimal number of clusters.
clusterer = GMM(n_components=2, random_state=101).fit(reduced_data)
# TODO: Predict the cluster for each data point
preds = clusterer.predict(reduced_data)
print preds
# TODO: Find the cluster centers
centers = clusterer.means_
print centers
# TODO: Predict the cluster for each transformed sample data point
sample_preds = clusterer.predict(pca_samples)
# TODO: Predict the cluster for each transformed sample data point
preds = clusterer.predict(reduced_data)
# Display the results of the clustering from implementation
vs.cluster_results(reduced_data, preds, centers, pca_samples)
Each cluster present in the visualization above has a central point. These centers (or means) are not specifically data points from the data, but rather the averages of all the data points predicted in the respective clusters. For the problem of creating customer segments, a cluster's center point corresponds to the average customer of that segment. Since the data is currently reduced in dimension and scaled by a logarithm, we can recover the representative customer spending from these data points by applying the inverse transformations.
In the code block below, you will need to implement the following:
centers
using pca.inverse_transform
and assign the new centers to log_centers
.np.log
to log_centers
using np.exp
and assign the true centers to true_centers
.# TODO: Inverse transform the centers
log_centers = pca.inverse_transform(clusterer.means_)
# TODO: Exponentiate the centers
true_centers = np.exp(log_centers)
# Display the true centers
segments = ['Segment {}'.format(i) for i in range(0,len(centers))]
true_centers = pd.DataFrame(np.round(true_centers), columns = data.keys())
true_centers.index = segments
display(true_centers)
true_good_data = np.exp(good_data)
display(true_good_data.describe())
display(true_centers)
Consider the total purchase cost of each product category for the representative data points above, and reference the statistical description of the dataset at the beginning of this project. What set of establishments could each of the customer segments represent?
Hint: A customer who is assigned to 'Cluster X'
should best identify with the establishments represented by the feature set of 'Segment X'
.
Answer:
Compared with the quantiles of true good data, we could find:
The main differences lie in 'Milk', 'Grocery', and 'Detergents_Paper', which is quite similar with the 1st principal component in PCA plotting where the 'Milk', 'Grocery', and 'Detergents_Paper' have the highest weights in the first principal component. These three features are significant to seperate segments. While the other three features 'Fresh', 'Frozen', and 'Dlicateseen' are relatively less different.
For each sample point, which customer segment from Question 8 best represents it? Are the predictions for each sample point consistent with this?
Run the code block below to find which cluster each sample point is predicted to be.
display(samples)
# Display the predictions
for i, pred in enumerate(sample_preds):
print "Sample point", i, "predicted to be in Cluster", pred
Answer:
Since Milk', 'Grocery', and 'Detergents_Paper' are significant to seperate segments, I can distinguish as :
I think the predictions are consistent with the representations.
In this final section, you will investigate ways that you can make use of the clustered data. First, you will consider how the different groups of customers, the customer segments, may be affected differently by a specific delivery scheme. Next, you will consider how giving a label to each customer (which segment that customer belongs to) can provide for additional features about the customer data. Finally, you will compare the customer segments to a hidden variable present in the data, to see whether the clustering identified certain relationships.
Companies will often run A/B tests when making small changes to their products or services to determine whether making that change will affect its customers positively or negatively. The wholesale distributor is considering changing its delivery service from currently 5 days a week to 3 days a week. However, the distributor will only make this change in delivery service for customers that react positively. How can the wholesale distributor use the customer segments to determine which customers, if any, would react positively to the change in delivery service?
Hint: Can we assume the change affects all customers equally? How can we determine which group of customers it affects the most?
Answer:
The hypothesis is like delivery service of 3 days a week is uniform to both segments of customers. We are going to conduct two groups of test.
For group 1 in use of segment 0: Split the segment 0 randomly into two groups, one continues with 5 days a week, and the other changes to 3 days a week. Then we check the purchse change.
For group 2 in use of segment 1: Split the segment 1 randomly into two groups, one continues with 5 days a week, and the other changes to 3 days a week. Then we check the purchse change.
As a result, the distributor could identify in which customer segment, which delivery service is better for maximizing the purchase amount.
Additional structure is derived from originally unlabeled data when using clustering techniques. Since each customer has a customer segment it best identifies with (depending on the clustering algorithm applied), we can consider 'customer segment' as an engineered feature for the data. Assume the wholesale distributor recently acquired ten new customers and each provided estimates for anticipated annual spending of each product category. Knowing these estimates, the wholesale distributor wants to classify each new customer to a customer segment to determine the most appropriate delivery service.
How can the wholesale distributor label the new customers using only their estimated product spending and the customer segment data?
Hint: A supervised learner could be used to train on the original customers. What would be the target variable?
Answer:
The distributor could treat each cluster as a categorical label, and give each customer a label according to its clustering. Then the problem would be supervised, and the distributor can analyse the relationship between the provided features such as Fresh, Milk, Grocery and the labels. Furthermore, the distributor could also regard the labels as a new feature and take them into consideration when analysing the relationship between features, i.e., to explore how Fresh, Milk and labels impact Grocery.
At the beginning of this project, it was discussed that the 'Channel'
and 'Region'
features would be excluded from the dataset so that the customer product categories were emphasized in the analysis. By reintroducing the 'Channel'
feature to the dataset, an interesting structure emerges when considering the same PCA dimensionality reduction applied earlier to the original dataset.
Run the code block below to see how each data point is labeled either 'HoReCa'
(Hotel/Restaurant/Cafe) or 'Retail'
the reduced space. In addition, you will find the sample points are circled in the plot, which will identify their labeling.
# Display the clustering results based on 'Channel' data
vs.channel_results(reduced_data, outliers_index, pca_samples)
How well does the clustering algorithm and number of clusters you've chosen compare to this underlying distribution of Hotel/Restaurant/Cafe customers to Retailer customers? Are there customer segments that would be classified as purely 'Retailers' or 'Hotels/Restaurants/Cafes' by this distribution? Would you consider these classifications as consistent with your previous definition of the customer segments?
Answer: I would consider these classifications as consistent with my clustering in the output of two clusters. Compared with this distribution, my clusters are less overlapping after removing outliers.
Note: Once you have completed all of the code implementations and successfully answered each question above, you may finalize your work by exporting the iPython Notebook as an HTML document. You can do this by using the menu above and navigating to
File -> Download as -> HTML (.html). Include the finished document along with this notebook as your submission.


In my less-than-a-year activity in crypto, this is the biggest bear market I’ve ever seen so far. And this is the best time too for examining each of my holdings when they are literally stuck for trading at such a terrible price.
I scan through my long-term holding coins to identify which of them are able to self-generating income.
Coins that is not self-generating
Bitcoin: Not providing any value if not using for payment. Maybe can be a source to bring some bonus from bitcoin hardfork, like Bitcoin cash, Bitcoin Gold and etc.
Ethereum: Some new ERC20 tokens will airdrop to ETH holders. Except that, ETH is not generating income.
Cardano: ADA is mainly used for creating new smart contract like ETH and the platform is not ready yet. Not generating income.
Litecoin, Stratis, Bitcoin Cash, Golem, Siacoin, IOTA is not generating any income by just holding it.
Self-generating coins
Steem: Nuff said. Even you are not participating in the Steem blockchain by authoring and curating, simply power up Steem to Steem Power is enough to earn the dividend from inflation every day. You could even sell your SP by delegate to others via Minnowbooster for higher income as well. Steem is definitely a self-multiplying machine.
Neo: Holding neo will generate free GAS everyday and the price of GAS tends to follow NEO’s. Not a bad way to treat it as some passive income.
Byteball: The nature of this coin is not self-generating, but the strategy running the devs is unique. They want to airdrop almost all the Byteball supply and so far 65% has been distributed. Holding Byteball can earn more of it by airdroping.
These 3 coins are my holdings that are self-generating, what is yours?
在熊市中，很多持有的币都狠狠的被套着了。这让我不禁反思有哪些币在这样的环境中依然能够自我增值。
比特币作为支付用途，如果不用来支付就等于没用 。但是持有比特币还是有些增值的旁门左道，就是那些硬分叉币比如BCC 和 BTG 。
ETH 也不会自我增值，除了某些新的 ERC20 代币有时会空降下来。
Litecoin, Stratis, Bitcoin Cash, Golem, Siacoin, IOTA 全部都不会自我增值。
接下来就说说那些会生蛋的母鸡币了
Steem 当然当之无愧的是以币生币的最佳母鸡。就算完全不参与写作和 Curation，Steem Power 还是能让你每天收到系统通膨带来的分红，更别说通过 Minnowbooster 卖 SP 能赚更多了。
持有 NEO 也会根据一定的比率分发 GAS，而 GAS 的价格根据历史而言也是和 NEO 一起浮动的，所以也不失为一个被动收入的方法。
Byteball 虽然设计上不会自我增值，但是开发团队会把几乎接近总量的币靠空降的方式派发给持有者。目前总共才派发出 65% ，也是个不错的选择。
你有什么会下蛋的好币？


{% extends "global/Page.html" %} {% load staticfiles otree %} {% block title %} Part 2 - Survey results {% endblock %} {% block content %}
Here are the results of the survey.
{{ group.num_yes}} participants chose the first option and pledged to bid 0 in the next rounds.
{{ group.num_no}} participants chose the second option and did not pledge to bid 0 in the next rounds.
{% next_button %} {% endblock %}


NimBLE Host Return Codes¶
Introduction¶
Summary¶
The NimBLE host reports status to the application via a set of return codes. The host encompasses several layers of the Bluetooth specification that each defines its own set of status codes. Rather than “abstract away” information from lower layers that the application developer might find useful, the NimBLE host aims to indicate precisely what happened when something fails. Consequently, the host utilizes a rather large set of return codes.
A return code of 0 indicates success. For failure conditions, the return codes are partitioned into five separate sets:
| Set | Condition |
|---|---|
| Core | Errors detected internally by the NimBLE host. |
| ATT | The ATT server has reported a failure via the transmission of an ATT Error Response. The return code corresponds to the value of the Error Code field in the response. |
| HCI | The controller has reported an error to the host via a command complete or command status HCI event. The return code corresponds to the value of the Status field in the event. |
| L2CAP | An L2CAP signaling procedure has failed and an L2CAP Command Reject was sent as a result. The return code corresponds to the value of the Reason field in the command. |
| Security manager (us) | The host detected an error during a security manager procedure and sent a Pairing Failed command to the peer. The return code corresponds to the value of the Reason field in the Pairing Failed command. |
| Security manager (peer) | A security manager procedure failed because the peer sent us a Pairing Failed command. The return code corresponds to the value of the Reason field in the Pairing Failed command. |
The return codes in the core set are defined by the NimBLE Host. The other sets are defined in the Bluetooth specification; the codes in this latter group are referred to as formal status codes. As defined in the Bluetooth specification, the formal status code sets are not disjoint. That is, they overlap. For example, the spec defines a status code of 1 to have all of the following meanings:
| Layer | Meaning |
|---|---|
| ATT | Invalid handle. |
| HCI | Unknown HCI command. |
| L2CAP | Signalling MTU exceeded. |
| SM | Passkey entry failed. |
Clearly, the host can’t just return an unadorned formal status code and expect the application to make sense of it. To resolve this ambiguity, the NimBLE host divides the full range of an int into several subranges. Each subrange corresponds to one of the five return code sets. For example, the ATT set is mapped onto the subrange [0x100, 0x200). To indicate an ATT error of 3 (write not permitted), the NimBLE host returns a value 0x103 to the application.
The host defines a set of convenience macros for converting from a formal status code to NimBLE host status code. These macros are documented in the table below.
| Macro | Status code set | Base value |
|---|---|---|
| BLE_HS_ATT_ERR() | ATT | 0x100 |
| BLE_HS_HCI_ERR() | HCI | 0x200 |
| BLE_HS_L2C_ERR() | L2CAP | 0x300 |
| BLE_HS_SM_US_ERR() | Security manager (us) | 0x400 |
| BLE_HS_SM_PEER_ERR() | Security manager (peer) | 0x500 |
Example¶
The following example demonstrates how an application might determine which error is being reported by the host. In this example, the application performs the GAP encryption procedure and checks the return code. To simplify the example, the application uses a hypothetical my_blocking_enc_proc() function, which blocks until the pairing operation has completed.
void
encrypt_connection(uint16_t conn_handle)
{
int rc;
/* Perform a blocking GAP encryption procedure. */
rc = my_blocking_enc_proc(conn_handle);
switch (rc) {
case 0:
console_printf("success - link successfully encrypted\n");
break;
case BLE_HS_ENOTCONN:
console_printf("failure - no connection with handle %d\n",
conn_handle);
break;
case BLE_HS_ERR_SM_US_BASE(BLE_SM_ERR_CONFIRM_MISMATCH):
console_printf("failure - mismatch in peer's confirm and random "
"commands.\n");
break;
case BLE_HS_ERR_SM_PEER_BASE(BLE_SM_ERR_CONFIRM_MISMATCH):
console_printf("failure - peer reports mismatch in our confirm and "
"random commands.\n");
break;
default:
console_printf("failure - other error: 0x%04x\n", rc);
break;
}
}
Return Code Reference¶
Header¶
All NimBLE host return codes are made accessible by including the following header:
#include "host/ble_hs.h"
Return codes - Core¶
The precise meaning of each of these error codes depends on the function that returns it. The API reference for a particular function indicates the conditions under which each of these codes are returned.
| Value | Name | Condition |
|---|---|---|
| 0x00 | N/A | Success |
| 0x01 | BLE_HS_EAGAIN | Temporary failure; try again. |
| 0x02 | BLE_HS_EALREADY | Operation already in progress or completed. |
| 0x03 | BLE_HS_EINVAL | One or more arguments are invalid. |
| 0x04 | BLE_HS_EMSGSIZE | The provided buffer is too small. |
| 0x05 | BLE_HS_ENOENT | No entry matching the specified criteria. |
| 0x06 | BLE_HS_ENOMEM | Operation failed due to resource exhaustion. |
| 0x07 | BLE_HS_ENOTCONN | No open connection with the specified handle. |
| 0x08 | BLE_HS_ENOTSUP | Operation disabled at compile time. |
| 0x09 | BLE_HS_EAPP | Application callback behaved unexpectedly. |
| 0x0a | BLE_HS_EBADDATA | Command from peer is invalid. |
| 0x0b | BLE_HS_EOS | Mynewt OS error. |
| 0x0c | BLE_HS_ECONTROLLER | Event from controller is invalid. |
| 0x0d | BLE_HS_ETIMEOUT | Operation timed out. |
| 0x0e | BLE_HS_EDONE | Operation completed successfully. |
| 0x0f | BLE_HS_EBUSY | Operation cannot be performed until procedure completes. |
| 0x10 | BLE_HS_EREJECT | Peer rejected a connection parameter update request. |
| 0x11 | BLE_HS_EUNKNOWN | Unexpected failure; catch all. |
| 0x12 | BLE_HS_EROLE | Operation requires different role (e.g., central vs. peripheral). |
| 0x13 | BLE_HS_ETIMEOUT_HCI | HCI request timed out; controller unresponsive. |
| 0x14 | BLE_HS_ENOMEM_EVT | Controller failed to send event due to memory exhaustion (combined host-controller only). |
| 0x15 | BLE_HS_ENOADDR | Operation requires an identity address but none configured. |
| 0x16 | BLE_HS_ENOTSYNCED | Attempt to use the host before it is synced with controller. |
| 0x17 | BLE_HS_EAUTHEN | Insufficient authentication. |
| 0x18 | BLE_HS_EAUTHOR | Insufficient authorization. |
| 0x19 | BLE_HS_EENCRYPT | Insufficient encryption level. |
| 0x1a | BLE_HS_EENCRYPT_KEY_SZ | Insufficient key size. |
| 0x1b | BLE_HS_ESTORE_CAP | Storage at capacity. |
| 0x1c | BLE_HS_ESTORE_FAIL | Storage IO error. |
Return codes - ATT¶
| NimBLE Value | Formal Value | Name | Condition |
|---|---|---|---|
| 0x0101 | 0x01 | BLE_ATT_ERR_INVALID_HANDLE | The attribute handle given was not valid on this server. |
| 0x0102 | 0x02 | BLE_ATT_ERR_READ_NOT_PERMITTED | The attribute cannot be read. |
| 0x0103 | 0x03 | BLE_ATT_ERR_WRITE_NOT_PERMITTED | The attribute cannot be written. |
| 0x0104 | 0x04 | BLE_ATT_ERR_INVALID_PDU | The attribute PDU was invalid. |
| 0x0105 | 0x05 | BLE_ATT_ERR_INSUFFICIENT_AUTHEN | The attribute requires authentication before it can be read or written. |
| 0x0106 | 0x06 | BLE_ATT_ERR_REQ_NOT_SUPPORTED | Attribute server does not support the request received from the client. |
| 0x0107 | 0x07 | BLE_ATT_ERR_INVALID_OFFSET | Offset specified was past the end of the attribute. |
| 0x0108 | 0x08 | BLE_ATT_ERR_INSUFFICIENT_AUTHOR | The attribute requires authorization before it can be read or written. |
| 0x0109 | 0x09 | BLE_ATT_ERR_PREPARE_QUEUE_FULL | Too many prepare writes have been queued. |
| 0x010a | 0x0a | BLE_ATT_ERR_ATTR_NOT_FOUND | No attribute found within the given attribute handle range. |
| 0x010b | 0x0b | BLE_ATT_ERR_ATTR_NOT_LONG | The attribute cannot be read or written using the Read Blob Request. |
| 0x010c | 0x0c | BLE_ATT_ERR_INSUFFICIENT_KEY_SZ | The Encryption Key Size used for encrypting this link is insufficient. |
| 0x010d | 0x0d | BLE_ATT_ERR_INVALID_ATTR_VALUE_LEN | The attribute value length is invalid for the operation. |
| 0x010e | 0x0e | BLE_ATT_ERR_UNLIKELY | The attribute request that was requested has encountered an error that was unlikely, and therefore could not be completed as requested. |
| 0x010f | 0x0f | BLE_ATT_ERR_INSUFFICIENT_ENC | The attribute requires encryption before it can be read or written. |
| 0x0110 | 0x10 | BLE_ATT_ERR_UNSUPPORTED_GROUP | The attribute type is not a supported grouping attribute as defined by a higher layer specification. |
| 0x0111 | 0x11 | BLE_ATT_ERR_INSUFFICIENT_RES | Insufficient Resources to complete the request. |
Return codes - HCI¶
| NimBLE Value | Formal Value | Name | Condition |
|---|---|---|---|
| 0x0201 | 0x01 | BLE_ERR_UNKNOWN_HCI_CMD | Unknown HCI Command |
| 0x0202 | 0x02 | BLE_ERR_UNK_CONN_ID | Unknown Connection Identifier |
| 0x0203 | 0x03 | BLE_ERR_HW_FAIL | Hardware Failure |
| 0x0204 | 0x04 | BLE_ERR_PAGE_TMO | Page Timeout |
| 0x0205 | 0x05 | BLE_ERR_AUTH_FAIL | Authentication Failure |
| 0x0206 | 0x06 | BLE_ERR_PINKEY_MISSING | PIN or Key Missing |
| 0x0207 | 0x07 | BLE_ERR_MEM_CAPACITY | Memory Capacity Exceeded |
| 0x0208 | 0x08 | BLE_ERR_CONN_SPVN_TMO | Connection Timeout |
| 0x0209 | 0x09 | BLE_ERR_CONN_LIMIT | Connection Limit Exceeded |
| 0x020a | 0x0a | BLE_ERR_SYNCH_CONN_LIMIT | Synchronous Connection Limit To A Device Exceeded |
| 0x020b | 0x0b | BLE_ERR_ACL_CONN_EXISTS | ACL Connection Already Exists |
| 0x020c | 0x0c | BLE_ERR_CMD_DISALLOWED | Command Disallowed |
| 0x020d | 0x0d | BLE_ERR_CONN_REJ_RESOURCES | Connection Rejected due to Limited Resources |
| 0x020e | 0x0e | BLE_ERR_CONN_REJ_SECURITY | Connection Rejected Due To Security Reasons |
| 0x020f | 0x0f | BLE_ERR_CONN_REJ_BD_ADDR | Connection Rejected due to Unacceptable BD_ADDR |
| 0x0210 | 0x10 | BLE_ERR_CONN_ACCEPT_TMO | Connection Accept Timeout Exceeded |
| 0x0211 | 0x11 | BLE_ERR_UNSUPPORTED | Unsupported Feature or Parameter Value |
| 0x0212 | 0x12 | BLE_ERR_INV_HCI_CMD_PARMS | Invalid HCI Command Parameters |
| 0x0213 | 0x13 | BLE_ERR_REM_USER_CONN_TERM | Remote User Terminated Connection |
| 0x0214 | 0x14 | BLE_ERR_RD_CONN_TERM_RESRCS | Remote Device Terminated Connection due to Low Resources |
| 0x0215 | 0x15 | BLE_ERR_RD_CONN_TERM_PWROFF | Remote Device Terminated Connection due to Power Off |
| 0x0216 | 0x16 | BLE_ERR_CONN_TERM_LOCAL | Connection Terminated By Local Host |
| 0x0217 | 0x17 | BLE_ERR_REPEATED_ATTEMPTS | Repeated Attempts |
| 0x0218 | 0x18 | BLE_ERR_NO_PAIRING | Pairing Not Allowed |
| 0x0219 | 0x19 | BLE_ERR_UNK_LMP | Unknown LMP PDU |
| 0x021a | 0x1a | BLE_ERR_UNSUPP_REM_FEATURE | Unsupported Remote Feature / Unsupported LMP Feature |
| 0x021b | 0x1b | BLE_ERR_SCO_OFFSET | SCO Offset Rejected |
| 0x021c | 0x1c | BLE_ERR_SCO_ITVL | SCO Interval Rejected |
| 0x021d | 0x1d | BLE_ERR_SCO_AIR_MODE | SCO Air Mode Rejected |
| 0x021e | 0x1e | BLE_ERR_INV_LMP_LL_PARM | Invalid LMP Parameters / Invalid LL Parameters |
| 0x021f | 0x1f | BLE_ERR_UNSPECIFIED | Unspecified Error |
| 0x0220 | 0x20 | BLE_ERR_UNSUPP_LMP_LL_PARM | Unsupported LMP Parameter Value / Unsupported LL Parameter Value |
| 0x0221 | 0x21 | BLE_ERR_NO_ROLE_CHANGE | Role Change Not Allowed |
| 0x0222 | 0x22 | BLE_ERR_LMP_LL_RSP_TMO | LMP Response Timeout / LL Response Timeout |
| 0x0223 | 0x23 | BLE_ERR_LMP_COLLISION | LMP Error Transaction Collision |
| 0x0224 | 0x24 | BLE_ERR_LMP_PDU | LMP PDU Not Allowed |
| 0x0225 | 0x25 | BLE_ERR_ENCRYPTION_MODE | Encryption Mode Not Acceptable |
| 0x0226 | 0x26 | BLE_ERR_LINK_KEY_CHANGE | Link Key cannot be Changed |
| 0x0227 | 0x27 | BLE_ERR_UNSUPP_QOS | Requested QoS Not Supported |
| 0x0228 | 0x28 | BLE_ERR_INSTANT_PASSED | Instant Passed |
| 0x0229 | 0x29 | BLE_ERR_UNIT_KEY_PAIRING | Pairing With Unit Key Not Supported |
| 0x022a | 0x2a | BLE_ERR_DIFF_TRANS_COLL | Different Transaction Collision |
| 0x022c | 0x2c | BLE_ERR_QOS_PARM | QoS Unacceptable Parameter |
| 0x022d | 0x2d | BLE_ERR_QOS_REJECTED | QoS Rejected |
| 0x022e | 0x2e | BLE_ERR_CHAN_CLASS | Channel Classification Not Supported |
| 0x022f | 0x2f | BLE_ERR_INSUFFICIENT_SEC | Insufficient Security |
| 0x0230 | 0x30 | BLE_ERR_PARM_OUT_OF_RANGE | Parameter Out Of Mandatory Range |
| 0x0232 | 0x32 | BLE_ERR_PENDING_ROLE_SW | Role Switch Pending |
| 0x0234 | 0x34 | BLE_ERR_RESERVED_SLOT | Reserved Slot Violation |
| 0x0235 | 0x35 | BLE_ERR_ROLE_SW_FAIL | Role Switch Failed |
| 0x0236 | 0x36 | BLE_ERR_INQ_RSP_TOO_BIG | Extended Inquiry Response Too Large |
| 0x0237 | 0x37 | BLE_ERR_SEC_SIMPLE_PAIR | Secure Simple Pairing Not Supported By Host |
| 0x0238 | 0x38 | BLE_ERR_HOST_BUSY_PAIR | Host Busy - Pairing |
| 0x0239 | 0x39 | BLE_ERR_CONN_REJ_CHANNEL | Connection Rejected due to No Suitable Channel Found |
| 0x023a | 0x3a | BLE_ERR_CTLR_BUSY | Controller Busy |
| 0x023b | 0x3b | BLE_ERR_CONN_PARMS | Unacceptable Connection Parameters |
| 0x023c | 0x3c | BLE_ERR_DIR_ADV_TMO | Directed Advertising Timeout |
| 0x023d | 0x3d | BLE_ERR_CONN_TERM_MIC | Connection Terminated due to MIC Failure |
| 0x023e | 0x3e | BLE_ERR_CONN_ESTABLISHMENT | Connection Failed to be Established |
| 0x023f | 0x3f | BLE_ERR_MAC_CONN_FAIL | MAC Connection Failed |
| 0x0240 | 0x40 | BLE_ERR_COARSE_CLK_ADJ | Coarse Clock Adjustment Rejected but Will Try to Adjust Using Clock Dragging |
Return codes - L2CAP¶
| NimBLE Value | Formal Value | Name | Condition |
|---|---|---|---|
| 0x0300 | 0x00 | BLE_L2CAP_SIG_ERR_CMD_NOT_UNDERSTOOD | Invalid or unsupported incoming L2CAP sig command. |
| 0x0301 | 0x01 | BLE_L2CAP_SIG_ERR_MTU_EXCEEDED | Incoming packet too large. |
| 0x0302 | 0x02 | BLE_L2CAP_SIG_ERR_INVALID_CID | No channel with specified ID. |
Return codes - Security manager (us)¶
| NimBLE Value | Formal Value | Name | Condition |
|---|---|---|---|
| 0x0401 | 0x01 | BLE_SM_ERR_PASSKEY | The user input of passkey failed, for example, the user cancelled the operation. |
| 0x0402 | 0x02 | BLE_SM_ERR_OOB | The OOB data is not available. |
| 0x0403 | 0x03 | BLE_SM_ERR_AUTHREQ | The pairing procedure cannot be performed as authentication requirements cannot be met due to IO capabilities of one or both devices. |
| 0x0404 | 0x04 | BLE_SM_ERR_CONFIRM_MISMATCH | The confirm value does not match the calculated compare value. |
| 0x0405 | 0x05 | BLE_SM_ERR_PAIR_NOT_SUPP | Pairing is not supported by the device. |
| 0x0406 | 0x06 | BLE_SM_ERR_ENC_KEY_SZ | The resultant encryption key size is insufficient for the security requirements of this device. |
| 0x0407 | 0x07 | BLE_SM_ERR_CMD_NOT_SUPP | The SMP command received is not supported on this device. |
| 0x0408 | 0x08 | BLE_SM_ERR_UNSPECIFIED | Pairing failed due to an unspecified reason. |
| 0x0409 | 0x09 | BLE_SM_ERR_REPEATED | Pairing or authentication procedure is disallowed because too little time has elapsed since last pairing request or security request. |
| 0x040a | 0x0a | BLE_SM_ERR_INVAL | The Invalid Parameters error code indicates that the command length is invalid or that a parameter is outside of the specified range. |
| 0x040b | 0x0b | BLE_SM_ERR_DHKEY | Indicates to the remote device that the DHKey Check value received doesn’t match the one calculated by the local device. |
| 0x040c | 0x0c | BLE_SM_ERR_NUMCMP | Indicates that the confirm values in the numeric comparison protocol do not match. |
| 0x040d | 0x0d | BLE_SM_ERR_ALREADY | Indicates that the pairing over the LE transport failed due to a Pairing Request sent over the BR/EDR transport in process. |
| 0x040e | 0x0e | BLE_SM_ERR_CROSS_TRANS | Indicates that the BR/EDR Link Key generated on the BR/EDR transport cannot be used to derive and distribute keys for the LE transport. |
Return codes - Security manager (peer)¶
| NimBLE Value | Formal Value | Name | Condition |
|---|---|---|---|
| 0x0501 | 0x01 | BLE_SM_ERR_PASSKEY | The user input of passkey failed, for example, the user cancelled the operation. |
| 0x0502 | 0x02 | BLE_SM_ERR_OOB | The OOB data is not available. |
| 0x0503 | 0x03 | BLE_SM_ERR_AUTHREQ | The pairing procedure cannot be performed as authentication requirements cannot be met due to IO capabilities of one or both devices. |
| 0x0504 | 0x04 | BLE_SM_ERR_CONFIRM_MISMATCH | The confirm value does not match the calculated compare value. |
| 0x0505 | 0x05 | BLE_SM_ERR_PAIR_NOT_SUPP | Pairing is not supported by the device. |
| 0x0506 | 0x06 | BLE_SM_ERR_ENC_KEY_SZ | The resultant encryption key size is insufficient for the security requirements of this device. |
| 0x0507 | 0x07 | BLE_SM_ERR_CMD_NOT_SUPP | The SMP command received is not supported on this device. |
| 0x0508 | 0x08 | BLE_SM_ERR_UNSPECIFIED | Pairing failed due to an unspecified reason. |
| 0x0509 | 0x09 | BLE_SM_ERR_REPEATED | Pairing or authentication procedure is disallowed because too little time has elapsed since last pairing request or security request. |
| 0x050a | 0x0a | BLE_SM_ERR_INVAL | The Invalid Parameters error code indicates that the command length is invalid or that a parameter is outside of the specified range. |
| 0x050b | 0x0b | BLE_SM_ERR_DHKEY | Indicates to the remote device that the DHKey Check value received doesn’t match the one calculated by the local device. |
| 0x050c | 0x0c | BLE_SM_ERR_NUMCMP | Indicates that the confirm values in the numeric comparison protocol do not match. |
| 0x050d | 0x0d | BLE_SM_ERR_ALREADY | Indicates that the pairing over the LE transport failed due to a Pairing Request sent over the BR/EDR transport in process. |
| 0x050e | 0x0e | BLE_SM_ERR_CROSS_TRANS | Indicates that the BR/EDR Link Key generated on the BR/EDR transport cannot be used to derive and distribute keys for the LE transport. |


QuotQualGrp
Tag
Name
Req'd
Description
735
NoQuoteQualifiers
N
695
QuoteQualifier
N
Code to qualify Quote use
See IOIQualifier (104) for description and valid values.
Used in Messages:
[Quote]
Used in Components:
[QuotReqGrp]


SNAKE & LADDERS
PLAY WITH
COMPUTER
ANOTHER PLAYER
Enter Your Username
PLAY
Enter Your Username
Enter Player 2 Username
PLAY
New Game
1 2 3 4 5 6
START ROLL
STOP ROLL
OK
Hey!! Ladder :)
OK
OMG!! Snake :(
OK
YOU WON!!(
OK


This document describes the changes made to the software between the previous and current versions (see above). If you don't find something listed here, then it was not done in this timeframe, or it was not considered important enough to be mentioned. The following information is located here:
The ChangeLog will follow, but please note the most important change: LZW compression has been removed.
Unisys has the patent on LZW compression and have been very active in their enforcement of late, demanding payments of $5000 or more from websites using unlicensed software to create GIF's. They could well do the same do persons using libtiff to create LZW compressed TIFF images.
From Burn All GIF's Day:
The catch is that it appears to be difficult or impossible to get a
Unisys license to use LZW in free software that complies with the Open
Source Definition
Unfortunately, the removal of LZW compression means that saved image size has grown dramatically. Without a change in the TIFF spec to support another lossless compression format, this is unavoidable.
The library can use zip for lossless compression, but as this is not part of the spec, TIFFs using zip compression may not work with other software
We will be making a patch available that will contain the LZW compression code for users who have either obtained a license from Unisys or are willing to risk it.
LZW decompression is unchanged.


We, as students of Skoltech, live with Sk-spirit, that's why we want to share Culture of Skoltech.
Please, practice your feedback in Courteous, Actionable (non-descriptive), Positive (CAP) manner.
That will help you become more charismatic. Help yourself and us.


Class AdapterInfo
Assembly: XRTK.dll
Syntax
[Serializable]
public class AdapterInfo
Fields
|
Improve this Doc
View Source
Description
Declaration
public string Description
Field Value
|
Improve this Doc
View Source
DHCP
Declaration
Field Value
|
Improve this Doc
View Source
Gateways
Declaration
public IpAddressInfo[] Gateways
Field Value
|
Improve this Doc
View Source
HardwareAddress
Declaration
public string HardwareAddress
Field Value
|
Improve this Doc
View Source
Index
Declaration
Field Value
|
Improve this Doc
View Source
IpAddresses
Declaration
public IpAddressInfo[] IpAddresses
Field Value
|
Improve this Doc
View Source
Name
Declaration
Field Value
|
Improve this Doc
View Source
Type
Declaration
Field Value
Extension Methods


Reservation Page
Make your reservation
View Tables
Return to Homepage
Table Reservation
Name
Phone Number
Email
Submit


Money Play. How should Red play 43?
pips Red=79 White=133
(CorrectAnswer= 0/0, ErrorScore= 0)
Over the board I played 5/2, 5/1 but upon initial analysis XG didn’t like the play, preferring the pay-me-now play of 13/6.
However, on a long rollout my original 5/2, 5/1 is proved to be correct, albeit by only 0.025.
I think the combination of White’s four-and-a-half-point home board and the fact that the remaining blot on the mid-point might not get to safety next turn just swings it in favour of the safe play.
However, on a long rollout my original 5/2, 5/1 is proved to be correct, albeit by only 0.025.
I think the combination of White’s four-and-a-half-point home board and the fact that the remaining blot on the mid-point might not get to safety next turn just swings it in favour of the safe play.
1. Cubeful 2-ply 13/6 Eq.: +0.192 0.596 0.196 0.004 - 0.404 0.056 0.002 2. Cubeful 2-ply 5/2 5/1 Eq.: +0.122 (-0.070) 0.596 0.128 0.000 - 0.404 0.060 0.001 3. Cubeful 2-ply 6/3 6/2 Eq.: -0.024 (-0.216) 0.538 0.165 0.002 - 0.462 0.098 0.002 4. Cubeful 0-ply 7/3 6/3 Eq.: -0.038 (-0.230) 0.534 0.157 0.001 - 0.466 0.105 0.001 5. Cubeful 0-ply 6/2 5/2 Eq.: -0.067 (-0.259) 0.528 0.140 0.001 - 0.472 0.103 0.001


{% extends "base.html" %} {% import "macros.html" as macros %} {% block page_styles %} {% endblock %} {% block navbar %} {% include 'navbar.html' %} {% endblock %} {% block content %}
Flavors are used by Appliances to describe Instance Type values for # of Compute Cores, Memory, Disk and Network Speed. You can update this appliance's Ask Prices for flavors it advertises via Instance Asks by clicking on the Flavor Name link.
Flavors are synced every 15 minutes from the Pool Operator and are automatically installed into the OpenStack Cluster by the appliance. You should only enable flavors your OpenStack cluster can readily support.
| State | Flavor | VPUs | Memory | Disk | Network | Ask Rate |
|---|---|---|---|---|---|---|
|
|
{{ flavor.name }} | {{ flavor.vpus }} Core{% if flavor.vpus > 1 %}s{% endif %} | {{ flavor.memory }}MB | {{ flavor.disk }}GB | {% if flavor.network < 0 %}Unlimited{% else %}{{ flavor.network }} Mb/sec{% endif %} | {{ flavor.ask }} μBTC/Hour |
10 μBTC = ~US${{ '%0.6f'| format(quote*10|float) }}
via Coinbase


Captify is a plugin for jQuery written by Brian Reavis (@brianreavis) to display simple, pretty image captions that appear on rollover. It has been tested on Firefox, Chrome, Safari, and the wretched Internet Explorer. Captify was inspired by ImageCaptions, another jQuery plugin for displaying captions like these.
The goal of Captify is to be easy to use, small/simple, and completely ready for use in production environments (unlike ImageCaptions at the moment). Also, it's only 2.3kb!
What do you think? Feel free to drop by my blog and/or follow me on twitter!

 Whatever caption you like

First off, if you haven't downloaded it already, download Captify here.
$(function(){
$('img.captify').captify({
// all of these options are... optional
// ---
// speed of the mouseover effect
speedOver: 'fast',
// speed of the mouseout effect
speedOut: 'normal',
// how long to delay the hiding of the caption after mouseout (ms)
hideDelay: 500,
// 'fade', 'slide', 'always-on'
animation: 'slide',
// text/html to be placed at the beginning of every caption
prefix: '',
// opacity of the caption on mouse over
opacity: '0.7',
// the name of the CSS class to apply to the caption box
className: 'caption-bottom',
// position of the caption (top or bottom)
position: 'bottom',
// caption span % of the image
spanWidth: '100%'
});
});
This javascript above should be wrapped in a


| Opcode/Instruction | Op/En | 64/32 -bit Mode | CPUID Feature Flag | Description |
| VEX.NDS.256.66.0F3A.W0 38 /r ib VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 | RVMI | V/V | AVX2 | Insert 128-bits of integer data from xmm3/mem and the remaining values from ymm2 into ymm1. |
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| RVMI | ModRM:reg (w) | VEX.vvvv | ModRM:r/m (r) | Imm8 |
Performs an insertion of 128-bits of packed integer data from the second source operand (third operand) into an the destination operand (first operand) at a 128-bit offset from imm8[0]. The remaining portions of the destination are written by the corresponding fields of the first source operand (second operand). The second source operand can be either an XMM register or a 128-bit memory location. The high 7 bits of the immediate are ignored. VEX.L must be 1; an attempt to execute this instruction with VEX.L=0 will cause #UD.
VINSERTI128 TEMP[255:0] ← SRC1[255:0] CASE (imm8[0]) OF 0: TEMP[127:0] ←SRC2[127:0] 1: TEMP[255:128] ← SRC2[127:0] ESAC DEST ←TEMP
VINSERTI128: __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, int offset);
None
See Exceptions Type 6; additionally
| #UD | If VEX.L = 0, If VEX.W = 1. |


This HIT cannot be started
The reason is that you have already created an account on our website using your worker id. If you'd like to work on this HIT, please contact us at sidewalk@@cs.uw.edu. Alternatively, you could continue using your account on our website: projectsidewalk.io and keep mapping! :)


The content of this section will cover the part of new entities/relations creation specific to MooseQuery. It will not cover how to create new Moose entities. For this, please refer to Moose documentation.
MooseQuery is the result of the Inria research team RMoD. This page documents the internals of MooseQuery. As prerequisites, it supposes the reader has a minimum of knowledge of Fame and Famix. If not, please read the Moose documentation. if you wish to understand everything.
This documentation covers:
The content of this section will cover the part of new entities/relations creation specific to MooseQuery. It will not cover how to create new Moose entities. For this, please refer to Moose documentation.
First, the developer of the model have to make his new entities/relations queryable with MooseQuery.
As said in the user documentation, MooseQuery is based on two concepts:
Here, for example, Entity1 is the container of Entity2 and also Entity1 is the source of an association to Entity3.
Moose query needs to know those relations in order to work. To declare them you just need to use three pragma: <container>, <source> and <target>
FAMIXAttribute>>parentType
<MSEProperty: #parentType type: #FAMIXType opposite: #attributes>
<MSEComment: 'Type declaring the attribute. belongsTo implementation'>
<container> "<=== Here is the containment relation definition"
^ parentType
FAMIXAccess>>accessor
<MSEProperty: #accessor type: #FAMIXBehaviouralEntity opposite: #accesses>
<MSEComment: 'Behavioural entity making the access to the variable. from-side of the association'>
<source> "<=== Here is the association's source definition"
^ accessor
FAMIXAccess>>variable
<MSEProperty: #variable type: #FAMIXStructuralEntity opposite: #incomingAccesses>
<MSEComment: 'Variable accessed. to-side of the association'>
<target> "<=== Here is the association's target definition"
^ variable
The definition of the relations give to MooseQuery all the requirements for querying the meta-model. Now, the new entities of the model need to have the behaviour, i.e., the methods, to execute the queries. To do so, MooseQuery comes with a set of Traits to use in the new entities.
| Trait | Default users | Description |
|---|---|---|
| TAssociationMetaLevelDependency | FAMIXAssociation | This trait includes the information about associations needed for the navigation queries. It needs to be used by every association in a meta-model. |
| TEntityMetaLevelDependency | FAMIXAnnotationInstance, FAMIXAnnotationInstanceAttribute, FAMIXNamedEntity | This trait includes the information about entities and adds the behaviour to explore the containment tree and execute scope queries. It needs to be used by every entity in a meta-model. |
| TDependencyQuery | FAMIXAnnotationInstance, FAMIXAnnotationInstanceAttribute | This trait includes the information about entities and adds the behaviour to execute navigation queries. It needs to be used by every entity in a meta-model. |
| TOODependencyQuery | FAMIXNamedEntity | This trait includes the information about object-oriented entities and adds the behaviour to execute navigation queries. It needs to be used by every object-oriented entities in a meta-model instead of TDependencyQuery. |
All those traits need to be used when implementing a new meta-model. For performance reasons, some more work is needed when using those traits. Some methods exist in two versions. One private with the real behaviour, and the other explicitly required to get a cached version. Here is the list of caches to implement:
TEntityMetaLevelDependency class>>allChildrenTypes
^ self explicitRequirement
TEntityMetaLevelDependency class>>privateAllChildrenTypes
^ (self childrenTypes withDeepCollect: #childrenTypes as: Set) asOrderedCollection
FAMIXNamedEntity class>>allChildrenTypes
^ allChildrenTypes ifNil: [ allChildrenTypes := self privateAllChildrenTypes ]
Now that we saw how to make entities queryable, we begin to check the internal mechanisms of MooseQuery. The easiest queries are the ones related to the exploration of the containment tree.
MooseQuery allows querying the children/parents of an entity. This behaviour is based on the meta-model of the application. Each Moose's entity possesses a meta-description that lists all the properties of the entity. These properties can be obtained with:
MooseEntity class>>allDeclaredProperties
"All properties described in the metamodel"
^self mooseDescription allAttributes
FAMIXType allDeclaredProperties. "==> An array of property descriptions"
Each property knows:
So, it is possible to get the selectors of an entity returning the potential parents or children.
TEntityMetaLevelDependency class>>privateChildrenSelectors
^ self allDeclaredProperties select: #isChildrenProperty thenCollect: #implementingSelector
TEntityMetaLevelDependency class>>privateParentSelectors
^ self allDeclaredProperties select: #isContainer thenCollect: #implementingSelector
FAMIXType parentSelectors. "=> #(#container #parentPackage)"
FAMIXType childrenSelectors. "=> #(#annotationInstances #types #definedAnnotationTypes #attributes #functions #methods)"
Once we retrieved all parents/children selectors it is possible to perform them on an entity to get their results and gather the children/parents of this entity.
TEntityMetaLevelDependency>>children
| res |
res := OrderedCollection new.
"Since some selector can return nil, an entity or a collection of entities, we need to do a nil check and to ensure everything is a collection via #asCollection"
self childrenSelectors do: [ :accessor | (self perform: accessor) ifNotNil: [ :r | res addAll: r asCollection ] ].
^ res asSet
TEntityMetaLevelDependency>>parents
| res |
res := OrderedCollection new.
"Since some selector can return nil, an entity or a collection of entities, we need to do a nil check and to ensure everything is a collection via #asCollection"
self parentSelectors do: [ :accessor | (self perform: accessor) ifNotNil: [ :r | res addAll: r asCollection ] ].
^ res asSet
It is now possible to get all the children/parents of an entity via the meta-model. With this, you exclude the problem of human error.
The next step is to be able to get children/parents recursively. Since containment trees can be pretty big, we use an accumulator to avoid creating a lot of collections.
TEntityMetaLevelDependency>>allChildren
"Returns all the children and sub-children of an entity, i.e my children and those of my children, and those of the children of my children, etc"
^ self addAllChildrenIn: OrderedCollection new
TEntityMetaLevelDependency>>addAllChildrenIn: aCollection
aCollection addAll: self children.
self children do: [ :each | each addAllChildrenIn: aCollection ].
^ aCollection


| From: {{service.source}} | To:{{service.destination}} | Journey Date: {{service.jdate | date}} | {{service.busType}} |
| Conductor: {{service.conductorInfo}} | Vehicle:{{service.vehicleRegNumber}} | Report ID: {{service.serviceReportId}} | Submitted By: {{service.attributes.submittedBy}} |
| Net Income - Redbus | {{service.netRedbusIncome}} | Net Income - Abhibus | {{service.netOnlineIncome}} | Net Income - Cash | {{service.netCashIncome}} | Total Income | {{service.netIncome}} |
| {{ booking.bookedBy }} | {{ booking.ticketNo }} | {{ booking.seatsCount }} | {{booking.basicAmount + booking.serviceTax}} | {{booking.netAmt}} Due |
| Total | {{service.seatsCount}} | |||
| No bookings found. |
| {{expense.name}} | {{expense.amount}} |
| {{s.nameCode}} | {{s.type}} |


Starstreak
Log Out
LEADER BOARD
Today
Week
Month
Year
#1. Priya
6
#2. Sahij
5
#3. Mahima
3
#4. David
2
#5. Mohammed
1


*whispers*
- Heydon Pickering
I don’t understand tests. If my code breaks, I get errors. I know already.
I don’t really understand tests either tbh 😂
- Una Kravets
Marcy Sutton – Senior Front-End Engineer, Deque Systems
http://marcysutton.com/smashingBCN17 – @marcysutton
...or no testing?
🤔The human mind has limits. We can only remember so many things; we can really only concentrate on one thing at a time.
- Jeff Sutherland
Unit testing is a balance between development velocity and ROI
Ashley Williams 💭
There’s a gradient from unit to integration based on how many external things the test touches and how many of those you mock.
-Alex Early
Use tools to focus manual testing on exact component states requiring human attention
Visual Testing — the pragmatic way to test UIs


No user-identifiable data is acquired by this application.
© DigitalLabs, 2017-2018
No actual species were identified during the development of this application.


Debian 10.2 'Buster' Linux distro released with many security updates and bugfixes
by Brian FagioliDebian is a great Linux distribution in its own right, but also, it serves as a solid base for many other distros. That's why when a new version of Debian is released, it has a huge impact across the Linux community.
Today, you can download the newest version of Debian 10 "Buster." Debian 10.2 is the latest and greatest, but it is hardly exciting. To be fair though, Debian point releases shouldn't really be seen as a source for new features. Instead, you should expect security updates and bugfixes. And this time, with version 10.2, we get many of them. In addition, Firefox ESR (Extended Support Release) is being dropped from the ARMEL variant of Debian, but that really shouldn't have any impact on desktop users.
ALSO READ: MSI Cubi 5 should make an excellent mini Linux computer
"The Debian project is pleased to announce the second update of its stable distribution Debian 10 (codename 'buster'). This point release mainly adds corrections for security issues, along with a few adjustments for serious problems. Security advisories have already been published separately and are referenced where available," says The Debian Project
ALSO READ: Sorry, Microsoft, but your Edge web browser will NEVER be installed on my Linux computer
The project further says, "Please note that the point release does not constitute a new version of Debian 10 but only updates some of the packages included. There is no need to throw away old "buster" media. After installation, packages can be upgraded to the current versions using an up-to-date Debian mirror. Those who frequently install updates from security.debian.org won't have to update many packages, and most such updates are included in the point release."
The Debian Project shares the many changes below.
Security Updates
Bugfixes and Various Updates
| Package | Reason |
|---|---|
| aegisub | Fix crash when selecting a language from the bottom of the Spell checker language list; fix crash when right-clicking in the subtitles text box |
| akonadi | Fix various crashes / deadlock issues |
| base-files | Update /etc/debian_version for the point release |
| capistrano | Fix failure to remove old releases when there were too many |
| cron | Stop using obsolete SELinux API |
| cyrus-imapd | Fix data loss on upgrade from version 3.0.0 or earlier |
| debian-edu-config | Handle newer Firefox ESR configuration files; add post-up stanza to /etc/network/interfaces eth0 entry conditionally |
| debian-installer | Fix unreadable fonts on hidpi displays in netboot images booted with EFI |
| debian-installer-netboot-images | Rebuild against proposed-updates |
| distro-info-data | Add Ubuntu 20.04 LTS, Focal Fossa |
| dkimpy-milter | New upstream stable release; fix sysvinit support; catch more ASCII encoding errors to improve resilience against bad data; fix message extraction so that signing in the same pass through the milter as verifying works correctly |
| emacs | Update the EPLA packaging key |
| fence-agents | Fix incomplete removal of fence_amt_ws |
| flatpak | New upstream stable release |
| flightcrew | Security fixes [CVE-2019-13032 CVE-2019-13241] |
| fonts-noto-cjk | Fix over-aggressive font selection of Noto CJK fonts in modern web browsers under Chinese locale |
| freetype | Properly handle phantom points for variable hinted fonts |
| gdb | Rebuild against new libbabeltrace, with higher version number to avoid conflict with earlier upload |
| glib2.0 | Ensure libdbus clients can authenticate with a GDBusServer like the one in ibus |
| gnome-shell | New upstream stable release; fix truncation of long messages in Shell-modal dialogs; avoid crash on reallocation of dead actors |
| gnome-sound-recorder | Fix crash when selecting a recording |
| gnustep-base | Disable gdomap daemon that was accidentally enabled on upgrades from stretch |
| graphite-web | Remove unused send_email function [CVE-2017-18638]; avoid hourly error in cron when there is no whisper database |
| inn2 | Fix negotiation of DHE ciphersuites |
| libapache-mod-auth-kerb | Fix use after free bug leading to crash |
| libdate-holidays-de-perl | Mark International Childrens Day (Sep 20th) as a holiday in Thuringia from 2019 onwards |
| libdatetime-timezone-perl | Update included data |
| libofx | Fix null pointer dereference issue [CVE-2019-9656] |
| libreoffice | Fix the postgresql driver with PostgreSQL 12 |
| libsixel | Fix several security issues [CVE-2018-19756 CVE-2018-19757 CVE-2018-19759 CVE-2018-19761 CVE-2018-19762 CVE-2018-19763 CVE-2019-3573 CVE-2019-3574] |
| libxslt | Fix dangling pointer in xsltCopyText [CVE-2019-18197] |
| lucene-solr | Disable obsolete call to ContextHandler in solr-jetty9.xml; fix Jetty permissions on SOLR index |
| mariadb-10.3 | New upstream stable release |
| modsecurity-crs | Fix PHP script upload rules [CVE-2019-13464] |
| mutter | New upstream stable release |
| ncurses | Fix several security issues [CVE-2019-17594 CVE-2019-17595] and other issues in tic |
| ndppd | Avoid world writable PID file, that was breaking daemon init scripts |
| network-manager | Fix file permissions for /var/lib/NetworkManager/secret_key and /var/lib/NetworkManager |
| node-fstream | Fix arbitrary file overwrite issue [CVE-2019-13173] |
| node-set-value | Fix prototype pollution [CVE-2019-10747] |
| node-yarnpkg | Force using HTTPS for regular registries |
| nx-libs | Fix regressions introduced in previous upload, affecting x2go |
| open-vm-tools | Fix memory leaks and error handling |
| openvswitch | Update debian/ifupdown.sh to allow setting-up the MTU; fix Python dependencies to use Python 3 |
| picard | Update translations to fix crash with Spanish locale |
| plasma-applet-redshift-control | Fix manual mode when used with redshift versions above 1.12 |
| postfix | New upstream stable release; work around poor TCP loopback performance |
| python-cryptography | Fix test suite failures when built against newer OpenSSL versions; fix a memory leak triggerable when parsing x509 certificate extensions like AIA |
| python-flask-rdf | Add Depends on python{3,}-rdflib |
| python-oslo.messaging | New upstream stable release; fix switch connection destination when a rabbitmq cluster node disappears |
| python-werkzeug | Ensure Docker containers have unique debugger PINs [CVE-2019-14806] |
| python2.7 | Fix several security issues [CVE-2018-20852 CVE-2019-10160 CVE-2019-16056 CVE-2019-16935 CVE-2019-9740 CVE-2019-9947] |
| quota | Fix rpc.rquotad spinning at 100% CPU |
| rpcbind | Allow remote calls to be enabled at run-time |
| shelldap | Repair SASL authentications, add a 'sasluser' option |
| sogo | Fix display of PGP-signed e-mails |
| spf-engine | New upstream stable release; fix sysvinit support |
| standardskriver | Fix deprecation warning from config.RawConfigParser; use external ip command rather than deprecated ifconfig command |
| swi-prolog | Use HTTPS when contacting upstream pack servers |
| systemd | core: never propagate reload failure to service result; fix sync_file_range failures in nspawn containers on arm, ppc; fix RootDirectory not working when used in combination with User; ensure that access controls on systemd-resolved's D-Bus interface are enforced correctly [CVE-2019-15718]; fix StopWhenUnneeded=true for mount units; make MountFlags=shared work again |
| tmpreaper | Prevent breaking of systemd services that use PrivateTmp=true |
| trapperkeeper-webserver-jetty9-clojure | Restore SSL compatibility with newer Jetty versions |
| tzdata | New upstream release |
| ublock-origin | New upstream version, compatible with Firefox ESR68 |
| uim | Resurrect libuim-data as a transitional package, fixing some issues after upgrades to buster |
| vanguards | New upstream stable release; prevent a reload of tor's configuration via SIGHUP causing a denial-of-service for vanguards protections |
While the Debian developers say existing Buster users don't have to create new install media, understandably, some anal-retentive folks will still want to anyway. If that is you, you can grab an updated ISO here. Those looking to try the Linux distribution for the first time will want to get an ISO from the same link.
Image credit: John Navajo/ Shutterstock


6.6. Query Planning¶
Query planning is the process of translating a GeoTools Query
into scans and filters for a
particular back-end. Query planning in GeoMesa consists of several steps:
- The CQL filter (if any) is re-written and optimized for fast evaluation
- The CQL filter is split apart, based on the available indices
- One of the available indices is selected to execute the query
- A logical query plan is created by the core GeoMesa indexing code
- A physical query plan is created for the particular back-end database
6.6.1. Filter Decomposition¶
A logical query plan in GeoMesa generally consists of a ‘primary’ CQL filter, which is used to determine scan ranges, and a ‘secondary’ CQL filter which is applied to matching rows. For example, the Z2 index will handle any spatial predicates as scan ranges, and any additional filters will be applied afterwards.
During step two of query planning, the full filter is decomposed and examined with an eye towards the available indices. For each index, a primary and a secondary filter will be determined (if any).
For example, consider the filter
BBOX(geom,0,0,10,10) AND dtg DURING 2017-01-01T00:00:00.000Z/2017-01-02T00:00:00.000Z AND name = 'alice'
.
This filter can be decomposed several ways - for the Z2 spatial index, the primary filter is the BBOX
, for
the Z3 spatio-temporal index, the primary filter is the BBOX
plus the DURING
, and for the attribute index
(assuming ‘name’ is indexed) the primary filter is name = 'alice'
.
6.6.2. Index Selection¶
Since skipping rows entirely is much faster than reading and filtering them, the best query plan will generally be the one that scans the fewest rows. In other words, the best plan is the one that has the most selective primary filter. GeoMesa has two methods for determining the best index - cost-based, or heuristic-based. Cached statistics are used to estimate the cost when available; however the method used can be configured per-query. See Query Index and Query Planning Type for more information.
<IP_ADDRESS>. Cost-Based Strategy¶
Note
Cached statistics, and thus cost-based query planning, are currently only implemented for the Accumulo data store
GeoMesa will collect stats during ingestion, and store them for use in query planning. The stats collected are:
- Total count
- Min/max (bounds) for the default geometry, default date and any indexed attributes
- Histograms for the default geometry, default date and any indexed attributes
- Frequencies for any indexed attributes, split up by week
- Top-k for any indexed attributes
- Z3 histogram based on the default geometry and default date (if both present)
These stats are used to estimate the number of features matching a given primary filter. The primary filter that matches the fewest features will be selected.
<IP_ADDRESS>. Heuristic Strategy¶
Heuristics can be used for query planning based solely on the query filter. The priorities are:
- Feature ID predicates using the ID index
- High-cardinality attribute predicates using the attribute index
- Attribute equality predicates using the attribute index
- Spatio-temporal predicates using the Z3/XZ3 index
- Attribute range predicates using the attribute index
- Spatial predicates using the Z2/XZ2 index
- Temporal predicates using the Z3/XZ3 index
- Low-cardinality attribute predicates using the attribute index
In addition, Accumulo data stores using ‘join’ attribute indices will de-prioritize any predicates that require a join, based on the query properties/transform.
If multiple attribute predicates are tied for highest priority, then there is no guarantee about which one will be selected from that group.
<IP_ADDRESS>. Custom Strategies¶
It is possible to use custom strategy implementations by specifying the class name with the system property
geomesa.strategy.decider
. The class must implement org.locationtech.geomesa.index.planning.StrategyDecider
.
<IP_ADDRESS>. Cardinality Hints¶
Attributes that are know to have many distinct values, i.e. a high cardinality, are likely to filter out many false positives through the index structure, and thus a query against the attribute index will touch relatively few records. Conversely, in the worst case, a Boolean attribute (for example), with only two distinct values, would likely require scanning half of the entire data set.
Cardinality hints may be used to influence the query planner when considering attribute indices. If an attribute is marked as having a high cardinality, the attribute index will be prioritized. Conversely, if an attribute is marked with low cardinality, the attribute index will be de-prioritized. For details on setting cardinality, see Configuring Attribute Cardinality.
6.7. Explaining Query Plans¶
GeoMesa will automatically log explain plans during query execution. This can be useful when debugging query issues, and can inform decisions to speed up execution time, such as when to add additional indices or when query hints may be helpful.
In order to show explain logging, configure your logging system to set
org.locationtech.geomesa.index.utils.Explainer
to trace
level. For example, in log4j use:
log4j.category.org.locationtech.geomesa.index.utils.Explainer=TRACE
Instead of passively logging, you can also generate explain logging without executing a query. Given a GeoMesa data store and a query, use the following method:
import org.locationtech.geomesa.index.utils.ExplainString
dataStore.getQueryPlan(query, explainer = new ExplainPrintln)
ExplainPrintln
will write to System.out
. Alternatively, you can use ExplainString
or
ExplainLogging
to redirect the output elsewhere.
Using the binary distribution, you can print out an explain plan using the explain
command. See
explain for more details.
6.7.1. GeoServer¶
For enabling explain loggingn in GeoServer, see Logging Explain Query Planning.


0
0
Create sector
Delete active shape
Create vertex
Move active vertex
Delete active vertex
Oh shit!
Oh no!


This is not my first time insufflating oxymorphone (opana ER) and will very likely not be my last. This is the only painkiller Iíve ever abused so I really donít have anything to compare it to. Iím an avid marijuana smoker and have experimented with a few other drugs including cocaine and Adderall. Iím writing this because the lack of other reports on this fascinating substance disappointed me. Oxymorphone is extremely potent and is said to be about 2-3 times stronger than oxycontin and about 4 times stronger than morphine. Iím not sure if this is true or not because Iíve never tried either of these.
Every time I have snorted oxymorphone I have experienced extreme nausea and once vomited about 15 times until my stomach was completely empty. I realize that the dosage I usually take is NOTHING compared to that of other users but I find that about 5mg suits me just fine. Although the negative effects (nausea, dizziness, the occasional vomiting, and itchiness) really suck, I find the positive effects (extreme euphoria, strong body high, sense of wellbeing, loss of inhibitions, and the ability to feel a strong connection with others) make it worthwhile.
 I make sure to eat a nice big meal first as I find that doing that doubles the effects. Another thing to note is that itís only half as effective if taken orally, crushed and taken as soon as itís mixed with water because it WILL GEL UP when it comes into contact with a liquid.
5 minutes- already slightly feeling the effects
10 minutes- feeling the familiar light body sensations as well as a bit of euphoria.
15 minutes- same as before only amplified, hands are noticeably shaking.
30 minutes- vision seems different for some reason as it always does, Iím extremely comfortable even though Iím just sitting on my crappy desk chair. I canít seem to stop smiling. I think itís a good time to put on the song Comfortably Numb by Pink Floyd, as it always enhances the experience for me. Iím also starting to get itchy, but that doesnít bother me.
45 minutes- I am a cloud, my shoulders feel as though they are sinking, and I now remember why I love this drug so much. The itchiness is bad now, mostly on my face, but I still could care less. Iím experiencing slight nausea, but I find that drinking milk, as I am, helps a lot. Having tried cocaine on numerous occasions I can say that the euphoria is much stronger and almost feels as if it inhabits every inch of my body.
60 minutes- I feel incredible, better than ever, and the music only amplifies the experience. I have a very strong urge to tell someone I love them. I wish this feeling would last forever and I can certainly understand how someone can easily become an addict. I love this drug.
75 minutes- I decided to venture into the kitchen to get more milk and Iím now burping and hiccupping which is what usually happens before I puke. Closing my eyes feels very nice. I think the effects are starting to lessen, unfortunately. The itching is getting annoying now. I think Iím going to lay down for a few minutes and enjoy my music.
105 minutes- Iím starting to step back into reality after a very pleasant and relaxing high. Another great thing about this drug is that the come up is fairly quick, while the comedown is nice and slow, almost rounded. It feels as though Iím coming back down to earth after floating around in atmosphere.
120 minutes- nearly all of the effects are gone, but I still feel nice and relaxed. Some people say that they have a hard time sleeping after using oxymorphone, for me it just makes me tired and lets me drift into a nice deep sleep, so Iíll be going to bed in a few minutes. Overall, I think this is a great drug.
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.


DIV #1
position: relative;
DIV #2
position: absolute;
z-index: 2;
DIV #3
position: relative;
z-index: 1;
DIV #4
position: absolute;
z-index: 10;
DIV #5
position:relative;
DIV #6
position:static;
Various border styles on same element


The @ [at] is not required.
* based on your lastest tweets. RT's not included.
Created by @palamago just for fun and learn - Code on GitHub
Using: jQuery - Twitter API & Bootstrap - JavaScript InfoVis Toolkit - "Superhero" theme from Bootswatch


RANK
orders the members of a dimension based on the values of an expression. The function returns the sequence numbers of the dimension members.
RANK
assigns the same rank to identical values. For example, RANK
may return 1, 2, 3, 3, 5 for a series of five dimension members.
NUMBER
RANK ( ) OVER (rank_clause)
rank_clause::=
{ DIMENSION dimension_id | HIERARCHY hierarchy_id } ORDER BY order_by_clause [, order_by_clause]... [ WITHIN { PARENT | LEVEL | ANCESTOR AT { DIMENSION LEVEL dim_lvl_id | HIERARCHY LEVEL hier_level_id } } ]
order_by_clause::=
expression [ASC | DESC] [NULLS {FIRST | LAST}]
The dimension over which the values are calculated using the default hierarchy.
The hierarchy over which the values are calculated. If dimension_id
is used instead, the default hierarchy is used.
Provides the basis for the ranking. You can provide additional ORDER BY
clauses to break any ties in the order.
Provides the values to use as the basis for the rankings.
Sorts the ranking from smallest to largest (ascending) or from largest to smallest (descending).
Determines whether members with null values are listed first or last.
Selects a set of related dimension members to be ranked.
PARENT
ranks members at the same level with the same parent.
LEVEL
ranks all members at the same level.
ANCESTOR
ranks all members at the same level and with the same ancestor at a specified level.
The name of a level of dimension_id
.
The name of a level of hierarchy_id
.
This example ranks time periods within a calendar year by Unit Cost. Notice that no month is ranked 7, because two months (JAN-02 and JUL-02) have the same value and the same rank (6).
RANK() OVER (DIMENSION TIME.CALENDAR ORDER BY PRICE_CUBE.UNIT_COST DESC NULLS LAST WITHIN ANCESTOR AT DIMENSION LEVEL TIME.CALENDAR_YEAR)
| Product | Time | Cost | Rank |
|---|---|---|---|
| Deluxe Mouse | MAR-02 | 24.05 | 1 |
| Deluxe Mouse | APR-02 | 23.95 | 2 |
| Deluxe Mouse | FEB-02 | 23.94 | 3 |
| Deluxe Mouse | AUG-02 | 23.88 | 4 |
| Deluxe Mouse | MAY-02 | 23.84 | 5 |
| Deluxe Mouse | JAN-02 | 23.73 | 6 |
| Deluxe Mouse | JUL-02 | 23.73 | 6 |
| Deluxe Mouse | JUN-02 | 23.72 | 8 |
| Deluxe Mouse | SEP-02 | 23.71 | 9 |
| Deluxe Mouse | NOV-02 | 23.65 | 10 |
| Deluxe Mouse | DEC-02 | 23.62 | 11 |
| Deluxe Mouse | OCT-02 | 23.37 | 12 |


Speciality:
230700.62 – «Application informatics» (form of education: the internal – 4 years, the correspondence reduced – 3,5 years)
Specialization:
«Application informatics in the information sphere»
Bachelor of application informatics – this is the analyst, the developer, the organizer, the manager in the sphere of application-oriented information technologies.
Information sphere – it constant the extending area of human activities connected to development and service of information and analytical systems, resources and technologies.
Scientific information centers, information networks, information and analytical centers, subdividings belong to the information sphere on development of systems of business management, library and archives, mass media. As a whole it is the industry of creation, storage, processing and information distribution in all areas of human activities. In the information sphere the professional oriented information systems are applied to implementation of various tasks according to specifics of data domain.
Speciality:
220402.65 – «Special organizational and technical systems» (form of education - internal, training period - 5 years)
Specialization:
«Information and analytical activities in special organizational and technical systems»
Vocational training of experts allows them to solve complex problems of business process management in design, planning, prediction, operational and strategic management, reengineering of organizational and technical systems on the basis of the modern computer technologies and computer simulation.
Graduates are IT broad specialists: analyst programmers, managers of IT projects of different complexity, system analitikamikompyyuternykh of technologies and computer simulation.
Knowledge and skills of the graduate in the specialty 220402 allows it to work effectively in oil and gas, energetic, transport, telecommunication, machine-building, aerospace branches, and also in organs of administrative-territorial control and the organizations of the financial and economic sphere.
Speciality:
220400.68 – «Control in technical systems»
Master program:
«Human-machine management systems»
Training of highly qualified specialists and principals for operation in the field of design, production and maintenance of intellectual human-machine management systems in the sphere of information technologies, oil and gas extraction and processing, telecommunication, financial and economic, transport, energetic, aviation and space complexes is carried out.
Speciality:
230100 – «Informatics and ADP equipment»
Master program:
«Theoretical informatics»
Preparation of a highly qualified scientific personnel for operations on creation, implementation and maintenance of new intellectual high information technologies, program systems, algorithms and computing architecture in the modern organizational and technical systems is carried out.
Within the program the combination of fundamental and theoretical preparation in the field of informatics and use of the advanced information technologies is provided.
Speciality:
230700 – «Application-oriented informatics»
Master program:
«Reengineering business - processes in organizational and technical systems»
Training of highly qualified analysts for operations on reengineering (redesign), creation, upgrade, implementation and business process modeling in difficult organizational and technical systems on the basis of the modern information technologies is carried out.
Within the program the combination of theoretical and practical preparation in the field of business process modeling with study of intellectual methods of optimization of organizational and technical systems is provided.


Constructor
new Wallet(settingsopt) → {Wallet}
Create an instance of a
Wallet.
Parameters:
| Name |
Type |
Attributes |
Default |
Description |
settings |
Object
|
<optional>
|
{}
|
Configure the wallet.
Properties
| Name |
Type |
Attributes |
Default |
Description |
verbosity |
Number
|
<optional>
|
2
|
One of: 0 (none), 1 (error), 2 (warning), 3 (notice), 4 (debug), 5 (audit) |
key |
Object
|
<optional>
|
|
Key to restore from.
Properties
| Name |
Type |
Attributes |
Description |
seed |
String
|
<optional>
|
Mnemonic seed for a restored wallet. |
|
|
Properties:
| Name |
Type |
Description |
id |
String
|
Unique identifier for this Wallet. |
- Source:
-
Returns:
Instance of the wallet.
-
Type
-
Wallet
Methods
(static) createSeed(passphrase) → {FabricSeed}
Create a new seed phrase.
Parameters:
| Name |
Type |
Description |
passphrase |
String
|
BIP 39 passphrase for key derivation. |
- Source:
-
Returns:
The seed object.
-
Type
-
FabricSeed
(static) fromSeed(seed) → {Wallet}
Create a new
Wallet from a seed object.
Parameters:
| Name |
Type |
Description |
seed |
FabricSeed
|
Fabric seed. |
- Source:
-
Returns:
Instance of the wallet.
-
Type
-
Wallet
(async) _createCrowdfund(fund)
Create a crowdfunding transaction.
Parameters:
| Name |
Type |
Description |
fund |
Object
|
|
- Source:
-
Generate
Script for reclaiming funds commited to a
Swap.
Parameters:
| Name |
Type |
Description |
redeemScript |
*
|
|
- Source:
-
Parameters:
| Name |
Type |
Description |
redeemScript |
*
|
|
secret |
*
|
|
- Source:
-
_load(settings)
Initialize the wallet, including keys and addresses.
Parameters:
| Name |
Type |
Description |
settings |
Object
|
Settings to load. |
- Source:
-
(async) _sign(tx)
Signs a transaction with the keyring.
Parameters:
| Name |
Type |
Description |
tx |
BcoinTX
|
|
- Source:
-
(async) createPricedOrder(order)
Create a priced order.
Parameters:
| Name |
Type |
Description |
order |
Object
|
Properties
| Name |
Type |
Description |
asset |
Object
|
|
amount |
Object
|
|
|
- Source:
-
getAddressForScript(script)
Returns a bech32 address for the provided
Script.
Parameters:
| Name |
Type |
Description |
script |
Script
|
|
- Source:
-
getAddressFromRedeemScript(redeemScript)
Generate a BitcoinAddress for the supplied BitcoinScript.
Parameters:
| Name |
Type |
Description |
redeemScript |
BitcoinScript
|
|
- Source:
-
loadKey(keypair) → {Wallet}
Import a key to the wallet.
Parameters:
| Name |
Type |
Description |
keypair |
Object
|
Keypair.
Properties
| Name |
Type |
Attributes |
Description |
public |
Buffer
|
|
Public key. |
private |
Buffer
|
<optional>
|
Private key. |
|
- Source:
-
Returns:
Instance of the Wallet.
-
Type
-
Wallet
publicKeyFromString(input)
Create a public key from a string.
Parameters:
| Name |
Type |
Description |
input |
String
|
Hex-encoded string to create key from. |
- Source:
-
start()
Start the wallet, including listening for transactions.
- Source:
-


- Steve Jobs


to P2
to P3 Dialog
content
Grid and block
Icon shrinks to 80 x 80
auto divider view
divide buttons
to P4 transition with slide
to P5 reversed transition
P1