Markets are, in my view, mostly random. However, they're not completely random. Many small inefficiencies and patterns exist in markets which can be identified and used to gain slight edge on the market.
These edges are rarely large enough to trade in isolation - transaction costs and overhead can easily exceed the expected profits offered. But when we are able to combine many such small edges together, the rewards can be great.
In this article, I'll present a framework for blending together outputs from multiple models using a type of ensemble modeling known as stacked generalization. This approach excels at creating models which "generalize" well to unknown future data, making them an excellent choice for the financial domain, where overfitting to past data is a major challenge.
This post is the sixth and final installment in my tutorial series on applying machine learning to financial time series data. If you haven't already read the prior articles, you may want to do that before starting this one.
Ensemble Learning¶
Ensemble learning is a powerful - and widely used - technique for improving model performance (especially it's generalization) by combining predictions made by multiple different machine learning models. The idea behind ensemble learning is not dissimilar from the concept "wisdom of the crowd", which posits that the aggregated/consensus answer of several diverse, well-informed individuals is typically better than any one individual within the group.
In the world of machine learning, this concept of combining multiple models takes many forms. The first form appears within a number of commonly used algorithms such as Random Forests, Bagging, and Boosting (though this one works somewhat differently). Each of these algorithms takes a single base model (e.g., a decision tree) and trains many versions of that single algorithm on differing sets of features or samples. The resulting collection of trained models are often more robust out of sample because they're likely to be less overfitted to certain features or samples in the training data.
A second form of ensembling methods involves aggregating across multiple different model types (e.g., an SVM, a logistic regression, and a decision tree) - or with different hyperparameters. Since each learning algorithm or set of hyperparameters tends to have different biases, it will tend to make different prediction errors - and extract different signals - from the same set of data. Assuming all models are reasonably good - and that the errors are reasonably uncorrelated to one another - they will partially cancel each other out and the aggregated predictions will be more useful than any single model's predictions.
One particularly flexible approach to this latter type of ensemble modeling is "stacked generalization", or "stacking". In this post, I will walk through a simple example of stacked generalization applied to time series data. If you'd like to replicate and experiment with the below code, you can download the source notebook for this post by right-clicking on the below button and choosing "save link as"
Overview of Stacked Generalization¶
The "stacked generalization" framework was initially proposed by Wolpert in a 1992 academic paper. Since it was first proposed, stacked generalization (aka "stacking") has received a modest but consistent amount of attention from the ML research community.
Stacked generalization is an ensemble modeling technique. The core concept of stacked generalization is to generate a single, optimally robust prediction for a regression or classification task by (a) building multiple different models (with varying learning algorithms, varying hyperparameters, and/or different features) to make predictions then (b) training a "meta-model" or "blending model" to determine how to combine the predictions of each of these multiple models.
A nice way to visualize this (borrowed from documentation for Sebastian Rashka's excellent mlxtend package) is shown below. Each model R1 thru Rm is trained on historical data and used to make predictions P1 thru Pm. Those predictions then become the features used to train a meta-model to determine how to combine these predictions.
I think of this using an analogy. Imagine that there is a team of investment analysts whose manager has asked each of them to make earnings forecasts for the same set of companies across many quarters. The manager "learns" which analysts have historically been most accurate, somewhat accurate, and inaccurate. When future predictions are needed, the manager can assign greater and lesser (and in some cases, zero) weighting to each analyst's prediction.
It's clear why it's referred to as "stacked". But why "generalization"? The principal motivation for applying this technique is to achieve greater "generalization" of models to out-of-sample (i.e., unseen) data by de-emphasizing models which appear to be overfitted to the data. This is achieved by allowing the meta-model to learn which of the base models' predictions have held up well (and poorly) out-of-sample and to weight models appropriately.
Motivations¶
In my view, stacked generalization is perfectly suited to the challenges we face when making predictions in noisy, non-stationary, regime-switching financial markets. When properly implemented (see next section), stacking help to defend against the scourge of overfitting - something which virtually all practitioners of investing ML will agree is a major challenge.
Better yet, stacking allows us to blend together relatively weak (but orthogonal and additive) signals together in a way that doesn't get drowned out by stronger signals.
To illustrate, consider a canonical trend-following strategy which is predicated on 12 month minus 1 month price change. Perhaps we also believe that month-of-year or recent IBIS earnings trend have a weak, but still useful effect on price changes. If we were to train a model that lumped together dominant features (12 minus 1 momentum) and weaker features (seasonality or IBIS trend), our model may miss the subtle information because the dominant features overshadow them.
A stacked model, which has one component (i.e., a base model) focused on solely momentum features, another component focused on solely seasonality features, and a third one focused on analyst revisions features can capture and use the more subtle effects alongside the more dominant momentum effect.
Keys to Success¶
Stacked generalization is sometimes referred to as a "black art" and there is truth to that view. However, there are also two concrete principles that will get you a long way towards robust results.
1. Out of Sample Training
First, it's absolutely critical that the predictions P1 thru Pm used to train the meta-model are exclusively out of sample predictions. Why? Because in order to determine which models are likely to generalize best to out of sample (ie those with least overfit), we must judge that based on past predictions which were themselves made out-of-sample.
Imagine that you trained two models using different algorithms, say logistic regression and decision trees. Both could be very useful (out of sample) but decision trees have a greater tendency to overfit training data. If we used in-sample predictions as features to our meta-learner, we'd likely give much more weight to the model with a tendancy to overfit the most.
Several methods can be used for this purpose. Some advise splitting training data into Train1 and Train2 sets so base models can be trained on Train1 and then can make predictions on Train2 data for use in training the ensemble model. Predictions of the ensemble model must, of course, be evaluated on yet another dataset.
Others use K-fold cross-validation prediction (such as scikit's cross_val_predict
) on base models to simulate out-of-sample(ish) predictions to feed into the ensemble layer.
However, in my view, the best method for financial time series data is to use walk-forward training and prediction on the base models, as described in my Walk-forward modeling post. In addition to ensuring that every base prediction is true out-of-sample, it simulates the impact of non-stationarity (a.k.a. regime change) over time.
2. Non-Negativity
Second - and this is less of a hard-and-fast rule - is to constrain the meta-model to learning non-negative coefficients only, using an algorithm like ElasticNet or lasso which allows non-negativity constraints.
This technique is important because quite often (and sometimes by design) there will be very high collinearity of the "features" fed into the meta-model (P1 thru Pm). In periods of high collinearity, learning algorithms can do funky things, such as finding a slightly better fit to past data by assigning a high positive coefficient to one model and a large negative coefficient to another. This is rarely what we really want.
Call me crazy, but if a model is useful only in that it consistently predicts the wrong outcome, it's probably not a model I want to trust.
Further Reading¶
That's enough (too much?) background for now. Those interested in more about the theory and practice of stacked generalization should check out the below research papers:
Preparing the Data¶
For this simple example, I will create synthetic data rather than using real market prices to remove the ambiguity about what features and transformations may be necessary to extract maximum value from the model.
Note: to make the dataset more realistic, I will extract an index from actual stock prices using quandl's API, but all features and target values will be constructed below.
With index in hand, we will generate four "hidden factors". These are the non-random drivers of the target variable, and are the "signal" we ideally want to learn.
To ensure that these factors are meaningful, we will create the target variable (y
) using combinations of these factors. The first two hidden factors have a linear relationship to the target. The second two hidden factors have a more complex relationship involving interaction effects between variables. Lastly, we will add a noise component to make our learners work for it.
Finally, we'll create several features that are each related to one or more hidden factors, including generous amounts of noise and bias.
Key point: we've created X and y data which we know is related by several different linkages, some of which are linear and some of which aren't. This is what our modeling will seek to learn.
import numpy as np
import pandas as pd
pd.core.common.is_list_like = pd.api.types.is_list_like # remove once updated pandas-datareader issue is fixed
# https://github.com/pydata/pandas-datareader/issues/534
import pandas_datareader.data as web
%matplotlib inline
from IPython.core.display import HTML,Image
HTML('<style>{}</style>'.format(config.CSS))
def get_symbols(symbols,data_source, begin_date=None,end_date=None):
out = pd.DataFrame()
for symbol in symbols:
df = web.DataReader(symbol, data_source,begin_date, end_date)[['AdjOpen','AdjHigh','AdjLow','AdjClose','AdjVolume']].reset_index()
df.columns = ['date','open','high','low','close','volume'] #my convention: always lowercase
df['symbol'] = symbol # add a new column which contains the symbol so we can keep multiple symbols in the same dataframe
df = df.set_index(['date','symbol'])
out = pd.concat([out,df],axis=0) #stacks on top of previously collected data
return out.sort_index()
idx = get_symbols(['AAPL','CSCO','MSFT','INTC'],data_source='quandl',begin_date='2012-01-01',end_date=None).index
# note, we're only using quandl prices to generate a realistic multi-index of dates and symbols
num_obs = len(idx)
split = int(num_obs*.80)
## First, create factors hidden within feature set
hidden_factor_1 = pd.Series(np.random.randn(num_obs),index=idx)
hidden_factor_2 = pd.Series(np.random.randn(num_obs),index=idx)
hidden_factor_3 = pd.Series(np.random.randn(num_obs),index=idx)
hidden_factor_4 = pd.Series(np.random.randn(num_obs),index=idx)
## Next, generate outcome variable y that is related to these hidden factors
y = (0.5*hidden_factor_1 + 0.5*hidden_factor_2 + # factors linearly related to outcome
hidden_factor_3 * np.sign(hidden_factor_4) + hidden_factor_4*np.sign(hidden_factor_3)+ # factors with non-linear relationships
pd.Series(np.random.randn(num_obs),index=idx)).rename('y') # noise
## Generate features which contain a mix of one or more hidden factors plus noise and bias
f1 = 0.25*hidden_factor_1 + pd.Series(np.random.randn(num_obs),index=idx) + 0.5
f2 = 0.5*hidden_factor_1 + pd.Series(np.random.randn(num_obs),index=idx) - 0.5
f3 = 0.25*hidden_factor_2 + pd.Series(np.random.randn(num_obs),index=idx) + 2.0
f4 = 0.5*hidden_factor_2 + pd.Series(np.random.randn(num_obs),index=idx) - 2.0
f5 = 0.25*hidden_factor_1 + 0.25*hidden_factor_2 + pd.Series(np.random.randn(num_obs),index=idx)
f6 = 0.25*hidden_factor_3 + pd.Series(np.random.randn(num_obs),index=idx) + 0.5
f7 = 0.5*hidden_factor_3 + pd.Series(np.random.randn(num_obs),index=idx) - 0.5
f8 = 0.25*hidden_factor_4 + pd.Series(np.random.randn(num_obs),index=idx) + 2.0
f9 = 0.5*hidden_factor_4 + pd.Series(np.random.randn(num_obs),index=idx) - 2.0
f10 = hidden_factor_3 + hidden_factor_4 + pd.Series(np.random.randn(num_obs),index=idx)
## From these features, create an X dataframe
X = pd.concat([f1.rename('f1'),f2.rename('f2'),f3.rename('f3'),f4.rename('f4'),f5.rename('f5'),
f6.rename('f6'),f7.rename('f7'),f8.rename('f8'),f9.rename('f9'),f10.rename('f10')],axis=1)
Exploratory Data Analysis¶
We'll avoid going too deeply into exploratory data analysis (refer to Feature engineering for more exploration of that topic). I will, however, plot three simple views:
- Distributions of the features and target variables.
- Simple univariate regressions for each of the ten features vs. the target variable.
- A clustermap showing correlations between the features (see Feature selection for more on this technique):
## Distribution of features and target
X.plot.kde(legend=True,xlim=(-5,5),color=['green']*5+['orange']*5,title='Distributions - Features and Target')
y.plot.kde(legend=True,linestyle='--',color='red') # target
## Univariate Regressions
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
sns.set(style="dark")
# Set up the matplotlib figure
fig, axes = plt.subplots(4, 3, figsize=(8, 6), sharex=True, sharey=True)
# Rotate the starting point around the cubehelix hue circle
for ax, s in zip(axes.flat, range(10)):
cmap = sns.cubehelix_palette(start=s, light=1, as_cmap=True)
x = X.iloc[:,s]
sns.regplot(x, y,fit_reg = True, marker=',', scatter_kws={'s':1},ax=ax,color='salmon')
ax.set(xlim=(-5, 5), ylim=(-5, 5))
ax.text(x=0,y=0,s=x.name.upper(),color='black',
**{'ha': 'center', 'va': 'center', 'family': 'sans-serif'},fontsize=20)
fig.tight_layout()
fig.suptitle("Univariate Regressions for Features", y=1.05,fontsize=20)
## Feature correlations
from scipy.cluster import hierarchy
from scipy.spatial import distance
corr_matrix = X.corr()
correlations_array = np.asarray(corr_matrix)
linkage = hierarchy.linkage(distance.pdist(correlations_array), \
method='average')
g = sns.clustermap(corr_matrix,row_linkage=linkage,col_linkage=linkage,\
row_cluster=True,col_cluster=True,figsize=(5,5),cmap='Greens',center=0.5)
plt.setp(g.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
plt.show()
label_order = corr_matrix.iloc[:,g.dendrogram_row.reordered_ind].columns
Making Base Models¶
The first step in a stacked generalization system is to generate the "base models", meaning the models which are learning from our input features. We'll create two base models to use in our ensemble:
- A collection of simple linear regression models
- A collection of tree models - in this case, using the ExtraTrees algorithm
As described above it's absolutely critical to build models which provide realistic out-of-sample predictions, I am going to apply the methodology presented in Walk-forward modeling. In short, this will retrain at the end of each calendar quarter, using only data which would have been available at that time. Predictions are made using the most recently trained model.
To make this easier to follow, I'll define a simple function called make_walkforward_model
that trains a series of models at various points in time and generates out of sample predictions using those trained models.
from sklearn.base import clone
from sklearn.linear_model import LinearRegression
def make_walkforward_model(features,outcome,algo=LinearRegression()):
recalc_dates = features.resample('Q',level='date').mean().index.values[:-1]
## Train models
models = pd.Series(index=recalc_dates)
for date in recalc_dates:
X_train = features.xs(slice(None,date),level='date',drop_level=False)
y_train = outcome.xs(slice(None,date),level='date',drop_level=False)
#print(f'Train with data prior to: {date} ({y_train.count()} obs)')
model = clone(algo)
model.fit(X_train,y_train)
models.loc[date] = model
begin_dates = models.index
end_dates = models.index[1:].append(pd.to_datetime(['2099-12-31']))
## Generate OUT OF SAMPLE walk-forward predictions
predictions = pd.Series(index=features.index)
for i,model in enumerate(models): #loop thru each models object in collection
#print(f'Using model trained on {begin_dates[i]}, Predict from: {begin_dates[i]} to: {end_dates[i]}')
X = features.xs(slice(begin_dates[i],end_dates[i]),level='date',drop_level=False)
p = pd.Series(model.predict(X),index=X.index)
predictions.loc[X.index] = p
return models,predictions
To create a series of walk-forward models, simply pass in X and y data along with a scikit estimator object. It returns a series of models and a series of predictions. Here, we'll create two base models on all features, one using linear regression and one with extra trees.
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import ExtraTreesRegressor
linear_models,linear_preds = make_walkforward_model(X,y,algo=LinearRegression())
tree_models,tree_preds = make_walkforward_model(X,y,algo=ExtraTreesRegressor())
Note that no predictions can be made prior to the first trained model, so it's important to dropna()
on predictions prior to use.
print("Models:")
print(linear_models.head())
print()
print("Predictions:")
print(linear_preds.dropna().head())
It can be instructive to see how the linear model coefficients evolve over time:
pd.DataFrame([model.coef_ for model in linear_models],
columns=X.columns,index=linear_models.index).plot(title='Weighting Coefficients for \nLinear Model')
Next, I'll create a simple function to evaluate multiple model performance metrics, called calc_scorecard
. Further detail on this method of model evaluation is provided in the earlier post Model evaluation.
from sklearn.metrics import r2_score,mean_absolute_error
def calc_scorecard(y_pred,y_true):
def make_df(y_pred,y_true):
y_pred.name = 'y_pred'
y_true.name = 'y_true'
df = pd.concat([y_pred,y_true],axis=1).dropna()
df['sign_pred'] = df.y_pred.apply(np.sign)
df['sign_true'] = df.y_true.apply(np.sign)
df['is_correct'] = 0
df.loc[df.sign_pred * df.sign_true > 0 ,'is_correct'] = 1 # only registers 1 when prediction was made AND it was correct
df['is_incorrect'] = 0
df.loc[df.sign_pred * df.sign_true < 0,'is_incorrect'] = 1 # only registers 1 when prediction was made AND it was wrong
df['is_predicted'] = df.is_correct + df.is_incorrect
df['result'] = df.sign_pred * df.y_true
return df
df = make_df(y_pred,y_true)
scorecard = pd.Series()
# building block metrics
scorecard.loc['RSQ'] = r2_score(df.y_true,df.y_pred)
scorecard.loc['MAE'] = mean_absolute_error(df.y_true,df.y_pred)
scorecard.loc['directional_accuracy'] = df.is_correct.sum()*1. / (df.is_predicted.sum()*1.)*100
scorecard.loc['edge'] = df.result.mean()
scorecard.loc['noise'] = df.y_pred.diff().abs().mean()
# derived metrics
scorecard.loc['edge_to_noise'] = scorecard.loc['edge'] / scorecard.loc['noise']
scorecard.loc['edge_to_mae'] = scorecard.loc['edge'] / scorecard.loc['MAE']
return scorecard
calc_scorecard(y_pred=linear_preds,y_true=y).rename('Linear')
Since we are concerned about not only average performance but also period-to-period consistency, I'll create a simple wrapper function which recalculates our metrics by quarter.
def scores_over_time(y_pred,y_true):
df = pd.concat([y_pred,y_true],axis=1).dropna().reset_index().set_index('date')
scores = df.resample('A').apply(lambda df: calc_scorecard(df[y_pred.name],df[y_true.name]))
return scores
scores_by_year = scores_over_time(y_pred=linear_preds,y_true=y)
print(scores_by_year.tail(3).T)
scores_by_year['edge_to_mae'].plot(title='Prediction Edge vs. MAE')
Making the Ensemble Model¶
Now that we've trained base models and generated out-of-sample predictions, it's time to train the stacked generalization ensemble model.
Training the ensemble model simply requires feeding in the base models' predictions in as the X dataframe. To clean up the data and ensure the X and y are of compatible dimensions, I've created a short data preparation function.
Here, we'll use Lasso to train the ensemble becuase it is one of a few linear models which can be constrained to positive = True
. This will ensure that the ensemble will assign either a positive or zero weight to each model, for reasons described above.
from sklearn.linear_model import LassoCV
def prepare_Xy(X_raw,y_raw):
''' Utility function to drop any samples without both valid X and y values'''
Xy = X_raw.join(y_raw).replace({np.inf:None,-np.inf:None}).dropna()
X = Xy.iloc[:,:-1]
y = Xy.iloc[:,-1]
return X,y
X_ens, y_ens = prepare_Xy(X_raw=pd.concat([linear_preds.rename('linear'),tree_preds.rename('tree')],
axis=1),y_raw=y)
ensemble_models,ensemble_preds = make_walkforward_model(X_ens,y_ens,algo=LassoCV(positive=True))
ensemble_preds = ensemble_preds.rename('ensemble')
print(ensemble_preds.dropna().head())
Note that the ensemble's predictions don't begin until July, since the earliest trained ensemble model isn't available until end of Q2. This is necessary to make sure the ensemble model is trained on out of sample data - and that its predictions are also out of sample.
Again, we can look at the coefficients over time of the ensemble model. Keep in mind that the coefficients of the ensemble model represents how much weight is being given to each base model. In this case, it appears that our tree model is much more useful relative to the linear model, though the linear model is gradually catching up.
pd.DataFrame([model.coef_ for model in ensemble_models],
columns=X_ens.columns,index=ensemble_models.index).plot(title='Weighting Coefficients for \nSimple Two-Model Ensemble')
Performance of Ensemble vs. Base Models¶
Now that we have predictions from both the base models and ensemble model, we can explore how the ensemble performs relative to base models. Is the whole really more than the sum of the parts?
# calculate scores for each model
score_ens = calc_scorecard(y_pred=ensemble_preds,y_true=y_ens).rename('Ensemble')
score_linear = calc_scorecard(y_pred=linear_preds,y_true=y_ens).rename('Linear')
score_tree = calc_scorecard(y_pred=tree_preds,y_true=y_ens).rename('Tree')
scores = pd.concat([score_linear,score_tree,score_ens],axis=1)
scores.loc['edge_to_noise'].plot.bar(color='grey',legend=True)
scores.loc['edge'].plot(color='green',legend=True)
scores.loc['noise'].plot(color='red',legend=True)
plt.show()
print(scores)
fig,[[ax1,ax2],[ax3,ax4]] = plt.subplots(2,2,figsize=(9,6))
metric = 'RSQ'
scores_over_time(y_pred=ensemble_preds.rename('ensemble'),y_true=y)[metric].rename('Ensemble').\
plot(title=f'{metric.upper()} over time',legend=True,ax=ax1)
scores_over_time(y_pred=linear_preds.rename('linear'),y_true=y)[metric].rename('Linear').\
plot(title=f'{metric.upper()} over time',legend=True, alpha = 0.5, linestyle='--',ax=ax1)
scores_over_time(y_pred=tree_preds.rename('tree'),y_true=y)[metric].rename("Tree").\
plot(title=f'{metric.upper()} over time',legend=True, alpha = 0.5, linestyle='--',ax=ax1)
metric = 'edge'
scores_over_time(y_pred=ensemble_preds.rename('ensemble'),y_true=y)[metric].rename('Ensemble').\
plot(title=f'{metric.upper()} over time',legend=True,ax=ax2)
scores_over_time(y_pred=linear_preds.rename('linear'),y_true=y)[metric].rename('Linear').\
plot(title=f'{metric.upper()} over time',legend=True, alpha = 0.5, linestyle='--',ax=ax2)
scores_over_time(y_pred=tree_preds.rename('tree'),y_true=y)[metric].rename("Tree").\
plot(title=f'{metric.upper()} over time',legend=True, alpha = 0.5, linestyle='--',ax=ax2)
metric = 'noise'
scores_over_time(y_pred=ensemble_preds.rename('ensemble'),y_true=y)[metric].rename('Ensemble').\
plot(title=f'{metric.upper()} over time',legend=True,ax=ax3)
scores_over_time(y_pred=linear_preds.rename('linear'),y_true=y)[metric].rename('Linear').\
plot(title=f'{metric.upper()} over time',legend=True, alpha = 0.5, linestyle='--',ax=ax3)
scores_over_time(y_pred=tree_preds.rename('tree'),y_true=y)[metric].rename("Tree").\
plot(title=f'{metric.upper()} over time',legend=True, alpha = 0.5, linestyle='--',ax=ax3)
metric = 'edge_to_noise'
scores_over_time(y_pred=ensemble_preds.rename('ensemble'),y_true=y)[metric].rename('Ensemble').\
plot(title=f'{metric.upper()} over time',legend=True,ax=ax4)
scores_over_time(y_pred=linear_preds.rename('linear'),y_true=y)[metric].rename('Linear').\
plot(title=f'{metric.upper()} over time',legend=True, alpha = 0.5, linestyle='--',ax=ax4)
scores_over_time(y_pred=tree_preds.rename('tree'),y_true=y)[metric].rename("Tree").\
plot(title=f'{metric.upper()} over time',legend=True, alpha = 0.5, linestyle='--',ax=ax4)
plt.tight_layout()
plt.show()
Observations:¶
- We can see that the ensemble is fairly consistently more effective than either of the base models.
- All models seem to be getting better over time (and as they have more data on which to train).
- The ensemble also appears to be a bit more consistent over time. Much like a diversified portfolio of stocks should be less volatile than the individual stocks within it, an ensemble of diverse models will often perform more consistently across time
Next Steps¶
The stacked generalization methodology is highly flexible. There are countless directions you can take this, including:
- More model types: add SVMs, deep learning models, regularlized regressions, and dimensionality reduction models to the mix
- More hyperparameter combinations: try multiple sets of hyperparameters on a particular algorithm.
- Orthogonal feature sets: try training base models on different subsets of features. Avoid the "curse of dimensionality" by limiting each base model to an appropriately small number of features.
Summary¶
This final post, combined with the five previous posts, presents an end-to-end framework for applying supervised machine learning techniques to financial time series data, in a way which helps mitigate the several unique challenges of this domain.
Please feel free to add to the comment section with your comments and questions on this post. I'm also interested in ideas for future posts.
Going forward, I plan to shift gears from tutorials to research on market anomalies and trading opportunities.
One more thing...¶
If you've found this post useful, please consider subscribing to the email list to be notified of future posts (email addresses will only be used for this purpose...).
You can also follow me on twitter and forward to a friend or colleague who may find this topic interesting.


Dodge Journey Replacement Plans Just Got More Interesting
Looks like Dodge is plotting a new HEMI-powered performance SUV to replace the Journey.
by Martin BiggThe Dodge Journey has been around since the 2009 model year. While it boasts a spacious cabin and an affordable price tag, the Journey is showing its age and looks dated compared to other newer crossovers on the market. A replacement is long overdue. FCA passenger car brand chief Steve Beahm has already admitted the Journey is living on borrowed time, as is the Grand Caravan.
When these models get discontinued, Dodge will only have three core models in its lineup: the Challenger, Charger, and Durango. According to Mopar Insiders, however, Dodge is plotting a new high-performance five-passenger utility vehicle to fill the void left by the Journey.
Sources have told the publication that the new utility vehicle will be based on the Giorgio architecture that underpins the Alfa Romeo Giulia and Stelvio, meaning it will be offered with rear-wheel drive or optional all-wheel drive. The same platform will also underpin the next-generation Jeep Grand Cherokee that's expected to debut in time for the 2020 model year, including the new three-row variant.
In terms of size, the new model will reportedly have similar proportions to the Alfa Romeo Stelvio and share styling cues with the Dodge Charger, so it should look sporty. It isn't clear if the new SUV will keep the Journey moniker or adopt a new name, however.
Several powertrain options will also be available, including a range-topping Hemi V8. Details of the displacement and horsepower are unknown, but Fiat Chrysler currently offers 5.7-liter and 6.4-liter variants of the Hemi V8. We'd also love to see it pack the Stelvio Quadrifoglio's Ferrari-derived twin-turbo 2.9-liter V6 that produces 505 hp.
Several trim levels will also be available including a Scat Pack model. The focus will also be on on-road performance rather than off-road capability, so when combined with rear-wheel drive it should also be a lot more fun to drive than the current Journey. As for when Dodge's new midsized UV will arrive, sources claim it will go on sale in 2022 possibly as a 2023 model.


Supportive policies, environments, schools
and communities are
fundamental in shaping
parents’ and children’s choices, making the
healthier choice of foods
and regular physical
activity the easiest choice (accessible,
available and affordable) and
thereby preventing
obesity.
Adolescents should:
- limit energy intake from total fats
and sugars
- increase consumption of fruit and
vegetables, as well as
legumes, whole grains and
nuts
- engage in regular physical activity
(60 minutes a day).


Happy Hour
Party Time
Our Happy Customers
George Richard
Great food!Menu is awesome, there foods are not only great but also in the right price.I'll highly recommend them :)
About Menu
We are menu a little team of 7 members.Nulla iaculis tristique iaculis. Praesent vitae sapien lorem. Fusce rhoncus enim dolor, sit amet euismod lacus pretium dapibus. Sed in lacinia justo, a faucibus magna. Ut et accumsan lorem. Pellentesque auctor at nibh et bibendum.
Get our daily food items delivered to your email
2016 Menu Restaurant


{{ content }}
enough.css
Interactive Demo™
enough.css
enough.media.css
enough.code.css
enough.table.css


You've got a new idea for a daily adventure or you've found a bug?Please report it here by sending me an E-Mail.


there has to be others who know besides Dr. Terminus
Oszy18-Dec-19 07:55 PM
Sambrerg is great
crumb18-Dec-19 07:55 PM
he basically gave away the answer
Dr.Terminus18-Dec-19 07:56 PM
yeah, people need to get in here and earn! not even trying
crumb18-Dec-19 07:56 PM
yeah, i like Sambergs' music thing too
Oszy18-Dec-19 07:56 PM
Elephant?
1
Dr.Terminus18-Dec-19 07:56 PM
!kmdtip @Oszy 2
KMD TipBotBOT18-Dec-19 07:56 PM
TipBot
@Dr.Terminus (Dr.Terminus#3269)
You tipped @Oszy2 KMD
crumb18-Dec-19 07:57 PM
yes, @Oszy
Oszy18-Dec-19 07:57 PM
Gosh
Dr.Terminus18-Dec-19 07:57 PM
you guys are cleaning up!
next question
Oszy18-Dec-19 07:59 PM
Gimme a minute thinking
Oszy18-Dec-19 08:13 PM
Ok sticking to movies and animals
Ready?
1
What animal was "featured" in Clerks 2?
daemonfox18-Dec-19 08:14 PM
Donkey
1
Kelly!
Oszy18-Dec-19 08:15 PM
Kinky Kelly
crumb18-Dec-19 08:15 PM
daemonfox18-Dec-19 08:15 PM
Huge fan
Going to see them Live in town in a couple months
crumb18-Dec-19 08:15 PM
Kevin Smith is THE MAN
daemonfox18-Dec-19 08:15 PM
Reboot Roadshow
Oszy18-Dec-19 08:15 PM
Hahahaa goood
You guys are great
crumb18-Dec-19 08:15 PM
his early movies are pure gold
Oszy18-Dec-19 08:16 PM
Indeed
daemonfox18-Dec-19 08:16 PM
Dogma was my first full watch... then Mallrats... once I saw Clerks it was over... fan for life
Oszy18-Dec-19 08:16 PM
@daemonfox next
Dogma is sick too
Dr.Terminus18-Dec-19 08:17 PM
!kmdtip @daemonfox 2
KMD TipBotBOT18-Dec-19 08:17 PM
TipBot
@Dr.Terminus (Dr.Terminus#3269)
You tipped @daemonfox2 KMD
daemonfox18-Dec-19 08:17 PM
Sticking to Kevin Smith then...
In an interview, Kevin admits to doing something illegal (technically) in order to finance his first film... two part question need to answer both... HOW was Clerks paid for, and what lie made it possible?
i may have to step away so I am DMing @Dr.Terminus the answers
Dr.Terminus18-Dec-19 08:20 PM
good question!
Oszy18-Dec-19 08:22 PM
Hmm
crumb18-Dec-19 08:22 PM
it was paid by credit cards and it was filmed during the night
Oszy18-Dec-19 08:23 PM
He sold his comic books
daemonfox18-Dec-19 08:23 PM
Not quite the lie
Nope
The last part may be obscure... I only ever heard him admit this part once in a podcast or audio interbiew...
but its a super important detail nonetheless
Oszy18-Dec-19 08:27 PM
Pass then
Don't know and don't want to Google cheat
daemonfox18-Dec-19 08:29 PM
Ill once again defer to @Dr.Terminus for a time limit... if no one else answers the second part, @crumb got the first half correct, which is public knowledge... Smith even thanked both credut cards by name via tweet the day they added Clerks to the Congressional Library last week
crumb18-Dec-19 08:34 PM
was it the fact that he enrolled into film class to get a discount and immediately dropped out once he used the student discount to rent equipment?(edited)
daemonfox18-Dec-19 08:34 PM
thats a good tidbit but not the one I know... where did you see that part?
So he built up a supply of ten credit cards with $2,000 limits, and maxed them all out. Clerks grossed $3 million in theaters. Kevin Smith's low-budget film
daemonfox18-Dec-19 08:53 PM
OK so im trying to find a link with proof but even that is not coming up... so ill say crumb has it @Dr.Terminus
Ill find it for my own peace of mind...
But in that interview he talks about getting all those CCs as a joke with a friend to see who could get more...
and he admits to lying to the creditors on the apps... that at the vid store he makes 50K a year and when they called it was him answering, acting as the manager and confirming that he did indeed make $50K a year at that store
Dr.Terminus18-Dec-19 08:58 PM
!kmdtip @crumb 2
KMD TipBotBOT18-Dec-19 08:58 PM
TipBot
@Dr.Terminus (Dr.Terminus#3269)
You tipped @crumb2 KMD
Dr.Terminus18-Dec-19 08:58 PM
sorry for delay.. stupid job getting all up in my face
crumb18-Dec-19 09:00 PM
should we wrap up for this session? seems like maybe 5 people take part in this
Dr.Terminus18-Dec-19 09:00 PM
yeah, lets break for a while
crumb18-Dec-19 09:00 PM
was cool tho
thanks @Dr.Terminus !
Dr.Terminus18-Dec-19 09:00 PM
more to come, try to gather a few more folks and we'll do another next few days, leading up to holidays / through new year
crumb18-Dec-19 09:01 PM
christmas through new year season in perfect for this stuff.
i think there was trivia like this last year also
very nice
daemonfox18-Dec-19 09:02 PM
Yeah def! This weekend and on should have lots of peeps here
Isnt there a trivia Discord bot?
Oszy18-Dec-19 09:02 PM
Lets get a trivia channel
There is
crumb18-Dec-19 09:03 PM
we are on it are we not?
daemonfox18-Dec-19 09:03 PM
Yeah lets make that happen
Dr.Terminus18-Dec-19 09:03 PM
I almost formally requested a trivia chan, thought this cryptopuzzle was most suitable of what already existed
Oszy18-Dec-19 09:03 PM
I'd leave this for actual crypto puzzles
Dr.Terminus18-Dec-19 09:04 PM
at times there will be puzzles / riddles
others trivia
will have to bounce between rooms.. not a big deal though
or just make a live events/ games chan of sorts to cover all such sessions
crumb18-Dec-19 09:05 PM
puzzles with occasional trivia would be fine. there are so many channels already
Dr.Terminus18-Dec-19 09:05 PM
leave cryptopuzzle for true long term / pinned puzzles only


We can use a special functionality which will allow us to synchronize the map center with a url GET param, and viceversa. You can see it on this example, where the URL changes when the center model or the map center is changed. If you copy and paste the URL in another browser window the GET param will take priority and will center the map on the defined position.
You can see a standalone example of this code here.


Chronic wasting disease spreads in northwestern Wisconsin
MADISON, Wis. (AP) - Wisconsin wildlife officials say chronic wasting disease has spread to Dunn County.
The Department of Natural Resources said Friday that a wild deer killed during the 2019 archery season near Menomonie has tested positive for the disease. The infection is the first detected in Dunn County.
Five wild deer have tested positive for CWD in neighboring Eau Claire County over the last two years.
Wisconsin’s traditional nine-day gun deer season opens Saturday. DNR officials are asking hunters in northwestern Wisconsin to turn in samples from any deer they kill in the region for CWD testing. A list of sampling stations can be found on the DNR’s website at https://dnr.wi.gov/wmcwd/RegStation/Search.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


CRAFTING
Visit this thread for an in depth yet clear guide on crafting 🔨
And this one for the cube recipes docs.
Items are subjected to being used in recipes, especially powerful ones, check the cube docs to know them all.
important recipes:
Make arcane shards Any unique item + Catalyst of Disenchantment → Arcane Shards + Catalyst of Disenchantment
Make arcane crystals Arcane Shards x5 → Arcane Crystal
Make a TU 2 Arcane Crystals + Oil of Enhancement + item = unique of same tier and same base
Uptier TU Non-sacred weapon/armor + Arcane Crystal → reroll as next higher tier
Socket item Non-socketed item + jewel x[1-6] → returns item with [1-6] sockets
GENERAL INFO
To understand each item types look into the first section of each item type's docs section in the Official Documentation. It is very clear and precise, and will help you grasp how they work.
TU (Tiers Uniques)
TUs have 4 ranks. Their stats requirement and general power depend on their stats. Check the docs for a list of them all, and their stats.
You can turn useless TU into arcane shards (see the recipes up on that page)
Be careful when up-tiering a tiered unique, the requirements can jump tremendously from one tier to the other. Always check the docs out first. You cannot reduce a TU tier, only up-tiering is possible.
SU ( Sacred Uniques)
SU are the next 'rank' of item. Generally better than T4 TU they are important for progressing in the game. Each item types has one SU and one SSU (sacred-sacred-unique). SU on the left, SSU on the right. A SSU isn't always better than an SU for your build. Read the documentation to check the item's stats and if they fit your build.
Sometimes a simple TU with good stats is better than an useless SU!
SU can be made into a token that add 1 (one) stat up when right clicking. Those are commonly referred as 'Sigs'. The maximum amount of sigs you can eat is 400.
This is a sig →
HONORIFICS AND MYSTIC ORBS
Honorifics are special items that can be made with either TU or SU items. Their text appear green in the game. They can be made in the cube with any magic item + Mark of infusion = honorific
Honorifics ( like any other items) can be cubed with Mystic Orbs (MO) one by one to transfer the MO stat to the item, except honorific gain double the amount of stats and have the maximum amount of sockets. Very handy if you don't find an item you need and want to get a lot of resistance/dexterity/stats on a glove, or boots. Use a base magic item with low lvl required since each MO adds a + 4 level required to the item. You can only apply up to 5 of the same type of regular Mystic Orb to your item.
The mark of infusion is dropped by Shenk in act5. Honorifics can't be made before this act ( except if you transfer from another char/friend).
MO can be brought from vendors, but they are very expensive. Around 13k each.
MISC ABOUT ITEMS
Hoarding item (gems, jewels, random crap) is useless in the beginning of the game.
Here's a list of item you should try to keep early on:
1. Resistance gems (Onyx/Bloodstone/Amber/Turquoise)
1. A couple of random runes (For reroll purposes)
1.  The catalysts, belladonas, etc
To get TU quicker (Check the recipes how to make any TU) you can farm Mephisto and then Nihlatak since both of them drops Arcane shards.
Uber charms have some randomization when it come to the amount of stats they have. Sometime you'll need to farm the charms to get a better roll.
TIPS
- Some maps have a drop bias towards specific types of items (check the doc).
- The best way to drop gems is K3K.
- Clear speed is better than MF in many cases. It's better to clear a lower level zone fast than struggle in an higher lvl one


MailSpoon Documentation
Sophisticated HTML and MIME email generation for Matlab.
About
MailSpoon is a Matlab library for generating advanced emails using HTML and MIME capabilities. It supports HTML email, inline images, file attachments, Cc and Bcc addresses, SMTP server configuration, and more. It is suitable for server-side automation of email generation.
MailSpoon can be used to produce nice reports, error notifications, or whatever else you want to use fancy emails for.
MailSpoon is written in a modern Matlab style. It’s my goal to make MailSpoon an example of how nice Matlab libraries can be organized.
Requirements
- Matlab R2019b or newer
Installation
To install MailSpoon:
- Download the MailSpoon repo.
- Add its
Mcode
directory to your Matlab path usingaddpath()
.
Usage
The main interface for building and sending email is mailspoon.HtmlEmail
. You create an email object, add text and attachments, and then send it.
e = mailspoon.HtmlEmail;
e.from = 'Alice Foo<EMAIL_ADDRESS>e.to =<EMAIL_ADDRESS>"Carol Bar<EMAIL_ADDRESS>e.subject = 'Hello, World!';
% Set HTML using setHtmlMsg()
e.html = strjoin({
''
'
Hello, World!
'
''
'
This is a message sent from '
' MailSpoon '
'for MATLAB®.
'
''
''
}, '\n');
% Attach files using attach()
e.attach([mfilename('fullpath') '.m'])
% Now send it!
e.send
Inline images
To incorporate inline images into your HTML message, you need to “embed” them into the message first in order to get “cid” identifiers for them, and then stick those cids into your HTML inside
tags.
e =<EMAIL_ADDRESS>'Me <from@example.com>');
e.subject = 'Look at these inline images from MailSpoon!';
% Embed images first, to get their cids
fig = figure('Visible','off');
surf(peaks);
fig_cid = e.embed(fig);
close(fig);
file = fullfile(mailspoon.libinfo.distroot, 'scratch', 'Brooklyn.jpg');
file_cid = e.embed(file);
% Then create your HTML using those cids
e.html = sprintf(strjoin({
''
''
'
Hello, World!
'
''
'
A Matlab Figure
'
'' % Do not put a "/" in the img tag!
''
'
An Image File
'
''
''
'
This is a message sent from '
'MailSpoon '
'for MATLAB®.
'
''
''
''
}, '\n'), fig_cid, file_cid);
e.send
Generating HTML from data
MailSpoon includes functions for rendering data (such as Matlab table
arrays) as HTML, for inclusion in your email. The main interface for that is the mailspoon.htmlify
function.
tbl = array2table(magic(5));
htmlFragment = mailspoon.htmlify(tbl);
html = sprintf(strjoin({
''
'
Here is a table
'
' %s'
''
}, '\n'), htmlFragment);
Example
If all goes well, you’ll soon be sending emails that look like this!
SMTP server configuration
Email server configuration is done through the mailspoon.MailHost
interface. Grab the default SMTP server configuration from mailspoon.MailHost.default
and set its properties.
host = mailspoon.MailHost.default;
host.username = 'my_smtp_username';
host.password = 'my_password';
% If your mail host requires SSL
host.useSsl = true;
host.sslPort = 9999; % If they don't use the default port 465
For settings that you don’t configure in mailspoon.MailHost
, MailSpoon will fall back to the defaults found in Matlab’s Internet
prefs, Java system properties, and maybe other places if I can find a reasonable way to look them up.
Configuring mailspoon.MailHost.default
is local to the Matlab session, and does not cause the Matlab preferences file to be updated, the way setpref('Internet')
does. This makes it suitable for use in automated processes on the server side.
Debugging
If you want to see debugging dumps of the internals of the objects, call inspect()
on them.
e.inspect
Technology
MailSpoon is built on top of Apache Commons Email and JavaMail/javax.mail
.
Author
MailSpoon was written by Andrew Janke.
The project home page is the repo page on GitHub at https://github.com/janklab/MailSpoon. Bug reports and feature requests are welcome.
MailSpoon is part of the Janklab suite of libraries for Matlab.


ǝ
home
|
about
|
writings
|
projects
my name is enzo saracen and i don't like lasagna.
contact:
<EMAIL_ADDRESS>i work mostly on github, find me there
< -- clik


@(reportContent: Map[String, phabricator.SummaryReport], nWeeks: Int, userNames: String, reviewMatrix: String, standardizedMatrix: String)
@import _root_.phabricator.SummaryReport
Phabricator report
Report for @nWeeks weeks
@for((username, report) <- reportContent) {
@username
Percent of diffs sent within team - @report.relativeSentAllReviews
Percent of diffs received within team - @report.relativeReceivedAllReviews
@if(report.durationSentReviewMetadata.maxClosedReview.isDefined) {
Closed diff sent with longest review -
link
(@report.durationSentReviewMetadata.maxClosedReview.get.daysDifference days)
}
@if(report.durationSentReviewMetadata.maxOpenReview.isDefined) {
Open diff sent still not reviewed -
link
(@report.durationSentReviewMetadata.maxOpenReview.get.daysDifference days)
}
@if(report.durationReceivedReviewMetadata.maxClosedReview.isDefined) {
Closed diff received with longest review -
link
(@report.durationReceivedReviewMetadata.maxClosedReview.get.daysDifference days)
}
@if(report.durationReceivedReviewMetadata.maxOpenReview.isDefined) {
Open diff received still not reviewed -
link
(@report.durationReceivedReviewMetadata.maxOpenReview.get.daysDifference days)
}
Top reviews sent to:
| Name | Reviews send count: |
@for((user, count) <- report.sentAllReviewsPerUsername) {
| @user | @count |
}
Top reviews received from:
| Name | Reviews received count: |
@for((user, count) <- report.receivedAllReviewsPerUsername) {
| @user | @count |
}
}


Wilbert:
Actually, we once played this game using the images on the Spirit Beads themselves, but it became easier to just use cards marked with images of Suns or Moons. Listen up! There are 10 types of cards, each marked with 1 to 5 pictures of the Sun or Moon. Here's how to play:
First, cards are dealt to each person in order. The last card drawn is placed face up.
Check how many pictures your cards have on them.
If there is more than one more card with 5 pictures on it, the person who got the card last wins.
Simple, eh?
Anything else you'd like to know?
"What is a Spirit Bead?"
"What do you get when you win the game?"
"I want to practice." (Need 1 Spirit Bead.)
"Let's play." (Need 50 Spirit Beads.)


| manage | index /Users/ryangiarusso/PycharmProjects/CS2720-SE/Flask-App/manage.py |
| Data | ||
| MigrateCommand = <flask_script.Manager object> SQLALCHEMY_DATABASE_URI =<EMAIL_ADDRESS>app = <Flask 'app'> db = <SQLAlchemy engine='mysql+mysqlconnector://Saili...pythonanywhere-services.com/SailingSales$master'> manager = <flask_script.Manager object> migrate = <flask_migrate.Migrate object> |


Both classes extend Exception (an unchecked exception object) - although
the two extended classes have no inheritance relationship with each other. Therefore (
since its implementation in Java SE 7),
both subclasses must be included in the throws clause (at line 4).
... After the if statement at line 6 evaluates to true,
Exception1 is thrown, and immediately caught (at line 11) – since (the compiler recognizes that) its a
subclass of Exception. Following this,
the exception is immediately
re-thrown, but this time – not caught.
The result is that, the exception is passed back down the stack to the calling method
(e.g. main) where the program terminates with an exception (of the type defined at line 7).
The act of re-throwing an exception allows for inserting and executing a logging statement
(or any another logic) just prior to the exception being re-thrown (i.e. just before line 12, in order to enhance the overall value
of the source code (e.g. troubleshooting). This contrasts with throwing an
exception and simply allowing a program to terminate without further action.
Re-throwing an exception, as described in this example, will only
successfully compile if; 1) there
are no other catch blocks that can handle the re-thrown exception, and 2) if the re-thrown exception
is a subtype or supertype of the exception in the catch clause (at line 11).


Authentication in Kubernetes
Authentication is an interesting area of Kubernetes security. The built-in options for authenticating users to clusters are fairly limited. Basic Authentication and Token Authentication are generally considered to be a bad idea as they rely on cleartext credentials stored in files on disk on the API server(s) and require an API server restart when changing their contents, which is not exactly a scalable solution.
This leaves client certificate authentication as the main default authentication mechanism and one that I see enabled in pretty much every cluster I look at. Client certificate authentication also gets used for component to component authentication (e.g. to allow the Kubelet to authenticate to the API server).
Client Certificate Authentication
Client certificate authentication, however, presents it’s own set of security concerns and challenges. Securely managing the keys associated with certificate authorities can be a significant challenge, and with many clusters using 3 or more distinct CAs (before we even start talking about add-ons like istio) there’s quite a bit of scope for problems. Kubernetes clusters will typically keep their CA certificates and keys online (i.e. they’re stored in the clear on disk on the API servers) as opposed to traditional PKI setups where a root CA key would never be held on a production system in the clear. In those more traditional setups the keys would either be stored in an HSM or kept offline and only used where needed to sign subordinate certificates.
CA Keys or “Golden Tickets”
You can then combine that with the problem that CA keys tend to have a very long validity period (from a review of common cluster installers, 10 years is typical) and you realise that if an attacker can get access to those CA key files they can effectively have a “golden ticket” to maintain unauthorised access to the cluster for a very long time, as the CA keys can be used to create new user identities whenever they like. This unauthorised access can happen in a number of ways, anything from a key mistakenly checked into source code control, or an attacker who can mount a volume from an API server component, could lead to leakage of a CA key.
One reason these attacks are possible is due to an important (and somewhat unintuitive) aspect of Kubernetes authentication which is that in general Kubernetes has no concept of a user database, it relies on the identity provided by the authentication mechanism, to determine who the user is and then matches this to RBAC bindings to provide rights to that user.
In the case of certificate authentication this is done by looking at the CN
and O
fields of the client certificate as it’s presented to the API server. A certificate which is signed by the appropriate CA is then given whatever rights that user identity correlates to.
So an attacker with access to the CA key can just mint new user identities whenever it likes, and Kubernetes won’t complain, even if there’s another certificate with that identity.
Certificate revocation (or lack thereof)
Another facet of client certificate authentication in Kubernetes which makes this problematic is that Kubernetes has no concept of certificate revocation. So an attacker who mints a privileged client cert can continue to use this as long as the CA key doesn’t change, and as mentioned earlier, these are usually valid for 10 years.
The only way to prevent this persistent access is to redeploy the entire certificate authority which, depending on the size of the cluster, could be tricky.
So how many clusters could this affect?
One other facet of the way that Kubernetes is being commonly deployed which could make this an issue going forward is the number of clusters which have their API server components exposed on the Internet. It’s relatively easy to search for Kubernetes clusters via search engines like Censys as they have common strings in their certificates. A recent check showed that there are now over a million likely Kubernetes cluster servers on-line…
It’s worth noting that these problems are more of a concern in unmanaged Kubernetes clusters, where the operator is responsible for CA management. The main managed clusters (GKE, AKS and EKS) don’t expose the CA keys to users of the cluster and GKE also offers the option to disable client certificate authentication all together, which is good as it’s not just a problem with CA keys, user kubeconfig files with client keys can also be a risk.


| President |
Assistant Professor |
1 |
Prof. Kranti Wagle |
| Vice President |
Assistant Professor |
1 |
Prof. Ashwini Pansare |
| Convener |
Assistant Professor |
1 |
Prof. Dileep C.C. |
| NISP Co-ordinator |
Assistant Professor |
1 |
Prof. Swati Ringe |
| Innovation Activity Co-ordinator |
Assistant Professor |
1 |
Prof. Heena Pendhari |
| Startup Activity Co-ordinator |
Assistant Professor |
2 |
Dr. V. S. Jorapur, Prof. Hitendra Vaishnav |
| Internship Activity Co-ordinator |
Assistant Professor |
1 |
Prof. Prachi Patil |
| IPR Activity Co-ordinator |
Professor and Dean R&D |
2 |
Dr. Bhushan Patil, Prof. Deepali Bhise |
| Social Media Co-ordinator |
Assistant Professor |
1 |
Prof. Sangeeta Parshionikar |
| ARIIA Co-ordinator |
Professor Dean-Student aafairs |
1 |
Dr. D.V. Bhoir |
| NIRF Co-ordinator |
Assistant Professor |
1 |
Prof. Ketaki Joshi |
| E-Cell In-charge |
Assistant Professor |
1 |
Prof. Prajakta Bhangale |
| Tinkering Lab |
Assistant Professor |
1 |
Prof. Saurabh Kulkarni |
| Member |
Assistant Professor |
1 |
Prof. Vaibhav Godbole |
| Member |
Assistant Professor |
1 |
Prof. Prajakta Dhamnaskar |
| Member |
Assistant Professor |
1 |
Prof. Vaibhav Godbole |
| Innovation Co-ordinator(Student) |
Student Co-ordinator |
1 |
Yash Kane |
| Startup Co-ordinator (Student) |
Student Co-ordinator |
1 |
Advait Bhushan Marde |
| IPR Co-ordinator |
Student Co-ordinator |
1 |
Sahil S Nikalje |
| Social Media Co-ordinator |
Student Co-ordinator |
1 |
Aryan Patil |
| Internship Co-ordinator |
Student Co-ordinator |
1 |
Hritik Manish Kothari |
| Representative from nearby Incubation Centre |
Member |
1 |
Prof. K.T.Talele, SPIT, Mumbai |
| Representatives of SIDBI/NABARD/Lead Bank/Investor |
Member |
1 |
Mr. Sanjeev Kumar, Sr. Manager, Corporation Bank, Hill Road Bandra-West |
| Technical Experts from nearby industry |
Member |
1 |
Mr. Samir Kaji, M.D. Selec Controls P.Ltd |
| Alumni Entrepreneurs |
Member |
1 |
Mr. Ayush Jain, UthopiaTech |


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/mutual.20inductive.20definition.html ---
can one of you explain why I cannot get this mutual inductive definition to work?
mutual inductive Foo, Bar with Foo : Type | bizz : Foo | buzz {f : Foo} : Bar f → Foo with Bar : Foo → Type | baz (f : Foo) : Bar f
For reference, the following works in Agda
mutual data Foo : Set where bizz : Foo buzz : {f : Foo} → Bar f → Foo data Bar : Foo → Set where baz : (f : Foo) → Bar f
this is called an inductive-recursive definition, and it is stronger than lean's axiomatics
There may be another way to encode the type you want, but inductive recursive definitions can be used to prove DTT is consistent, so lean can't do it
Incidentally, Mario, were you working on a Lean consistency project at some point?
What is DTT?
dependent type theory
That's the name of the game we are playing
yes, I'll be defending my masters thesis in a few weeks and lean consistency is in it
https://github.com/digama0/lean-type-theory/releases/tag/v0.21
so, is lean consistent?
@Kenny Lau How is that not independent?
yes, assuming some large cardinal assumptions
which is the usual story with consistency proofs
I think this shape is called inductive-inductive: mutual inductive types where at least one is indexed by the other one, inductive-recursive means to mutually define inductive types and recursive definitions where at least one inductive type depends on the recursive definition.
I think inductive-inductive can be reduced to inductive, inductive-recursive cannot
you might be right about the name, but I'm pretty sure inductive-inductive is also axiomatically strong
because you can define the well typed terms of DTT by induction-induction with the set of well formed contexts and the set of types in a context
Inductive recursive can be reduced to inductive inductive, I think, where the recursive function becomes a functional relation
Ah, or it was this way round
There may be another way to encode the type you want, but inductive recursive definitions can be used to prove DTT is consistent, so lean can't do it
Consistent with respect to what?
with respect to DTT with a larger type universe and inductive recursive definitions (I guess)
This is indeed an inductive-inductive definition. I think adding these won't increase the proof stength of the system. In extensional type theory, inductive-inductive definitions can be defined from indexed inductive types, but I don't think it's known in whether this is the case in intensional type theory.
Inductive-recursive definitions indeed do increase the proof stength of the system: you can build a (Tarski) universe using induction-recursion.
Ncatlab links:
https://ncatlab.org/nlab/show/inductive-inductive+type
https://ncatlab.org/nlab/show/inductive-recursive+type
Last updated: Apr 24 2020 at 19:02 UTC


This distributed directory module may be used alone or in conjunction with Zoltan's load balancing capability and memory and communication services. The user should note that external names (subroutines, etc.) prefaced by Zoltan_DD_ are reserved when using this module. Since the distributed directory uses collective communication, it is important that all processors call the same function at the same time in their processing.
The user initially creates an empty distributed directory using Zoltan_DD_Create. Then each global ID (GID), which are the directory keys, together with other optional information is added to the directory using Zoltan_DD_Update. The directory maintains the GID's basic information: local ID (optional), part (optional), arbitrary user data (optional), and the current data owner (optional). Zoltan_DD_Update is also called after data migration or whenever it is useful to update the information in the directory. Zoltan_DD_Find returns the directory information for a list of GIDs. A selected list of GIDs may be removed from the directory by Zoltan_DD_Remove. When the user has finished using the directory, its memory is returned to the system by Zoltan_DD_Destroy.
An object is known by its GID. Hashing provides very fast lookup for the information associated with a GID in a two step process. The first hash of the GID yields the processor number owning the directory entry for that GID. The directory entry owner remains constant even if the object associated with the GID migrates or changes over time. Second, a different hash algorithm on the GID looks up the associated information in directory processor's hash table. The user may optionally register their own (first) hash function to take advantage of their knowledge of their GID naming scheme and the GID's neighboring processors. See the documentation for Zoltan_DD_Set_Hash_Fn for more information. If no user hash function is registered, Zoltan's Zoltan_Hash will be used. This module's design was strongly influenced by the paper "Communication Support for Adaptive Computation" by Pinar and Hendrickson.
Some users number their GIDs by giving the first "n" GIDs to processor 0, the next "n" GIDs to processor 1, and so forth. The function Zoltan_DD_Set_Neighbor_Hash_Fn1 will provide efficient directory communication when these GIDs stay close to their origin. The function Zoltan_DD_Set_Neighbor_Hash_Fn2 allows the specification of ranges of GIDs to each processor for more flexibility. The source code for DD_Set_Neighbor_Hash_Fn1 and DD_Set_Neighbor_Hash_Fn2 provide examples of how a user can create their own "hash" functions taking advantage of their own GID naming convention.
The routine Zoltan_DD_Print will print the contents of the directory. The companion routine Zoltan_DD_Stats prints out a summary of the hash table size, number of linked lists, and the length of the longest linked list. This may be useful when the user creates their own hash functions.
All modules use the following response to the debug_level:
debug_level=0, Output is silent except for FATAL or MEMERR errors.
debug_level=1, Turns on checking for legal, but possibly wrong conditions such as
updating the same directory multiple times in one update cycle.
debug_level=5, Adds tracing information for the routines defined below.
debug_level=6, Adds tracing information for all DD routines.
debug_level=7, Adds tracing within each routine,
debug_level>7, Adds information about each object when used.
Calling DD_Stats or DD_Print is automatically verbose independent of the debug_level.
The C++ interface to this utility is defined in the header file zoltan_dd_cpp.h as the class Zoltan_DD. A single Zoltan_DD object represents a distributed directory.
A Fortran90 interface is not yet available.
| Source code location: | Utilities/DDirectory |
| C Function prototypes file: | Utilities/DDirectory/zoltan_dd.h |
| C++ class definition: | Utilities/DDirectory/zoltan_dd_cpp.h |
| Library name: | libzoltan_dd.a |
| Other libraries used by this library: | libmpi.a, libzoltan_mem.a, libzoltan_comm.a |
Routines:Zoltan_DD_Create: Allocates memory and initializes the directory. |
|
Data Stuctures:
struct Zoltan_DD_Struct: State & storage used by all DD routines. Users should not modify any internal values in this structure. Users should only pass the address of this structure to the other routines in this package. |
| C: | int Zoltan_DD_Create (struct Zoltan_DD_Struct **dd, MPI_Comm comm, int num_gid_entries, int num_lid_entries, int user_length, int table_length, int debug_level); |
| C++: |
Zoltan_DD(
const MPI_Comm & comm,
const int & num_gid_entries,
const int & num_lid_entries,
const int & user_length,
const int & table_length,
const int & debug_level);
or Zoltan_DD(); Zoltan_DD::Create( const MPI_Comm & comm, const int & num_gid_entries, const int & num_lid_entries, const int & user_length, const int & table_length, const int & debug_level); |
The Zoltan_DD_Struct must be passed to all other distributed directory routines. The MPI Comm argument designates the processors used for the distributed directory. The MPI Comm argument is duplicated and stored for later use. The length of the GID, length of the LID, and the length of the optional user data (user_length) must be consistent for all processors.
| Arguments: | |
| dd | Structure maintains directory state and hash table. |
| comm | MPI comm duplicated and stored specifying directory processors. |
| num_gid_entries | Length (number of ZOLTAN_ID_TYPE) of GID. |
| num_lid_entries | Length (number of ZOLTAN_ID_TYPE) of local ID or zero to ignore local IDs. |
| user_length | Length (number of char) of user defined data field (optional, may be zero). |
| table_length | Length of hash table (zero forces default value of 100,000 slots). For large problems, this value should be increased to approximately the number of global GIDs / number of processors (if you have enough memory) in order to improve performance. |
| debug_level | Legal values range in [0,9]. Sets the output response to various error conditions where 9 is the most verbose. |
| Returned Value: | |
| int | Error code. |
ZOLTAN_FATAL is returned for MPI problems or if num_gid_entries,
num_lid_entries, or user_length
do
not match globally.
ZOLTAN_MEMERR is returned if sufficient memory can not be allocated.
ZOLTAN_OK is the normal return value.
In the C++ interface, the distributed directory is represented by a Zoltan_DD object. It is created when the Zoltan_DD constructor executes. There are two constructors. The first one listed above uses parameters to initialize the distributed directory. The second constructor does not, but it can subsequently be initialized with a call to Zoltan_DD::Create().
| C: | struct Zoltan_DD_Struct   *Zoltan_DD_Copy (struct Zoltan_DD_Struct *from); |
| C++: | Zoltan_DD(const Zoltan_DD &dd); |
| Arguments: | |
| from | The existing directory structure which will be copied to the new one. |
| Returned Value: | |
| struct Zoltan_DD_Struct * | The newly created directory structure. |
| C: | int Zoltan_DD_Copy_To (struct Zoltan_DD_Struct **to, struct Zoltan_DD_Struct *from); |
| C++: | Zoltan_DD & operator=(const Zoltan_DD &dd); |
| Arguments: | |
| to | A pointer to a pointer to the target structure. The structure will be destroyed and the pointer set to NULL before proceeding with the copy. |
| from | A pointer to the source structure. The contents of this structure will be copied to the target structure. |
| Returned Value: | |
| int | Error code. |
| C: | void Zoltan_DD_Destroy (struct Zoltan_DD_Struct **dd); |
| C++: | ~Zoltan_DD(); |
| Arguments: | |
| dd | Directory structure to be deallocated. |
| Returned Value: | |
| void | NONE |
There is no explicit Destroy method in the C++ Zoltan_DD class. The object is deallocated when its destructor is called.
|
C: |
int Zoltan_DD_Update (struct Zoltan_DD_Struct *dd, ZOLTAN_ID_PTR gid, ZOLTAN_ID_PTR lid, char *user, int *part, int count); |
| C++: | int Zoltan_DD::Update( ZOLTAN_ID_PTR gid, ZOLTAN_ID_PTR lid, char *user, int *part, const int & count); |
The user can set the debug level argument in Zoltan_DD_Create
to determine the module's response to multiple updates for any GID
within one update cycle.
| Arguments: | |
| dd | Distributed directory structure state information. |
| gid | List of GIDs to update (in). |
| lid | List of corresponding local IDs (optional) (in). |
| user | List of corresponding user data (optional) (in). |
| part | List of corresponding parts (optional) (in). |
| count | Number of GIDs in update list. |
| Returned Value: | |
| int | Error code. |
|
C: |
int Zoltan_DD_Find (struct Zoltan_DD_Struct *dd, ZOLTAN_ID_PTR gid, ZOLTAN_ID_PTR lid, char *data, int *part, int count, int *owner); |
| C++: | int Zoltan_DD::Find( ZOLTAN_ID_PTR gid, ZOLTAN_ID_PTR lid, char *data, int *part, const int & count, int *owner) const; |
| Arguments: | |
| dd | Distributed directory structure state information. |
| gid | List of GIDs whose information is requested. |
| lid | Corresponding list of local IDs (optional) (out). |
| data | Corresponding list of user data (optional) (out). |
| part | Corresponding list of parts (optional) (out). |
| count | Count of GIDs in above list. |
| owner | Corresponding list of data owners (out). |
| Returned Value: | |
| int | Error code. |
ZOLTAN_OK is the normal return.
ZOLTAN_WARN is returned when at
least one GID in the gid list is not found AND debug level > 0.
ZOLTAN_MEMERR is returned whenever memory can not be allocated.
ZOLTAN_FATAL is returned whenever there is a problem with the input arguments (such as
dd being NULL) or communications error.
|
C: |
int Zoltan_DD_Remove (struct Zoltan_DD_Struct *dd, ZOLTAN_ID_PTR gid, int count); |
| C++: | int Zoltan_DD::Remove( ZOLTAN_ID_PTR gid, const int & count); |
| Arguments: | |
| dd | Distributed directory structure state information. |
| gid | List of GIDs to eliminate from the directory. |
| count | Number of GIDs to be removed. |
| Returned Value: | |
| int | Error code. |
|
C: |
void Zoltan_DD_Set_Hash_Fn (struct Zoltan_DD_Struct *dd, unsigned int (*hash) (ZOLTAN_ID_PTR, int, unsigned int)); |
| C++: | void Zoltan_DD::Set_Hash_Fn( unsigned int (*hash) (ZOLTAN_ID_PTR, int, unsigned int)); |
Experienced users may elect to create their own hash function based on
their knowledge of their GID naming scheme. The user's hash
function must have calling arguments compatible with Zoltan_Hash.
The final argument, nprocs, is the number of processors in
the communicator passed to Zoltan_DD_Create.
Consider that a user has defined a hash function, myhash, as
extern int total_num_gid;
unsigned int myhash(ZOLTAN_ID_PTR gid, int length, unsigned int nproc)
{
/* Assuming a processor is more likely to query GIDs that are numerically
close to the GIDs it owns, */
/* this hash function tries to store the gid's directory information
near the gid's owning processor's neighborhood. */
/* GID length is one ; total_num_gid is a global variable with the total number of GIDs in the application. */
return ((*gid * nproc) / total_num_gid);
}
Then the call to register this hash function is:
Zoltan_DD_Set_Hash(dd, myhash);
| Arguments: | |
| dd | Distributed directory structure state information. |
| hash | Name of user's hash function. |
| Returned Value: | |
| void | NONE |
|
C: |
void Zoltan_DD_Stats (struct Zoltan_DD_Struct *dd); |
| C++: | void Zoltan_DD::Stats() const; |
| Arguments: | |
| dd | Distributed directory structure for state information |
| Returned Value: | |
| void | NONE |
| Arguments: | |
| dd | Distributed directory structure state information. |
| size | Number of consecutive GIDs associated with a processor. |
| Returned Value: | |
| int | Error code. |
| Arguments: | |
| dd | Distributed directory structure state information. |
| proc | List of processor ids labeling for corresponding high, low value. |
| low | List of low GID limits corresponding to proc list. |
| high | List of high GID limits corresponding to proc list. |
| n | Number of elements in the above lists. Should be number of processors! |
| Returned Value: | |
| int | Error code. |
| C: | int Zoltan_DD_Print (struct Zoltan_DD_Struct *dd); |
| C++: | int Zoltan_DD::Print () const; |
| Arguments: | |
| dd | Distributed directory structure state information. |
| Returned Value: | |
| int | Error code. |
User's Notes
Because Zoltan places no restrictions on the content or length of GIDs, hashing does not guarantee a balanced distribution of objects in the distributed directory.  Fortunately, the average behavior is very good! The user may specify their own hash function via Zoltan_DD_Set_Hash_Fn to improve performance.
This software module is built on top of the Zoltan Communications functions for efficiency. Improvements to the communications library will automatically benefit the distributed directory.


| Author | Stef Mientki, Copyright © 2002..2006, all rights reserved. |
| Adapted-by | Sebastien Lelong, Albert Faber, Joep Suijs (on behalf of Tijs van Roon), |
| Compiler | 2.4o |
Software RS232 library Library supports software RS232 send and receive procedure on any IO-pin. Both the inverted and non-inverted routines are available, so it should fit any hardware. Baudrate can be set between 110 and 230_400 (for 20 Mhz Xtal), for lower Xtal frequencies the maximum baudrate will be equally lower. Baudrates are optimized, so even the high baudrates shouldn't be a problem (my [Stef] standard = 115_200 Baud, which has never given me any problems). Interrupts are disabled during transmissions. Default parameters are 8 databits, 2 stopbits, no parity, no handshake. . To use this serial_software library in a user program: . 1. The following aliases must be defined: serial_sw_tx_pin is pin_xy (any output pin) serial_sw_rx_pin is pin_xy (any input pin) . 2. the following constants must be defined by the user program: serial_sw_baudrate = 110 .. 240_000 . 3. The following constants may [optionally] be defined by the user program: serial_sw_invert = FALSE | TRUE (default: TRUE) serial_sw_databits = 5 .. 8 (default: 8) serial_sw_stopbits = 1 | 2 (default: 2) . 4. Include serial_software . 5. Set the selected serial_sw_tx_pin for output and set the serial_sw_rx_pin for input. . 6. serial_sw_init()
No dependency found
const serial_sw_databits = 8
const serial_sw_stopbits = 2
const serial_sw_bit_time = (1_000_000/serial_sw_baudrate) - ((13 * serial_sw_instruction_time) / 100)
const bit serial_sw_invert = true
const serial_sw_instruction_time = 400_000_000 / target_clock
serial_sw_data'put(byte in data)
serial_sw_write(byte in data)
serial_sw_init()
serial_sw_read_wait(byte out data)
const serial_sw_databits = 8
Define number of databits default is 8 databits
const serial_sw_stopbits = 2
Define number of stopbits default is 2 stopbits
const serial_sw_bit_time = (1_000_000/serial_sw_baudrate) - ((13 * serial_sw_instruction_time) / 100)
No documentation found
const bit serial_sw_invert = true
Define if signal has to be inverted or not. default is low active-serial (like serial_hw)
const serial_sw_instruction_time = 400_000_000 / target_clock
calculate instruction execution time in 10ns units
serial_sw_data'put(byte in data)
Here the serial_sw_write procedure is declared as a pseudo variable so you can use it in the following way: {{{ serial_sw_write = 0x33 }}}
serial_sw_write(byte in data)
Transmit a character. Interrupts will be disabled during this routine, but restored afterwards. Also here the code is doubled (inverting and non-inverting) and selection is done by a compiler-directive.
serial_sw_init()
Initialize the library The only action needed is to set the transmit pin high or low, (depending on serial_sw_invert definition).
serial_sw_read_wait(byte out data)
Wait until a character is received. Interrupts will be disabled during this routine, but restored afterwards. Also here the code is doubled (inverting and non-inverting) and selection is done by a compiler-directive.
serial_sw_data'get() return byte
Here the serial_sw_read_wait procedure is declared as a pseudo variable so you can use it in the following way {{{ Data = serial_sw_write }}}
serial_sw_read(byte out data) return bit
Wait until a character is received or time out is reached. Interrupts will be disabled during this routine, but restored afterwards. Also here the code is doubled (inverting and non-inverting) and selection is done by a compiler-directive.
| 12f615 | 12f615_print.jal |
| 16f877a | 16f877a_serial_software.jal |
| 16f88 | 16f88_serial_sw_echo.jal |
| 18f4550 | 18f4550_fat32_sd_card.jal |
| 18f4550 | 18f4550_23k256.jal |
| 18f4550 | 18f4550_sd_card.jal |
| 18f4550 | 18f4550_serial_software.jal |
| 18f4550 | 18f4550_fat32_small_sd_card.jal |
| 18f4620 | 18f4620_network_udp_server.jal |
| 18f4620 | 18f4620_network_slip_isr_ping_udp.jal |
| 18f4620 | 18f4620_network_all_in_one.jal |
| 18f4620 | 18f4620_network_webserver_enc28j60.jal |
| 18f4620 | 18f4620_network_udp_client.jal |
| 18f4620 | 18f4620_network_tcp_client.jal |
| 18f4620 | 18f4620_network_tcp_server.jal |
| 18f4620 | 18f4620_network_ping.jal |


Club Championship 2023 Event 14
| Lubenham 10 |
09 July 23 |
|
10 |
miles |
| Name |
Position |
Road bike |
Actual Time |
Avg. mph |
| |
|
|
|
|
| Jonathan
Durnin |
1 |
|
00:23:42 |
25.32 |
| Phil
Rayner |
2 |
|
00:24:32 |
24.46 |
| Andy
Poulton |
3 |
|
00:24:38 |
24.36 |
| Austin
Smith |
4 |
|
00:25:03 |
23.95 |
| Maciej
Suchocki |
5 |
|
00:25:19 |
23.70 |
| Stuart
Haycox |
6 |
|
00:25:55 |
23.15 |
| Richard
Krause |
7 |
1 |
00:26:04 |
23.02 |
| Kevin
Mills |
8 |
2 |
00:26:39 |
22.51 |
| Simon
Ward |
9 |
|
00:27:03 |
22.18 |
| Jen
Clegg |
10 |
|
00:27:10 |
22.09 |
| Kevin
Willett |
11 |
3 |
00:27:17 |
21.99 |
| Milly
Pinnock |
12 |
4 |
00:27:29 |
21.83 |
| Steven
Coulam |
13 |
|
00:28:41 |
20.92 |
| Vic
Barnett |
14 |
5 |
00:31:02 |
19.33 |
| John
Welsford |
15 |
6 |
00:31:44 |
18.91 |
| Sophie
Ward |
16 |
|
00:32:36 |
18.40 |
| Debbie
Ward |
17 |
7 |
00:35:00 |
17.14 |
| Amanda
McPherson |
|
|
DNS |
|
|
|
|
|
|


Content-type: text/html; charset=UTF-8
Man page of IDA
IDA
Section: Ida Manual (1)
Updated:
Index
Return to Main Contents
NAME
ida - use ida to provide rooter, symbolizer and reconstructor
SYNOPSIS
ida [OPTION]...
DESCRIPTION
This plugin provides rooter, symbolizer and reconstuctor services.
If IDA instance is found on the machine, or specified by a user, it will be queried for the specified information.
OPTIONS
- --headless=VAL (absent=false)
-
Use headless curses based IDA.
- --help[=FMT] (default=pager)
-
Show this help in format FMT (pager, plain or groff).
- --path=VAL (absent=/home/ivg/ida-6.9/)
-
Path to IDA directory.
SEE ALSO
bap-ida(3), regular(3),bap-plugin-byteweight(1), bap-plugin-objdump(1)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- OPTIONS
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 20:04:42 GMT, February 09, 2017


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| ended.js | 20% | 2/10 | 0% | 0/8 | 33.33% | 1/3 | 20% | 2/10 | |
| events.js | 75.44% | 129/171 | 45.65% | 21/46 | 92% | 23/25 | 75.44% | 129/171 | |
| keydown.js | 5.88% | 2/34 | 0% | 0/22 | 11.11% | 1/9 | 5.88% | 2/34 | |
| mute.js | 100% | 9/9 | 83.33% | 5/6 | 100% | 2/2 | 100% | 9/9 | |
| next.js | 71.43% | 10/14 | 58.33% | 7/12 | 75% | 3/4 | 71.43% | 10/14 | |
| pause.js | 100% | 25/25 | 96.55% | 28/29 | 100% | 6/6 | 100% | 25/25 | |
| play.js | 91.89% | 34/37 | 76.67% | 23/30 | 100% | 6/6 | 91.89% | 34/37 | |
| playPause.js | 91.11% | 41/45 | 89.47% | 34/38 | 100% | 6/6 | 91.11% | 41/45 | |
| playbackSpeed.js | 100% | 11/11 | 80% | 4/5 | 100% | 2/2 | 100% | 11/11 | |
| prev.js | 100% | 14/14 | 91.67% | 11/12 | 100% | 4/4 | 100% | 14/14 | |
| progress.js | 28.57% | 2/7 | 0% | 0/2 | 50% | 1/2 | 28.57% | 2/7 | |
| repeat.js | 100% | 12/12 | 83.33% | 5/6 | 100% | 4/4 | 100% | 12/12 | |
| repeatSong.js | 100% | 5/5 | 50% | 1/2 | 100% | 2/2 | 100% | 5/5 | |
| shuffle.js | 100% | 11/11 | 75% | 3/4 | 100% | 4/4 | 100% | 11/11 | |
| skipTo.js | 92.59% | 25/27 | 64.29% | 9/14 | 100% | 4/4 | 92.59% | 25/27 | |
| songSlider.js | 6.9% | 2/29 | 0% | 0/34 | 16.67% | 1/6 | 6.9% | 2/29 | |
| stop.js | 100% | 6/6 | 50% | 1/2 | 100% | 2/2 | 100% | 6/6 | |
| timeUpdate.js | 7.69% | 2/26 | 0% | 0/12 | 20% | 1/5 | 7.69% | 2/26 | |
| volumeDown.js | 100% | 10/10 | 83.33% | 5/6 | 100% | 2/2 | 100% | 10/10 | |
| volumeSlider.js | 40% | 2/5 | 0% | 0/2 | 50% | 1/2 | 40% | 2/5 | |
| volumeUp.js | 100% | 10/10 | 66.67% | 4/6 | 100% | 2/2 | 100% | 10/10 |


Welcome
Welcome to this tutorial for application development on SAP Business Technology Platform (SAP BTP). We provide information and examples on how to develop and deploy an application based on SAP Cloud Application Programming Model (CAP) on SAP BTP using different tools and services step by step.
It's planned to provide multiple modules that are built upon each other. You can start the tutorial with the first module, or start in between, because the source code for every tutorial module is provided in this repository.
Download and Installation
If you want to start from a specific tutorial module, get the name of its branch from the tutorial, download this repository and switch to the desired branch:
git clone https://github.com/SAP-samples/cloud-cap-risk-management
cd cloud-cap-risk-management
checkout <branch>
Known Issues
You can find the known issues here.
How to Obtain Support
Check out the documentation for:
In case you have a question, find a bug, or otherwise need support to use SAP products, use:
If you face a problem with the example application or the description, feel free to create an issue.
Contributing
If you have suggestions on how to improve the tutorial, you're welcome to provide your input here.
License
Copyright (c) 2021 SAP SE or an SAP affiliate company. All rights reserved. This project is licensed under the Apache Software License, version 2.0 except as noted otherwise in the LICENSE file.


|
|
David Sibley
Full Name: David McAdams Sibley
|
|
|
Terms of Service top
|
| Chamber |
District |
Dates of Service |
Legislatures |
Party |
City/County |
Note |
Counties in District |
|
S
|
22
|
Jan 12, 1999 - Jan 9, 2002
|
76th
77th
(1)
(2)
|
Republican
|
Waco / McLennan
|
|
Bosque, Comanche, Denton, Eastland, Erath, Hamilton, Hill, Hood, Jack, Johnson, McLennan, Palo Pinto, Parker, Somervell, Tarrant, Wise
|
|
S
|
22
|
Jan 10, 1995 - Jan 12, 1999
|
74th
(3)
75th
|
Republican
|
Waco / McLennan
|
|
Bosque, Comanche, Denton, Eastland, Erath, Hamilton, Hill, Hood, Jack, Johnson, McLennan, Palo Pinto, Parker, Somervell, Tarrant, Wise
|
|
S
|
9
|
Jan 12, 1993 - Jan 10, 1995
|
73rd
(4)
(5)
|
Republican
|
Waco / McLennan
|
|
Dallas, Ellis, Hill, McLennan, Navarro
|
|
S
|
9
|
Mar 5, 1991 - Jan 12, 1993
|
72nd
(6)
(7)
(8)
|
Republican
|
Waco / McLennan
|
|
Dallas, Ellis, Falls, Freestone, Henderson, Hill, Limestone, McLennan, Navarro
|
|
(1)
Sibley resignation letter, 1/9/2002; Proclamation, 1/25/2002, Ordering special election in Senate District 22 on 5/4/2002 to serve unexpired term of David Sibley.
Governor Rick Perry.
(2)
In Senate, Kip Averitt, sworn 4/10/2002, succeeded David Sibley, resigned 1/9/2002. In House, Holt Getterman, sworn 4/10/2002, succeeded Kip Averitt, resigned 3/21/2002.
Members of the Texas Congress 1836-1845; Members of the Texas Legislature 1846-2004, 2005.
(3)
74th Legislature - Drawing for Terms of Office, 1/11/1995, pp. 75-76. Drew 4-year term.
Senate Journal.
(4)
73rd Legislature - Drawing for Terms of Office, 3/25/1993, pp. 589-590. Drew 4-year term.
Senate Journal.
(5)
Due to redistricting litigation, entire Senate went up for reelection in 1994. See also Clips database, 4/6/1993 - 4/8/1993, Redistricting - Legislature; and Guide to 2001 Redistricting - Appendix A, 1990s Redistricting (Texas Legislative Council).
Terrazas v. Slagle, 821 F.Supp. 1162 (April 5, 1993), 1993.
(6)
Special election 1/19/1991, runoff 2/23/1991.
Texas Secretary of State - Election Dates Including Special Elections, 1966-2001.
(7)
David Sibley, in special election 2/23/1991, sworn 3/5/1991, succeeded Thomas C. (Chet) Edwards, resigned when sworn to Congress 1/2/1991.
Members of the Texas Congress 1836-1845; Members of the Texas Legislature 1846-2004, 2005.
(8)
72nd Legislature, Regular Session - Statement of Canvass for the Second Special Election for State Senate, District 9, 3/5/1991, pp. 329-330; Oath of Office, 3/5/1991, p. 330.
Senate Journal.
|
|
|
|
Biographical Notes and Resources top
|
| Biographical Sketches |
|
Biographical sketch, "Texas Legislature's 75th Session Takes Shape," September 1996.
Insurance Journal: The Property/Casualty Magazine of Texas.
Biographical sketch, "TCJL's 'Eleven Best' Legislators," July 1999, pp. 1, 3.
Texas Civil Justice League Advocate.
Dental legislation preview, 75th Legislature, 1997, and biographical sketch, "Legislative Expectations High for 1997," by State Senator David Sibley, D.D.S., District 22, September 1996, pp. 30-31.
Texas Dental Journal.
Biographical sketch, "Movers and Shakers: Meet the Legislators Who Make the Decisions About Public Education," March 1995, pp. 13-17.
Texas Lone Star.
Legislative profile, 74th Legislature, 1995. "Scenes From the 74th: The Laney-Bush Session," 6/16/1995.
Texas Observer.
Biographical sketch, 77th Legislature.
Texas Senate.
Biographical sketch and photo.
Texas Senate, 77th Legislative Session, 2001.
Biographical sketch and photo.
Texas Senators, 73rd Legislature, 1993.
Biographical sketch and photo.
Texas Senators, 74th Legislature, 1995.
Biographical sketch and photo.
Texas Senators, 75th Legislature, 1997.
Biographical sketch and photo.
Texas Senators, 76th Legislative Session, 1999.
|
| Other Resources |
|
Mentioned in "Lobbyists Keep City's Interests in State's Sight," 9/6/1994.
Austin American-Statesman.
Sibley, David McAdams.
Texas State Cemetery.
Photo and interview with Senator David Sibley, pp. 11, 27, January 1993.
Texas Town & City.
|
| Photographs |
|
Photograph.
David Sibley, 72nd Legislature, State Preservation Board
Photograph.
David Sibley, 73rd Legislature, State Preservation Board
Photograph.
David Sibley, 74th Legislature, State Preservation Board
Photograph.
David Sibley, 75th Legislature, State Preservation Board
Photograph.
David Sibley, 76th Legislature, State Preservation Board
Photograph.
David Sibley, 77th Legislature, State Preservation Board
|
| Composite Photographs on Display in the Capitol |
|
72nd session composite photo of Senate members (Ground floor corridor, north wall. GE.C1). State Preservation Board.
73rd session composite photo of Senate members (Ground floor corridor, north wall. GE.C1). State Preservation Board.
74th session composite photo of Senate members (Ground floor corridor, north wall. GE.C1). State Preservation Board.
75th session composite photo of Senate members (Ground floor corridor, north wall. GE.C1). State Preservation Board.
76th session composite photo of Senate members (Ground floor corridor, north wall. GE.C1). State Preservation Board.
77th session composite photo of Senate members (Ground floor corridor, north wall. GE.C1). State Preservation Board.
|
|
Committee Informationtop
|
77th R.S. - 2001
Business and Commerce
(Chair)
Committee of the Whole Senate
Education
Electric Utility Restructuring, Legislative Oversight
(Co-Chair)
Health and Human Services
|
76th R.S. - 1999
Border Affairs, Special
(Vice Chair)
Committee of the Whole Senate
Economic Development
(Chair)
Education
Electric Utility Restructuring, Legislative Oversight
(Co-Chair)
Electric Utility Restructuring, Special
(Chair)
|
75th R.S. - 1997
Administration
Civil Justice, Interim
(Chair)
Economic Development
(Chair)
Economic Development, Interim
(Chair)
Education
Electric Utility Restructuring, Interim
(Chair)
Finance
Funding Issues in Education, Interim
International Relations, Trade, and Technology
Legislative and Congressional Redistricting, Committee of the Whole Senate
Municipal Franchise Agreements for Telecommunications Utilities
|
74th R.S. - 1995
Economic Development
(Chair)
Education
Finance
Finance Subcommittee II
General Investigating, Special
International Relations, Trade and Technology
Legislative and Congressional Redistricting, Committee of the Whole Senate, Special
Managed Care and Consumer Protections, Interim
(Chair)
|
73rd R.S. - 1993
Committee of the Whole Senate
Criminal Justice
Education
Nominations, Special
(Vice Chair)
Public Utility Commission, Interim
Redistricting, Ethics and Elections, Committee of the Whole Senate, Special
Redistricting, Ethics and Elections, Committee of the Whole Senate, Special Subcommittee
State Affairs
Telecommunications, Interim
(Co-Chair)
|
72nd R.S. - 1991
Committee of the Whole on Redistricting, Special
Committee of the Whole on Redistricting, Special, Subcommittee on Congressional Districts
Criminal Justice
Health and Human Services, Interim
Intergovernmental Relations
Natural Resources
Natural Resources Subcommittee on Agriculture
|
|


Freshly made delicious pizza
All pizzas come with our special three cheese blend.
Select Pizza Size:
Select Pizza Crust:
Toppings: ($5 per topping)
Will you be picking up your order, or getting it delivered?
Pick Up cost $0
Delivery cost $10
Thanks for ordering from Tony PizzaMaker. can pick up your order in 15 to 20 minutes!
Our Location: 435559 Tom Mboya street, Nairobi
Okay! We are sending this order to at .
You can expect your order to arrive in 30 minutes.


Please provide a name for the session!
Please provide a value for the session duration!
Please provide a name for the session location!
Please provide a value for the session programming language!
Please fill in this mandatory field!


About
Fandango was a project that was voted as a winning solution on CulTIP Challenges 2014, sponsored by British Council Macedonia. The idea was submitted by National and University Library "St. Clement of Ohrid" - Macedonia in partnership with MASIT. The final product was developed with support from Faculty of Computer Science and Engineering (FINKI).


No Selection / No Header / No Footer
Single Selection / No Header / No Footer
Multi Selection / No Header / Paged
Single Check / No Header / Paged / Only Pager
Multi Check / Paged / No Commands
Single Selection-Check / Paged / No Totals
Multi Selection / Multi Check / No Footer
Multi Selection-Check / No Footer
loading...


Enter a number greater than zero, and this program will count up to that number, replacing certain numbers with "ping", "pong", or "ping-pong"!


|
| | Forge ()=default |
| | Uninitialized Forge. More...
|
| |
| | Forge (LV2_URID_Map *map) |
| | Initialized Forge. More...
|
| |
| void | init (LV2_URID_Map *map) |
| | Initialize the underlying atom forge. More...
|
| |
| void | set_buffer (uint8_t *buf, uint32_t size) |
| | Set the Forge's buffer. More...
|
| |
|
ForgeRef | write_sequence_head (ForgeFrame &frame, uint32_t unit) |
| | Forge the header of a sequence.
|
| |
|
ForgeRef | write_beat_time (double beats) |
| | Forge frame time (in a sequence)
|
| |
| ForgeRef | write_frame_time (int64_t frames) |
| | Forge frame time (in a sequence). More...
|
| |
| ForgeRef | write_property_head (uint32_t key, uint32_t context) |
| | Write a property header. More...
|
| |
| void | pop (ForgeFrame &frame) |
| | Pop a forge frame. More...
|
| |
| void | pop_frame (ForgeFrame &frame) |
| | Pop a forge frame. More...
|
| |
| ForgeRef | write_atom (uint32_t size, uint32_t type) |
| | Write an atom header. More...
|
| |
|
ForgeRef | write_key (uint32_t urid) |
| |
|
ForgeRef | write_object (ForgeFrame &frame, uint32_t id, uint32_t otype) |
| | Write an atom object.
|
| |
| ForgeRef | write_path (const std::string &path) |
| | Write an atom path from string. More...
|
| |
|
ForgeRef | write_primitive (const Atom &atom) |
| |
| ForgeRef | write_resource (ForgeFrame &frame, uint32_t id, uint32_t otype) |
| | Write an atom resource. More...
|
| |
| ForgeRef | write_blank (ForgeFrame &frame, uint32_t id, uint32_t otype) |
| | Write a blank object. More...
|
| |
| ForgeRef | write_bool (const bool val) |
| | Write a boolean value. More...
|
| |
| ForgeRef | write_int (const int val) |
| | Write an integeger value. More...
|
| |
| ForgeRef | write_double (const double val) |
| | Write a double value. More...
|
| |
|
ForgeRef | write_float (const float val) |
| | Write a float value.
|
| |
|
ForgeRef | write_long (const int64_t val) |
| | Write a long integer value.
|
| |
|
ForgeRef | write_string (const char *str) |
| | Write a string value.
|
| |
|
ForgeRef | write_uri (const char *uri) |
| | Write a URI string.
|
| |
| ForgeRef | write_raw (const void *data, uint32_t size) |
| | Write raw data. More...
|
| |
| ForgeRef | write_urid (LV2_URID id) |
| | Write a URID value. More...
|
| |
Class wrapper around LV2_Atom_Forge.


leaf expression evolution {border-style development evolutionary limb px;} #ffffff;} Biol. digit growth patterning auxin morphological regulatory organ Arabidopsis cell developmental form gene Cell formation genetic ./science. Plant Science different post-patterning processes Development RCO digits diversity genes loss tinkering ./nature Curr. Nature Ptch changes leaves meristem networks px; vertebrate {font-family Barkoulas Cooper Dev. Msx font-size plants shape stages thaliana tissue transcription variation (Figure -toed ./j.cub... Fgf Genet. PIN Tsiantis Vlad death dissected double; evolved expressed leaflet leaflets likely maxima morphogenesis ./dev. Blein CUC Coen Hay KNOX Prusinkiewicz Sci. Shh apical basis border-color border-width bud cellular development. diverse evolution. findings hirsuta individual influence later local mechanisms pattern potential solid; suggest {font-style {font-weight ./pnas. Acad. Aida Bar Butterfield Cardamine Evolution Nat. Natl. Proc. Salazar-Ciudad Stern Tsiantis, U.S.A. animal animals apoptosis biology bold causing cells considerable controls courier; creates develop diversification em; expanded expression, flanks flexibility generation grant identified model novel outgrowths pathways patterns plant posterior primordium pt;} regulator signaling studies study


Fitting a class of Lee-Carter mortality models using iterative fitting algorithm.
| Version: | 1.0 |
| Depends: | R (≥ 3.0.3), demography, rainbow, forecast, date |
| Imports: | survival |
| Published: | 2014-11-20 |
| Author: | Zoltan Butt, Steven Haberman and Han Lin Shang |
| Maintainer: | Zoltan Butt <Z.Butt at city.ac.uk> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: | no |
| Materials: | ChangeLog |
| CRAN checks: | ilc results |
| Reference manual: | ilc.pdf |
| Vignettes: |
The ilc Package |
| Package source: | ilc_1.0.tar.gz |
| Windows binaries: | r-devel: ilc_1.0.zip, r-release: ilc_1.0.zip, r-oldrel: ilc_1.0.zip |
| OS X binaries: | r-release: ilc_1.0.tgz, r-oldrel: ilc_1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=ilc to link to this page.


{% extends "base.html" %} {% block page %} {% load get_creator %} {% url "moderator" as mod_link %} <Return to moderator home
Report #{{ report.id }}: {% comment %} No good way of declaring variables out of scope in template, so we create whatever the correct title/hyperlink is {% endcomment %} {% if report.type == "RV" %} {% url 'noodle' report.review.noodle.id as review_link %} {{ report.review.title }} {% elif report.type == "ND" %} {% url 'noodle' report.noodle.id as noodle_link %} {{ report.noodle.name }} {% elif report.type == "PF" %} {% url 'profile' report.profile.user.id as profile_link %} {{ report.profile.name }} {% endif %}
{{ report.get_reason_display }} {{ report.get_status_display }} {% comment %} Buttons are stacked for some reason, seems fine {% endcomment %} {% comment %} These are done as HTML forms bc there's no way to make links POST requests in Django normally {% endcomment %}


§264-73 Regulations. The director of transportation may promulgate rules and regulations governing the erection and maintenance of outdoor advertising permitted under section 264-72, consistent with the safety and welfare of the traveling public and with the national standards promulgated by the Secretary of Transportation pursuant to Title 23, United States Code. [L 1966, c 45, pt of §2; HRS §264-73]
Cross References
Rulemaking, see chapter 91.


distance?
Any
Very close
Close
Neutral
Far
Very far
Unknown
To-go?
Any
Delivery
Pick up
Eat in
Eat in & Delivery
Eat in & Pick up
Unknown


Back
Create Event Page
Event Name
{{vm.eventNameError}}
Event Description
Minimum Team Size:
{{vm.event.minTeamSize}}
Maximum Team Size:
{{vm.event.maxTeamSize}}
Leaders Per Team:
{{vm.event.numberOfLeaders}}
Create event


Yes. The parameter for the constructor is a string, which could contain user data.
The next example program writes
to a disk file named by the user.
The trim()
method removes leading
and trailing spaces from the user data.
Two try{}
blocks are
used so that if
the constructor throws an exception
an appropriate error message is written.
import java.io.*; class CreateFile { public static void main ( String[] args ) { // Get filename and create the file FileWriter writer = null; BufferedReader user = new BufferedReader( new InputStreamReader( System.in ) ); String fileName = ""; System.out.print("Enter Filename-->"); System.out.flush(); try { fileName = user.readLine().trim(); writer = new FileWriter( fileName ); } catch ( IOException iox ) { System.out.println("Error in creating file"); return; } // Write the file. try { writer.write( "Behold her, single in the field,\n" ); writer.write( "Yon solitary Highland Lass!\n" ); writer.write( "Reaping and singing by herself;\n" ); writer.write( "Stop here, or gently pass!\n" ); writer.close(); } catch ( IOException iox ) { System.out.println("Problem writing " + fileName ); } } }


Shiori is a Bootstrap-based Jekyll theme. It looks great by default, but you can customize it easily. It supports Bootstrap and Font Awesome classes out of the box.
View on GitHub →
Shiori comes with these color schemes:
Shiori is written by Elle Kasai.
Follow @ellekasai


6. Performance¶
6.1. Speed¶
FusionVet is very efficient. It took about 1 second to examine 1 fusion in a typical TCGA BAM file (7.1 Gb, 184 million reads)
6.2. Comparison to other tools¶
We used FusionVet to detect ERG-TMPRSS2 fusion from the 333 TCGA prostate cancer samples. A sample is called ERG-TMPRSS2 fusion positive if it has two or more supporting fragments.
We then compare FusionVet result to:
FusionSeq-HighSens (Sboner et al., Genome Biology, 2010)
MapSplice (Wang et al., Nucleic Acids Res. 2010)
DEEPEST (Dehghannasiri et al., PNAS 2019)
PRADA (tumorfusions.org) (Hu et al., Nucleic Acids Res. 2018)
We chose FusionSeq-HighSens and MapSplice because they were used in the original TCGA Cell paper. We chose DEEPEST and PRADA because they were newly developed and have demonstrated superior performance to other tools.
It has been found that ERG expression is significantly increased in fusion positive samples through the TMPRSS2 (an androgen responsive gene) mediated over expression (Tomlins et al., Science, 2005). Therefore, we used ERG expression as an indirect measurement of the authenticity of ERG-TMPRSS2 fusions.
FusionVet vs FusionSeq/MapSplice
FusionVet vs DEEPEST
FusionVet vs PRADA(TumorFusions.org)


Simple Search
Advanced Search
Snippet Search
Project Search
© Copyright AGORA 2017
API
|
Help
|
About
|
Disclaimer
Class
Name
Interface
Extends
Implements
Imports
Package
Access
default
public
final
abstract
Variables
Variable {{$index + 1}}
Name
Type
Access
any
public
protected
private
final
abstract
static
+
−
Methods
Method {{$index + 1}}
Name
Return type
Access
any
public
protected
private
final
abstract
static
Parameters
Name
Type
+
−
Exceptions
+
−
No results
Found {{total}} results in {{took}} seconds
Project:
See at GitHub