Three Boring Movies Film reviews by Michael John Legeros Copyright 1995 Michael John Legeros
Contents ========
- Introduction - SPECIES - FIRST KNIGHT - SMOKE
Introduction ============
Three boring movies opened in Triangle theaters last weekend. Sigh. Perhaps a movie's greatest failure is the failure to entertain--that single, extraordinary misstep that can never be recovered. For once the audience is asleep, the only sound left in the theater is the surroundsound wail of a fat lady singing somewhere in the distance....
SPECIES =======
The dopey title credits are a warning not to take things too seriously, and, sure enough, in the very first scene of this Roger Donaldson (NO WAY OUT) sci-fi feature, covert government scientist (is there any other kind?). Ben Kingsley botches an attempt to gas a little girl. She escapes from the lab because somebody left a door open, and, more importantly, because she's a little monster who was grown from a DNA sequence received via intergalactic e-mail.  Little Miss Dangerous makes it away from the compound, hops a train to L.A. (where else?), and transforms into a sexy adult terror (Natasha Henstridge) overnight.
Meanwhile, Ghandi is recruiting a team of experts that includes a sociologist, a biologist, an empath (!), and a "specialist." (The latter is played by Michael Madsen, not Sylvester Stallone.) They're a fun lot, and though they don't have a lick of common sense between them, they bring a unique flavor to a film that's already way too derivative to begin with. (Think THE FUGITIVE meets ALIEN.)
Prolonged exposure to this movie apparently affects human brain cells.
Grade: C
FIRST KNIGHT ============
This one fares better, a bit better, because it's more coherent. Three writers are credited with this retooling of the Arthurian legend that plays like a pitch from a Hollywood power-lunch. Connery as Arthur! Ormand as Guinevere! Gere as Lancelot! Though quite the tidy affair under the assured hand of director Jerry Zucker (GHOST), the film is really as uninspired as the title. (FIRST KNIGHT? First in what??) Most of the mythology has been jettisoned in favor of a chaste love story with action sequences. Excalibur? Merlin? African swallows?? Forget it. This is a polite Camelot where the dashing hero, Lancelot, is an existential wanderer who's better with a sword and a horse than ye olde English accent. Think of Eroll Flynn as Roy Rogers.
Grade: C
SMOKE =====
Then there's SMOKE, which unites director Wayne Wang (THE JOY LUCK CLUB), author Paul Auster ("The Music of Chance"), and a handful of characters at a Brooklyn cigar shop. We meet three at the beginning: store owner Auggie Wrenn (Harvey Keitel), writer/customer Paul Benjamin (William Hurt), and teen lifesaver Rashid (newcomer Harold Perrineau). There are other characters, played by other cast members including Forest Whitaker, Stockard Channing, and Ashley Judd, all of whom lead interconnected lives with interconnected meanings, and none of which I paid much attention to while asleep. The film finally shows a pulse at the beginning of the second hour, when Ashley Judd makes her appearance as Wrenn's crackhead daughter. And that's just about the time that my date and I decided to leave. What a drag.
-- Michael J. Legeros Raleigh, NC<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


