Inherits Assimp::Blender::ElemBase.
◆ FalloffType
| Enumerator |
|---|
| FalloffType_Constant | |
| FalloffType_InvLinear | |
| FalloffType_InvSquare | |
◆ Type
| Enumerator |
|---|
| Type_Local | |
| Type_Sun | |
| Type_Spot | |
| Type_Hemi | |
| Type_Area | |
◆ area_shape
| short Assimp::Blender::Lamp::area_shape |
◆ area_size
| float Assimp::Blender::Lamp::area_size |
◆ area_sizey
| float Assimp::Blender::Lamp::area_sizey |
◆ area_sizez
| float Assimp::Blender::Lamp::area_sizez |
◆ att1
| float Assimp::Blender::Lamp::att1 |
◆ att2
| float Assimp::Blender::Lamp::att2 |
| float Assimp::Blender::Lamp::b |
◆ colormodel
| short Assimp::Blender::Lamp::colormodel |
◆ constant_coefficient
| float Assimp::Blender::Lamp::constant_coefficient |
◆ dist
| float Assimp::Blender::Lamp::dist |
◆ dna_type
| const char* Assimp::Blender::ElemBase::dna_type |
|
inherited |
Type name of the element.
The type string points is the c_str
of the name
attribute of the corresponding Structure
, that is, it is only valid as long as the DNA is not modified. The dna_type is only set if the data type is not static, i.e. a std::shared_ptr<ElemBase> in the scene description would have its type resolved at runtime, so this member is always set.
◆ energy
| float Assimp::Blender::Lamp::energy |
◆ FAIL [1/2]
| ID id Assimp::Blender::Lamp::FAIL |
◆ FAIL [2/2]
| Type type Assimp::Blender::Lamp::FAIL |
◆ falloff_type
◆ flags
| short Assimp::Blender::Lamp::flags |
| float Assimp::Blender::Lamp::g |
◆ linear_coefficient
| float Assimp::Blender::Lamp::linear_coefficient |
◆ quadratic_coefficient
| float Assimp::Blender::Lamp::quadratic_coefficient |
| float Assimp::Blender::Lamp::r |
◆ spotblend
| float Assimp::Blender::Lamp::spotblend |
◆ spotsize
| float Assimp::Blender::Lamp::spotsize |
◆ sun_brightness
| float Assimp::Blender::Lamp::sun_brightness |
◆ totex
| short Assimp::Blender::Lamp::totex |
◆ WARN
| float k Assimp::Blender::Lamp::WARN |
The documentation for this struct was generated from the following file:


--- title: Lesson 1 - Adults keywords: fastai sidebar: home_sidebar nb_path: "nbs/course2020/tabular/01_Adults.ipynb" ---
We'll call in the tabular
module:
from fastai.tabular.all import *
Below you will find exact imports for everything used today:
from fastcore.basics import range_of, ifnone
from fastai.callback.progress import ProgressCallback
from fastai.callback.schedule import lr_find
from fastai.data.block import CategoryBlock
from fastai.data.core import DataLoaders
from fastai.data.external import untar_data, URLs
from fastai.data.transforms import RandomSplitter
from fastai.learner import load_learner, Learner
from fastai.metrics import accuracy
from fastai.tabular.core import Categorify, FillMissing, FillStrategy, Normalize, TabularPandas, TabDataLoader
from fastai.tabular.model import TabularModel
from fastai.tabular.learner import tabular_learner
import pandas as pd
And let's grab some data!
path = untar_data(URLs.ADULT_SAMPLE)
path.ls()
The data we want lives in adult.csv
df = pd.read_csv(path/'adult.csv')
Let's take a look at it:
df.head()
TabularPandas
fastai
has a new way of dealing with tabular data in a TabularPandas
object. It expects some dataframe, some procs
, cat_names
, cont_names
, y_names
, y_block
, and some splits. We'll walk through all of them
First we need to grab our categorical and continuous variables, along with how we want to process our data.
cat_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race']
cont_names = ['age', 'fnlwgt', 'education-num']
When we pre-process tabular data, fastai
we do one or more of three transforms:
Categorify
will transform columns that are in your cat_names
into that type, along with label encoding our categorical data:
First we'll make an instance of it:
cat = Categorify()
df.dtypes
And now let's try transforming a dataframe
to = TabularPandas(df, cat, cat_names)
cats = to.procs.categorify
Let's take a look at the categories:
cats['race']
We can see that it added a #na#
category. Let's look at the actual column:
to.show(max_n=3)
We can see that for instance occupation
got returned a #na#
value (as it was missing)
And if we call to.cats
we can see our one-hot encoded variables:
to.cats.head()
Normalize
To properly work with our numerical columns, we need to show a relationship between them all that our model can understand. This is commonly done through Normalization, where we scale the data between -1 and 1, and compute a z-score
norm = Normalize()
Let's make another to
cont_names
to = TabularPandas(df, norm, cont_names=cont_names)
norms = to.procs.normalize
Let's take a look:
We can grab the means and standard deviations like so:
norms.means
norms.stds
And we can also call to.conts
to take a look at our transformed data:
to.conts.head()
FillMissing
Now the last thing we need to do is take care of any missing values in our continuous variables (we have a special #na#
for categorical data). We have three strategies we can use:
median
constant
mode
By default it uses median
:
fm = FillMissing(fill_strategy=FillStrategy.median)
We'll recreate another TabularPandas
:
to = TabularPandas(df, fm, cont_names=cont_names)
Let's look at those missing values in the first few rows:
to.conts.head()
But wait! There's more!
to.cat_names
We have categorical values?! Yes!
to.cats.head()
We now have an additional boolean value based on if the value was missing or not too!
DataLoaders
Now let's build our TabularPandas
. We're also going to want to split our data too, and declare our y_names
:
splits = RandomSplitter()(range_of(df))
splits
What is range_of
?
range_of(df)[:5], len(df)
It's a list of total index's in our DataFrame
cat_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race']
cont_names = ['age', 'fnlwgt', 'education-num']
procs = [Categorify, FillMissing, Normalize]
y_names = 'salary'
y_block = CategoryBlock()
Now that we have everything declared, let's build our TabularPandas
to = TabularPandas(df, procs=procs, cat_names=cat_names, cont_names=cont_names,
y_names=y_names, y_block=y_block, splits=splits)
And we can build our DataLoaders
. We can do this one of two ways:
dls = to.dataloaders()
dls.show_batch()
We can create our DataLoaders (a train and a valid). One great reason to do this this way is we can pass in different batch sizes into each TabDataLoader, along with changing options like shuffle and drop_last (at the bottom I'll show why that's super cool)
So how do we use it? Our train and validation data live in to.train and to.valid right now, so we specify that along with our options. When you make a training DataLoader, you want shuffle to be True and drop_last to be True
trn_dl = TabDataLoader(to.train, bs=64, shuffle=True, drop_last=True)
val_dl = TabDataLoader(to.valid, bs=128)
Now we can make some DataLoaders
:
dls = DataLoaders(trn_dl, val_dl)
dls.show_batch()
Why can we do the .dataloaders()
? Because TabularPandas
actually are TabDataLoader
's!
to._dbunch_type
dls._dbunch_type
TabularLearner
Now we can build our model!
When dealing with our categorical data, we create what is called an embedding matrix. This allows for a higher dimentionality for relationships between the different categorical cardinalities. Finding the best size ratio was done through experiments by Jeremy on the Rossmann dataset
def get_emb_sz(to, sz_dict=None):
"Get default embedding size from `TabularPreprocessor` `proc` or the ones in `sz_dict`"
return [_one_emb_sz(to.classes, n, sz_dict) for n in to.cat_names]
def _one_emb_sz(classes, n, sz_dict=None):
"Pick an embedding size for `n` depending on `classes` if not given in `sz_dict`."
sz_dict = ifnone(sz_dict, {})
n_cat = len(classes[n])
sz = sz_dict.get(n, int(emb_sz_rule(n_cat))) # rule of thumb
return n_cat,sz
And now if we go look at his rule of thumb:
def emb_sz_rule(n_cat):
"Rule of thumb to pick embedding size corresponding to `n_cat`"
return min(600, round(1.6 * n_cat**0.56))
We either choose a maximum size of 600, or 1.6 * the cardinality to the .56
emb_szs = get_emb_sz(to)
emb_szs
If we want to see what each one aligns to, let's look at the order of cat_names
to.cat_names
to['workclass'].nunique()
If you notice, we had 10
there, this is to take one more column for any missing categorical values that may show
Numericals we just simply pass in how many there are:
cont_len = len(to.cont_names)
cont_len
And now we can build our model!
What makes this model a little different is our batches is actually two inputs:
batch = dls.one_batch()
len(batch)
batch[0][0], batch[1][0]
With the first being our categorical variables and the second being our numericals.
Now let's make our model. We'll want our size of our embeddings, the number of continuous variables, the number of outputs, and how large and how many fully connected layers we want to use:
net = TabularModel(emb_szs, cont_len, 2, [200,100])
net
Now that we know the background, let's do that a bit quicker:
learn = tabular_learner(dls, [200,100], metrics=accuracy)
And now we can fit!
learn.lr_find()
learn.fit(3, 1e-2)
Can we speed this up a little? Yes we can! The more you can load into a batch, the faster you can process the data. This is a careful balance, for tabular data I go to a maximum of 4096 rows per batch:
dls = to.dataloaders(bs=1024)
learn = tabular_learner(dls, [200,100], metrics=accuracy)
learn.lr_find()
learn.fit(3, 1e-2)
We can see we fit very quickly, but it didn't fit quite as well (there is a trade-off):
dls = to.dataloaders(bs=4096)
learn = tabular_learner(dls, [200,100], metrics=accuracy)
learn.lr_find()
learn.fit_one_cycle(3, 1e-2)
learn.export('myModel.pkl')
del learn
learn = load_learner('myModel.pkl')
Once we load in our learner, we can create a test dataloader like so:
dl = learn.dls.test_dl(df.iloc[:100])
Let's look at a batch
dl.show_batch()
You can see it's actually labelled! Is that right?
df2 = df.iloc[:100].drop('salary', axis=1)
df2.head()
dl = learn.dls.test_dl(df2)
dl.show_batch()
And now we can pass either into our learn
! (You can't do validate
on a test_dl
that did not have ground truth labels)
learn.validate(dl=dl)
dl = learn.dls.test_dl(df.iloc[:100])
learn.validate(dl=dl)


Try our app for sending out quotes to your potential clients instantly without any extra work on your part!
Our app makes quotes easy for agencies, companies, developers, and freelancers!
Our online form is a quick, pain-free process for your client covering the most important questions you need to know to generate a professional, customized quote.
Once the form is submitted, your client will be able to review their quote automatically. At the same time, you will receive your clients answers and be able to schedule a follow up call right away.
"Desgn Worth is a perfect fit for my company! I run a web developing company in Seattle and I don't have enough time to generate quotes on my own time. All I had to do was plug in my specific prices and plug-in the code into my site and I was up in running. Now I have more time to create the websites that I want to desgin. Desgn Worth was worth my time!""
- Mr. Aubrey Drake Graham
We are Desgn Worth
"I couldn't ask for a better app! It is quick and easy to set up and deploy. I have heard nothing but good feedback from my clients."
- Ms. Onika Tanya Maraj


Pregnant woman fatally mauled by pack of dogs in woods: report
by Jackie SaloA six-months pregnant woman was mauled to death by a pack of dogs in a forest in France, according to reports.
Elisa Pilarski, 29, died Saturday afternoon in the Forest of Retz, about 50 miles northeast of Paris, while taking her own pooch for a walk, the French outlet L’union reported.
Pilarski’s husband went to look for her after she called him about a pack of threatening dogs, officials said. He discovered her dead with bite wounds on her head, arms and legs from multiple dogs.
An autopsy performed Monday determined that she bled to death from her injuries — and the dogs continued to bite her once she was dead, according to the report.
Police are investigating whether the dogs were the ones who participated the same day in a local hunt.