Refund and Cancellation Policy
Our focus is complete customer satisfaction. In the event, if you are displeased with the services provided, we will refund back the money, provided the reasons are genuine and proved after investigation. Please read the fine prints of each deal before buying it, it provides all the details about the services or the product you purchase.
Each Databuddy bid (a “Bid”) is a limited, non-transferable, one-month license to place one bid on a Databuddy auction. Bids have no monetary value; are not credited against the purchase price of products purchased on the Site; and may not be exchanged for money or any items of monetary value. Due to the billing of charges, Databuddy would like to advise all users to monitor their bidding practices. Repeated online bidding can incur high costs. Users should therefore pay attention to their bidding practices.
In case of dissatisfaction from our services, clients have the liberty to cancel their projects and request a refund from us. Our Policy for the cancellation and refund will be as follows:
Cancellation Policy
For Cancellations please contact us via contact us link or write an email to<EMAIL_ADDRESS>Requests received later than 1 business days prior to the end of the current service period will be treated as cancellation of services for the next service period.
Refund Policy
We will try our best to create the suitable design concepts for our clients.
In case any client is not completely satisfied with our products we can provide a refund.
If paid by credit card, refunds will be issued to the original credit card provided at the time of purchase and in case of payment gateway name payments refund will be made to the same account.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use ServerTask | |
|---|---|
| com.perforce.p4java.ant.tasks | The Perforce tasks implement Perforce commands using the Perforce Java API. |
| Uses of ServerTask in com.perforce.p4java.ant.tasks |
|---|
| Subclasses of ServerTask in com.perforce.p4java.ant.tasks | |
|---|---|
class |
AddTask
Opens new files for adding to the depot. |
class |
ChangesTask
Display list of pending and submitted changelists. |
class |
ChangeTask
Create or edit a changelist description. |
class |
ClientTask
Base class for Perforce client specific Ant tasks. |
class |
CounterTask
Display, set, or delete a counter. |
class |
DeleteTask
Opens a file that currently exists in the depot for deletion. |
class |
Diff2Task
Run diff (on the server) of two files in the depot. |
class |
EditTask
Open an existing file for edit. |
class |
FilesTask
List files in the depot. |
class |
FixTask
Mark jobs as being fixed by a changelist number. |
class |
FstatTask
Dumps information about each file, with each item of information on a separate line. |
class |
GrepTask
Grep searches files for lines matching a given regular expression, the expression (or pattern) can contain wild cards. |
class |
HaveTask
List files and revisions that have been synced to the client workspace. |
class |
IntegrateTask
Open files for branching or merging. |
class |
JobsTask
Reports the list of all jobs currently known to the system. |
class |
JobTask
Create and edit job specifications. |
class |
LabelsyncTask
Synchronize label with the current client contents. |
class |
LabelTask
Create a new label specification or edit an existing label specification. |
class |
LockTask
Lock an opened file against changelist submission. |
class |
MoveTask
Move file(s) from one location to another. |
class |
ReopenTask
Move opened files between changelists or change the files' type. |
class |
ResolveTask
Merge open files with other revisions or files. |
class |
RevertTask
Discard changes from opened files. |
class |
ShelveTask
Store files from a pending changelist in the depot, without submitting them. |
class |
SubmitTask
Commits a pending changelist and its files to the depot. |
class |
SyncTask
Synchronize the client with its view of the depot. |
class |
TagTask
Tag files with a label. |
class |
UnlockTask
Release a locked file but leave it open. |
class |
UnshelveTask
Restore shelved files from a pending change into a workspace. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Different Learners for Different Data
Let us start at the very beginning (a very good place to start). When you read you begin with A-B-C. When you mine, you begin with data.
Different kinds of data miners work best of different kinds of data. Such data may be viewed as tables of examples:
- Tables have one column per feature and one row per example.
- The columns may be numeric (have numbers) or symbolic (contain discrete values).
- Also, some columns are goals (things we want to predict using the other columns).
- Finally, columns may contain missing values.
For example, in text mining, where there is one column per word and one row per document, the columns contain many missing values (since not all words appear in all documents) and there may be hundreds of thousands of columns.
- While text mining applications can have many columns, Big Data applications can have any number of columns and millions to billions of rows.
- For such very large datasets, a complete analysis may be impossible. Hence, these might be sampled probabilistically (e.g., using the naive Bayesian algorithm discussed below).
On the other hand,
- when there are very few rows, data mining may fail since there are too few examples to support summarization.
- For such sparse tables, k- nearest neighbors (kNN) may be best. kNN makes conclusions about new examples by looking at their neighborhood in the space of old examples. Hence, kNN only needs a few (or even only one) similar examples to make conclusions.
If a table has no goal columns, then this is an unsupervised learning problem that might be addressed by (say) finding clusters of similar rows using, say, K- means or expectation maximization.
An alternate approach, taken by the Apriori association rule learner, is to assume that every column is a goal and to look for what combinations of any values predict for any combination of any other.
If a table has one goal, then this is a supervised learning problem where the task is to find combinations of values from the other columns that predict for the goal values. Note that for datasets with one discrete goal feature, it is common to call that goal the class of the dataset.
For example, here is a table of data for a simple data mining problem:
outlook, temp,humid,wind,play
-----------------------------
sunny, 85, 85, FALSE, no
sunny, 80, 90, TRUE, no
overcast, 83, 86, FALSE, yes
rainy, 70, 96, FALSE, yes
rainy, 68, 80, FALSE, yes
rainy, 65, 70, TRUE, no
overcast, 64, 65, TRUE, yes
sunny, 72, 95, FALSE, no
sunny, 69, 70, FALSE, yes
rainy, 75, 80, FALSE, yes
sunny, 75, 70, TRUE, yes
overcast, 72, 90, TRUE, yes
overcast, 81, 75, FALSE, yes
rainy, 71, 91, TRUE, no
In this table, we are trying to predict for the goal of play?, given a record of the weather.
Each row is one example where we did or did not play golf (and the goal of data mining is to find what weather predicts for playing golf).
Note that temp and humidity are numeric columns and there are no missing values.
Such simple tables are characterized by just a few columns and not many rows (say, dozens to thousands).
Traditionally, such simple data mining problems have been explored by C4.5 and CART.
However, with some clever sampling of the data, it is possible to scale these traditional learners to Big Data problems.
Y = F(X)
One way to look at a table of data is an example of some function that computes columns "Y" from input columns "X".
Splits
Another way to look at a table of data is as a source of Split
s.
- Columns have ranges
- Most ranges are not interesting (not useful for decision making)
- So most columns are not interesting
- Standard lesson: need only
sqrt(col)
of the columns (and for text mining data, even fewer)
- Standard lesson: need only
Sym columns:
- Splits are solo simples or disjunctions
Num columns:
- Splits can be found oh so many ways. In one file called auto, I can set a
min
imum size (say sqrt(size(rows)) and combine adjacent bins when the combination is no different to the parts. This is the expected value calculation- let
X
be a bin of size n and standard deviations
- if
X<=2*min
returnX
- else
- Split
X
intoY,Z
of sizen1,n2
and standard deviations1,s2
- Ifn1/n+s1 + n2/n*s2 < s
, then recurse to returnsplit(Y)
,split(Z)
- Else returnX
- let
Why Split?
Timm's rule: the best thing to do with data is to throw most of it away.
- Simpler models,
- Quicker to explain, audit
- Less work for anything down stream that has to watch or act on any variable
Occam's Razor
- English philosopher, William of
Occam (1300-1349) propounded Occam's Razor:
- Entia non sunt multiplicanda praeter necessitatem.
- (Latin for "Entities should not be multiplied more than necessary"). That is, the fewer assumptions an explanation of a phenomenon depends on, the better it is.
- (BTW, Occam's razor did not survive into the 21st century.
- The data mining community modified it to the Minimum Description Length (MDL) principle.
- MDL: the best theory is the smallest BOTH is size AND number of errors).
- Many ways to throw away data
- feature selection
- range selection
- instance selection (prototype generation)
Feature Section
The case for FSS
Repeated result: throwing out features rarely damages a theory
And, sometimes, feature removal is very useful:
-
E.g. linear regression on bn.arff yielded:
Defects = 82.2602 * S1=L,M,VH + 158.6082 * S1=M,VH + 249.407 * S1=VH + 41.0281 * S2=L,H + 68.9153 * S2=H + 151.9207 * S3=M,H + 125.4786 * S3=H + 257.8698 * S4=H,M,VL + 108.1679 * S4=VL + 134.9064 * S5=L,M + -385.7142 * S6=H,M,VH + 115.5933 * S6=VH + -178.9595 * S7=H,L,M,VL + ... [ 50 lines deleted ]
-
On a 10-way cross-validation, this correlates 0.45 from predicted to actuals.
-
10 times, take 90% of the date and run a WRAPPER- a best first search through combinations of attributes. At each step, linear regression was called to asses a particular combination of attributes. In those ten experiments, WRAPPER found that adding feature X to features A,B,C,... improved correlation the following number of times:
number of folds (%) attribute 2( 20 %) 1 S1 0( 0 %) 2 S2 2( 20 %) 3 S3 1( 10 %) 4 S4 0( 0 %) 5 S5 1( 10 %) 6 S6 6( 60 %) 7 S7 <== 1( 10 %) 8 F1 1( 10 %) 9 F2 2( 20 %) 10 F3 2( 20 %) 11 D1 0( 0 %) 12 D2 5( 50 %) 13 D3 <== 0( 0 %) 14 D4 0( 0 %) 15 T1 1( 10 %) 16 T2 1( 10 %) 17 T3 1( 10 %) 18 T4 0( 0 %) 19 P1 1( 10 %) 20 P2 0( 0 %) 21 P3 1( 10 %) 22 P4 6( 60 %) 23 P5 <== 1( 10 %) 24 P6 2( 20 %) 25 P7 1( 10 %) 26 P8 0( 0 %) 27 P9 2( 20 %) 28 Hours 8( 80 %) 29 KLoC <== 4( 40 %) 30 Language 3( 30 %) 32 log(hours)
-
Four variables appeared in the majority of folds. A second run did a 10-way using just those variables to yield a smaller model with (much) larger correlation (98\%):
Defects = 876.3379 * S7=VL + -292.9474 * D3=L,M + 483.6206 * P5=M + 5.5113 * KLoC + 95.4278
Excess attributes
- Confuse decision tree learners
- Too much early splitting of data
- Less data available for each sub-tree
- Too many things correlated to class?
- Dump some of them!
Why FSS?
- throw away noisy attributes
- throw away redundant attributes
- smaller model= better accuracies (often)
- smaller model= simpler explanation
- smaller model= less variance
- smaller model= any downstream processing will thank you
Problem
- Exploring all subsets exponential
- Need heuristic methods to cull search;
- e.g. forward/back select
-
Forward select:
- start with empty set
- grow via hill climbing:
- repeat
- try adding one thing and if that improves things
- try again using the remaining attributes
- until no improvement after N additions OR nothing to add
-
Back select
-
as above but start with all attributes and discard, don't add
-
Usually, we throw away most attributes:
-
so forward select often better
- exception: J48 exploits interactions more than,say, NB.
- so, possibly, back select is better when wrapping j48
- so, possibly, forward select is as good as it gets for NB
Supervised vs Unsupervised
- Supervised, use the class variable in column2 to discretize column1.
- E.g. split column1 such that the etropy of the column2 symbols are minimized.
- see below
- Unsupervised, just refect on column1.
- E.g. find splits that minimize the variance afer the spits.
E.g. here unsupervised discretization running on the horsepower
column of auto.csv
. Note these
numbers run 46 to 230 and this code](http://menzies.us/lean/unsuper.html) decides that this should be divided into:
- less that 65
- 66 to 69
- 69 to 72
- 74 to 82
- 83 to 86
- 87 to 89
- 90 to 91
- 92 to 97
- 98 to 105
- 107 to 116
- 120 to 140
- 142 to 160
- over 165
46.. 230
|.. 46.. 116
|.. |.. 46.. 82
|.. |.. |.. 46.. 65 (..65)
|.. |.. |.. 66.. 82
|.. |.. |.. |.. 66.. 72
|.. |.. |.. |.. |.. 66.. 69 (66..69)
|.. |.. |.. |.. |.. 69.. 72 (69..72)
|.. |.. |.. |.. 74.. 82 (74..82)
|.. |.. 83.. 116
|.. |.. |.. 83.. 97
|.. |.. |.. |.. 83.. 91
|.. |.. |.. |.. |.. 83.. 86 (83..86)
|.. |.. |.. |.. |.. 87.. 91
|.. |.. |.. |.. |.. |.. 87.. 89 (87..89)
|.. |.. |.. |.. |.. |.. 90.. 91 (90..91)
|.. |.. |.. |.. 92.. 97 (92..97)
|.. |.. |.. 98.. 116
|.. |.. |.. |.. 98.. 105 (98..105)
|.. |.. |.. |.. 107.. 116 (107..116)
|.. 120.. 230
|.. |.. 120.. 160
|.. |.. |.. 120.. 140 (120..140)
|.. |.. |.. 142.. 160 (142..160)
|.. |.. 165.. 230 (165..)
FSS types:
-
filters vs wrappers:
- wrappers: use an actual target learners e.g. WRAPPER
- filters: study aspects of the data e.g. the rest
- filters are faster!
- wrappers exploit bias of target learner so often perform better,
when they terminate
- don't terminate on large data sets
-
solo vs combinations:
-
evaluate solo attributes: e.g. INFO GAIN, RELIEF
- evaluate combinations: e.g. PCA, SVD, CFS, CBS, WRAPPER
- solos can be faster than combinations
-
supervised vs unsupervised:
-
use/ignores class values e.g. PCA/SVD is unsupervised, reset supervised
-
numeric vs discrete search methods
-
ranker: for schemes that numerically score attributes e.g. RELIEF, INFO GAIN,
-
best first: for schemes that do heuristic search e.g. CBS, CFS, WRAPPER
Hall and Holmes:
This paper: pre-discretize numerics using entropy.
INFO GAIN
- often useful in high-dimensional problems
- real simple to calculate
- attributes scored based on info gain: H(C) - H(C|A)
- Sort of like doing decision tree learning, just to one level.
RELIEF
- Kononenko97
- useful attributes differentiate between instances from other class
- randomly pick some instances (here, 250)
- find something similar, in an another class
- compute distance this one to the other one
- Stochastic sampler: scales to large data sets.
-
Binary RELIEF (two class system) for "n" instances for weights on features "F"
set all weights W[f]=0 for i = 1 to n; do randomly select instance R with class C find nearest hit H // closest thing of same class find nearest miss M // closest thing of difference class for f = 1 to #features; do W[f] = W[f] - diff(f,R,H)/n + diff(f,R,M)/n done done
-
diff:
- discrete differences: 0 if same 1 if not.
- continuous: differences absolute differences
- normalized to 0:1
- When values are missing, see Kononenko97, p4.
-
N-class RELIEF: not 1 near hit/miss, but k nearest misses for each class C
W[f]= W[f] - ∑i=1..k diff(f,R, Hi) / (n*k) + ∑C ≠ class(R) ∑i=1..k ( P(C) / ( 1 - P(class(R))) * diff(f,R, Mi(C)) / (n*k) )
The P(C) / (1 - P(class(R)) expression is a normalization function that
- demotes the effect of R from rare classes
- and rewards the effect of near hits from common classes.
CBS (consistency-based evaluation)
- Seek combinations of attributes that divide data containing a strong
single class majority.
- Kind of like info gain, but emphasis of single winner
- Discrete attributes
- Forward select to find subsets of attributes
WRAPPER
- Forward select attributes
- score each combination using a 5-way cross val
- When wrapping, best to try different target learners
- Check that we aren't over exploiting the learner's bias
- e.g. J48 and NB
PRINCIPAL COMPONENTS ANALYSIS (PCA)
(The traditional way to do FSS.)
- Only unsupervised method studied here
- Transform dimensions
- Find covariance matrix C[i,j] is the correlation i to j;
- C[i,i]=1;
- C[i,j]=C[j,i]
- Find eigenvectors
- Transform the original space to the eigenvectors
- Rank them by the variance in their predictions
- Report the top ranked vectors
- Makes things easier, right? Well...
if domain1 <= 0.180 then NoDefects else if domain1 > 0.180 then if domain1 <= 0.371 then NoDefects else if domain1 > 0.371 then Defects domain1 = 0.241 * loc + 0.236 * v(g) + 0.222 * ev(g) + 0.236 * iv(g) + 0.241 * n + 0.238 * v - 0.086 * l + 0.199 * d + 0.216 * i + 0.225 * e + 0.236 * b + 0.221 * t + 0.241 * lOCode + 0.179 * lOComment + 0.221 * lOBlank + 0.158 * lOCodeAndComment + 0.163 * uniqO p + 0.234 * uniqOpnd + 0.241 * totalOp + 0.241 * totalOpnd + 0.236 * branchCount
CFS (correlation-based feature selection)
- Scores high subsets with strong correlation to class and weak correlation to each other.
- Numerator: how predictive
- Denominator: how redundant
- FIRST ranks correlation of solo attributes
- THEN heuristic search to explore subsets
And the winner is:
- Wrapper! and it that is too slow...
- CFS, Relief are best all round performers
- CFS selects fewer features
- Phew. Hall invented CFS
Instance Selection
Prototype Selection with Clusters
- Step1: Feature selection: sort columns by their Infogain score. Delete bottom half.
- Step2: Cluster: return one example pre centroid.
Reduction of 800 rows by 24 attributes to 5 attributes by 22 rows
For many data sets:
Note that for classification by weighted scores from 2 nearest neighbors, the reduced data as accurate as the full data.


huge: High-Dimensional Undirected Graph Estimation
Provides a general framework for
high-dimensional undirected graph estimation. It integrates
data preprocessing, neighborhood screening, graph estimation,
and model selection techniques into a pipeline. In
preprocessing stage, the nonparanormal(npn) transformation is
applied to help relax the normality assumption. In the graph
estimation stage, the graph structure is estimated by
Meinshausen-Buhlmann graph estimation or the graphical lasso,
and both methods can be further accelerated by the lossy
screening rule preselecting the neighborhood of each variable
by correlation thresholding. We target on high-dimensional data
analysis usually d >> n, and the computation is
memory-optimized using the sparse matrix output. We also
provide a computationally efficient approach, correlation
thresholding graph estimation. Three
regularization/thresholding parameter selection methods are
included in this package: (1)stability approach for
regularization selection (2) rotation information criterion (3)
extended Bayesian information criterion which is only available
for the graphical lasso.
| Version: |
1.2.7 |
| Depends: |
R (≥ 3.0.0), Matrix, lattice, igraph, MASS |
| Imports: |
grDevices, graphics, methods, stats, utils |
| Published: |
2015-09-16 |
| Author: |
Tuo Zhao, Xingguo Li, Han Liu, Kathryn Roeder, John Lafferty, Larry
Wasserman |
| Maintainer: |
Tuo Zhao <tzhao5 at jhu.edu> |
| License: |
GPL-2 |
| NeedsCompilation: |
yes |
| In views: |
gR |
| CRAN checks: |
huge results |
Downloads:
Reverse dependencies:
| Reverse imports: |
bootnet, equSA, GGMM, IROmiss, netassoc, netgwas, qgraph, stminsights, Tlasso |
| Reverse suggests: |
CompareCausalNetworks, edgebundleR, LICORS, pcalg, pulsar, sand, smart, stabs, stm, themetagenomics |
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=huge
to link to this page.


In this example, a PreloadJS plugin is defined, which parses a load item into an HTML image ID that is already present in the HTML DOM. PreloadJS will then use the image to do the loading, and the image will be displayed in its defined position when it is loaded.


Once models and controllers grow to a certain size and complexity, it gets tricky to figure out what callbacks act upon them. This is especially true for objects that are several inheritance layers deep, have multiple mixins, were written a long long time ago, or any combination of the above. I've picked up a few tools for crushing nasty little callback buggers that crop up every now and then. I hope you find them useful!
Model validation and save callbacks are provided by the module ActiveRecord::Callbacks. If you read through this code, you'll find that it's built on top of a great little module called ActiveSupport::Callbacks.
The callbacks defined on ActiveRecord::Base sub-classes are
after_find
after_initialize
before_save
after_save
before_create
after_create
before_update
after_update
before_validation
after_validation
before_validation_on_create
after_validation_on_create
before_validation_on_update
after_validation_on_update
before_destroy
after_destroy
To see the list of a particular callbacks, suffix the callback type with '_callback_chain'. For example, to see the 'before_save' callbacks defined on the model Supplier:
Supplier.before_save_callback_chain
This will give you a list of ActiveSupport::Callbacks::Callback objects that have interesting attributes such as identifier, kind, method, and options.
To get a named list of callbacks, do
Supplier.before_save_callback_chain.map(&:method)
To see whether a callback is conditional, check out it's 'options'
Supplier.before_save_callback_chain.first.options
Controller callbacks documentation can be found at ActionController::Filters::ClassMethods.
SuppliersController.filter_chain
Again, the array of filter objects returned by 'filter_chain' are ActiveSupport::Callbacks::Callback instances. This lets you check the method names being called, as well as what options are set on it.
Unrelated to callbacks, but a useful debugging tool to figure out what caused your code to be in it's current context, use Kernel.caller to get a list of filenames and methods of the call stack. It's usually pretty noisy, so I use Enumerable#grep to filter for what I'm interested in.
Kernel.caller.grep /supplier/
The combination of these 3 tips have helped me debug strange callback order bugs, as well as help me learn about a complex model that I've never dealt with before. Unfortunately, I put off writing about this topic for so long that I've forgotten some of the tips. As always, I found reading into the ActiveRecord and ActiveSupport code to be particularly enlightening. If you have some other interesting introspection tips that help you develop, please share them in the comments ;)


Pi Kappa Alpha is dedicated to developing men of integrity, intellect, and high moral character and to fostering a truly lifelong fraternal experience.
The PIKE experience builds skills and relationships that last long after graduation. We seek men who want to be the best at everything they do, but also value teamwork. The social and practical skills honed during the PIKE experience set the foundation for a lifetime of professional and personal success.
Read more


Wrong Credentials
If you are not Registered, Please use demo Id and Pass
Username : 'user1' Password : 'pass1'


{{job?.title}}
Date created: {{job?.date_created}}
Created by: {{job?.author}}
Address: {{ job?.address }}
Balance: {{ api_data_job.confirmed_balance*1 }} tBTC
Unconfirmed Balance: {{ api_data_job.confirmed_balance*1 + api_data_job.unconfirmed_balance*1 }} tBTC
this is your job


This is one the first big projects that I worked on, and it was a great learning experience for me. We took an outdated design and created a new e-commerce base while also improving aesthetics.
Because of brand colours we had to work within a strict limit. As well, in Canada, AODA is one of the guidelines that we really need to take it into consideration. We kept the site clean, but at the same time we managed to put a lot of information into the home page.
Our objective was to encourage people to make purchases, but at the same time we wanted to push them towards the blog, which is filled with plenty of relevant information.


Game over
Try againUse the arrow keys to slide the tiles. Connect three or more same coloured tiles in a vertical or horizontal line to remove tiles from the board.
Works best in Chrome and Safari. Firefox still needs some style wrangling. Not tested in IE.
Created by pyko, with heavy inspiration from 2048 which was based off Threes.
Short blog post for some background about Connect Three.
If you enjoyed the game, a small donation would be much appreciated :)


Wraps a block in a Python virtualenv. pysh
or pybat
steps are deprecated, and are simply
copies or sh
and bat
respectively.
Example:
withPythonEnv('python3') {
sh 'python --version'
}
The argument supplied to withPythonEnv
is the name of the virtualenv to make available to any
sh
or bat
steps called within the block.
Initially, withPythonEnv
tries to match the string passed to it to a tool name. Currently, this means
examining the installed tools for ShiningPanada. If the string matches an installed ShiningPanda Python tool
instance, the virtualenv within that block is generated from that ShiningPanda tool.
Next, we attempt to match the string against an existing virtualenv directory. If we can find an existing virtualenv
directory, we utilize that for the withPythonEnv
block.
Otherwise, the text is treated "as-is". You can pass "python" to use the default Python installation of the node that the job runs on, or specify an executable path.


enjaden
This is an example of a MATLAB file which publishes nicely to Jade via
the enjaden
tool. It shows what types of paragraph styles and inline
markup are possible, like bold and italic markup.
New paragraphs will each get their own <p> tag.
It shows links. Links are only captured when they look like the above. Note that < this > will not show up as a link, and neither will this.
There are numerous paragraph styles, such as code blocks:
code
line 2: code
line 3: code
and preformatted text:
PRE TEXT
There are also the expected ordered and unordered lists. Note that these must be offset with a spacer line so that they can be differentiated from bold inline text that happens to start a new line.
Numbered lists work the same way:
Here in this section (marked with %%), we'll include some actual code.
When enjaden
comes across this, it will evaluate it and show the
resulting command window output and figures, just below the code.
% Make a series of random walks.
t = 1:1000;
y = cumsum(randn(5, length(t)), 2);
y(:, end)
% Plot some things.
figure(1);
clf();
plot(t, y);
xlabel('Time');
ylabel('Position');
title('Random Walks');
ans =
-5.1937
-6.0350
46.7917
25.2979
39.5703
In this section, we'll highlight that you don't always have to skip a line between the header and paragraph. But we might want to before inserting an image so that it will get its own line and not be part of the paragraph:
Note that the location of the image can be absolute or relative to the file.
Note that any time you change a figure, it gets included in the output. Let's add some units to the x axis.
xlabel('Time (s)');
By the way, we can keep adding paragraphs by making new %% sections and just not giving them headers.
This part is pretty fun. We're going to show how to use MathJax for
equations! This looks way better than what publish
does. (Also, note
that the inline markup in this paragraph spans multiple lines; it's still
detected correctly.)
Inline equations use single dollar signs, like \(x\). Let's discuss in more detail in a display equation:
$$x = f(x)$$
Looks nice, right? The only downside to using MathJax is that one must be connected to the internet. So if you're publishing a MATLAB file to Jade from a desert island (or, more likely, on some ancient plane that doesn't give you free wifi), you won't be able to see your equations.
This concludes the example. See ml2jade_example.jade
for an example of
a Jade file ready to have its MATLAB sections evaluated and inserted into
a new Jade file.