In my last statistic post about steemmonster, I found out that the Green team seems to be weaker than other splinter. Now I created a more detailed view.
The following data includes only the battles from the ongoing tournament (start date: 2018-11-26 14:00:00). I excluded all matches where the mana cap is not equal the mana sum of the used cards.
Thus, matches are counted in which both teams have used the optimal mana sum equal to the mana cap.
Results
The team win ratio shows how often a splinter has won. For matches where both splinter are equal, the winning rate is 100%, e.g. Blue vs Blue has a Blue team win ratio of 100%.
Blue team match statistics
Novice - Blue team
| match |
played matches |
Blue team win ratio |
| Blue vs Blue |
70 |
100.00 % |
| Blue vs Red |
120 |
54.17 % |
| Blue vs Green |
102 |
71.57 % |
| Blue vs White |
73 |
52.05 % |
| Blue vs Black |
89 |
33.71 % |
| Blue vs Gold |
13 |
38.46 % |
Bronze - Blue team
| match |
played matches |
Blue team win ratio |
| Blue vs Blue |
279 |
100.00 % |
| Blue vs Red |
417 |
48.20 % |
| Blue vs Green |
517 |
59.57 % |
| Blue vs White |
382 |
55.50 % |
| Blue vs Black |
348 |
39.37 % |
| Blue vs Gold |
31 |
32.26 % |
Silver - Blue team
| match |
played matches |
Blue team win ratio |
| Blue vs Blue |
3889 |
100.00 % |
| Blue vs Red |
5609 |
48.85 % |
| Blue vs Green |
5026 |
56.61 % |
| Blue vs White |
5196 |
51.83 % |
| Blue vs Black |
6673 |
44.25 % |
| Blue vs Gold |
809 |
40.79 % |
Gold - Blue team
| match |
played matches |
Blue team win ratio |
| Blue vs Blue |
1426 |
100.00 % |
| Blue vs Red |
1825 |
46.79 % |
| Blue vs Green |
1745 |
53.58 % |
| Blue vs White |
1885 |
46.37 % |
| Blue vs Black |
2604 |
40.98 % |
| Blue vs Gold |
644 |
36.96 % |
Diamond - Blue team
| match |
played matches |
Blue team win ratio |
| Blue vs Blue |
380 |
100.00 % |
| Blue vs Red |
515 |
49.51 % |
| Blue vs Green |
411 |
53.28 % |
| Blue vs White |
468 |
52.56 % |
| Blue vs Black |
721 |
42.72 % |
| Blue vs Gold |
380 |
41.58 % |
Champion - Blue team
| match |
played matches |
Blue team win ratio |
| Blue vs Blue |
287 |
100.00 % |
| Blue vs Red |
393 |
47.07 % |
| Blue vs Green |
266 |
59.02 % |
| Blue vs White |
365 |
52.60 % |
| Blue vs Black |
382 |
52.36 % |
| Blue vs Gold |
518 |
46.91 % |
Red team match statistics
Novice - Red team
| match |
played matches |
Red team win ratio |
| Red vs Blue |
105 |
51.43 % |
| Red vs Red |
49 |
100.00 % |
| Red vs Green |
91 |
56.04 % |
| Red vs White |
78 |
47.44 % |
| Red vs Black |
100 |
31.00 % |
| Red vs Gold |
5 |
40.00 % |
Bronze - Red team
| match |
played matches |
Red team win ratio |
| Red vs Blue |
424 |
54.95 % |
| Red vs Red |
214 |
100.00 % |
| Red vs Green |
460 |
57.61 % |
| Red vs White |
348 |
39.66 % |
| Red vs Black |
373 |
29.22 % |
| Red vs Gold |
33 |
24.24 % |
Silver - Red team
| match |
played matches |
Red team win ratio |
| Red vs Blue |
5617 |
50.79 % |
| Red vs Red |
3272 |
100.00 % |
| Red vs Green |
4407 |
49.97 % |
| Red vs White |
4863 |
42.87 % |
| Red vs Black |
6102 |
36.86 % |
| Red vs Gold |
656 |
36.43 % |
Gold - Red team
| match |
played matches |
Red team win ratio |
| Red vs Blue |
1824 |
53.23 % |
| Red vs Red |
1009 |
100.00 % |
| Red vs Green |
1444 |
56.37 % |
| Red vs White |
1580 |
46.46 % |
| Red vs Black |
2245 |
42.94 % |
| Red vs Gold |
549 |
46.99 % |
Diamond - Red team
| match |
played matches |
Red team win ratio |
| Red vs Blue |
516 |
50.39 % |
| Red vs Red |
363 |
100.00 % |
| Red vs Green |
457 |
61.49 % |
| Red vs White |
435 |
47.36 % |
| Red vs Black |
712 |
46.21 % |
| Red vs Gold |
427 |
46.37 % |
Champion - Red team
| match |
played matches |
Red team win ratio |
| Red vs Blue |
393 |
52.93 % |
| Red vs Red |
362 |
100.00 % |
| Red vs Green |
265 |
64.91 % |
| Red vs White |
408 |
47.55 % |
| Red vs Black |
468 |
54.06 % |
| Red vs Gold |
581 |
54.91 % |
Green team match statistics
Novice - Green team
| match |
played matches |
Green team win ratio |
| Green vs Blue |
95 |
36.84 % |
| Green vs Red |
110 |
48.18 % |
| Green vs Green |
56 |
100.00 % |
| Green vs White |
68 |
41.18 % |
| Green vs Black |
101 |
21.78 % |
| Green vs Gold |
12 |
16.67 % |
Bronze - Green team
| match |
played matches |
Green team win ratio |
| Green vs Blue |
500 |
43.60 % |
| Green vs Red |
431 |
44.55 % |
| Green vs Green |
264 |
100.00 % |
| Green vs White |
387 |
40.31 % |
| Green vs Black |
381 |
25.20 % |
| Green vs Gold |
22 |
22.73 % |
Silver - Green team
| match |
played matches |
Green team win ratio |
| Green vs Blue |
5048 |
42.93 % |
| Green vs Red |
4414 |
49.68 % |
| Green vs Green |
2592 |
100.00 % |
| Green vs White |
4236 |
43.15 % |
| Green vs Black |
5296 |
35.08 % |
| Green vs Gold |
629 |
30.68 % |
Gold - Green team
| match |
played matches |
Green team win ratio |
| Green vs Blue |
1747 |
46.31 % |
| Green vs Red |
1446 |
43.71 % |
| Green vs Green |
890 |
100.00 % |
| Green vs White |
1357 |
45.62 % |
| Green vs Black |
2108 |
42.22 % |
| Green vs Gold |
465 |
37.85 % |
Diamond - Green team
| match |
played matches |
Green team win ratio |
| Green vs Blue |
411 |
46.72 % |
| Green vs Red |
458 |
38.43 % |
| Green vs Green |
259 |
100.00 % |
| Green vs White |
367 |
47.68 % |
| Green vs Black |
651 |
47.00 % |
| Green vs Gold |
338 |
38.76 % |
Champion - Green team
| match |
played matches |
Green team win ratio |
| Green vs Blue |
266 |
40.98 % |
| Green vs Red |
265 |
35.09 % |
| Green vs Green |
107 |
100.00 % |
| Green vs White |
247 |
43.72 % |
| Green vs Black |
294 |
44.90 % |
| Green vs Gold |
326 |
40.80 % |
White team match statistics
Novice - White team
| match |
played matches |
White team win ratio |
| White vs Blue |
75 |
46.67 % |
| White vs Red |
85 |
60.00 % |
| White vs Green |
83 |
74.70 % |
| White vs White |
38 |
100.00 % |
| White vs Black |
64 |
18.75 % |
| White vs Gold |
7 |
14.29 % |
Bronze - White team
| match |
played matches |
White team win ratio |
| White vs Blue |
373 |
51.21 % |
| White vs Red |
345 |
64.06 % |
| White vs Green |
384 |
61.46 % |
| White vs White |
156 |
100.00 % |
| White vs Black |
291 |
24.05 % |
| White vs Gold |
20 |
35.00 % |
Silver - White team
| match |
played matches |
White team win ratio |
| White vs Blue |
5200 |
47.71 % |
| White vs Red |
4858 |
56.77 % |
| White vs Green |
4223 |
56.38 % |
| White vs White |
2727 |
100.00 % |
| White vs Black |
5563 |
32.32 % |
| White vs Gold |
570 |
42.28 % |
Gold - White team
| match |
played matches |
White team win ratio |
| White vs Blue |
1888 |
53.60 % |
| White vs Red |
1580 |
53.42 % |
| White vs Green |
1358 |
54.34 % |
| White vs White |
968 |
100.00 % |
| White vs Black |
2168 |
42.20 % |
| White vs Gold |
552 |
49.28 % |
Diamond - White team
| match |
played matches |
White team win ratio |
| White vs Blue |
469 |
47.33 % |
| White vs Red |
436 |
52.75 % |
| White vs Green |
367 |
52.32 % |
| White vs White |
289 |
100.00 % |
| White vs Black |
625 |
44.48 % |
| White vs Gold |
367 |
44.14 % |
Champion - White team
| match |
played matches |
White team win ratio |
| White vs Blue |
364 |
47.53 % |
| White vs Red |
408 |
52.45 % |
| White vs Green |
247 |
56.28 % |
| White vs White |
295 |
100.00 % |
| White vs Black |
368 |
44.84 % |
| White vs Gold |
549 |
53.92 % |
Black team match statistics
Novice - Black team
| match |
played matches |
Black team win ratio |
| Black vs Blue |
113 |
66.37 % |
| Black vs Red |
97 |
77.32 % |
| Black vs Green |
84 |
82.14 % |
| Black vs White |
72 |
83.33 % |
| Black vs Black |
46 |
100.00 % |
| Black vs Gold |
11 |
63.64 % |
Bronze - Black team
| match |
played matches |
Black team win ratio |
| Black vs Blue |
328 |
67.68 % |
| Black vs Red |
382 |
72.77 % |
| Black vs Green |
405 |
79.51 % |
| Black vs White |
297 |
78.45 % |
| Black vs Black |
229 |
100.00 % |
| Black vs Gold |
21 |
38.10 % |
Silver - Black team
| match |
played matches |
Black team win ratio |
| Black vs Blue |
6673 |
55.39 % |
| Black vs Red |
6100 |
62.85 % |
| Black vs Green |
5287 |
64.54 % |
| Black vs White |
5551 |
67.48 % |
| Black vs Black |
4879 |
100.00 % |
| Black vs Gold |
912 |
30.04 % |
Gold - Black team
| match |
played matches |
Black team win ratio |
| Black vs Blue |
2600 |
59.00 % |
| Black vs Red |
2241 |
57.07 % |
| Black vs Green |
2108 |
57.69 % |
| Black vs White |
2164 |
57.81 % |
| Black vs Black |
2197 |
100.00 % |
| Black vs Gold |
781 |
38.28 % |
Diamond - Black team
| match |
played matches |
Black team win ratio |
| Black vs Blue |
721 |
57.28 % |
| Black vs Red |
712 |
53.93 % |
| Black vs Green |
653 |
52.99 % |
| Black vs White |
627 |
55.50 % |
| Black vs Black |
746 |
100.00 % |
| Black vs Gold |
520 |
35.38 % |
Champion - Black team
| match |
played matches |
Black team win ratio |
| Black vs Blue |
382 |
47.64 % |
| Black vs Red |
468 |
45.94 % |
| Black vs Green |
294 |
55.10 % |
| Black vs White |
368 |
55.16 % |
| Black vs Black |
298 |
100.00 % |
| Black vs Gold |
502 |
41.63 % |
Gold team match statistics
Novice - Gold team
| match |
played matches |
Gold team win ratio |
| Gold vs Blue |
14 |
64.29 % |
| Gold vs Red |
13 |
84.62 % |
| Gold vs Green |
4 |
75.00 % |
| Gold vs White |
6 |
83.33 % |
| Gold vs Black |
7 |
42.86 % |
| Gold vs Gold |
0 |
0.00 % |
Bronze - Gold team
| match |
played matches |
Gold team win ratio |
| Gold vs Blue |
37 |
78.38 % |
| Gold vs Red |
28 |
75.00 % |
| Gold vs Green |
43 |
86.05 % |
| Gold vs White |
29 |
68.97 % |
| Gold vs Black |
30 |
70.00 % |
| Gold vs Gold |
1 |
100.00 % |
Silver - Gold team
| match |
played matches |
Gold team win ratio |
| Gold vs Blue |
803 |
58.66 % |
| Gold vs Red |
653 |
63.25 % |
| Gold vs Green |
617 |
68.72 % |
| Gold vs White |
562 |
57.30 % |
| Gold vs Black |
907 |
69.68 % |
| Gold vs Gold |
133 |
100.00 % |
Gold - Gold team
| match |
played matches |
Gold team win ratio |
| Gold vs Blue |
643 |
62.99 % |
| Gold vs Red |
549 |
53.19 % |
| Gold vs Green |
465 |
62.15 % |
| Gold vs White |
553 |
50.81 % |
| Gold vs Black |
781 |
61.72 % |
| Gold vs Gold |
202 |
100.00 % |
Diamond - Gold team
| match |
played matches |
Gold team win ratio |
| Gold vs Blue |
382 |
58.38 % |
| Gold vs Red |
427 |
53.40 % |
| Gold vs Green |
337 |
61.13 % |
| Gold vs White |
366 |
56.01 % |
| Gold vs Black |
520 |
64.42 % |
| Gold vs Gold |
288 |
100.00 % |
Champion - Gold team
| match |
played matches |
Gold team win ratio |
| Gold vs Blue |
516 |
53.10 % |
| Gold vs Red |
581 |
45.09 % |
| Gold vs Green |
326 |
59.20 % |
| Gold vs White |
549 |
46.08 % |
| Gold vs Black |
502 |
58.37 % |
| Gold vs Gold |
654 |
100.00 % |
Conclusion
The Blue team (water) is weak against the Red (fire) and the Gold (dragon) team. Blue is weak against the Black team below the Champion league.
The Red team (fire) is weak against the White (life) team. Below the Champion league, the Red team is also weak against the Black (death) and the Gold (dragon) team.
The Green team (earth) is weak against every other splinter.
The White team (life) is weak against the Black (death) and Blue (water) team. Below the Champion league, the White team is also weak against the Gold (dragon) team.
The Black team (death) is weak against the Blue, Red and Gold team.
The Gold team (dragon) is weak against the Red and the White team.
Summary for Champion league
| splinter |
weak against |
strong against |
| Blue |
Red, Gold, |
Green, White, Black |
| Red |
White |
Blue, Green, Black, Gold |
| Green |
Blue, Red, White, Black, Gold |
- |
| White |
Blue, Black |
Red, Green, Gold |
| Black |
Blue, Red, Gold |
Green, White |
| Gold |
Red, White |
Blue, Green, Black |
So it seems that Green/Earth is the weakest splinter and should not be used but for solving a quest. Is could be that Gold in combination with Green is strong. This is something, I will analyze next.
This page is synchronized from the post: ‘Which splinter is the strongest one and what are the best counter splinters?’