Nyzo version 563 (commit on GitHub) adds proper HTML rendering of client results.
In ClientController, a reference to the simple-hover-button CSS class was replaced with a reference to hover-button. This is a simple renaming of the CSS class to eliminate an unnecessarily long name.
In CommandEndpointWeb, the same changes from simple-hover-button to hover-button were made.
Later in CommandEndpointWeb, the old rendering of the progress page only applies now to long-running commands. For commands that complete immediately, the HTML result is rendered and returned in the page. This eliminates the need for asynchronous updates for these commands. It also improves the appearance of the page.
In CommandTableHeader, a new field was added to mark columns that do not display well with wrapping only on typical word breaks. Long hexadecimal values and Nyzo identifier strings are examples of columns that benefit from use of this flag.
The SimpleExecutionResult.toHtml() method is now implemented. The styles define rounded boxes with color-coded backgrounds for displaying errors and notices. They also define a table with visible cell borders, rounded edges, and contrasting header.
The errors are added to the top of the page, followed by the notices.
The result table is added below the notices. Rendering respects row/column inversion and the preference for applying extra wrapping for a column.
In version 562, the display wallet balances command displayed console-like output.
In version 563, the same command displays an HTML table with a separate notice.
In BalanceDisplayCommand, the walletId and walletIdNyzoString columns were marked for extra line wrapping.
In NttpDataGenerateCommand, the gitHash and senderData columns were marked for extra line wrapping. Also, the table was inverted for improved display of the multiple columns and single data row.
All PrefilledDataCreateCommand columns were marked for extra line wrapping.
All PrivateNyzoStringCommand columns were marked for extra wrapping.
Both PublicNyzoStringCommand columns were marked for extra wrapping.
In DocumentationEndpoint, both uses of simple-hover-button were changed to hover-button.
In WebUtil.hoverButtonStyles, the simple-hover-button CSS classes were changed to hover-button.