Hello World
A smaller header
An even smaller one
A very small header
A really small version
And the final one


Your subscription was cancelled and you won't be charged again. Your account will expire on {{user.pretty.expiry}}.
Restart my subscription
Disable my account
Since you were among the earliest to buy an account you can use Blot for free for as long as Blot exists!
Your subscription will renew on {{user.pretty.expiry}}.


Rugby Australia appoints panel to review 2019 season
Rugby Australia (RA) said on Wednesday it has appointed a panel to review the Wallabies 2019 season, which saw coach Michael Cheika stand down after their World Cup quarter-final defeat to England.
REUTERS: Rugby Australia (RA) said on Wednesday it has appointed a panel to review the Wallabies 2019 season, which saw coach Michael Cheika stand down after their World Cup quarter-final defeat to England.
The panel will consist of former Australia internationals Pat Howard and Nathan Sharpe, and four-time Olympian Bo Hanson, and will work with RA Director of Rugby Scott Johnson to deliver the review over the next month.
It had been tasked with reviewing the entire Wallabies program and World Cup campaign and delivering feedback that will be used for the 2020 international season and future Rugby World Cup and Olympic Games campaigns, RA said.
"Twelve months ago Rugby Australia completed a restructure of its High Performance environment," RA Chief Executive Raelene Castle said in a statement https://australia.rugby/news/2019/11/06/wallabies-end-of-season-review.
"Whilst we've made significant progress in a number of areas, the new structure is only in its early stages and still needs time to bed-in completely and show long-term results.
"Having these three individuals leading the (review) process will provide a well-rounded perspective on the Wallabies program and enable us to take forward any key learnings for delivery into the major tournament preparations."
(Reporting by Simon Jennings in Bengaluru; Editing by Peter Rutherford)


Creates a new
Platypus.js
project in an existing folder. Platypus.js projects can be used as a standalone application or as web application within a Java EE server/Servlet3.0+ container.


Standalone value in the style tag
Style supplied as a template string from css
Style supplied as a svelte-template string from css


Sorry, we have no information about this company!
Please click below to add company information and send a request to find direct competitors.
Please click below to add company information and send a request to find direct competitors.


Leadership
What is your experience of compassionate (or not) leadership?
Over the years I think we all have had a mixed bag of both camppasionate leaders. Some of the most memorable one for me have been with mountaineering. You have to have a lot trust and lot comradery with a small crew. When things get tough it takes a special type of leader to really encourage and keep everyone calm. While knowing we are fully capable of doing what we came there to do even if we have some small doubts.
Do the multiplying goodness meditation. How did you find it?
This was another great meditation. It was amazing feeling goodness welling in myself and giving it to the world.
Do the Tonglen meditation. How did you find it?
This was really similar to the multiplying goodnes meditation. It was really interesting to turn the negative feeling into something positive it was rather empowering.
Have a difficult conversation. How did it go?
I have had lot of practice with this one in the last year. After having my accident it seems like there is a constant need for difficult conversations. My body no longer goes into the fight or flight mode. It has improved a lot since I have been thinking more about the intent of the person who is initating the conversation. Over all I am pretty confident in this deparment.


When European settlers came to North America, they brought Britain’s practice of the death
penalty with them. Capital punishment was a mainstay in the United States up until the early twentieth century,
when several states either outlawed or reduced capital punishment. Starting in the 1960s, there was a sharp decline in executions due to growing doubts about execution as a method of punishment. In 1967, an unofficial moratorium began on the death penalty. In 1972, the Furman v. Georgia case it was argued that capital cases were often
arbitrary and capricious. It was thus determined to be “cruel and unusual”, which led the
Supreme Court to invalidate the legality of capital punishment. Thus, there was a decade-long suspension
from 1967 until 1977.
The below graph, originally published by TIME, shows the trend of capital punishment over the past
few centuries.
The brief hiatus of the death penalty was brought to an end in the Gregg v. Georgia case in 1976, concluding that the death penalty was no longer in violation of the Eighth Amendment due to a new trial system.The subsequent execution of Gary Gilmore in Utah by firing squad in 1977 rang in a new era of executions.
Determining when and where the death penalty is legal in the United States is complicated business.
While creating this interactive, we learned that the system does not simply rely on the binary of legal versus
illegal; rather, other statuses exist such as a Moratorium, a De Facto Moratorium, a Formal Hold, and a
De Facto Momento.
Particularly in the cases of De Facto Moratoriums and De Facto Momento, it is difficult to find reliable
information about the exact starting and ending dates for each of these phases (particularly since "de facto",
by definition, means "not by law").
For the sake of clarity, we chose to stick to the legal versus illegal binary in our map because that
is considered the "official status" for each state during the given year.
If you would like more detailed information about the status of a particular state, the Death Penalty Information Center's "Death Penalty in Flux" is a great resource.
David von Drehle, an author at TIME, staunchly believes that the death penalty is going to draw to a close
in the United States (though he does not specify when). However, as this interactive shows, there has been no dearth of executions since
the last time the death penalty nearly ended due to it being deemed "cruel and unusual". What are some reasons von Drehle
believes we will reach the end of the death sentence?
For one, he notes that the process is not particularly simple. Even with lethal injection, which is the most
"sanitized" method for execution that allows us to escape the gruesome nature of the practice, it does not
always work as expected.
Another reason von Drehle posits is that crime rates have fallen in the past decades (particularly in
comparison to 1990s rates), so public opinion is less in favor of the death penalty in general. It just
seems less necessary.
Another reason is simply that capital punishment comes with a hefty price tag. One may believe
it is less costly than a life sentence for a prisoner, but in actuality, the death penalty
can cost significantly more than life imprisonment due to additional costs of housing a
death row inmate, according to the Huffington Post.
Daniel Bier, writing for Newsweek, brings up an interesting point:
"Even if some people do deserve to die, should we invest the state with the awesome power to decide who lives and who dies? ... Currently, over 3,000 people are awaiting execution in the United States. Even if some or most of them deserve to die, is our faith in government so profound that we think that they are all guilty, that no mistakes have been made?"
Since the 1970s, a grand total of 1,407 people have been executed and 156 death row inmates have been exonerated.
None of this necessarily means that the death penalty will come to an end soon, but it is worth
considering whether the death penalty is worthwhile for the United States, given the cost, the risk of
executing innocent people, and the question of whether execution is the responsibility of the state at all.
Should the Death Penalty be Put to Death? is a collaboration between Natalee Desotell, Kai Brito, and Gaby Barrett. We created this interactive for Robert Roth and Robin Tolochko's Spring 2016 Interactive Cartography & Geovisualization course at the University of Wisconsin-Madison.
We created this project using the D3 library, jQuery, and Bootstrap.
A big thanks goes out to Professor Robert Rothand our teaching assistant Robin Tolochko for their help. The design of this project was inspired by Your Body, (Not) Your Choice, created by Robin Tolochko, Katie Kowalsky, and Dylan Moriarty.
Source code for "Your Body, Not Your Choice"
University of Michigan, Death Penalty Curriculum
Scientific American, How Many Prisoners on Death Row are Wrongfully Convicted?


Sign In To Admin
Remember me
Forget Password ?
Sign In
Sign Up
Enter your details to create your account:
I Agree the
terms and conditions
.
Sign Up
Cancel
Forgotten Password ?
Enter your email to reset your password:
Request
Cancel
Don't have an account yet ?
Sign Up


LASSIE COME HOME A Film Review Copyright Dragan Antulov 1999
The latest STAR WARS craze clearly shows that certain categories of movies are very hard to review objectively. The reviewer is often tempted to judge movie not by its own merit, but by his or her own feelings of nostalgia towards past times. Many of those movies belong to the category of family entertainment, which is natural, because for many, those films invoke happy memories of childhood. For the author of this review, one of such films is LASSIE COME HOME, 1943 Hollywood film by Fred M. Wilcox, one of the classics of family entertainment. I first saw this movie at the very early age and it was one of the most memorable movie experiences in my life.
Based on the novel by English author Eric Knight, this film is set in Depression era Yorkshire, where Sam Carraclough (Donald Crisp) and his wife (Elsa Lanchester) and son Joe (Roddy McDowall) must endure the hard times caused by employment. For the little Joe the only comfort in those hard times comes in the shape of Lassie, collie which is his father's pride and joy. But one day money runs out and family is forced to sell the dog to rich Duke of Rudling (Nigel Bruce). The dog, however, is using every opportunity to run back to his old owner, which is causing great frustration to Duke's kennel keeper Hynes (Pat O'Malley). The escapes are to stop when Duke moves to Scotland. Duke's granddaughter Priscilla (Elizabeth Taylor) would allow dog to escape and begin long, hard and dangerous journey south.
At first glance, LASSIE COME HOME might look like nothing more than standard Old Hollywood tearjerker. But even those who don't like tearjerkers would, in most likelihood, agree that this film looks almost like a mythical masterpiece compared with some of the recent examples of the genre. The script by Hugo Butler is very tight and simple, but, in the same time, provides enough material not only to entertain the young audience, but even to make them think. The main element of the plot is based on real life - conflict between reason and emotion, this time accelerated by down-to-Earth economic hardships, something very palpable not only to the audience fifty years ago, but for people in many countries today. The sub-theme of poverty is very present in the film - on her journey Lassie encounter many characters who suffer because of it, and the only act of violence in the movie is economically motivated. But even those who don't appreciate this social aspect of the film would enjoy it, because it is well-told and interesting adventure story, full of not so spectacular, but really moving and memorable scenes. In hour and half we see some barely sketched characters, who are magically fleshed out by excellent actors, whether they are veterans like Donald Crisp or child newcomers like young Roddy McDowall and Elizabeth Taylor. Another thing that distinguishes this film from the rest is absence of true villains - compared with today's cinema, the characters seem surreally good. The music by Daniele Amfitheatrof sets the right, melancholic atmosphere, same as Oscar-nominated colour photography by Leonard Smith. The film was great success in its time and spawned many sequels, and, in later years, many remakes and imitations. But for the author of this review LASSIE COME HOME is one of those rare and precious films that are to be enjoyed by all generations - children and adult.
RATING: 7/10 (+++)
Review written on July 28th 1999
Dragan Antulov a.k.a. Drax Fido: 2:381/100 E-mail<EMAIL_ADDRESS>E-mail<EMAIL_ADDRESS>E-mail<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Johnny Vegas tribute to ‘Ma Vegas’: As a Mum I dare to argue I had the best
Johnny Vegas has announced the death of his mother, Patricia, saying she died “peacefully in her sleep”.
The 49-year-old comedian posted a heartfelt message on Twitter alongside a photograph.
He wrote: “With a kind of deep regret that I’m still incapable of processing, I have to confirm that Ma Vegas, Patricia, passed away last Sunday, peacefully in her sleep.
“To say she was a bit of a character would be too huge an underestimation. As a Mum I dare to argue I had the best x”.
Author Kate Kinsella and singer Joe McElderry were among those offering their condolences.
Kinsella tweeted: “I’m so sorry to hear this. I remember a while ago you talking of her fondness for cardigans … this stuck in my head for some reason. She sounded like a wonderful mum x”.
 Lots of a (sic) love and thoughts to you and your family xxxx”.
Welsh singer Aled Jones said: “Sending you all my love pal and here if you need anything xxxx”.
Scores of Vegas’s fans also sent him messages of support on Twitter following the news.


What is PARK HERE?
Are you get confusing when parking your vehicle somewhere?
Now it’s time to change your way. Solution PARK HERE
We assure your safety and the best ever experience with parking
Our Mission
"To provide a secure, and pleasurable environment to park your vehicle with effient and relaiable manner
Our Vision
Beyond the boundaries make the best plase in your heart as the most realiable and effienet parking system in Sri Lanka


Before Change
f"--owner-of={spec.glob}" for spec in self._specs.filesystem_specs
)
suggestion = f"run `{pants_bin_name} {suggested_owners_args} {v1_goals}`."
trying_to_use_globs = any("*" in spec.glob for spec in self._specs.filesystem_specs)
if trying_to_use_globs:
suggestion = (
f"run `{pants_bin_name} --owner-of=src/python/f1.py --owner-of=src/python/f2.py "
f"{v1_goals}`. (You must explicitly enumerate every file because " f"`--owner-of` does "
f"not support globs.)"
)
raise FilesystemSpecsUnsupported(
f"Instead of running `{approximate_original_command}`, {suggestion}\n\n"
f"Why? Filesystem specs like `src/python/example.py` and `src/**/*.java` (currently) only "
f"work when running goals implemented with the V2 engine. When using V1 goals, either use "
After Change
BuildFileAddresses, [self._specs.filesystem_specs]
)
updated_address_specs = AddressSpecs(
dependencies=tuple(
SingleAddress(a.spec_path, a.target_name) for a in owned_addresses
),
tags=self._specs.address_specs.matcher.tags,
exclude_patterns=self._specs.address_specs.matcher.exclude_patterns,
)


{{ . }}
{{ end}}Sunrise {{ $.Site.Data.settings.site.hub_name_short }} has published {{ $newsCount }} {{ if eq $newsCount 1 }} story {{ else }} stories {{ end }} since {{ dateFormat "January 2006" $earliestNews.Params.publish_date }}
See All NewsFollow Sunrise {{ $.Site.Data.settings.site.hub_name_short }} on social media to stay up-to-date with the latest news and actions from our members.


NOTE: This problem is a significantly more challenging version of Problem 81.
In the 5 by 5 matrix below, the minimal path sum from the top left to the bottom right, by moving left, right, up, and down, is indicated in bold red and is equal to 2297.
|
|
|
|
Find the minimal path sum, in matrix.txt (right click and 'Save Link/Target As...'), a 31K text file containing a 80 by 80 matrix, from the top left to the bottom right by moving left, right, up, and down.


<< Back to Lesson 11
Use lighting
Spin the moon by dragging it with the mouse.
Directional light:
Direction:
X:
Y:
Z:
Colour:
R:
G:
B:
Ambient light:
Colour:
R:
G:
B:
Moon texture courtesy of
the Jet Propulsion Laboratory
.
<< Back to Lesson 11


FiniteSet | list
ImageSet, | list (if `f` is periodic)
Union |
EmptySet | empty list
Others | None
-
Adding
domain
support.I added a
domain
argument toisolve
whose default value is the real domain (domain=S.Reals
). A few limitation to the conditions ofS.Infinity
andS.NegativeInfinity
followed.Another noticable point, from the point of implementation, was to deal with singularities and discontinuities of the given inequality. For this, I used the
continuous_domain
method to find the continuous domains of the expression within the specified domain.This was a minimalistic addition with considerable returns (especially for solving periodic inequalties).
-
Solving trigonometric inequalities.
Since most of the trigonometric inequalities are periodic in nature and have infinite solutions, solving the expression in the entire real domain is a repetitive task and computationally expensive.
In order to simplify the problem, I intend to solve all the inequalities in a positive periodic interval (say
[0, 2*pi)
forsin(x)
). We already have a function to compute the real period of a function :periodicity
.
In case of a non-finitedomain
argument, I intend to use this to restrict the solutions of the problem to a periodic interval.This might not seem the perfect approach but it seems reasonable to handle infinite interval sets for now. We need a new
Set
object :BigUnion
to represent infinite number of interval objects.
New Implementation Link to heading
I have opened PR#11458 for the same with all the implementation details.
In []: isolve(cos(x) > S(0), x, relational=False)
Out[]: [0, pi/2) U (3*pi/2, 2*pi)
In []: isolve(tan(x) > S(0), x, relational=False)
Out[]: (0, pi/2)
After thoughts Link to heading
For the past couple of weeks, I haven’t been able to give much time to the project due to my college schedule. I try to make up for the lost time during the weekend and meet the 40 hour weekly deadline.
With the endsem evaluation soon approaching, I expect this PR to get merged and count as a part of my project.


The HealthKit object is a piece of data that can be stored inside the HealthKit store.
This is an abstract class; you always work with one of its concrete subclasses:
The universally unique identifier (UUID) for this HealthKit object. (read-only)
HealthKit assigns a UUID to the object when you create it. If you want to add your own unique ID, add it to the object's metadata using the METADATA_KEY_EXTERNAL_UUID key.
A dictionary containing the metadata for this HealthKit object. (read-only)
The metadata dictionary contains extra information describing this object. The values can be String, Number, or Date objects. For a complete list of predefined metadata keys, see the METADATA_KEY_* constants.
Using predefined keys helps facilitate sharing data between apps; however, you are also encouraged to create your own, custom keys as needed to extend the HealthKit object's capabilities.
You set an object's metadata when you create the object by calling one of these methods (or a related method):
Ti.Healthkit.createQuantitySample
Ti.Healthkit.createCategorySample
Ti.Healthkit.createCorrelation
Ti.Healthkit.createWorkout
A HealthKit source, representing the app or device that created this object. (read-only)
The source property is only available on objects you have retrieved from the HealthKit store. When you create a new object, the source is set to undefined. The system automatically sets the source property when you save the object to the HealthKit store. The source is then available the next time the object is retrieved from the store.