support
`Prev `__
S
`Next `__
--------------
**support**: n.
After-sale handholding; something many software vendors promise but few
deliver. To hackers, most support people are useless — because by the
time a hacker calls support he or she will usually know the software and
the relevant manuals better than the support people (sadly, this is
*not* a joke or exaggeration). A hacker's idea of ‘support’ is a
*têete-à-têete* with the software's designer.
--------------
+------------------------------+----------------------------+-------------------------+
| `Prev `__ | `Up <../S.html>`__ | `Next `__ |
+------------------------------+----------------------------+-------------------------+
| superuser | `Home <../index.html>`__ | surf |
+------------------------------+----------------------------+-------------------------+


Thanks for the help!!
From @ibddoctor: https://t.co/193sOToMJB
levels(toPlot$genderAge)
## [1] "Female 18-29" "Male 18-29" "Female 30-44" "Male 30-44"
## [5] "Female 45-60" "Male 45-60" "Female > 60" "Male > 60"
ggplot(toPlot,aes(V28,y=percent,fill=genderAge,order=genderAge))+geom_bar(stat="identity",position = position_dodge2(preserve = "total"))+theme(axis.text.x=element_text(angle=45,hjust=1))+xlab("")+ggtitle("How do you feel about Padme?")+scale_fill_manual("legend",values=c("Female 18-29"="indianred","Male 18-29"="red","Female 30-44"="dodgerblue","Male 30-44" ="blue","Female 45-60"="green", "Male 45-60"="forestgreen","Female > 60" ="grey","Male > 60" ="black"))
## NOPE, but this would be ideal
From @hadleywickham: try arrange()ing
toPlot$Gender=as.factor(toPlot$Gender)
toPlot$Age=as.factor(toPlot$Age)
levels(toPlot$genderAge) ## fine
## [1] "Female 18-29" "Male 18-29" "Female 30-44" "Male 30-44"
## [5] "Female 45-60" "Male 45-60" "Female > 60" "Male > 60"
levels(toPlot$Age) ## need to relevel
## [1] "> 60" "18-29" "30-44" "45-60"
toPlot$Age=factor(toPlot$Age,levels=levels(toPlot$Age)[c(2,3,4,1)]) ## GROSS!
#toPlot$genderAge=factor(toPlot$genderAge,levels=levels(toPlot$genderAge)[c(2,6,3,7,4,8,1,5)]) ## GROSS!
## if it plots one level of V28 at a time, this would make sense
test=toPlot%>%arrange(Age,V28)
head(test)
## # A tibble: 6 x 7
## # Groups: Gender, Age [2]
## Gender Age V28 count.x count.y percent genderAge
## <fct> <fct> <fct> <int> <int> <dbl> <fct>
## 1 Female 18-29 Unfamiliar (N/A) 10 85 0.118 Female 18-29
## 2 Male 18-29 Unfamiliar (N/A) 5 93 0.0538 Male 18-29
## 3 Female 18-29 Very unfavorably 3 85 0.0353 Female 18-29
## 4 Male 18-29 Very unfavorably 8 93 0.0860 Male 18-29
## 5 Female 18-29 Somewhat unfavorably 6 85 0.0706 Female 18-29
## 6 Male 18-29 Somewhat unfavorably 12 93 0.129 Male 18-29
ggplot(test,aes(V28,y=percent,fill=genderAge))+geom_bar(stat="identity",position = position_dodge2(preserve = "total"))+theme(axis.text.x=element_text(angle=45,hjust=1))+xlab("")+ggtitle("How do you feel about Padme?")+scale_fill_manual("legend",values=c("Female 18-29"="indianred","Male 18-29"="red","Female 30-44"="dodgerblue","Male 30-44" ="blue","Female 45-60"="green", "Male 45-60"="forestgreen","Female > 60" ="grey","Male > 60" ="black"))
## NOPE but closer, now all the females are together
THIS IS THE ONE
Members of the older female generation are not (proportionally) Padme fans.
test=as.data.frame(toPlot%>%arrange(Age,V28))
head(test)
## Gender Age V28 count.x count.y percent
## 1 Female 18-29 Unfamiliar (N/A) 10 85 0.11764706
## 2 Male 18-29 Unfamiliar (N/A) 5 93 0.05376344
## 3 Female 18-29 Very unfavorably 3 85 0.03529412
## 4 Male 18-29 Very unfavorably 8 93 0.08602151
## 5 Female 18-29 Somewhat unfavorably 6 85 0.07058824
## 6 Male 18-29 Somewhat unfavorably 12 93 0.12903226
## genderAge
## 1 Female 18-29
## 2 Male 18-29
## 3 Female 18-29
## 4 Male 18-29
## 5 Female 18-29
## 6 Male 18-29
ggplot(test,aes(V28,y=percent,fill=genderAge))+geom_bar(stat="identity",position = position_dodge2(preserve = "total"))+theme(axis.text.x=element_text(angle=45,hjust=1))+xlab("")+ggtitle("How do you feel about Padme?")+scale_fill_manual("legend",values=c("Female 18-29"="indianred","Male 18-29"="red","Female 30-44"="dodgerblue","Male 30-44" ="blue","Female 45-60"="green", "Male 45-60"="forestgreen","Female > 60" ="grey","Male > 60" ="black"))
## MAGICALLY WORKS
Mystery: Why is as.data.frame
needed?

What’s up with the female youths here?!
toPlot$Gender=as.factor(toPlot$Gender)
toPlot$Age=as.factor(toPlot$Age)
levels(toPlot$genderAge) ## fine
## [1] "Female 18-29" "Male 18-29" "Female 30-44" "Male 30-44"
## [5] "Female 45-60" "Male 45-60" "Female > 60" "Male > 60"
levels(toPlot$Age) ## need to relevel
## [1] "> 60" "18-29" "30-44" "45-60"
toPlot$Age=factor(toPlot$Age,levels=levels(toPlot$Age)[c(2,3,4,1)]) ## GROSS!
## if it plots one level of V18 at a time, this would make sense
test=as.data.frame(toPlot%>%arrange(Age,V18))
ggplot(test,aes(V18,y=percent,fill=genderAge))+geom_bar(stat="identity",position = position_dodge2(preserve = "total"))+theme(axis.text.x=element_text(angle=45,hjust=1))+xlab("")+ggtitle("How do you feel about Leia?")+scale_fill_manual("legend",values=c("Female 18-29"="indianred","Male 18-29"="red","Female 30-44"="dodgerblue","Male 30-44" ="blue","Female 45-60"="green", "Male 45-60"="forestgreen","Female > 60" ="grey","Male > 60" ="black"))
## make colors more informative (light and dark of a color for male and female same age), rearrange levels so easier to compare
Side by side instead of stacked (geom_bar
documentation)
Releveling. In haste, I did not do this well. Read this to see why I’m wrong and how I could do better.
Normalizing by the number per category. Letting stat="count"
was a red herring. It would be nice if there was a way to input values to normalize the fill variable by, but instead I ended up manually calculating the percentages and using stat="identity"
.
Correct and consistent ordering of colors (to match the legend) Thanks for the pointers @ibddoctor and @hadleywickham!


Our simple slider widget receives a basic "click" to move the slider. Of much more interest to us is to be able to drag and move the slider. Hints were given at the end of that previous tutorial on how to go about creating your own onBrowserEvent() function, and this tutorial will cover events such as drag and move, and keyboard events such as up and down.
(For those people who would like to see the completed source code in advance and the second demo in action, click here and here)
As we already have a demo slider to work from, we're going to derive from that as a base class. Our primary focus is to add mouse event handling - up, down, and move.
class VerticalDemoSlider2(VerticalDemoSlider): def __init__(self, min_value, max_value, start_value=None): VerticalDemoSlider.__init__(self, min_value, max_value, start_value) self.mouseListeners = [] self.addMouseListener(self) self.sinkEvents(Event.MOUSEEVENTS) self.dragging = False def addMouseListener(self, listener): self.mouseListeners.append(listener) def removeMouseListener(self, listener): self.mouseListeners.remove(listener)
Here, we derive from VerticalDemoSlider, add ourselves as a "mouse listener" - and indicate to the DOM model that we would like to receive notifications about all Mouse Events. So, when the mouse moves into the widget, we receive a "mouse enter" event; we then also receive all move, down and up events, and, when the mouse moves out, we receive a mouse "leave" event. All of these events will result in onBrowserEvent being called, which is the next key function needed:
def onBrowserEvent(self, event): type = DOM.eventGetType(event) if type == "mousedown" or type == "mouseup" or type == "mousemove" or type == "mouseover" or type == "mouseout": MouseListener().fireMouseEvent(self.mouseListeners, self, event)
Here, as you can see, it's very straightforward: mouse events are passed to a convenience function - fireMouseEvent - which will call the appropriate handler functions on each of the listeners. Examining fireMouseEvent, we see that there are five possible functions that could be called (on every one of the listeners, in turn); onMouseDown, onMouseUp, onMouseMove, onMouseLeave and onMouseEnter.
onMouseEnter and onMouseLeave, we are not going to concern ourselves with, so we make those do nothing. However, if we wanted to make the slider visually "respond" to the mouse hovering over the slider, it is these two functions which would take care of that.
def onMouseEnter(self, sender): pass def onMouseLeave(self, sender): pass
The core of the work is done in the remaining three functions. Firstly, onMouseMove, which takes care of translating the mouse pointer's absolute y position into actual movement of the slider:
def onMouseMove(self, sender, x, y): if not self.dragging: return self.moveSlider(y)
Notice how we only allow slider movement when "dragging" is set? If we didn't do this, then the slider would immediately start to jump and move when the mouse cursor was placed over the widget. This isn't what we want: we only want the slider to move when a mouse button is held down:
def onMouseDown(self, sender, x, y): self.dragging = True DOM.setCapture(self.getElement()) self.moveSlider(y)
So, when a mouse down event occurs, we set the "dragging" flag to True, indicate that we want to capture all future events into this widget, and we also move the slider. The reason for moving the slider is because it is a separate event from "mouse move", and people will get rather annoyed if they click the "mouse button" and see the slider staying where it is. The reason for capturing mouse events from now on is because people will quite likely move the mouse out of the widget whilst the button is still held down, and they will expect the slider to still move. Only when they let go of the mouse button will they expect the slider to stop moving about:
def onMouseUp(self, sender, x, y): self.dragging = False DOM.releaseCapture(self.getElement())
So, here you can see, we simply indicate that we no longer want the slider to move about when "mouse move" events occur, and we also cancel the capturing of all events. This is all that's required: the majority of the user-interface hard work was done in the previous tutorial - all we're doing here is calling VerticalDemoSlider.moveSlider() at the appropriate times.
Keyboard Events and Keyboard Focus


{% include head.html %}
{% include_relative home/nav.html %} {% include_relative home/header.html %} {% include_relative home/details.html %} {% include_relative home/portfolio.html %} {% include_relative home/downloads.html %} {% include contact.html %} {% include nav-bottom.html %} {% include scripts.html %}


{$that_year.title}
{$that_year.description}
{$KingCarry.0.cat_name}
Who is he?
Hey, I call Wang Xiaogang a handsome, sunny and coquettish
hi are you ok
In this world of materialism? I've been thinking in my heart How to get out of the characters! Is it easy to be rich? It is the temperament of the heart as a whole, and it is vulgar. I don't want to find reasons for my money, but I'm really poor. So I want to pretend to be a rich man. But it still needs to be rich. It is beyond logic and above reason


This is the 14-21 November 2014 edition of a “weekly digest of W3C news and trends” that I prepare for the W3C Membership and public-w3c-digest mailing list (publicly archived). This digest aggregates information about W3C and W3C technology from online media —a snapshot of how W3C and its work is perceived in online media.
W3C and HTML5 related Twitter trends
[What was tweeted frequently, or caught my attention. Most recent first]
- (
527
) HTML5: HTML5’s “Dirty Little Secret”: It’s Already Everywhere, Even In Mobile - (
177
) Michael Mahemoff: Chrome’s new HTML5 features in past 12 months #chromedevsummit - (
16
) Spec: ServiceWorkers now a W3C draft – let’s make that happen, we do need it. - (
19
) Accessibility: W3C Brazil and the State Public Ministry of São Paulo disclose Booklet Web #Accessibility - (
19
) HTML5: HTML5 is a W3C recommendation, here are 5 now-obsolete features in HTML5
Net Neutrality
- Mashable (21 November), There won’t be a net neutrality decision this year
- Gigaom (20 November), Net neutrality looks doomed in Europe before it even gets started
W3C in the Press (or blogs)
8 articles since the last Digest; a selection follows. You may read all articles in our Press Clippings page.
- The New Yorker (20 November), The Group That Rules the Web
- Heise online (18 November), H.264 ind VP8: IETF findet Codec-Kompromiss für Videotelefonie im Web (H.264 and VP8: IETF takes compromise codec for video telephony on the web)
- Christian Science Monitor (16 November), Possibility unbound: 25 years of progress for those with disability
- Ars Technica (15 November), Microsoft builds a Skype Web client… for at least one version of the Web