Source code for qiskit.providers.ibmq.circuits.manager
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Manager for interacting with Circuits."""
from functools import wraps
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.ibmqjob import IBMQJob
from qiskit.providers.ibmq.api_v2.exceptions import RequestsApiError
from .exceptions import (CircuitError,
CircuitAvailabilityError, CircuitResultError,
CircuitSubmitError)
GRAPH_STATE = 'graph_state'
HARDWARE_EFFICIENT = 'hardware_efficient'
RANDOM_UNIFORM = 'random_uniform'
[docs]def requires_api_connection(func):
"""Decorator that ensures that a CircuitsManager has a valid API."""
@wraps(func)
def wrapper(self, *args, **kwargs):
if not self.client:
raise CircuitAvailabilityError(
'An account must be loaded in order to use Circuits')
return func(self, *args, **kwargs)
return wrapper
[docs]class CircuitsManager:
"""Class that provides access to the different Circuits."""
def __init__(self):
self.client = None
def _call_circuit(self, name, **kwargs):
"""Execute a Circuit.
Args:
name (str): name of the Circuit.
**kwargs: parameters passed to the Circuit.
Returns:
Result: the result of executing the circuit.
Raises:
CircuitAvailabilityError: if Circuits are not available.
CircuitSubmitError: if there was an error submitting the Circuit.
CircuitResultError: if the result of the Circuit could not be
returned.
"""
try:
response = self.client.circuit_run(name=name, **kwargs)
except RequestsApiError as ex:
# Revise the original requests exception to intercept.
response = ex.original_exception.response
# Check for errors related to the submission.
try:
body = response.json()
except ValueError:
body = {}
# Generic authorization or unavailable endpoint error.
if response.status_code in (401, 404):
raise CircuitAvailabilityError() from None
if response.status_code == 400:
# Hub permission error.
if body.get('error', {}).get('code') == 'HUB_NOT_FOUND':
raise CircuitAvailabilityError() from None
# Generic error.
if body.get('error', {}).get('code') == 'GENERIC_ERROR':
raise CircuitAvailabilityError() from None
# Handle the rest of the exceptions as unexpected.
raise CircuitSubmitError(str(ex))
except Exception as ex:
# Handle non-requests exception as unexpected.
raise CircuitSubmitError(str(ex))
# Extra check for IBMQConnector code path.
if 'error' in response:
# Hub permission error.
if response['error'].get('code') == 'HUB_NOT_FOUND':
raise CircuitAvailabilityError() from None
# Generic error.
if response['error'].get('code') == 'GENERIC_ERROR':
raise CircuitAvailabilityError() from None
raise CircuitSubmitError(str(response))
# Create a Job for the circuit.
try:
job = IBMQJob(backend=None,
job_id=response['id'],
api=self.client,
creation_date=response['creationDate'],
api_status=response['status'])
except Exception as ex:
raise CircuitResultError(str(ex))
# Wait for the job to complete, explicitly checking for errors.
job._wait_for_completion()
if job.status() is JobStatus.ERROR:
raise CircuitResultError(
'Job {} finished with an error'.format(job.job_id()))
return job.result()
[docs] @requires_api_connection
def graph_state(self, number_of_qubits, adjacency_matrix, angles):
"""Execute the graph state Circuit.
This circuit implements graph state circuits that are measured in a
product basis. Measurement angles can be chosen to measure graph state
stabilizers (for validation/characterization) or to measure in a basis
such that the circuit family may be hard to classically simulate.
Args:
number_of_qubits (int): number of qubits to use, in the 2-20 range.
adjacency_matrix (list[list]): square matrix of elements whose
values are 0 or 1. The matrix size is `number_of_qubits` by
`number_of_qubits` and is expected to be symmetric and have
zeros on the diagonal.
angles (list[float]): list of phase angles, each in the interval
`[0, 2*pi)` radians. There should be 3 * number_of_qubits
elements in the array. The first three elements are the
theta, phi, and lambda angles, respectively, of a u3 gate
acting on the first qubit. Each of the number_of_qubits triples
is interpreted accordingly as the parameters of a u3 gate
acting on subsequent qubits.
Returns:
Result: the result of executing the circuit.
Raises:
CircuitError: if the parameters are not valid.
"""
if not 2 <= number_of_qubits <= 20:
raise CircuitError('Invalid number_of_qubits')
if len(angles) != number_of_qubits*3:
raise CircuitError('Invalid angles length')
return self._call_circuit(name=GRAPH_STATE,
number_of_qubits=number_of_qubits,
adjacency_matrix=adjacency_matrix,
angles=angles)
[docs] @requires_api_connection
def hardware_efficient(self, number_of_qubits, angles):
"""Execute the hardware efficient Circuit.
This circuit implements the random lattice circuit across a user
specified number of qubits and phase angles.
Args:
number_of_qubits (int): number of qubits to use, in the 4-20 range.
angles (list): array of three phase angles (x/y/z) each from
0 to 2*Pi, one set for each qubit of each layer of the lattice.
There should be 3 * number_of_qubits * desired lattice depth
entries in the array.
Returns:
Result: the result of executing the circuit.
Raises:
CircuitError: if the parameters are not valid.
"""
if not 4 <= number_of_qubits <= 20:
raise CircuitError('Invalid number_of_qubits')
if len(angles) % 3*number_of_qubits != 0:
raise CircuitError('Invalid angles length')
return self._call_circuit(name=HARDWARE_EFFICIENT,
number_of_qubits=number_of_qubits,
angles=angles)


The Tellinen hysteresis model is described in more detail in [Te98, ZB12]. It is a simple model to describe the static magnetic hysteresis behavior of ferromagnetic materials. It only requires the Upper BU(H) and lower BL(H) branches of the limiting hysteresis loop for the adaption to a material specific hysteresis shape. Coming from negative magnetic saturation with increasing magnetic field strength H(t) the flux density B(T) travels along the BL(H). Coming from positive saturation with a decreasing H(t), B(t) travels along BU(H). The Tellinen model is defined by the following equation, which gives a calculation rule for time derivative of the magnetic flux density B(t) with respect to the current value of B(t), H(t) and its slope dH(t)/dt.
Therein, SU(H) and SL(H) are the derivatives of limiting branches of the hysteresis loop with respect to the magnetic field strength H, as illustrated in Fig 1.
Fig. 1: Upper BU(H) and lower BL(H) branches of the hysteresis envelope curve, their corresponding slope functions SUH(H) and SLH(H) and the actual operating point H(t), B(t).


Reference listing: Visual Studio Shortcuts
Outlines
| Shortcut |
Description |
| CTRL + m + o |
Collapse to definitions |
| Ctrl + m, Ctrl + a |
Collapse all outlining |
| Ctrl + m, Ctrl + s |
Collapse current region |
| CTRL + m + l |
Expand all |
| CTRL + m + p |
Expand all and disable outlining |
| CTRL + m + m |
Collapse/expand the current section |
Navigation 2017
| Shortcut |
Description |
| Ctrl+, # |
Goto symbol |
| Ctrl+, m |
Goto members |
| Ctrl+, f |
Goto files |
| Ctrl+, : |
Goto line |
| Ctrl+, t |
Goto types |
Test Explorer 2017
| Shortcut |
Description |
| Ctrl+r, t |
Run All Tests In Context |
| Ctrl+r, a |
Run All Tests |
| Ctrl+r, l |
Repeat Last Run |
| Ctrl+r, Ctrl+t |
Debug All Tests In Context |
| Ctrl+r, Ctrl+a |
Debug All Tests |
Windows
| Shortcut |
Description |
| Ctrl+, e |
View.ErrorList |
| Ctrl+, Ctrl+m |
TFS Team Explorer |
| Ctrl+K, Ctrl+w |
Bookmarks |
| Ctrl ` |
Resharper Bookmarks |
| Ctrl+Alt+b |
Breakpoints |
| Ctrl+Shift+e |
View Source Control Explorer (mine) |
| Ctrl+Alt+F4 |
Close all but pinned (mine) |
| Ctrl+Shift+p |
Pin tab (mine) |
Code Generation
| Shortcut |
Description |
| Shift+Alt+c |
Add Class |
Miscellaneous
| Shortcut |
Description |
| CTRL + , |
Fix |
| Ctrl + m + h |
Hide selection |
| CTRL + u |
Uppercase |
| CTRL + SHIFT + u |
Lowercase |
| Alt + Num* |
Debug.ShowNextStatement |
| Ctrl+Alt+k |
Collapse solution explorer (mine) |
| Alt-F7 |
Switch windows |
| Ctrl-Shift-l |
Delete line |
| Alt -F, R, F, S |
Find shelveset |
| Shift+Alt+Down Arrow |
Line Down Extend Column |


These control the amount that the attack time of each {_envelope} generator is modulated. The displayed values are the percentage of the total attack time parameter range covered by one {_unit} of modulation.
These are contained in the {Envelope_attack_cluster Envelope attack clusters} within the {Envelope_sections}.
These are contained in the ENVELOPE 1 and ENVELOPE 2 sections of the right panel, under the following parameter numbers:
| Env 1 | Env 2 | |
| {sw-set-split.png height=48} {sw-15.png height=48} | {sw-set-split.png height=48} {sw-22.png height=48} |
These appear in the display as Env1/2 Att Mod Depth.
These are accessed via the following {_NRPN NRPNs}:
| Env 1 | Env 2 | ||
| A | 1,16 | 1,29 | |
| B | 2,16 | 2,29 |
Since these are {_bipolar} parameters, the values are offset by 64.
| MIDI | display | ||
| 0 | \-100% | ||
| \b\n\b\n\b | \b\n\b\n\b | ||
| 64 | off | (default) | |
| \b\n\b\n\b | \b\n\b\n\b | ||
| 127 | +100% |


source src/xdiff/xpatience.c
| Line | Flow | Count | Block(s) | Source |
|---|---|---|---|---|
| 1 | - | /* | ||
| 2 | - | * LibXDiff by Davide Libenzi ( File Differential Library ) | ||
| 3 | - | * Copyright (C) 2003-2016 Davide Libenzi, Johannes E. Schindelin | ||
| 4 | - | * | ||
| 5 | - | * This library is free software; you can redistribute it and/or | ||
| 6 | - | * modify it under the terms of the GNU Lesser General Public | ||
| 7 | - | * License as published by the Free Software Foundation; either | ||
| 8 | - | * version 2.1 of the License, or (at your option) any later version. | ||
| 9 | - | * | ||
| 10 | - | * This library is distributed in the hope that it will be useful, | ||
| 11 | - | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 12 | - | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
| 13 | - | * Lesser General Public License for more details. | ||
| 14 | - | * | ||
| 15 | - | * You should have received a copy of the GNU Lesser General Public | ||
| 16 | - | * License along with this library; if not, see | ||
| 17 | - | * <http://www.gnu.org/licenses/>. | ||
| 18 | - | * | ||
| 19 | - | * Davide Libenzi<EMAIL_ADDRESS>| ||
| 20 | - | * | ||
| 21 | - | */ | ||
| 22 | - | #include "xinclude.h" | ||
| 23 | - | #include "xtypes.h" | ||
| 24 | - | #include "xdiff.h" | ||
| 25 | - | |||
| 26 | - | /* | ||
| 27 | - | * The basic idea of patience diff is to find lines that are unique in | ||
| 28 | - | * both files. These are intuitively the ones that we want to see as | ||
| 29 | - | * common lines. | ||
| 30 | - | * | ||
| 31 | - | * The maximal ordered sequence of such line pairs (where ordered means | ||
| 32 | - | * that the order in the sequence agrees with the order of the lines in | ||
| 33 | - | * both files) naturally defines an initial set of common lines. | ||
| 34 | - | * | ||
| 35 | - | * Now, the algorithm tries to extend the set of common lines by growing | ||
| 36 | - | * the line ranges where the files have identical lines. | ||
| 37 | - | * | ||
| 38 | - | * Between those common lines, the patience diff algorithm is applied | ||
| 39 | - | * recursively, until no unique line pairs can be found; these line ranges | ||
| 40 | - | * are handled by the well-known Myers algorithm. | ||
| 41 | - | */ | ||
| 42 | - | |||
| 43 | - | #define NON_UNIQUE ULONG_MAX | ||
| 44 | - | |||
| 45 | - | /* | ||
| 46 | - | * This is a hash mapping from line hash to line numbers in the first and | ||
| 47 | - | * second file. | ||
| 48 | - | */ | ||
| 49 | - | struct hashmap { | ||
| 50 | - | int nr, alloc; | ||
| 51 | - | struct entry { | ||
| 52 | - | unsigned long hash; | ||
| 53 | - | /* | ||
| 54 | - | * 0 = unused entry, 1 = first line, 2 = second, etc. | ||
| 55 | - | * line2 is NON_UNIQUE if the line is not unique | ||
| 56 | - | * in either the first or the second file. | ||
| 57 | - | */ | ||
| 58 | - | unsigned long line1, line2; | ||
| 59 | - | /* | ||
| 60 | - | * "next" & "previous" are used for the longest common | ||
| 61 | - | * sequence; | ||
| 62 | - | * initially, "next" reflects only the order in file1. | ||
| 63 | - | */ | ||
| 64 | - | struct entry *next, *previous; | ||
| 65 | - | |||
| 66 | - | /* | ||
| 67 | - | * If 1, this entry can serve as an anchor. See | ||
| 68 | - | * Documentation/diff-options.txt for more information. | ||
| 69 | - | */ | ||
| 70 | - | unsigned anchor : 1; | ||
| 71 | - | } *entries, *first, *last; | ||
| 72 | - | /* were common records found? */ | ||
| 73 | - | unsigned long has_matches; | ||
| 74 | - | mmfile_t *file1, *file2; | ||
| 75 | - | xdfenv_t *env; | ||
| 76 | - | xpparam_t const *xpp; | ||
| 77 | - | }; | ||
| 78 | - | |||
| 79 | 6 | 2 | static int is_anchor(xpparam_t const *xpp, const char *line) | |
| 80 | - | { | ||
| 81 | - | unsigned long i; | ||
| 82 | 6 | 2,5,6 | for (i = 0; i < xpp->anchors_nr; i++) { | |
| 83 | ##### | 3 | if (!strncmp(line, xpp->anchors[i], strlen(xpp->anchors[i]))) | |
| 84 | ##### | 4 | return 1; | |
| 85 | - | } | ||
| 86 | 6 | 7 | return 0; | |
| 87 | - | } | ||
| 88 | - | |||
| 89 | - | /* The argument "pass" is 1 for the first file, 2 for the second. */ | ||
| 90 | 17 | 2 | static void insert_record(xpparam_t const *xpp, int line, struct hashmap *map, | |
| 91 | - | int pass) | ||
| 92 | - | { | ||
| 93 | 17 | 5 | xrecord_t **records = pass == 1 ? | |
| 94 | 17 | 2-4 | map->env->xdf1.recs : map->env->xdf2.recs; | |
| 95 | 17 | 5 | xrecord_t *record = records[line - 1], *other; | |
| 96 | - | /* | ||
| 97 | - | * After xdl_prepare_env() (or more precisely, due to | ||
| 98 | - | * xdl_classify_record()), the "ha" member of the records (AKA lines) | ||
| 99 | - | * is _not_ the hash anymore, but a linearized version of it. In | ||
| 100 | - | * other words, the "ha" member is guaranteed to start with 0 and | ||
| 101 | - | * the second record's ha can only be 0 or 1, etc. | ||
| 102 | - | * | ||
| 103 | - | * So we multiply ha by 2 in the hope that the hashing was | ||
| 104 | - | * "unique enough". | ||
| 105 | - | */ | ||
| 106 | 17 | 5 | int index = (int)((record->ha << 1) % map->alloc); | |
| 107 | - | |||
| 108 | 17 | 5,19 | while (map->entries[index].line1) { | |
| 109 | 11 | 6 | other = map->env->xdf1.recs[map->entries[index].line1 - 1]; | |
| 110 | 11 | 6,8 | if (map->entries[index].hash != record->ha || | |
| 111 | 11 | 7 | !xdl_recmatch(record->ptr, record->size, | |
| 112 | - | other->ptr, other->size, | ||
| 113 | 11 | 7 | map->xpp->flags)) { | |
| 114 | ##### | 9 | if (++index >= map->alloc) | |
| 115 | ##### | 10 | index = 0; | |
| 116 | ##### | 11 | continue; | |
| 117 | - | } | ||
| 118 | 11 | 12 | if (pass == 2) | |
| 119 | 7 | 13 | map->has_matches = 1; | |
| 120 | 11 | 14,15 | if (pass == 1 || map->entries[index].line2) | |
| 121 | 7 | 16 | map->entries[index].line2 = NON_UNIQUE; | |
| 122 | - | else | ||
| 123 | 4 | 17 | map->entries[index].line2 = line; | |
| 124 | 11 | 18 | return; | |
| 125 | - | } | ||
| 126 | 6 | 20 | if (pass == 2) | |
| 127 | ##### | 21 | return; | |
| 128 | 6 | 22 | map->entries[index].line1 = line; | |
| 129 | 6 | 22 | map->entries[index].hash = record->ha; | |
| 130 | 6 | 22 | map->entries[index].anchor = is_anchor(xpp, map->env->xdf1.recs[line - 1]->ptr); | |
| 131 | 6 | 23 | if (!map->first) | |
| 132 | 1 | 24 | map->first = map->entries + index; | |
| 133 | 6 | 25 | if (map->last) { | |
| 134 | 5 | 26 | map->last->next = map->entries + index; | |
| 135 | 5 | 26 | map->entries[index].previous = map->last; | |
| 136 | - | } | ||
| 137 | 6 | 27 | map->last = map->entries + index; | |
| 138 | 6 | 27 | map->nr++; | |
| 139 | - | } | ||
| 140 | - | |||
| 141 | - | /* | ||
| 142 | - | * This function has to be called for each recursion into the inter-hunk | ||
| 143 | - | * parts, as previously non-unique lines can become unique when being | ||
| 144 | - | * restricted to a smaller part of the files. | ||
| 145 | - | * | ||
| 146 | - | * It is assumed that env has been prepared using xdl_prepare(). | ||
| 147 | - | */ | ||
| 148 | 1 | 2 | static int fill_hashmap(mmfile_t *file1, mmfile_t *file2, | |
| 149 | - | xpparam_t const *xpp, xdfenv_t *env, | ||
| 150 | - | struct hashmap *result, | ||
| 151 | - | int line1, int count1, int line2, int count2) | ||
| 152 | - | { | ||
| 153 | 1 | 2 | result->file1 = file1; | |
| 154 | 1 | 2 | result->file2 = file2; | |
| 155 | 1 | 2 | result->xpp = xpp; | |
| 156 | 1 | 2 | result->env = env; | |
| 157 | - | |||
| 158 | - | /* We know exactly how large we want the hash map */ | ||
| 159 | 1 | 2 | result->alloc = count1 * 2; | |
| 160 | 1 | 3 | result->entries = (struct entry *) | |
| 161 | 1 | 2 | xdl_malloc(result->alloc * sizeof(struct entry)); | |
| 162 | 1 | 3 | if (!result->entries) | |
| 163 | ##### | 4 | return -1; | |
| 164 | 1 | 5 | memset(result->entries, 0, result->alloc * sizeof(struct entry)); | |
| 165 | - | |||
| 166 | - | /* First, fill with entries from the first file */ | ||
| 167 | 11 | 5,7 | while (count1--) | |
| 168 | 10 | 6 | insert_record(xpp, line1++, result, 1); | |
| 169 | - | |||
| 170 | - | /* Then search for matches in the second file */ | ||
| 171 | 8 | 8,10 | while (count2--) | |
| 172 | 7 | 9 | insert_record(xpp, line2++, result, 2); | |
| 173 | - | |||
| 174 | 1 | 11 | return 0; | |
| 175 | - | } | ||
| 176 | - | |||
| 177 | - | /* | ||
| 178 | - | * Find the longest sequence with a smaller last element (meaning a smaller | ||
| 179 | - | * line2, as we construct the sequence with entries ordered by line1). | ||
| 180 | - | */ | ||
| 181 | 4 | 2 | static int binary_search(struct entry **sequence, int longest, | |
| 182 | - | struct entry *entry) | ||
| 183 | - | { | ||
| 184 | 4 | 2 | int left = -1, right = longest; | |
| 185 | - | |||
| 186 | 9 | 2,6 | while (left + 1 < right) { | |
| 187 | 5 | 3 | int middle = left + (right - left) / 2; | |
| 188 | - | /* by construction, no two entries can be equal */ | ||
| 189 | 5 | 3 | if (sequence[middle]->line2 > entry->line2) | |
| 190 | ##### | 4 | right = middle; | |
| 191 | - | else | ||
| 192 | 5 | 5 | left = middle; | |
| 193 | - | } | ||
| 194 | - | /* return the index in "sequence", _not_ the sequence length */ | ||
| 195 | 4 | 7 | return left; | |
| 196 | - | } | ||
| 197 | - | |||
| 198 | - | /* | ||
| 199 | - | * The idea is to start with the list of common unique lines sorted by | ||
| 200 | - | * the order in file1. For each of these pairs, the longest (partial) | ||
| 201 | - | * sequence whose last element's line2 is smaller is determined. | ||
| 202 | - | * | ||
| 203 | - | * For efficiency, the sequences are kept in a list containing exactly one | ||
| 204 | - | * item per sequence length: the sequence with the smallest last | ||
| 205 | - | * element (in terms of line2). | ||
| 206 | - | */ | ||
| 207 | 1 | 2 | static struct entry *find_longest_common_sequence(struct hashmap *map) | |
| 208 | - | { | ||
| 209 | 1 | 2 | struct entry **sequence = xdl_malloc(map->nr * sizeof(struct entry *)); | |
| 210 | 1 | 3 | int longest = 0, i; | |
| 211 | - | struct entry *entry; | ||
| 212 | - | |||
| 213 | - | /* | ||
| 214 | - | * If not -1, this entry in sequence must never be overridden. | ||
| 215 | - | * Therefore, overriding entries before this has no effect, so | ||
| 216 | - | * do not do that either. | ||
| 217 | - | */ | ||
| 218 | 1 | 3 | int anchor_i = -1; | |
| 219 | - | |||
| 220 | 1 | 3 | if (!sequence) | |
| 221 | ##### | 4 | return NULL; | |
| 222 | - | |||
| 223 | 7 | 5,19,20 | for (entry = map->first; entry; entry = entry->next) { | |
| 224 | 6 | 6,7 | if (!entry->line2 || entry->line2 == NON_UNIQUE) | |
| 225 | 2 | 8 | continue; | |
| 226 | 4 | 9 | i = binary_search(sequence, longest, entry); | |
| 227 | 4 | 10-12 | entry->previous = i < 0 ? NULL : sequence[i]; | |
| 228 | 4 | 13 | ++i; | |
| 229 | 4 | 13 | if (i <= anchor_i) | |
| 230 | ##### | 14 | continue; | |
| 231 | 4 | 15 | sequence[i] = entry; | |
| 232 | 4 | 15 | if (entry->anchor) { | |
| 233 | ##### | 16 | anchor_i = i; | |
| 234 | ##### | 16 | longest = anchor_i + 1; | |
| 235 | 4 | 17 | } else if (i == longest) { | |
| 236 | 4 | 18 | longest++; | |
| 237 | - | } | ||
| 238 | - | } | ||
| 239 | - | |||
| 240 | - | /* No common unique lines were found */ | ||
| 241 | 1 | 21 | if (!longest) { | |
| 242 | ##### | 22 | xdl_free(sequence); | |
| 243 | ##### | 23 | return NULL; | |
| 244 | - | } | ||
| 245 | - | |||
| 246 | - | /* Iterate starting at the last element, adjusting the "next" members */ | ||
| 247 | 1 | 24 | entry = sequence[longest - 1]; | |
| 248 | 1 | 24 | entry->next = NULL; | |
| 249 | 4 | 24,26 | while (entry->previous) { | |
| 250 | 3 | 25 | entry->previous->next = entry; | |
| 251 | 3 | 25 | entry = entry->previous; | |
| 252 | - | } | ||
| 253 | 1 | 27 | xdl_free(sequence); | |
| 254 | 1 | 28 | return entry; | |
| 255 | - | } | ||
| 256 | - | |||
| 257 | 2 | 2 | static int match(struct hashmap *map, int line1, int line2) | |
| 258 | - | { | ||
| 259 | 2 | 2 | xrecord_t *record1 = map->env->xdf1.recs[line1 - 1]; | |
| 260 | 2 | 2 | xrecord_t *record2 = map->env->xdf2.recs[line2 - 1]; | |
| 261 | 2 | 2 | return xdl_recmatch(record1->ptr, record1->size, | |
| 262 | 2 | 2 | record2->ptr, record2->size, map->xpp->flags); | |
| 263 | - | } | ||
| 264 | - | |||
| 265 | - | static int patience_diff(mmfile_t *file1, mmfile_t *file2, | ||
| 266 | - | xpparam_t const *xpp, xdfenv_t *env, | ||
| 267 | - | int line1, int count1, int line2, int count2); | ||
| 268 | - | |||
| 269 | 1 | 2 | static int walk_common_sequence(struct hashmap *map, struct entry *first, | |
| 270 | - | int line1, int count1, int line2, int count2) | ||
| 271 | - | { | ||
| 272 | 1 | 2 | int end1 = line1 + count1, end2 = line2 + count2; | |
| 273 | - | int next1, next2; | ||
| 274 | - | |||
| 275 | - | for (;;) { | ||
| 276 | - | /* Try to grow the line ranges of common lines */ | ||
| 277 | 5 | 3 | if (first) { | |
| 278 | 4 | 4 | next1 = first->line1; | |
| 279 | 4 | 4 | next2 = first->line2; | |
| 280 | 6 | 4,6,7,9 | while (next1 > line1 && next2 > line2 && | |
| 281 | 2 | 8 | match(map, next1 - 1, next2 - 1)) { | |
| 282 | 2 | 5 | next1--; | |
| 283 | 2 | 5 | next2--; | |
| 284 | - | } | ||
| 285 | - | } else { | ||
| 286 | 1 | 10 | next1 = end1; | |
| 287 | 1 | 10 | next2 = end2; | |
| 288 | - | } | ||
| 289 | 5 | 11,13,14,16 | while (line1 < next1 && line2 < next2 && | |
| 290 | ##### | 15 | match(map, line1, line2)) { | |
| 291 | ##### | 12 | line1++; | |
| 292 | ##### | 12 | line2++; | |
| 293 | - | } | ||
| 294 | - | |||
| 295 | - | /* Recurse */ | ||
| 296 | 5 | 17,18 | if (next1 > line1 || next2 > line2) { | |
| 297 | - | struct hashmap submap; | ||
| 298 | - | |||
| 299 | 3 | 19 | memset(&submap, 0, sizeof(submap)); | |
| 300 | 3 | 19,20 | if (patience_diff(map->file1, map->file2, | |
| 301 | - | map->xpp, map->env, | ||
| 302 | - | line1, next1 - line1, | ||
| 303 | - | line2, next2 - line2)) | ||
| 304 | 3 | 21,22 | return -1; | |
| 305 | - | } | ||
| 306 | - | |||
| 307 | 5 | 23 | if (!first) | |
| 308 | 1 | 24 | return 0; | |
| 309 | - | |||
| 310 | 4 | 25,27,28 | while (first->next && | |
| 311 | 3 | 28,29 | first->next->line1 == first->line1 + 1 && | |
| 312 | ##### | 29 | first->next->line2 == first->line2 + 1) | |
| 313 | ##### | 26 | first = first->next; | |
| 314 | - | |||
| 315 | 4 | 30 | line1 = first->line1 + 1; | |
| 316 | 4 | 30 | line2 = first->line2 + 1; | |
| 317 | - | |||
| 318 | 4 | 30 | first = first->next; | |
| 319 | 4 | 30 | } | |
| 320 | - | } | ||
| 321 | - | |||
| 322 | ##### | 2 | static int fall_back_to_classic_diff(struct hashmap *map, | |
| 323 | - | int line1, int count1, int line2, int count2) | ||
| 324 | - | { | ||
| 325 | - | xpparam_t xpp; | ||
| 326 | ##### | 2 | xpp.flags = map->xpp->flags & ~XDF_DIFF_ALGORITHM_MASK; | |
| 327 | - | |||
| 328 | ##### | 2 | return xdl_fall_back_diff(map->env, &xpp, | |
| 329 | - | line1, count1, line2, count2); | ||
| 330 | - | } | ||
| 331 | - | |||
| 332 | - | /* | ||
| 333 | - | * Recursively find the longest common sequence of unique lines, | ||
| 334 | - | * and if none was found, ask xdl_do_diff() to do the job. | ||
| 335 | - | * | ||
| 336 | - | * This function assumes that env was prepared with xdl_prepare_env(). | ||
| 337 | - | */ | ||
| 338 | 4 | 2 | static int patience_diff(mmfile_t *file1, mmfile_t *file2, | |
| 339 | - | xpparam_t const *xpp, xdfenv_t *env, | ||
| 340 | - | int line1, int count1, int line2, int count2) | ||
| 341 | - | { | ||
| 342 | - | struct hashmap map; | ||
| 343 | - | struct entry *first; | ||
| 344 | 4 | 2 | int result = 0; | |
| 345 | - | |||
| 346 | - | /* trivial case: one side is empty */ | ||
| 347 | 4 | 2 | if (!count1) { | |
| 348 | 2 | 3,5 | while(count2--) | |
| 349 | 1 | 4 | env->xdf2.rchg[line2++ - 1] = 1; | |
| 350 | 1 | 6 | return 0; | |
| 351 | 3 | 7 | } else if (!count2) { | |
| 352 | 6 | 8,10 | while(count1--) | |
| 353 | 4 | 9 | env->xdf1.rchg[line1++ - 1] = 1; | |
| 354 | 2 | 11 | return 0; | |
| 355 | - | } | ||
| 356 | - | |||
| 357 | 1 | 12 | memset(&map, 0, sizeof(map)); | |
| 358 | 1 | 12,13 | if (fill_hashmap(file1, file2, xpp, env, &map, | |
| 359 | - | line1, count1, line2, count2)) | ||
| 360 | ##### | 14 | return -1; | |
| 361 | - | |||
| 362 | - | /* are there any matching lines at all? */ | ||
| 363 | 1 | 15 | if (!map.has_matches) { | |
| 364 | ##### | 16,18 | while(count1--) | |
| 365 | ##### | 17 | env->xdf1.rchg[line1++ - 1] = 1; | |
| 366 | ##### | 19,21 | while(count2--) | |
| 367 | ##### | 20 | env->xdf2.rchg[line2++ - 1] = 1; | |
| 368 | ##### | 22 | xdl_free(map.entries); | |
| 369 | ##### | 23 | return 0; | |
| 370 | - | } | ||
| 371 | - | |||
| 372 | 1 | 24 | first = find_longest_common_sequence(&map); | |
| 373 | 1 | 25 | if (first) | |
| 374 | 1 | 26 | result = walk_common_sequence(&map, first, | |
| 375 | - | line1, count1, line2, count2); | ||
| 376 | - | else | ||
| 377 | ##### | 27 | result = fall_back_to_classic_diff(&map, | |
| 378 | - | line1, count1, line2, count2); | ||
| 379 | - | |||
| 380 | 1 | 28 | xdl_free(map.entries); | |
| 381 | 1 | 29 | return result; | |
| 382 | - | } | ||
| 383 | - | |||
| 384 | 1 | 2 | int xdl_do_patience_diff(mmfile_t *file1, mmfile_t *file2, | |
| 385 | - | xpparam_t const *xpp, xdfenv_t *env) | ||
| 386 | - | { | ||
| 387 | 1 | 2,3 | if (xdl_prepare_env(file1, file2, xpp, env) < 0) | |
| 388 | ##### | 4 | return -1; | |
| 389 | - | |||
| 390 | - | /* environment is cleaned up in xdl_diff() */ | ||
| 391 | 1 | 5,5 | return patience_diff(file1, file2, xpp, env, | |
| 392 | 1 | 5,5 | 1, env->xdf1.nrec, 1, env->xdf2.nrec); | |
| 393 | - | } |


Plodac1656.github.io
Weller Dsx 80 Betriebsanleitung. View and Download Weller WXD 2 operating instructions manual online. Dual port digital soldering and desoldering station. WXD 2 Soldering Gun pdf manual download. View and Download Weller DSX 80 operating instructions manual online. DSX 80 Power Tool pdf manual download.
WELLER WXD 2 OPERATING INSTRUCTIONS MANUAL Pdf Download. WELLER DSX 80 OPERATING INSTRUCTIONS MANUAL Pdf Download.


We buy platforms!
- exploit e-business solutions
- enhance cross-media methodologies
- syndicate leading-edge e-business
- architect interactive metrics
- iterate innovative systems
- visualize interactive methodologies
- incentivize end-to-end content
- revolutionize sticky web-readiness
- integrate cross-platform schemas
- productize 24/365 partnerships
- scale granular systems
- evolve extensible bandwidth
- engage B2C supply-chains
- monetize sexy infrastructures


DEEP END, THE (director/writer: David Siegel & Scott McGehee; screenwriter: based on Elizabeth Sanxay Holding's novel "The Blank Wall"; cinematographer: Giles Nuttgens; editor: Lauren Zuckerman; cast: Tilda Swinton (Margaret Hall), Goran Visnjic (Alek Spera), Jonathan Tucker (Beau Hall), Peter Donat (Jack Hall), Josh Lucas (Darby Reese), Raymond J. Barry (Carlie Nagel), Jordon Dorrance (Dylan Hall), Tamara Hope (Paige Hall); Runtime: 99; Fox Searchlight Pictures; 2001)
Reviewed by Dennis Schwartz
If you've seen Max Ophüls' Reckless Moment (49), you've seen this film. It's the same story but updated to fit modern times. My take on remakes is--if it was a great film, as the 1940s noir film was, why make another! But, at least, this version is as good.  In the older version, it was the teenage girl having an affair with a sleazy older guy in LA that concerned Joan Bennett. Both matriarchs give Oscar quality performances, in a film that is based on the novel by Elizabeth Sanxay Holding called "The Blank Wall" and directed by the team who did Suture--David Siegel & Scott McGehee.
Margaret Hall (Swinton) is all-family, her Navy officer hubby is all-Navy, as he distances himself from family affairs by being almost unreachable in the middle of the Atlantic Ocean on a carrier while she tries to ply her musically inclined Lake Tahoe spoiled rotten son to enrol in a good college back east and stay away from a parasitic Reno sybaritic bar owner who exudes sex, larceny and sleaze, Darby Reese (Josh Lucas).
Darby is tempted by Maggie's offer of $5,000 to split from Beau, but when the lascivious Darby comes sneaking in on his younger lover's house late at night they get into a little tiff down by the waterfront area and Darby is accidently killed. The spoiled young man doesn't even realize what he's done, but mom cleans up the mess early in the AM by dumping his body, with an anchor stuck in it, out in the lake.
The blackmail comes into play when Alek Spera (Visnjic), in the James Mason role, of the young career hood who falls for Swinton's motherhood and can't go through with the callous scheme with his ruthless partner Nagel of getting $50,000 from her to prevent him from going to the police with a sex videotape of her son and Darby humping their tails off--which will likely implicate him in the murder.
Mom proves she will do anything for her family, as she frantically tries to raise the money she doesn't have. Despite the crisis she doesn't miss a beat taking care of the family who are always around her-- she takes care of her heart attack victim elderly father-in-law (Donat), attends her ballet dancing daughter Paige's school performance and nurtures her youngest son Dylan, while also doing anything possible to protect Beau from misfortune--plus doing all the housework. This perfect mom moves Alek greatly, enough so he will give up his life for some respect from the middle-class icon of family values. It didn't convince me in the older version, nor does it in the newer; but Swinton as the perfect mom is convincing, as we see the determination and pain in her face as it is drawn tight in gaunt looks out at the world that has turned hostile for her. This suburban soccer mom and SUV-driver is taking on the representatives of the world she has escaped from--the city world of lowbrow crime figures, and she's willing to go to the mat for her unaware son and family. It's a moving but restraint performance and gives the art-house thriller some depth.
REVIEWED ON 10/7/2001 GRADE: B +
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
========== X-RAMR-ID: 29780 X-Language: en X-RT-ReviewID: 254149 X-RT-TitleID: 1109447 X-RT-SourceID: 873 X-RT-AuthorID: 1315 X-RT-RatingText: B+
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Draw draws a new number.
New Game resets the board.
No Guarantees - No Warantees
Your reults may vary


Software Engineer student, with knowledge in web application development, databases, software testing, object-oriented programming and desktop applications. With skills to work in a team and meet the established objectives. Interested in developing web applications.


Small bumps on certain keycaps to keep touch-typists registered. Usually
on the ``5`` of a numeric keypad, and on the ``F`` and ``J`` of a
`*QWERTY* <../Q/QWERTY.html>`__ keyboard; but older Macs (like pre-PC
electric typewriters) had them on the ``D`` and ``K`` keys (this changed
in 1999).
--------------
+-------------------------------+----------------------------+------------------------+
| `Prev `__ | `Up <../T.html>`__ | `Next `__ |
+-------------------------------+----------------------------+------------------------+
| tired iron | `Home <../index.html>`__ | TLA |
+-------------------------------+----------------------------+------------------------+


The release can be canceled and possibly rolled back by clicking the Cancel Release button.
Note: sections colored in bold red can cause server restarts when changed.
Hover over text boxes for detailed information on each configuration
Available Indexes:
Name
From
To
Count
-
=
Warning
The changes you've made require that ZooKeeper instances get reconfigured and restarted. You
can do this all at once (which can cause the ensemble to appear to be down for several minutes)
or you can do a rolling release of the config.
Warning
The changes you've made require that ZooKeeper instances get reconfigured and restarted. This Exhibitor
is running in standalone mode. You will need to manually make these changes to the other ZooKeeper instances.
Are you sure you want to cancel the rolling configuration release? If so, choose to either
rollback to the previous configuration or force commit to the updated configuration.
Enter one or more paths that represent a lock recipe. For each path, enter the maximum number of entries that represent ownership of the lock. i.e. mutexes have a max
of 1; semaphores have a max of 1 to n.
 It cannot be undone and might
irreparably harm the ZooKeeper data.
Enter a starting path for the listing and the maximum size path for traversal (i.e. paths with Max Traversal children will not be recursively listed). A detailed listing
will be generated showing all the paths, their creation time, their immediate children count and their deep children count.


{% extends '_layout/base.html' %} {% block content %} {# Content to display while loading Google APIs #}
Select an existing spreadsheet from your Google Drive. The contents of the selected spreadsheet will be overwritten with data from this database.
Should you not want {{ config.SITE_NAME }} to continue to have access to your Google Drive, you may revoke access.
{{ config.SITE_NAME }} needs to be explicitly authorised to export data to Google Sheets.
Please wait. Exporting content to spreadsheet…


React
and a bit about simular tools
Tools
vui
angular
React
Developer
Some statistic
React-spring
It's your choice


Hi.
This is 2-Tic-Tac-Toe (aka Ultimate Tic-Tac-Toe).
Learn more
here
.
Source code
here
.
ongoing games
{% for room in rooms %}
{{room}}
{% endfor %}
Start!


A Jack of Many Trades, a Wearer of Hats.
(both literally and figuratively)
Prior to Code Fellows I was a bartender and manager in Chicago for nearly a decade, specializing in craft cocktails and high volume. I was very fortunate to be a part of some teams at highly regarded, award-winning establishments. I took on leadership roles where I created systems, assisted in operations, and trained new staff.
The unfortunate result of Covid-19 closing everything down led me to move to Seattle with my partner and our two cats to pursue a career change into software engineering. It's taken some time to get here, but I couldn't be more excited for what lies ahead. Up to this point, my coding knowledge is fairly rudimentary with a reasonable understanding of the basics of HTML and CSS, but my Javascript experience is quite limited and the backend is completely foreign territory, so I’m considering myself as starting from scratch.
My education background is in cabinetmaking and furniture design. In addition to pulling long hours in the service industry, I have simultaneously done work in both residential and commercial finish carpentry. I am passionate about all things design related, and hope to apply my love for aesthetics in my new profession. I love to ride bikes and go hiking in my free time, and am constantly trying to learn new things on just about any random subject.
My primary goal at the moment is to get all the way through Code Fellows and pass 401 with flying colors. I anticipate the challenge of a lifetime accompanied by repeated failures, frustrations, and moments of sheer exhaustion, but I'm going to give it my all while somehow maintaining my self care. (Should be interesting!) I'm really looking forward to further connecting with my cohort-mates and building my network in a new field and new city. Let's do this!
My Top 10 Trips (So Far):
My travels overseas are limited, and I have so much traveling that I'd like to do in this life, but here are some of my favorites up to this point.
- Banff National Park, Alberta, Canada
- Palma de Mallorca, Spain
- Vancouver, BC, Canada
- Copenhagen, Denmark
- Tromsø, Norway
- Montserrat, Barcelona, Spain
- Northern Cascades National Park, Washington, US
- Taos / Santa Fe, New Mexico, US
- Custer National Forest, Black Hills, South Dakota, US
- Bonneville Salt Flats, Utah, US
My Travel Bucket List:
Here is a partial list of places I can't wait to explore, if and when the day comes that I have the time and $$$!
- Iceland
- Alaska
- New Zealand
- Faroe Islands
- Japan
- Scotland
- Chile
- Peru
- Switzerland
- Italy
Work Experience:
- Emporium, Chicago, IL
- Senior Bartender & Shift Manager, Oct 2017 - Mar 2020
- Blind Barber, Chicago, IL
- Bartender, Sep 2018 - May 2019
- The Revel Room, Chicago, IL
- Senior Bartender & Shift Manager, Apr 2015 - Nov 2017
- The Heavy Feather, Chicago, IL
- Senior Bartender, Mar 2015 - May 2016
- Scofflaw, Chicago, IL
- Senior Bartender, Apr 2012 - Jul 2015
- The Betty, Chicago, IL
- Bartender, Dec 2014 - Apr 2015
- Soho House, Chicago, IL
- Assistant Beverage Director, Jul 2014 - Oct 2014
- Threefold, Chicago, IL
- Woodworker & Finish Carpenter, May 2013 - Nov 2013
- Artpentry, Chicago, IL
- Woodworker & Finish Carpenter, Oct 2011 - Feb 2012
Education Summary:
- Code Fellows, Seattle, WA, Jun 2021 - Present
- Certificate - Advanced Software Development in Full-Stack JavaScript
- Seattle Central College, Seattle, WA, Graduated Aug 2011
- Associate of Applied Science in Cabinetmaking & Furniture Design
- Harold Washington College, Chicago, IL, Sep 2005 - May 2008
- Liberal Arts and Sciences, Humanities


Preparation time
30 mins to 1 hour
Cooking time
10 to 30 mins
Serves
Serves 4
Making your own linguine is a labour of love, so make it extra special by adding squid ink.
For the linguine, put the flour, 2 egg yolks and the whole eggs in a large food processor. Add the squid ink and blend until the mixture resembles wet breadcrumbs. Squeeze a small amount in your hand to check if the dough comes together easily, if not add another egg yolk. (Make sure you remove the blade before placing your hand in the food processor.)
Remove the mixture and turn out onto a floured work surface. Shape the dough into a ball and knead until smooth. Wrap in cling film and set aside to rest for at least 30 minutes.
Remove the cling film and using a pasta machine roll out the dough, starting with the thickest setting and working down to the thinnest. Then feed through the linguine attachment, or cut into strips.
For the crab, chilli and parsley sauce, heat a frying pan and, when hot, add the oil. Add the garlic and chilli and cook for 1-2 minutes. Add the capers and fry for another minute. Pour in the white wine and cook for a further minute, then stir in the crab.
Meanwhile, bring a large saucepan of salted water to the boil and add the pasta. Cook for 2 minutes, or until the pasta is al dente.
To serve, stir in the parsley, coriander, lemon (or lime) juice to the crab sauce. Add the pasta to the sauce and toss together, at this point you could add a touch of the pasta water to emulsify the sauce. Place in serving bowls and eat immediately.


Stocks/Equities¶
A stock (also known as “shares” or “equity”) is a type of security that signifies proportionate ownership in the issuing corporation. This entitles the stockholder to that proportion of the corporation’s assets and earnings.
Stocks are bought and sold predominantly on stock exchanges, though there can be private sales as well, and are the foundation of nearly every portfolio. These transactions have to conform to government regulations which are meant to protect investors from fraudulent practices. Historically, they have outperformed most other investments over the long run. These investments can be purchased from most online stock brokers.
Source: Investopedia
Getting Started¶
To get started using investpy you first need to install it as described on Installation. Once you have it installed you can proceed to use it in order to retrieve data from stocks/equities, after importing the package as it follows:
import investpy
Listing¶
investpy offers some listing functions that allow the user to get the general information of the indexed stocks/equities on Investing as that information is already stored on CSV files generated automatically on the package installation.
We can either retrieve the whole pandas.DataFrame
containing all the information stored on the CSV file or a
list
containing just the names of the stocks/equities, which are the input parameters for the data retrieval functions.
Also there is a param called country
which by default is None, which means that the equity listing to be retrieved
will include all the available countries (indexed in Investing.com); on the contrary, if the param country
is an
available country, the returned equity information will be filtered by country.
Tip
To get a listing of all the available countries you can use the function investpy.get_equity_countries()
which
will return a list
containing all the available country names which have equities as indexed on Investing.com.
# Retrieve all available stocks/equities information as a pandas.DataFrame
equities_df = investpy.get_equities(country=None)
# Retrieve a listing of all the available stock/equity names
equities_list = investpy.get_equities_list(country=None)
Note
The equity pandas.DataFrame
contains internal package information that is useless for users, but it is provided
anyways. On a future release stocks/equities listing functions will be improved in order to provide just useful data.
Recent & Historical Data¶
The main functions of investpy are focused on historical data extraction, stocks/equities in this case. As the main functionality of the package is to retrieve data from Investing.com, so on, some functions have been developed in order to retrieve both recent and historical data.
As to explain its usage an example is proposed to present historical data retrieval functions:
# Retrieves the recent data of BBVA (last month) a spanish equity, as a pandas.DataFrame on ascending order
df = investpy.get_recent_data(equity='bbva', country='spain', as_json=False, order='ascending', debug=False)
# Retrieves the historical data of BBVA, a spanish equity, on the specified date range as a pandas.DataFrame on ascending order
df = investpy.get_historical_data(equity='bbva', country='spain', from_date='01/01/2018', to_date='01/01/2019', as_json=False, order='ascending', debug=False)
As we already saw, both functions take some parameters, but some of them are optional, which means that the function does not need the user to specify them as they already have a default value.
Both parameters equity
and country
are mandatory, since they are the ones that specify which information should be
retrieved from Investing.com. Consider that both parameters should match, which means that the name of the equity should
be an equity from the specified country, if the equity is not found on the specified country, an error will be raised.
When retrieving recent data from an equity, we can additionally specify if we want the output as a json object or not, by
setting the parameter as_json
as either True or False, respectively. We can also set the order
we want the
returned object to have based on dates, where ascending goes from the very first date retrieved until now, and
descending goes the other way. Additionally, there is a parameter called debug
which will enable or disable debug
log information if True or False, respectively; debug mode will display debug messages on the console, so to let
the user know which is happening inside the function.
Furthermore, when it comes to historical data retrieval, we also need to specify both from_date
and to_date
values, as they are mandatory. Both date values are str
formatted as dd/mm/yyyy.
Tip
If you are not familiar with stocks/equities you can either retrieve a listing of the ones available or check the one presented in Investing Equities.
Company Profile¶
As an extra feature, via investpy you can retrieve the company profile from a company in order to either classify or analyse them based on the information these companies publicly provide, as it is a self-made description of the company.
investpy.get_equity_company_profile(equity='bbva', country='spain', language='english')
As explained before, when it comes to data retrieval, both equity
and country
parameters are mandatory, and
should match; as the default value for the language
of the retrieved company profile is english (as Investing
provides company profiles written in english), but besides that, the function
also retrieves the company profile on spanish from Bolsa de Madrid,
which is the additional resource used along this package.
Warning
This function is just available for spanish equities, since investpy was first created just for Spanish Equities, Funds and ETFs retrieval. Future coverage for world equities company profiles is intended, but currently just the spanish ones are available.


{% extends 'BootCRUDApp/base.html' %} {% block content %}
To add an Item
To edit an Item
The item costs {{ eachEntry.price }}. It is used for {{ eachEntry.description }}


UL
Section: User Commands (1)Index Return to Main Contents
BSD mandoc
BSD 4
NAME
ul - do underliningSYNOPSIS
ul [-i ] [-t terminal ] [name ... ]DESCRIPTION
Ul reads the named files (or standard input if none are given) and translates occurrences of underscores to the sequence which indicates underlining for the terminal in use, as specified by the environment variable TERM The terminfo database is read to determine the appropriate sequences for underlining. If the terminal is incapable of underlining, but is capable of a standout mode then that is used instead. If the terminal can overstrike, or handles underlining automatically, ul degenerates to cat(1). If the terminal cannot underline, underlining is ignored.The following options are available:
- -i
- Underlining is indicated by a separate line containing appropriate dashes `-'; this is useful when you want to look at the underlining which is present in an nroff output stream on a crt-terminal.
- -t terminal
- Overrides the terminal type specified in the environment with terminal
ENVIRONMENT
The following environment variable is used:- TERM
- The TERM variable is used to relate a tty device with its device capability description (see terminfo(5)). TERM is set at login time, either by the default terminal type specified in /etc/ttys or as set during the login process by the user in their login file (see setenv(1)).
SEE ALSO
man(1), nroff(1), colcrt(1)BUGS
Nroff usually outputs a series of backspaces and underlines intermixed with the text to indicate underlining. No attempt is made to optimize the backward motion.HISTORY
The ul command appeared in BSD 3.0AVAILABILITY
The ul command is part of the util-linux-ng package and is available from ftp://ftp.kernel.org/pub/linux/utils/util-linux-ng/.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:11 GMT, December 24, 2015


Preseason | Week 1 | Week 2 | Week 3 | Week 4 | Week 5
Dayton Manning (1-0)
Teddy Baldassarre
JK who? Will have better days from the Mikes (Davis and Evans) but has enough consistent players to win when they don't.
Cook'n These Hoes (1-0)
Eric Tchen
Other than getting nothing from the TE position, very solid week.
Pound My Hole (1-0)
Bryan Opaskar
Not only scored 135 points from starters but also 93 points from bench.
Hockenson A Loogie On Me (1-0)
Justin Cicchella
Could have been an even bigger win if Jefferson wasn’t cheated out of a touchdown and Najee did anything with his 16 carries.
Blue Balls (1-0)
Kevin Mullinger
Bad news: Looks like only 4 players showed up. Good news: Those 4 players combined for 96 points.
Should be better going forward with Rodgers having better days than his one-point game.
Pour One For Mahomies (1-0)
Josh Dasch
Already leads the league in transactions(7) and name changes(5).
But 4 weeks ahead of schedule with the first win of the year in week one.
CeeDeez Nuts (0-1)
Michael Gragg
60 points from 3 players on Thursday, 69 points from 6 players on Sunday. Might be a rough week with no one playing on Thursday.
Solid Poo (0-1)
Brian Havrilla
A league high 5 players who didn't score, yet still managed to score 125. Until Trey Sermon starts, RB will most likely be a problem.
Still the better Poo for now.
Liquid Poo (0-1)
Brien Mullinger
Sam Darnold scoring more than Lamar isn't ideal. Also not ideal, starting an injured player.
Trophy Wife (0-1)
Courtney Ressa
Didn't get the win but is already ahead of Jonny in the standings.
Gib-me-Son More Don Julio (0-1)
Aaron Lam
3/9 starters scoring below their projected totals could be bad luck. Or it could be bad coaching and management.
Adam Shafter (0-1)
Jonny Chernek
While Gus Edwards isn't a steal anymore. scoring the least points to get the #1 waiver wire pick is a bold strategy. Chess not checkers.


Unlocks a repository that was locked for migration.
DELETE /orgs/:org/migrations/:id/repos/:repo_name/lock
Status: 204 No Content


This guide explains you how to create custom HttpResponseMessage and HttpResponseException and advantages of using them.
1. HttpResponseMessage
Dinoloop recommends to create your own version of
HttpResponseMessage for a common response by creating and registering a
RequestEnd middleware. Here is how you do it:
- This is useful when you want to set the HttpStatusCode in the action method.
2. HttpResponseException
Dinoloop recommends to create your own version of
HttpResponseException derived from
CustomException for a common response by creating and registering the
ServerError middleware. Here is how it is done:
- This is useful when you want to set the HttpStatusCode in the action method on exceptions.


--- layout: post title: Abundance date: 2012-02-08 10:54:35.000000000 -05:00 categories: - Gastronomic Explosions - aka Yummy Food/Recipes - Seasons tags: - Apple and rhubarb sponge - Bottled fruit - preserving fruit - Rhubarb status: publish type: post published: true meta: aktt_notify_twitter: 'no' _edit_last: '1' dsq_thread_id: '1188049056' author: login: cint email<EMAIL_ADDRESS>display_name: Jacinta first_name: Jacinta last_name: '' ---
I harvested our first bunch of rhubarb today as it was taking over more than it's fair share of the veggie patch. I'm getting so excited with all the produce that is starting to ripen in our garden. Beans are appearing overnight as are cucumbers. Although, Jairah seems to have a radar for finding the ripe cucumbers and manages to get them without me seeing. Cheeky boy. We have a lovely amount of lettuce that is tripling its size everyday and I am looking forward to tasting at least one of the three strawberries that are growing. We're certainly a long way from becoming self sufficient, heck, look at our crop of blueberries....
.....and no, no one had raided the bush first. I suppose I should go easy on the plant, after all, it isn't much bigger that a stick. Hopefully all our other fruit trees will eventually provide us with more than just a token bounty.
But alas, I believe I made my inner granny very happy with my kitchen endeavours this afternoon, as I managed to bottle some nectarines (courtesy of a friend's tree) and rhubarb. Obviously deciding that wasn't enough, I also stewed up the rest of the rhubarb with some apples so we could have apple and rhubarb sponge for dessert. It's just as well I didn't have more fruit on hand, as I doubt it would have escaped being preserved!
[caption id="attachment_1465" align="aligncenter" width="500" caption="Bottled Rhubarb and Nectarines"][/caption]
[caption id="attachment_1466" align="aligncenter" width="400" caption="I think this nectarine is happy, don't you?"][/caption]
[caption id="attachment_1467" align="aligncenter" width="500" caption="Apple and rhubarb sponge"][/caption]
I love that I am able to bottle a little of this summer's abundance, which will hopefully last to be enjoyed once summer's warmth is long gone, reminding us of the goodness that mother nature has provided. Oh yes, my inner granny is most satisfied. Jacinta x