--- layout: post authors: ["Matt Davis"] title: Expanding Our Bootcamp Types date: 2013-02-15 time: "09:00:00" tags: ["Bootcamps", "Curriculum", "Reflection"] ---
Prompted by a recent email I gave some thought to our plans to expand the types of bootcamps we offer, especially when it comes to a sort of "next level" bootcamp and whether we might offer bootcamps that introduce traditional software developers to the world of scientific programming:
There is significant discussion on the best way to expand Software Carpentry. Longer bootcamps, advanced bootcamps, etc. At some point we need to start actually experimenting with these things, but we have many constraints, most notably a severe shortage of person-hours to devote to developing curriculum and staffing events. Scientists, it turns out, are very busy people!
We focus on teaching software engineering to scientists, but I think it would be an interesting experiment to try to identify the overlapping interests of Software Carpentry graduates and web developers and run a bootcamp based on that. I could see people getting a lot out of the co-mingling at such an event.
Picking curriculum could be a challenge. Do we keep it general or pick a subfield? Even in our regular bootcamps we find it useful to change lessons based on the audience. Biologists are into SQL, physicists more interested in fast numeric processing. And the more specific we make things the fewer people we interest. My mind goes immediately to scientific Python but then that's my specialty.
If you have thoughts on what to teach in a "next level" boot camp please leave them in the comments, and if you'd like to host one please get in touch!


Back in 03', I quit smoking pot entirely. However, after various extreme circumstances, I became very stressed and wanted to lose myself in a different world. I didn't have much money at the time, but I knew about Diphenhydramine and decided to try it. Going to the store to pick up some cigarettes, I also picked up two boxes of Sleep-Eze D Extra Strength, containing 20 pills in each, 50mg of Diphenhydramine per.
When I got home, I told my mom I was going to be painting in my room, which I then did after popping the pills. At first, I only took 9 50mg pills at 8:00pm. I painted a fairly good portrait at first as the buzz came on. Looking around the room, I could see strange shapes and patterns forming in the wallpaper. In the corner of my eye, I would also see what looked like a flashing light, spinning in circles as if it were a siren.
Realizing I was just freaking myself out, I decided to go downstairs on the computer, which was right next to my mother, at 9:30. Sitting down, I felt sober all of a sudden, which to me was a good thing. My mother and I were having normal conversations, and everything seemed fine. But out of the corner of my eye, I saw a mouse crawl under a pillow. I could see it move under the pillow. I told my mother, but then the mouse magically ran to the crawlspace, which was nearby. This continued to happen, until I ignored it.
Everything seemed perfectly fine from then on, but apparently I was muttering to myself, which I do not remember. I went to my room soon after, and I felt a very lucid, heavy feeling overcome me, and noticed my emotions swung from one polar extreme to the other in bursts.
After this, I remember sitting in my room painting, when a dragon fly came in and perched itself on my hand. This, of course, was a hallucination. When I went to go touch it, it disappeared. At this point, I again felt as thought I were coming down. I felt as though the trip was ending, and so in my unbeknownst stoned state, proceeded to eat 15 more pills somewhere around 12:30am. However, this may be wrong, since the boxes were empty when they were found, and I don't know if I ate them all later on or did something else with them.
Most of my memory is blacked out from that point on, with short bursts. I remember trying to light a paintbrush on fire thinking it was really a cigarette, as well as painting my teeth black. This drug made me completely out of my head. I had absolutely no control over reality and couldn't distinguish it from fantasy. It seemed to induce psychosis, causing completely irratic, schizophrenic-like behaviours.
I didn't sleep at all that night, and was found covered in paint, screaming in the bedroom hallway for a telephone call to someone named Shawn at 6:00am. My mom, who knows I am bipolar with tendancies, thought I had entered in a psychosis, and took me to the hospital.
On the way there I thought it was still night, since the clock said 8:49, and asked why it was so bright out, only to find out its the morning. I tried not to talk after that, but my mind couldn't retain any information. I kept talking to people who weren't there, or continuing a conversation in the middle of it with no one at all, all the while with my mother in the front seat.
At the hospital, I was counselled by a nurse in a small room. I remember thinking that my cousin was just outside the window and he was banging on the window and telling me to come out.
I had to get blood tests to see what it was I was on, even though I gave them the technical name, and so I went to a different section of the hospital. There, I was given a small room to see the doctor in. I sat up on the tall bed covered in paper, and looking to the cubbords, I saw two small Mexican children shutting it and hiding. I then saw another run through the room and climb into the cubbord. And yes, it was a hallucination. Soon after that, my friend Julia came in, and hid where the mattress of the bed rose at the end. We had a conversation together, but then someone walked in and put a box on the bed next to me and she was gone.
Later on, still somewhat psychotic, I was taken to the Adolescent Psychiatric Ward in the hospital. I felt the effects of the drug, and continued to see visual hallucinations at a more sober state until about 7:00pm the next day. I ended up staying there for two months to go through psychological evaluation and substance abuse treatment and counselling.
This may sound like a 'Reefer Madness' segment, but it actually happened and it was scary as fuck. This drug offers no control, especially at high doses. The hallucinations aren't cartoonish but very realistic to the point where I didn't know the difference.
This is a dangerous drug, even if it can be bought at a drugstore, and I wouldn't want anyone but very experienced psychedelics users to try it, but overall if anyone does try it, be sure to have a sitter. It's important with this drug. I urge any would-be new users to this to think strongly before they even consider it.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Connect
Load Server Graph
Generate Random Graph
Take Snapshot
Start Force Layout
Stop Force Layout
Neighbors
Page Rank


split_by_cats
(n_splits
=10
, test_size
=None
, train_size
=None
, random_state
=None
) :: StratifiedShuffleSplit
Stratified ShuffleSplit cross-validator
Provides train/test indices to split data in train/test sets.
This cross-validation object is a merge of StratifiedKFold and
ShuffleSplit, which returns stratified randomized folds. The folds
are made by preserving the percentage of samples for each class.
Note: like the ShuffleSplit strategy, stratified random splits
do not guarantee that all folds will be different, although this is
still very likely for sizeable datasets.
Read more in the :ref:User Guide <cross_validation>
.
Parameters
n_splits : int, default=10
Number of re-shuffling & splitting iterations.
test_size : float or int, default=None
If float, should be between 0.0 and 1.0 and represent the proportion
of the dataset to include in the test split. If int, represents the
absolute number of test samples. If None, the value is set to the
complement of the train size. If train_size
is also None, it will
be set to 0.1.
train_size : float or int, default=None
If float, should be between 0.0 and 1.0 and represent the
proportion of the dataset to include in the train split. If
int, represents the absolute number of train samples. If None,
the value is automatically set to the complement of the test size.
random_state : int or RandomState instance, default=None
Controls the randomness of the training and testing indices produced.
Pass an int for reproducible output across multiple function calls.
See :term:Glossary <random_state>
.
Examples
import numpy as np
from sklearn.model_selection import StratifiedShuffleSplit
X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
y = np.array([0, 0, 0, 1, 1, 1])
sss = StratifiedShuffleSplit(n_splits=5, test_size=0.5, random_state=0)
sss.get_n_splits(X, y)
5
print(sss)
StratifiedShuffleSplit(n_splits=5, random_state=0, ...)
for train_index, test_index in sss.split(X, y):
... print("TRAIN:", train_index, "TEST:", test_index)
... X_train, X_test = X[train_index], X[test_index]
... y_train, y_test = y[train_index], y[test_index]
TRAIN: [5 2 3] TEST: [4 1 0]
TRAIN: [5 1 4] TEST: [0 2 3]
TRAIN: [5 0 2] TEST: [4 3 1]
TRAIN: [4 1 0] TEST: [2 3 5]
TRAIN: [0 5 1] TEST: [3 4 2]


Robert PetersenWeb Developer - Game Designer - Programmer
Hoarding Terrain Generator
A random video game terrain generator that will eventually become a game of it's own.
Vanderbloemen Creative
A simple website upgrade to include the artist's porfolio, as well as an updated contact page.
Blackhawk Tech Uber Program
A final semester website project outlining a sample Blackhawk Technical College and Uber partnership.
Hoarding Survival PC Game
Though actually gameplay is to come, it does feature random voxel terrain, buildings with structural integrity, and volumetric 3D water.
Last One Out Android Game
A simple survival game, where you rescue people from the zombie outbreak. Cities are randomly generated for supreme replayability.
Stranded Visual Basic Game
Cut trees, mine rocks, kill pigs,
and avoid bears while you manage your health and stamina to find your missing crew members.
Hoarding Website
This has been a long ongoing project of mine. It features an infinite random voxel world for terrain deformation,
a custom building system with structural integrity, and flowing 3D volumetric water. Check out the website for more details.
This was an website I did for an internship. The client wanted something simple and provided direction for
the home page. The other pages I was left to create. This site uses jquery for various functions, and uses php to double verify form data on the server
and send a email to the client upon completion.
This was a final school project website for jquery class. It uses pretty extensive use of Jquery for animations to liven the page up.
I tried to keep most of it simple to avoid being obnoxious. It also features form validation in Html5, Javascript, and JQuery.
This has been a long ongoing project of mine. It features an infinite random voxel world for terrain deformation,
a custom building system with structural integrity, and flowing 3D volumetric water. Check out the website for more details.
A simple 3D driving survival game made for Android. Your goal is to rescue survivors from their houses and return them to designed drop-off
points on the edges of the map. Each level has 5 stages, each with a larger number of cities and survivors to collect. Naturally
this increases the difficulty. Each level and it's stages are generated using a seeded random number generator, so you can
your friends can pick the same level number and play the same random stage. The Youtube link below shows me playing the first stage. It
is still a work in progress, but will eventually be released on the Play Store.
A small roguelike game I made using VB.Net. It features a random 2d world of mountains and trees that stand in the way of
your lost crewmates. You have to manage your stamina, which decreases a little for each move, more for each tree cut down,
and a lot for mining. You regain stamina by hunting pigs and eating meat. Survive bear attacks and find your missing crew.


Saghir Bashir (www.ilustat.com)
A Master Chef
A master chef can transform any set of ingredients into an eye pleasing and appetising festival for your taste buds. Before embarking on their creation, they will begin by understanding the quality and freshness of all the ingredients which will determine the quantities in which they will be fused. Understanding the source and origins will be equally important to them (e.g. type of olives, location grown and extraction method for olive oil). Their full grasp of the processes (e.g. mixing, baking, steaming) will lead to a beautifully presented and mouthwatering delight for you to savour. Subtle or even major variations in the processes will result in differing masterpieces for you to feast on. It is possible that even with this greatness that some (or all) of them are not to your liking.
If the quality of the ingredients are lower than desired, a master chef with knowledge, experience and understanding, will still serve up an appetising delight (perhaps with less profound flavours). In the event that some of the ingredients are missing the situation could still be salvaged by using suitable substitutes (or even doing without). However if a key ingredient is missing (e.g. eggs for an omelette) or if the overall quality is terrible then even a master chef cannot rescue the situation.
The brands of the equipment/tools (e.g. sauce pans, ovens) do not determine the success of the end product. Provided that they are of good quality then they should be enough. The real art is in knowing how, when and why to use them.
A Data Science Master Chef
A data science master chef can transform a set of data into a festival of numbers for your eyes to savour and your mind to indulge. Before embarking on any analysis, they will begin by understanding the quality, appropriateness and validity of the data. Understanding the source and origins (e.g. dates, data collection methods, bias reduction measures) will be equally important to them. Their full grasp of the processes (e.g. summarising, modelling or visualising) will, through their mastery, reveal relevant and insightful patterns in the data. Subtle or even major variations in the processes will result in alternate savvy insights for you to ponder and to act on. It is possible that even with this greatness that some (or all) of them are not in agreement with your point of view.
If the quality of the data is lower than desired then the data science master chef can still construct practical and pragmatic insights (most likely with more uncertainty). If some of the data are missing the situation could still be rescued with suitable substitutes (e.g. surrogate variables, missing data methods) or even doing without. If key data is (mostly) missing (e.g. date of event for time to event data) then it is a lost cause. Further if the overall quality is terrible then even a data science master chef cannot rescue the situation.
The brands of the equipment/tools (e.g. data processing and analysis software, IDE) do not determine the success of the end product. Provided that they are of good quality then they should be enough. The real art is in knowing how, when and why to use them.
A Fast Food Data Scientist
The appeal of fast food is convenience and “taste” often created by using lower quality ingredients with some (primarily fat, salt and sugar) in unhealthy doses. The processing is often rudimentary in the form of frying or microwaving. The (very) occasional consumption of fast food may be an acceptable experience but as a day-to-day dietary regime it will lead to undesirable longer term health effects. The same ingredients with the proper understanding and processing could lead to a gratifying experience. If the ingredients are of lower quality then this will be reflected in the flavour.
A fast food data scientist will take some data and pipe it through a “sexy” model or algorithm. Occasionally the results could be alluring and useful by chance. However, such “frying” or “microwaving” of the data will only lead to undesirable consequences in the longer term. The same data with the proper understanding and processing could lead to useful and usable results. If the data are of lower quality then this should be reflected in the statistical variation (uncertainty).
Summary
A data scientist like a master chef should fully understand the ingredients (data) of their craft before any processing which includes going back to the source and origins of the data. This foundation will assist in wisely choosing the best methods and processes to reveal relevant and insightful patterns in the data. Although not every one will agree with or like the patterns that are presented they will appreciate the trustworthiness of the results and reasoning. They will also know that is far better for them than fast food data science.


Webhook URL
Your custom webhook url.
See
here
on how to setup incoming webhooks.
Message
The MS Teams JSON payload to send in the form of
Office 365 connector card
Send


|
QuantLib: a free/open-source library for quantitative finance
Fully annotated sources - version 1.30
|
Gaussian kernel function. More...
#include <ql/math/kernelfunctions.hpp>
Public Member Functions | |
| GaussianKernel (Real average, Real sigma) | |
| Real | operator() (Real x) const override |
| Real | derivative (Real x) const |
| Real | primitive (Real x) const |
| Public Member Functions inherited from KernelFunction | |
| virtual | ~KernelFunction ()=default |
| virtual Real | operator() (Real x) const =0 |
Private Attributes | |
| NormalDistribution | nd_ |
| CumulativeNormalDistribution | cnd_ |
| Real | normFact_ |
Gaussian kernel function.
Definition at line 44 of file kernelfunctions.hpp.
| GaussianKernel | ( | Real | average, |
| Real | sigma | ||
| ) |
Definition at line 46 of file kernelfunctions.hpp.
Implements KernelFunction.
Definition at line 50 of file kernelfunctions.hpp.
Definition at line 56 of file kernelfunctions.hpp.
|
private |
Definition at line 61 of file kernelfunctions.hpp.
|
private |
Definition at line 62 of file kernelfunctions.hpp.
|
private |
Definition at line 63 of file kernelfunctions.hpp.