Now it's time to review machine learning knowledge. Actually, I was thinking about how to start reviewing this part a long time ago, but here is the dilemma: I have written some reviews before but it did not that useful as it is supposed to be. Therefore, I will follow these new rules as I'm writing the next several ML posts:
- Focus more on the mathematical theory of each model (MLE/Loss function/evaluation method)
- Pay attention to each model's assumption. Then I could list the pros and cons comparing with other similar models.
- For some basic but very important models (such as logistic regression/k-means/random forest), try to write the algorithm myself from scratch by Python.
All right, let us see whether it will be a good way to fully review the Machine Learning.
1. Introduction
Classification problem is one of the most important parts of supervised learning. In the next several posts, I will mainly cover these methods: Logistic Regression, Naive Bayes Model, Linear Discriminate Analysis(LDA), Quadratic Discriminate Analysis(QDA), KNN and SVM model.
In this post let us talk about Logistic Regression.
2. Theoretical Basis
Logistic Regression is a simple linear classification model. It seeks to model the probability that Y belongs to a particular category.
2.1 Logistic Regression Model
Logistic regression is a generalized linear model, there is no doubt that it has a very close relationship with the linear regression model. So let us then see how logistic regression model was generated, or how it extended from the linear regression model.
In a word, Logistic Regression model the class label given the data as:
$$P(y = k|x) = Bernoulli(p) = p^k\cdot (1-p)^{(1-k)}$$
Then, what is $p$? It must have a relationship with our dataset $X$, we call it $p(X)$. From our first thought, can $p(X)$ be a linear regression model with $X$? However, we know $p(X)$ is a probability, and it could happen that for some $X$s, $p(X)$ could go out of $[0,1]$. So we need to find a function to both map $p(X)$ within $[0,1]$ and also catch the data's information. Then it comes sigmoid function.
$$\sigma(x) = \frac{1}{1+e^{-x}}$$
And here is the plot of this function:
Then our model is now like this:
$$P(y=1|x)= \frac{1}{1+e^{-\beta x}}$$
$$P(y=0|x)= \frac{e^{-\beta x}}{1+e^{-\beta x}}$$
Or more general:
$$P(y=k|x)=(\frac{1}{1+e^{-\beta x}})^k \cdot (\frac{e^{-\beta x}}{1+e^{-\beta x}})^{1-k}$$
where $\beta$ is a column vector. You may wonder where is the $\beta$ comes from. To see what the $\beta$ is, we need to do some transformation:
$$ln(\frac{P(y=1|x)}{P(y=0|x)}) = ln(\frac{1}{e^{-\beta x}})=ln(e^{x\beta})=x\beta$$
By looking at this formula, we could see how logistic regression connects with linear regression and what is $\beta$ function here:
- Control the weight of each predictor
- Also called scaling parameter: the larger the $\beta$, the closer the sigmoid function to indicator function
Finally, we often call this formula logit. If the logit larger than zero, we assign the data to class one; If smaller than zero, we assign the data to class two.
2.2 Parameter Estimation and Loss Function
Now we would like to estimate the coefficients $\beta$. We will use MLE here. Based on 2.1, we could easily write down the likelihood function (likelihood function is a function of the parameter of a statistics given data) of this model:
$$L(\mathbf{y},\mathbf{X}|\beta) = \prod_{i=1}^{n}L(y{_i},x_i|\beta) = \prod_{i=1}^{n}
(\frac{1}{1+e^{-x_i \beta}})^{y{_i}} \cdot (\frac{e^{-x_i \beta }}{1+e^{-x_i \beta}})^{1-y_i}$$
And the negative log likelihood is:
$$L(\beta)=-log(L(\mathbf{y},\mathbf{X}|\beta))=-\sum_{i=1}^{n}log(L(y{_i},x_i|\beta))=-\sum_{i=1}^{n}y_ilog(\sigma(x_i \beta))+(1-y_i)log(1-\sigma(x_i \beta))$$
Here we suppose each observation is independent with others.
Then:
$$\hat{\beta} = \arg\max_{\beta} L(\mathbf{y},\mathbf{X}|\beta)=\arg\max_{\beta}\prod_{i=1}^{n}L(y{_i},x_i|\beta)=\arg\min_{\beta}L(\beta)$$
So, it is natural that $L(\beta)$ is our loss function since we would like to minimize this if we want to get the optimal MLE. We often call this loss function: log loss.
Unfortunately, there is no explicit solution to this function, so we need to use some numerical algorithms such as gradient descent.
2.3 Model Assumption
After performing these analyses above, we could more easily understand the following assumptions:
- Require the observations to be independent of each other: That's the assumption for Bernoulli distribution
- Require little or no multicollinearity among the independent variables: Same with linear regression. Multicollinearity will influence mostly the interpretability and stability of the model. The estimate of one variable's impact on the dependent variable tends to be less precise (Since the weight of the parameter for logit can be used to explain the model); Also it produces large standard errors in the related independent variables and solutions that are wildly varying and possibly numerically unstable
- Assume linearity of independent variables and log odds: Since logistic regression provides a linear decision boundary ($\beta x = 0$), so if the linearity is not satisfied, it is impossiable to find a good solution.
- Require large sample size: always good to have more data
2.4 Multinomial Logistic Regression Model
Based on the analysis above, we find that logistic regression could solve the binary classification problem, then how to generalize the model to multi-classes condition?
1) As a set of independent binary regressions
One way to deal with this situation is to see this model as a set of independent binary regressions. So for $K$ possible outcomes, running $k-1$ independent binary logistic regression models, in which one outcome is chosen as a 'pivot' and then the other $K-1$ outcomes are seperately regressed against the pivot outcome. This would proceed as follows, if outcome $K$ is chosen as the pivot:
$$ln\frac{P(y_i=1)}{P(y_i=K)} =X_i \beta_1$$
$$\cdots \cdots$$
$$ln\frac{P(y_i=K-1)}{P(y_i=K)} = X_i\beta_{K-1}$$
If we exponentiate both sides, and solve for the probabilities, we got:
$$P(Y_i=1)=P(Y_i=K)e^{X_i\beta_1}$$
$$\cdots \cdots$$
$$P(Y_i=K-1)=P(Y_i=K)e^{X_i\beta_{K-1}}$$
Use the fact that all $K$ of the probabilities must sum to one, we find:
$$P(Y_i=K)=1-\sum_{k=1}^{K-1}P(Y_i=K)e^{X_i\beta_k }$$
$$=> \ P(Y_i=K)=\frac{1}{1+\sum_{k=1}^{K-1}e^{X_i\beta_k }}$$
Then we can use this to find other probabilities:
$$P(Y_i=1) = \frac{e^{X_i\beta_1}}{1+\sum_{k=1}^{K-1}e^{X_i\beta_k}} $$
$$\cdots \cdots$$
$$P(Y_i=K-1) = \frac{e^{X_i\beta_{K-1}}}{1+\sum_{k=1}^{K-1}e^{X_i\beta_k}} $$
2) As a log-linear model
The formulation of binary logistic regression as a log-linear model can be directly extended to multi-way regression. That is, we model the logarithm of the probability of seeing a given output using the linear predictor as well as an additional normalizaion factor, the logarithm of the partition function:
$$lnP(Y_i=1)=X_i\beta_1 - lnZ$$
$$\cdots \cdots$$
$$lnP(Y_i=K)=X_i\beta_K - lnZ$$
Since $\sum_{k=1}^{K}P(Y_i=K)=1$, therefore $Z = \sum_{k=1}^{K}e^{X_i\beta_k}$, then we have:
$$P(Y_i=c)=\frac{e^{X_i\beta_c}}{\sum_{k=1}^{K}e^{X_i\beta_k}}$$
The following function:
$$softmax(k,x_1,...,x_n)=\frac{e^{x_k}}{\sum_{i=1}^{n}e^{x_i}}$$is referred to as the softmax function. The reason is that the effect of exponentiating the values $x_1,...,x_n$ is to exaggerate the differences between them. As a result, softmax will return a value close to 0 whenever $x_k$ is significantly less than the maximum of all the values, and will return a value close to 1 when applied to the maximum value. Thus the softmax function can be used to construct a weighted average that behaves as a smooth function and which approximates the indicator function. Thus, we can write the probability equations as:
$$P(Y_i=c)=softmax(c, X_i\beta_1, ..., X_i\beta_K)$$
The softmax function thus serves as the equivalent of the sigmoid function in binary logistic regression.
3. Model Construction
Then let me construct a binary logistic regression from scratch by Python.
Due to the space constraint, please refer to this link to see more detailed coding information:
Jupyter Notebook For Logistic Regression
We could see logistic regression classify IRIS data very well.
4. Summary
Finally, lets summarize the pros and cons of logistic regression:
Pros:
- Outputs have a nice probabilistic interpretation. We can also find the important feature by looking at the parameter weights
- Outputs are easy to be modified based on the cut off threshold. Since LR output the probability score.
- Very fast and computationally cheap
- Can be regularized
Cons:
- Underperform when there are multiple or non-linear decision boundaries. It is not flexible enough to naturally capture more complex relationship
- Cannot handle large number of categorical features
- Cannot deal with the imbalanced data problem
If we want to use one sentence to describe logistic regression: Logistic regression assumes the binary data belongs to Bernoulli distribution, by using sigmoid function to approximate p(x), we then use MLE to estimate the parameter, and to get the solution we use gradient descent.
All right, I think now we could have a very good understanding of Logistic Regression both on theory and implementation. Let us move to some other classification problems in the next post.
Reference:
http://ml-cheatsheet.readthedocs.io/en/latest/logistic_regression.html
James的blog


Initiatives
Speakers
Pledges
Pledges
Make a Pledge
(Maximum characters: 240)
You have
characters left.
Send
Clear
Please make a pledge.
Click the button below to add your pledge
Add


What language are you?
Greetings human! Fill out the short questionnaire below to find out which programming language YOU are!
Q1:
on a scale from "indubitable virtuoso" to "scholastically elite", how would you rate your procrastination skills?
-- select an option --
indubitable virtuoso
wait, is this for real?
scholastically elite
Q2:
what do you want to be when you grow up?
werewolf astronaut
werewolf marine biologist
just a werewolf
Q3:
tell us a little bit about why you want to become a procrastinating werewolf!
Q4:
choose a number between infinity and non-infinity:
Q5:
how serious did you take this quiz?
extremely serious
inordinately serious
seriously serious
according to our sophisticated analytics, you are
.
.
.


This document discusses how the Java virtual machine (JVM) maps priorities for threads executing in the JVM (Java threads) onto native thread priorities on Solaris. It covers both current and past implementations of Solaris threads and the JVM.
The JVM defines a range of ten logical priorities for Java threads, including:
java.lang.Thread.MIN_PRIORITY = 1 java.lang.Thread.NORM_PRIORITY = 5 java.lang.Thread.MAX_PRIORITY = 10
These values [1..10] are passed into
Thread.setPriority(int)
to assign priorities to Java
threads. The default priority of a Java thread is
NORM_PRIORITY
. (A Java thread that doesn't explicitly
call setPriority
runs at NORM_PRIORITY
.)
A JVM is free to implement priorities in any way it chooses,
including ignoring the value.
The Java HotSpot virtual machine currently associates each Java thread with a unique native thread. The relationship between the Java thread and the native thread is stable and persists for the lifetime of the Java thread.
Prior to Solaris 9 the default libthread was the so-called
T1 libthread. T1 provided an M:N threading model where M
native threads were multiplexed on top of N kernel threads
(LWPs). The relationship between native threads and LWPs was
fluid and dynamic and could change even while a thread was running
and without the knowledge of the thread. Solaris provided the
priocntl()
system call to change the dispatching
priority of an LWP, but because the relationship between LWPs and
native threads was unstable so there was no reliable way to change
to change the dispatching priority of a native thread. (The JVM
could change the priority of the LWP on which a Java thread was
currently running, but the thread could switch to another LWP
without the JVM's knowledge).
T2, the default libthread in Solaris 9 and better, implements a much more simple and robust 1:1 threading model. Each native thread is assigned to a unique LWP, and that relationship is stable for the lifetime of the native thread.
Both T1 and T2 expose a thr_setprio()
API that
applications use to set a thread's process-local priority. The
value assigned by thr_setprio()
is a process-local
attribute and is not visible to the kernel scheduler. The
thr_setprio()
-priority controls the placement and
ordering of threads on user-level process-local sleep queues, such
as the queue of threads associated with a contended process-local
mutex. In HotSpot most mutexes are uncontended and condvars have
usually have either 0 or 1 threads. As such, the ordering imposed
by thr_setprio()
-priority has very little effect on
most Java threads. The thr_setprio()
function supports
priority values in the range 0 through 127, inclusive, with 127
representing the highest priority.
T1 also uses thread priority to implement rudimentary user-mode
preemption. T1 maintains an invariant that the
thr_setprio()
-priority of any thread on the local
ready queue must be less than or equal to the priority of any
unbound thread that's currently running and associated with an LWP.
If the invariant is threatened, T1 preempts the lowest priority
executing thread to "steal" its LWP in order to reestablish the
invariant.
Preemption can occur in these cases:
An early version of T2, referred to as the alternate libthread, appeared in Solaris 8.
In Solaris an LWP's priority influences how many CPU cycles a
thread receives relative to other threads. The Solaris scheduler
uses priority (among other factors) to determine if one thread
should preempt another thread, how often a thread runs, and how
long a thread runs. Native LWP priorities are assigned by the
priocntl()
system call.
To recap, we have Java threads, with priorities set by the
Thread.setPriority
method. Java threads run on native
threads. The thr_setprio()
function is used to change
the priority of native threads. Native threads run on LWPs. The
priocntl()
system call is used to change the priority
of LWPs.
In releases earlier than 1.4.2, when a Java thread called the
Thread.setPriority
method or when a thread was
created, HotSpot would call thr_setprio()
to map the
Java priority to an native priority. Calling
thr_setprio()
had very little effect on the execution
behavior of a Java thread. The JVM did not call
priocntl()
to adjust the priority of the underlying
LWP. This was a conscious design decision because in the 1.4.2 time
frame the only libthread available on Solaris was the older T1
libthread.
Note: The JVM could have forced native threads to be
bound 1:1 to LWPs under T1 by specifying THR_BOUND
when threads are created. THR_BOUND
is not sufficient,
however, as threads that attach to the JVM might not be
THR_BOUND
and the primordial thread is not
THR_BOUND
. Given that there's no way in Solaris to
force a thread to be bound after it's been created, the HotSpot
implementors decided that it was prudent not to change LWP priority
when a Java thread called setPriority()
In 1.4.2 HotSpot was able to determine at startup time if it was running under T1 or T2. If the JVM started under T1 the effect of priorities would be precisely the same as in earlier releases.
Under T2, however, 1.4.2 translated calls to the
Thread.setPriority
method into calls to both
thr_setprio()
(to change the native process-local
priority) and to priocntl()
(to change the dispatching
priority of the underlying LWP). The JVM called
priocntl()
only for threads that are running in the
TS (timeshare), IA (interactive), and RT
(real-time) scheduling classes. Refer to the Solaris
priocntl(2)
man page for a description of scheduling
classes. If a Java thread was not in the TS, IA, or RT scheduling
classes the JVM would not attempt to set the priority of the
underlying LWP with priocntl()
.
Unfortunately the default priority of native threads in the TS
and IA scheduling classes is the highest possible priority. The
default logical priority for Java threads is
NORM_PRIORITY
, which is midway in domain of Java
thread priorities. When the JVM maps NORM_PRIORITY
to
native and LWP priorities, the outcome is a value that is less then
the default native priority. Let's say we have a 2-CPU system
running a JVM, and that JVM has two Java threads, both at
NORM_PRIORITY
. Assume that the threads are in the IA
or TS scheduling class, as is commonly the case. When the Java
threads are created, the JVM calls priocntl()
to map
NORM_PRIORITY
to the middle of the TS or IA priority
bands. Furthermore, assume that 2 native "C" threads in another
process are running/ready concurrently with the Java threads. Both
the native C threads and the Java threads are CPU-bound and spin,
computing. The native threads will run at the highest priority in
the TS or IA scheduling class, and the JVM threads will run at the
middle priority. Since all four threads are competing for CPU
cycles, the native threads will receive relatively more CPU cycles
and the Java threads will, in a sense, be disadvantaged. This
effect occurs only when Java threads compete with normal threads
and the system is entirely saturated.
Conversely, a benefit of using lower relative priorities is that in the TS and IA scheduling classes a thread running at lower priorities receives a longer quantum, assuming that it's not preempted mid-quantum by higher priority threads that become ready. A longer quantum is often beneficial for threads in server applications as the context switch rate from preemption decreases. A thread is permitted to run on a CPU for a longer period and the cache-reload transient (the period immediately after a thread is scheduled on to a CPU: when a thread incurs a high cache miss rate as it repopulates the CPU's data caches and displaces the previous thread's data) is amortized over a longer quantum.
JRE 5.0 provides the same priority mapping as 1.4.2 except that
Java priorities in the range [10...5] are all mapped to the highest
possible TS or IA priority, while priorities in the range [1..4]
are mapped to correspondingly lower native TS or IA priorities. The
advantage of this change is that Java threads at
NORM_PRIORITY
can now compete as expected with native
threads. If neither the Java threads nor the native threads have
explicitly set priorities (which is commonly the case), both
classes of thread will compete on an equal footing, running at the
highest priority in the TS or IA scheduling class.
Assuming that Java threads don't explicitly set their priority
with setPriority()
, this change restores the behavior
and effective LWP priority of Java threads that was used prior to
1.4.2. The disadvantage to this implementation is that Java
priorities from 5 to 10 are not differentiated. A Java thread at
logical priority 8 maps to the same LWP priority as a Java thread
at priority 9, for instance.
The following statements apply to all versions of HotSpot:
Thread.setPriority
method may be an
expensive operation. Frivolous priority adjustments can reduce
performance.NORM_PRIORITY
. This, in turn,
changes the thread's native priority and potentially changes the
priority of the LWP on which the native thread is running.
Specifically, if a native thread adjusts its priority and then
attaches to a JVM, the JVM overwrites the previous priority
settings of the thread. The JVM does not "undo" or restore a native
thread's priority if the thread detaches.The Thread.setPriority
and
Thread.yield
methods are advisory. They constitute
hints from the application to the JVM. Properly written, robust,
platform-independent code can use setPriority()
and
yield()
to optimize the performance of the
application, but should not depend on these attributes for
correctness. Likewise, no assumptions should be made about the
order in which threads are granted ownership of a monitor or the
order in which threads wake in response to the notify
or notifyAll
method.


DOFH - Dependency Overload from Hell
Data
Upload CREF file
Layout
Active layout
Force-directed
Concentric by centrality
Hierarchy by centrality
Custom


Could not connect to the micboard server. Please refresh the page.
all devices | edit extended names
edit group
RX COM Error


{% extends "layout.html" %} {% block page_title %} Registered Traveller {% endblock %} {% block content %} Back Which of these applies to you? Select which of these applies to you Spouse or civil partner of a British citizen Spouse or civil partner of an EEA citizen Spouse or partner of someone with a UK visa Continue {% endblock %}


This class contains a list of UI elements, where one specific one is focused on.
More...
|
| void | addElement (const std::shared_ptr< UI_Element > &element) |
| | Add an element to this focus map, setting it in focus. More...
|
| |
| bool | removeElement (const std::shared_ptr< UI_Element > &element) |
| | Remove an element from this focus map, comparing its underlying pointer. More...
|
| |
| void | clear () noexcept |
| | Remove all elements from this focus map. More...
|
| |
| void | focusIndex (const int &newIndex) noexcept |
| | Set the focus onto a specific index, if it is able to be focused on. More...
|
| |
| bool | focusElement (const std::shared_ptr< UI_Element > &element) noexcept |
| | Set the focus onto a specific element, if it is able to be focused on, if it's pointer can be found. More...
|
| |
| void | applyActionState (ActionState &actionState) |
| | Apply user input to the focus map, forwarding it to the focused element and perhaps changing the focus as well. More...
|
| |
| void | back () noexcept |
| | Move the focus back by 1. More...
|
| |
| void | forward () noexcept |
| | Move the focus ahead by 1. More...
|
| |
This class contains a list of UI elements, where one specific one is focused on.
Focus can be changed manually, or by user input directly. Goal is to decouple basic UI elements from changing focus, and have more complex ones use FocusMap to standardize movement between them.


Knit images into polygons in the round.
This tool takes an image and creates a pattern to knit this over a pattern of increases giving a polygon shape - whether it's a square, a triangle, or something more exotic. Here is a sample I made to test this!
It works by segmenting the image into a small number of colours, then creating a pattern of increases to produce the requested polygon. It then maps the locations of each of the stitches onto the image to decide the appropriate colour. The pattern is then converted into a spread sheet and downloaded by your browser.
This will work best for images with a small number of colours, so there isn't a lot of carrying floats required. The pattern ends when the outermost row touches the edge of the image, so if you want to knit the whole image, you may need to add some padding around the edges to make sure it is all included.
As with the shadow knitting tool, please be patient with the error handling - I've tried to keep this flexible, which makes some errors unavoidable. If your original image fails, please try a different image.


--- layout: default title: Contact summary: We would love to hear from you! Please use the following form to send us a message. app: formioContact ---


# Compile time benchmarks
The benchmarks are done with [**this**](../../scripts/bench/bench.py) script using CMake. There are 2 benchmarking scenarios:
- [the cost of including the header](#cost-of-including-the-header)
- [the cost of an assertion macro](#cost-of-an-assertion-macro)
Compilers used:
- WINDOWS: Microsoft Visual Studio Community 2015 - Version 14.0.25431.01 Update 3
- WINDOWS: gcc 6.2.0 (x86_64-posix-seh-rev0, Built by MinGW-W64 project)
- LINUX: gcc 5.2.1 20151010 (Ubuntu 5.2.1-22ubuntu2)
- LINUX: clang 3.6.2-1 (tags/RELEASE_362/final) (based on LLVM 3.6.2) Ubuntu - Target: x86_64-pc-linux-gnu
Environment used (Intel i7 3770k, 16g RAM):
- Windows 7 - on an SSD
- Ubuntu 15.10 in a VirtualBox VM - on a HDD
**doctest** version: 1.1.0 (released on 2016.09.21)
[**Catch**](https://github.com/philsquared/Catch) version: 1.5.6 (released on 2016.06.09)
## Cost of including the header
This is a benchmark that is relevant only to single header and header only frameworks - like **doctest** and [**Catch**](https://github.com/philsquared/Catch).
The script generates 201 source files and in 200 of them makes a function in the form of ```int f135() { return 135; }``` and in ```main.cpp``` it forward declares all the 200 such dummy functions and accumulates their result to return from the ```main()``` function. This is done to ensure that all source files are built and that the linker doesn't remove/optimize anything.
- **baseline** - how much time the source files need for a single threaded build with ```msbuild```/```make```
- **+ implement** - only in ```main.cpp``` the header is included with a ```#define``` before it so the test runner gets implemented:
```
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"
```
- **+ header everywhere** - the framework header is also included in all the other source files
- **+ disabled** - **doctest** specific - only this framework can remove everything related to it from the binary
| doctest | baseline | + implement | + header everywhere | + disabled |
|---------------------|----------|-------------|---------------------|------------|
| MSVC Debug | 5.9 | 7.1 | 8.3 | 7.0 |
| MSVC Release | 5.4 | 6.9 | 8.7 | 6.5 |
| MinGW GCC Debug | 9.4 | 11.7 | 14.4 | 11.1 |
| MinGW GCC Release | 9.6 | 12.3 | 14.9 | 11.4 |
| Linux GCC Debug | 6.3 | 7.1 | 10.2 | 7.4 |
| Linux GCC Release | 6.5 | 8.4 | 10.8 | 7.8 |
| Linux Clang Debug | 6.9 | 7.6 | 10.6 | 8.2 |
| Linux Clang Release | 7.2 | 8.4 | 11.4 | 8.4 |
| Catch | baseline | + implement | + header everywhere |
|---------------------|----------|-------------|---------------------|
| MSVC Debug | 5.9 | 8.5 | 102 |
| MSVC Release | 5.4 | 10.3 | 96 |
| MinGW GCC Debug | 9.4 | 24.5 | 125 |
| MinGW GCC Release | 9.6 | 18.4 | 113 |
| Linux GCC Debug | 6.3 | 10.4 | 59 |
| Linux GCC Release | 6.5 | 14.1 | 64 |
| Linux Clang Debug | 6.9 | 9.8 | 64 |
| Linux Clang Release | 7.2 | 12.8 | 67 |
### Conclusion
#### doctest
- instantiating the test runner in one source file costs ~1.5 seconds ```implement - baseline```
- the inclusion of ```doctest.h``` in one source file costs below 9ms ```(header_everywhere - implement) / 200```
- including the library everywhere but everything disabled costs less than 2 seconds ```disabled - baseline``` for 200 files
#### [Catch](https://github.com/philsquared/Catch)
- instantiating the test runner in one source file costs ~5 second ```implement - baseline```
- the inclusion of ```catch.hpp``` in one source file costs around 430ms ```(header_everywhere - implement) / 200```
----------
So if ```doctest.h``` costs 8ms and ```catch.hpp``` costs 430ms on MSVC - then the **doctest** header is >> **54** << times lighter!
----------
The results are in seconds and are in **no way** intended to bash [**Catch**](https://github.com/philsquared/Catch) - the **doctest** framework wouldn't exist without it.
The reason the **doctest** header is so light on compile times is because it forward declares everything and doesn't drag any headers in the source files (except for the source file where the test runner gets implemented). This was a key design decision.
## Cost of an assertion macro
The script generates 11 ```.cpp``` files and in 10 of them makes 50 test cases with 100 asserts in them (of the form ```CHECK(a==b)``` where ```a``` and ```b``` are always the same ```int``` variables) - **50k** asserts! The testing framework gets implemented in ```main.cpp```.
- **baseline** - how much time a single threaded build takes with the header included everywhere - no test cases or asserts!
- ```CHECK(a==b)``` - will add ```CHECK()``` asserts which decompose the expression with template machinery
**doctest** specific:
- ```CHECK_EQ(a,b)``` - will use ```CHECK_EQ(a,b)``` instead of the expression decomposing ones
- ```FAST_CHECK_EQ(a,b)``` - will use ```FAST_CHECK_EQ(a,b)``` instead of the expression decomposing ones
- **+faster** - will add [**```DOCTEST_CONFIG_SUPER_FAST_ASSERTS```**](configuration.html#doctest_config_super_fast_asserts) which speeds up ```FAST_CHECK_EQ(a,b)``` even more
- **+disabled** - all test case and assert macros will be disabled with [**```DOCTEST_CONFIG_DISABLE```**](configuration.html#doctest_config_disable)
| doctest | baseline | ```CHECK(a==b)``` | ```CHECK_EQ(a,b)``` | ```FAST_CHECK_EQ(a,b)``` | +faster | +disabled |
|---------------------|----------|-------------------|---------------------|--------------------------|---------|-----------|
| MSVC Debug | 2.5 | 21 | 16.2 | 6.7 | 4.4 | 2.2 |
| MSVC Release | 2.6 | 64 | 55 | 63 | 5.3 | 1.8 |
| MinGW GCC Debug | 3.2 | 77 | 52 | 29.5 | 12.2 | 1.6 |
| MinGW GCC Release | 3.9 | 425 | 295 | 81 | 18.6 | 1.9 |
| Linux GCC Debug | 1.3 | 72 | 48 | 20.3 | 9.5 | 0.9 |
| Linux GCC Release | 2.3 | 339 | 210 | 42 | 18.3 | 1.3 |
| Linux Clang Debug | 1.3 | 70 | 46 | 18.8 | 7.0 | 0.9 |
| Linux Clang Release | 1.8 | 205 | 136 | 30 | 10.8 | 1.1 |
And here are [**Catch**](https://github.com/philsquared/Catch) and **doctest 1.0** which only have normal ```CHECK(a==b)``` asserts:
| Catch | baseline | ```CHECK(a==b)``` | | doctest 1.0 | ```CHECK(a==b)``` |
|---------------------|----------|-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|-------------------|
| MSVC Debug | 8.4 | 34 | | MSVC Debug | 58 |
| MSVC Release | 9.7 | 77 | | MSVC Release | 367 |
| MinGW GCC Debug | 20.5 | 115 | | MinGW GCC Debug | 202 |
| MinGW GCC Release | 15.1 | 496 | | MinGW GCC Release | 1257 |
| Linux GCC Debug | 7.3 | 101 | | Linux GCC Debug | 204 |
| Linux GCC Release | 10.3 | 435 | | Linux GCC Release | 1090 |
| Linux Clang Debug | 6.0 | 91 | | Linux Clang Debug | 167 |
| Linux Clang Release | 8.5 | 159 | | Linux Clang Release | 494 |
### Conclusion
**doctest 1.1**:
- improves the compile time of it's ```CHECK(a==b)``` asserts by roughly 3 times compared to **doctest** 1.0 (released 2016.05.22)
- is around 25% faster than [**Catch**](https://github.com/philsquared/Catch) when using expression decomposing ```CHECK(a==b)``` asserts
- adds asserts of the form ```CHECK_EQ(a,b)``` with no expression decomposition - around 20% faster than ```CHECK(a==b)```
- adds fast asserts like ```FAST_CHECK_EQ(a,b)``` with no ```try/catch``` blocks - around 30-70% faster than ```CHECK_EQ(a,b)```
- adds the [**```DOCTEST_CONFIG_SUPER_FAST_ASSERTS```**](configuration.html#doctest_config_super_fast_asserts) identifier which makes the fast assertions even faster by another 35-80%
- using the [**```DOCTEST_CONFIG_DISABLE```**](configuration.html#doctest_config_disable) identifier the assertions just disappear as if they were never written
----------
If you want a benchmark that is not synthetic - check out [**this blog post**](http://baptiste-wicht.com/posts/2016/09/blazing-fast-unit-test-compilation-with-doctest-11.html) of [**Baptiste Wicht**](https://github.com/wichtounet) who tested the compile times of the asserts in the 1.1 release with his [**Expression Templates Library**](https://github.com/wichtounet/etl)!
While reading the post - keep in mind that if a part of a process takes 50% of the time and is made 10000 times faster - the overall process would still be only roughly 50% faster.
---------------
[Home](readme.html#reference)


Trading_SellingStatusType Class Reference
| Inherits from | NSObject |
| Conforms to | PicoBindable |
| Declared in | Trading_SellingStatusType.h Trading_SellingStatusType.m |
Overview
Contains various details about the current status of a listing. These
values are computed by eBay and cannot be specified at listing time.
@ingroup EBayAPIInterface
Tasks
-
bidCount
Number of bids placed so far against the item. Only applicable to
property
competitive-bid item listings (Chinese auctions). -
bidIncrement
The minimum amount a progressive bid must be above the current high bid to be accepted. This field is only
property
applicable to auction listings. The value of this field will always be ‘0.00’ for Classified Ad and fixed-price
listings. -
convertedCurrentPrice
Converted value of the CurrentPrice in the currency of the site that
property
returned this response. For active items, refresh the listing’s data every 24
hours to pick up the current conversion rates. Only returned when the item's
CurrentPrice on the listing site is in different currency than the currency of
the host site for the user/application making the API call. ConvertedCurrentPrice
is not returned for Classified listings (Classified listings are not available
on all sites).
In multi-variation listings, this value matches the lowest-priced
variation that is still available for sale. -
currentPrice
For auction listings, this price is the starting price or the current highest
property
bid for the item if bids have been placed.
For fixed-price listings, this price is the sale price of the item.
In multi-variation, fixed-price listings, this value matches the lowest-priced
variation that is still available for sale. -
highBidder
For ended Chinese auction listings that have a winning bidder,
property
this field is a container for the high bidder’s user ID.
For ended, single-item, basic fixed price (FixedPriceItem) and
ended Store Inventory (StoresFixedPrice) listings,
this field is a container for the user ID of the purchaser.
This field isn’t returned for auctions with no bids, or for active fixed price listings,
or for active Store Inventory listings.
In the case of PlaceOffer, for chinese auctions,
this field is a container for the high bidder’s user ID.
In the PlaceOffer response, the following applies:
For multiple-quantity, fixed-price listings,
the high bidder is only returned if there is just one order line item
(or only for the first order line item that is created). -
leadCount
Applicable to Ad type listings only. Indicates how many leads to
property
potential buyers are associated with this item. Returns 0 (zero) for listings in other formats. You must be the seller of the item to retrieve the lead count. -
minimumToBid
Smallest amount the next bid on the item can be. Returns same value as
property
Item.StartPrice (if no bids have yet been placed) or CurrentPrice plus
BidIncrement (if at least one bid has been placed). Only applicable to
competitive-bid item listings (Chinese auctions). Returns null for basic
Fixed Price (FixedPriceItem), Store Inventory (StoresFixedPrice),
and Ad type listings.
In multi-variation listings, this value matches the lowest-priced
variation that is still available for sale.
Note:
As of version 619, Dutch-style (multi-item) competitive-bid auctions are deprecated.
eBay throws an error if you submit a Dutch item listing with AddItem
or VerifyAddItem. If you use RelistItem to update a Dutch auction listing,
eBay generates a warning and resets the Quantity value to 1.
-
quantitySold
The total number of items purchased so far (in the listing’s lifetime).
property
Subtract this from Quantity to determine the quantity available.
If the listing has Item Variations,
then in GetItem (and related calls) and GetItemTransactions,
Item.SellingStatus.QuantitySold contains the sum of all quantities
sold across all variations in the listing, and Variation.SellingStatus.QuantitySold contains the number
of items sold for that variation.
In GetSellerTransactions,
Transaction.Item.SellingStatus.QuantitySold contains the number
of items sold in that order line item.
For order line item calls, also see Transaction.QuantityPurchased for
the number of items purchased in the order line item.
In multi-variation listings, this value matches total quantity sold
across all variations. -
reserveMet
Indicates whether the reserve price has been met for the listing. Returns
property
true if the reserve price was met or no reserve price was specified. -
secondChanceEligible
Part of the Second Chance Offer feature, indicates whether the seller can
property
extend a second chance offer for the item. -
bidderCount
Number of bidders for an item. Only applicable to competitive-bid item listings
property
(Chinese auctions). Only returned for the seller of the item. -
listingStatus
Specifies an active or ended listing’s status in eBay’s processing workflow.
property
If a listing ends with a sale (or sales), eBay needs to update the sale details
(e.g., total price and buyer/high bidder) and the final value fee. This processing
can take several minutes. If you retrieve a sold item and no details about the buyer/high bidder
are returned or no final value fee is available, use this listing status information
to determine whether eBay has finished processing the listing. -
finalValueFee
You are charged a Final Value Fee (FVF) if your item is sold, ends with a
property
winning bid, or is purchased. This fee applies whether or not you actually
complete the sale with the buyer. The Final Value Fee is returned in
Transaction.FinalValueFee. See the eBay.com Web site online help for more
information about the final value fee.
The Final Value Fee for fixed price format (FixedPriceItem) and Store Inventory
(StoresFixedPrice) items is returned by GetSellerTransactions,
GetItemTransactions, and GetOrderTransactions in a Transaction container, regardless of the listing status. For all other listing types, (excluding
Buy It Now purchases), the Final Value Fee is returned when the listing status
is Completed.
If you request a Final Value Fee Credit, the value of Transaction.FinalValueFee
will not change for the item if a credit is issued. (The credit only appears in
the seller’s account data.) -
promotionalSaleDetails
If a seller has reduced the price of a listed item with the Promotional Price Display feature,
property
this field contains the original price of the discounted item, along with the start-time
and end-time of the discount. -
adminEnded
If included in the response as true, indicates that the listing was administratively
property
canceled due to a violation of eBay’s listing policies and that the item can be relisted
using RelistItem. Note that GetItem returns an error (invalid item ID)
in the response if Item.SellingStatus.AdminEnded is true and the requesting user
is not the seller of the item. -
soldAsBin
If this flag appears in the <b>GetItem</b> response, the auction has ended due to the
item being sold to a seller using the Buy It Now option.
property
This flag is not relevant for fixed-priced listings. -
any
(public property)
property
Properties
adminEnded
If included in the response as true, indicates that the listing was administratively
canceled due to a violation of eBay’s listing policies and that the item can be relisted
using RelistItem. Note that GetItem returns an error (invalid item ID)
in the response if Item.SellingStatus.AdminEnded is true and the requesting user
is not the seller of the item.
@property (nonatomic, retain) NSNumber *adminEnded
Discussion
If included in the response as true, indicates that the listing was administratively
canceled due to a violation of eBay’s listing policies and that the item can be relisted
using RelistItem. Note that GetItem returns an error (invalid item ID)
in the response if Item.SellingStatus.AdminEnded is true and the requesting user
is not the seller of the item.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_SellingStatusType.h
any
(public property)
@property (nonatomic, retain) NSMutableArray *any
Discussion
(public property)
entry type : PicoAnyElement, wrapper for primitive anyelement
Declared In
Trading_SellingStatusType.h
bidCount
Number of bids placed so far against the item. Only applicable to
competitive-bid item listings (Chinese auctions).
@property (nonatomic, retain) NSNumber *bidCount
Discussion
Number of bids placed so far against the item. Only applicable to
competitive-bid item listings (Chinese auctions).
type : NSNumber, wrapper for primitive int
Declared In
Trading_SellingStatusType.h
bidIncrement
The minimum amount a progressive bid must be above the current high bid to be accepted. This field is only
applicable to auction listings. The value of this field will always be ‘0.00’ for Classified Ad and fixed-price
listings.
@property (nonatomic, retain) Trading_AmountType *bidIncrement
Discussion
The minimum amount a progressive bid must be above the current high bid to be accepted. This field is only
applicable to auction listings. The value of this field will always be ‘0.00’ for Classified Ad and fixed-price
listings.
type : class Trading_AmountType
Declared In
Trading_SellingStatusType.h
bidderCount
Number of bidders for an item. Only applicable to competitive-bid item listings
(Chinese auctions). Only returned for the seller of the item.
@property (nonatomic, retain) NSNumber *bidderCount
Discussion
Number of bidders for an item. Only applicable to competitive-bid item listings
(Chinese auctions). Only returned for the seller of the item.
type : NSNumber, wrapper for primitive long
Declared In
Trading_SellingStatusType.h
convertedCurrentPrice
Converted value of the CurrentPrice in the currency of the site that
returned this response. For active items, refresh the listing’s data every 24
hours to pick up the current conversion rates. Only returned when the item's
CurrentPrice on the listing site is in different currency than the currency of
the host site for the user/application making the API call. ConvertedCurrentPrice
is not returned for Classified listings (Classified listings are not available
on all sites).
In multi-variation listings, this value matches the lowest-priced
variation that is still available for sale.
@property (nonatomic, retain) Trading_AmountType *convertedCurrentPrice
Discussion
Converted value of the CurrentPrice in the currency of the site that
returned this response. For active items, refresh the listing’s data every 24
hours to pick up the current conversion rates. Only returned when the item's
CurrentPrice on the listing site is in different currency than the currency of
the host site for the user/application making the API call. ConvertedCurrentPrice
is not returned for Classified listings (Classified listings are not available
on all sites).
In multi-variation listings, this value matches the lowest-priced
variation that is still available for sale.
type : class Trading_AmountType
Declared In
Trading_SellingStatusType.h
currentPrice
For auction listings, this price is the starting price or the current highest
bid for the item if bids have been placed.
For fixed-price listings, this price is the sale price of the item.
In multi-variation, fixed-price listings, this value matches the lowest-priced
variation that is still available for sale.
@property (nonatomic, retain) Trading_AmountType *currentPrice
Discussion
For auction listings, this price is the starting price or the current highest
bid for the item if bids have been placed.
For fixed-price listings, this price is the sale price of the item.
In multi-variation, fixed-price listings, this value matches the lowest-priced
variation that is still available for sale.
type : class Trading_AmountType
Declared In
Trading_SellingStatusType.h
finalValueFee
You are charged a Final Value Fee (FVF) if your item is sold, ends with a
winning bid, or is purchased. This fee applies whether or not you actually
complete the sale with the buyer. The Final Value Fee is returned in
Transaction.FinalValueFee. See the eBay.com Web site online help for more
information about the final value fee.
The Final Value Fee for fixed price format (FixedPriceItem) and Store Inventory
(StoresFixedPrice) items is returned by GetSellerTransactions,
GetItemTransactions, and GetOrderTransactions in a Transaction container, regardless of the listing status. For all other listing types, (excluding
Buy It Now purchases), the Final Value Fee is returned when the listing status
is Completed.
If you request a Final Value Fee Credit, the value of Transaction.FinalValueFee
will not change for the item if a credit is issued. (The credit only appears in
the seller’s account data.)
@property (nonatomic, retain) Trading_AmountType *finalValueFee
Discussion
You are charged a Final Value Fee (FVF) if your item is sold, ends with a
winning bid, or is purchased. This fee applies whether or not you actually
complete the sale with the buyer. The Final Value Fee is returned in
Transaction.FinalValueFee. See the eBay.com Web site online help for more
information about the final value fee.
The Final Value Fee for fixed price format (FixedPriceItem) and Store Inventory
(StoresFixedPrice) items is returned by GetSellerTransactions,
GetItemTransactions, and GetOrderTransactions in a Transaction container, regardless of the listing status. For all other listing types, (excluding
Buy It Now purchases), the Final Value Fee is returned when the listing status
is Completed.
If you request a Final Value Fee Credit, the value of Transaction.FinalValueFee
will not change for the item if a credit is issued. (The credit only appears in
the seller’s account data.)
type : class Trading_AmountType
Declared In
Trading_SellingStatusType.h
highBidder
For ended Chinese auction listings that have a winning bidder,
this field is a container for the high bidder’s user ID.
For ended, single-item, basic fixed price (FixedPriceItem) and
ended Store Inventory (StoresFixedPrice) listings,
this field is a container for the user ID of the purchaser.
This field isn’t returned for auctions with no bids, or for active fixed price listings,
or for active Store Inventory listings.
In the case of PlaceOffer, for chinese auctions,
this field is a container for the high bidder’s user ID.
In the PlaceOffer response, the following applies:
For multiple-quantity, fixed-price listings,
the high bidder is only returned if there is just one order line item
(or only for the first order line item that is created).
@property (nonatomic, retain) Trading_UserType *highBidder
Discussion
For ended Chinese auction listings that have a winning bidder,
this field is a container for the high bidder’s user ID.
For ended, single-item, basic fixed price (FixedPriceItem) and
ended Store Inventory (StoresFixedPrice) listings,
this field is a container for the user ID of the purchaser.
This field isn’t returned for auctions with no bids, or for active fixed price listings,
or for active Store Inventory listings.
In the case of PlaceOffer, for chinese auctions,
this field is a container for the high bidder’s user ID.
In the PlaceOffer response, the following applies:
For multiple-quantity, fixed-price listings,
the high bidder is only returned if there is just one order line item
(or only for the first order line item that is created).
type : class Trading_UserType
Declared In
Trading_SellingStatusType.h
leadCount
Applicable to Ad type listings only. Indicates how many leads to
potential buyers are associated with this item. Returns 0 (zero) for listings in other formats. You must be the seller of the item to retrieve the lead count.
@property (nonatomic, retain) NSNumber *leadCount
Discussion
Applicable to Ad type listings only. Indicates how many leads to
potential buyers are associated with this item. Returns 0 (zero) for listings in other formats. You must be the seller of the item to retrieve the lead count.
type : NSNumber, wrapper for primitive int
Declared In
Trading_SellingStatusType.h
listingStatus
Specifies an active or ended listing’s status in eBay’s processing workflow.
If a listing ends with a sale (or sales), eBay needs to update the sale details
(e.g., total price and buyer/high bidder) and the final value fee. This processing
can take several minutes. If you retrieve a sold item and no details about the buyer/high bidder
are returned or no final value fee is available, use this listing status information
to determine whether eBay has finished processing the listing.
@property (nonatomic, retain) NSString *listingStatus
Discussion
Specifies an active or ended listing’s status in eBay’s processing workflow.
If a listing ends with a sale (or sales), eBay needs to update the sale details
(e.g., total price and buyer/high bidder) and the final value fee. This processing
can take several minutes. If you retrieve a sold item and no details about the buyer/high bidder
are returned or no final value fee is available, use this listing status information
to determine whether eBay has finished processing the listing.
type: string constant in Trading_ListingStatusCodeType.h
Declared In
Trading_SellingStatusType.h
minimumToBid
Smallest amount the next bid on the item can be. Returns same value as
Item.StartPrice (if no bids have yet been placed) or CurrentPrice plus
BidIncrement (if at least one bid has been placed). Only applicable to
competitive-bid item listings (Chinese auctions). Returns null for basic
Fixed Price (FixedPriceItem), Store Inventory (StoresFixedPrice),
and Ad type listings.
In multi-variation listings, this value matches the lowest-priced
variation that is still available for sale.
Note:
As of version 619, Dutch-style (multi-item) competitive-bid auctions are deprecated.
eBay throws an error if you submit a Dutch item listing with AddItem
or VerifyAddItem. If you use RelistItem to update a Dutch auction listing,
eBay generates a warning and resets the Quantity value to 1.
@property (nonatomic, retain) Trading_AmountType *minimumToBid
Discussion
Smallest amount the next bid on the item can be. Returns same value as
Item.StartPrice (if no bids have yet been placed) or CurrentPrice plus
BidIncrement (if at least one bid has been placed). Only applicable to
competitive-bid item listings (Chinese auctions). Returns null for basic
Fixed Price (FixedPriceItem), Store Inventory (StoresFixedPrice),
and Ad type listings.
In multi-variation listings, this value matches the lowest-priced
variation that is still available for sale.
Note:
As of version 619, Dutch-style (multi-item) competitive-bid auctions are deprecated.
eBay throws an error if you submit a Dutch item listing with AddItem
or VerifyAddItem. If you use RelistItem to update a Dutch auction listing,
eBay generates a warning and resets the Quantity value to 1.
type : class Trading_AmountType
Declared In
Trading_SellingStatusType.h
promotionalSaleDetails
If a seller has reduced the price of a listed item with the Promotional Price Display feature,
this field contains the original price of the discounted item, along with the start-time
and end-time of the discount.
@property (nonatomic, retain) Trading_PromotionalSaleDetailsType *promotionalSaleDetails
Discussion
If a seller has reduced the price of a listed item with the Promotional Price Display feature,
this field contains the original price of the discounted item, along with the start-time
and end-time of the discount.
type : class Trading_PromotionalSaleDetailsType
Declared In
Trading_SellingStatusType.h
quantitySold
The total number of items purchased so far (in the listing’s lifetime).
Subtract this from Quantity to determine the quantity available.
If the listing has Item Variations,
then in GetItem (and related calls) and GetItemTransactions,
Item.SellingStatus.QuantitySold contains the sum of all quantities
sold across all variations in the listing, and Variation.SellingStatus.QuantitySold contains the number
of items sold for that variation.
In GetSellerTransactions,
Transaction.Item.SellingStatus.QuantitySold contains the number
of items sold in that order line item.
For order line item calls, also see Transaction.QuantityPurchased for
the number of items purchased in the order line item.
In multi-variation listings, this value matches total quantity sold
across all variations.
@property (nonatomic, retain) NSNumber *quantitySold
Discussion
The total number of items purchased so far (in the listing’s lifetime).
Subtract this from Quantity to determine the quantity available.
If the listing has Item Variations,
then in GetItem (and related calls) and GetItemTransactions,
Item.SellingStatus.QuantitySold contains the sum of all quantities
sold across all variations in the listing, and Variation.SellingStatus.QuantitySold contains the number
of items sold for that variation.
In GetSellerTransactions,
Transaction.Item.SellingStatus.QuantitySold contains the number
of items sold in that order line item.
For order line item calls, also see Transaction.QuantityPurchased for
the number of items purchased in the order line item.
In multi-variation listings, this value matches total quantity sold
across all variations.
type : NSNumber, wrapper for primitive int
Declared In
Trading_SellingStatusType.h
reserveMet
Indicates whether the reserve price has been met for the listing. Returns
true if the reserve price was met or no reserve price was specified.
@property (nonatomic, retain) NSNumber *reserveMet
Discussion
Indicates whether the reserve price has been met for the listing. Returns
true if the reserve price was met or no reserve price was specified.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_SellingStatusType.h
secondChanceEligible
Part of the Second Chance Offer feature, indicates whether the seller can
extend a second chance offer for the item.
@property (nonatomic, retain) NSNumber *secondChanceEligible
Discussion
Part of the Second Chance Offer feature, indicates whether the seller can
extend a second chance offer for the item.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_SellingStatusType.h
soldAsBin
If this flag appears in the <b>GetItem</b> response, the auction has ended due to the
item being sold to a seller using the Buy It Now option.
This flag is not relevant for fixed-priced listings.
@property (nonatomic, retain) NSNumber *soldAsBin
Discussion
If this flag appears in the <b>GetItem</b> response, the auction has ended due to the
item being sold to a seller using the Buy It Now option.
This flag is not relevant for fixed-priced listings.
type : NSNumber, wrapper for primitive bool
Declared In
Trading_SellingStatusType.h


August 24–26th — Chicago, IL
The conference is held at The Chicago Theatre, a beautiful historical landmark. The conference hotel, Four Seasons, is a short walk away down State Street.
175 N State St
Chicago, IL 60601
(312) 462-6300
120 E Delaware PI
Chicago, IL 60611
(312) 280-8800


When are the College Football Playoff semifinals 2019? Date, schedule, location for Peach, Fiesta bowls
by Eli BoettgerThe College Football Playoff semifinals are officially in place for the 2019 season.
This year will mark the sixth season of the Playoff: Alabama and Clemson have won the championship twice since the CFP's birth in 2015 while Ohio State won the first Playoff title.
MORE: College football bowl tracker
The Fiesta Bowl and Peach Bowl will be the sites of this year's semifinal games with the College Football Playoff championship being played in New Orleans at the Mercedes-Benz Superdome on Monday, Jan. 13.
The Playoff will be made up of four conference champions: LSU (SEC), Ohio State (Big Ten), Clemson (ACC) and Oklahoma (Big 12). In addition to the two semifinals, the Cotton Bowl, Orange Bowl, Rose Bowl and Sugar Bowl will make up the New Year's Six bowl games.
Below is all the information you need to watch and tune in to this year's College Football Playoff semifinals.
When are the College Football Playoff semifinals?
- Date: Saturday, Dec. 28
- Peach Bowl: 4 p.m. ET | 1 p.m. PT
- Fiesta Bowl: 8 p.m. ET | 5 p.m. PT
The College Football Playoff semifinals are played on Saturday, Dec. 28, the final weekend of 2019. The Peach Bowl between LSU and Oklahoma is scheduled for 4 p.m. ET followed by the Fiesta Bowl between Ohio State and Clemson at 8 p.m. ET. ESPN on ABC will broadcast both games nationally.
CFP schedule 2019
| Date | Bowl | Time (channel) |
| Dec. 28 | Chick-fil-A Peach Bowl | 4 p.m. ET (ABC) |
| Dec. 28 | PlayStation Fiesta Bowl | 8 p.m. ET (ABC) |
| Jan. 13 | College Football Playoff championship | 8 p.m. ET (ABC) |
Who plays in the Peach Bowl 2019?
The 2019 Peach Bowl will feature No. 1 LSU vs. No. 4 Oklahoma. The Tigers (13-0) and Sooners (12-1) won the SEC and Big 12 championships, respectively. LSU and Oklahoma are both led by a pair of transfer quarterbacks. Heisman favorite and Ohio State transfer Joe Burrow runs the Tigers offense, throwing for 4,715 yards and 48 touchdowns this season. The opposing quarterback is Alabama transfer Jalen Hurts, who has tallied 3,634 passing yards and 32 passing touchdowns.
Who plays in the Fiesta Bowl 2019?
No. 2 Ohio State and No. 3 Clemson will battle in the 2019 Fiesta Bowl. Like LSU and Oklahoma, Ohio State (13-0) and Clemson (13-0) are also conference champions this season, capturing the Big Ten and ACC titles, respectively. The Buckeyes have a formidable offensive duo in Justin Fields (40 passing touchdowns) and running back J.K. Dobbins (20 rushing touchdowns). Clemson, meanwhile, is the reigning national champion and hasn't lost a game since Jan. 1, 2018.
Where is the Peach Bowl played?
The 2019 Peach Bowl between LSU and Oklahoma will be played Saturday, Dec. 28 in Atlanta at the Mercedes-Benz Stadium.
Where is the Fiesta Bowl played?
The 2019 Fiesta Bowl between Ohio State and Clemson will be played Saturday, Dec. 28 in Glendale, Ariz., at the State Farm Stadium.


rotten > Library > Crime > Murder
Murdered
- Joy Adamson, author of Born Free, shot and killed January 3, 1980 by a former employee. Her husband, George Adamson, was shot and killed by poachers on August 20, 1989.
- Archimedes
- Thomas Becket
- Black Dahlia Murder
- Ennis Cosby, son of comedian Bill Cosby
- Bob Crane, actor, Hogan's Heroes
- Jeffrey Dahmer, murdered in prison
- Jill Dando, British TV newscaster, shot by Barry George, April 26 1999.
- Dominique Dunne, actress, murdered by ex-boyfriend John Sweeney.
- Abigail Folger, coffee fortune heiress, by Charles Manson groupies.
- Marvin Gaye, singer, murdered by his father
- Phil Hartman, comedian, murder/suicide by his wife
- Jimmy Hoffa, Teamster President, disappeared by the Mafia.
- Jam Master Jay (Jason Mizell of Run DMC)
- Polly Klaas, child, murder fomented California's three strikes law
- Beatle John Lennon
- Lindbergh Baby
- Malcolm X, assassinated
- Christopher Marlowe, playwright, murdered in London in 1593
- Sal Mineo, actor, Rebel Without a Cause
- Artie Mitchell, porn king, murdered by the other Mitchell brother, Jim.
 Maher later escaped prison but was recaptured.
- Selena, the popular Tejano singer, murdered by the president of the Selena Fan Club, Yolanda Saldivar. "It just went off, I didn't mean to do it. I didn't mean to kill anybody."
- Rebecca Schaffer, television star (My Sister Sam), shot by her stalker
- Dutch Schultz, gangster killing
- Tupac Shakur, rapper killed in driveby
- Matthew Shepard, killed in notorious gay hate crime incident
- Nicole Simpson, ex-wife of O.J. Simpson
- Nancy Spungen, murdered by the Sex Pistols' Sid Vicious
- Sharon Tate, by Charles Manson groupies
- Officer J. D. Tippit, killed by Lee Harvey Oswald.
- Peter Tosh, reggae musician, murdered by three "robbers" who actually did not steal anything. Whether or not this is the actual motive is a matter of speculation.
 Accident, or murder?
Murderers and the like
Pornopolis |
Rotten |
Faces of Death |
Famous Nudes
|


Get
insights
that help your business grow.
Discover the benefits of data analytics and make better decisions regarding revenue, customer experience, and overall efficiency.
10k+
COMPANIES
314
TEMPLATES
12m+
QUERIES


#include "Halide.h"
#include <stdio.h>
int main(int argc, char **argv) {
gradient(x, y) = e;
for (int j = 0; j < output.height(); j++) {
for (int i = 0; i < output.width(); i++) {
if (output(i, j) != i + j) {
printf("Something went wrong!\n"
"Pixel %d, %d was supposed to be %d, but instead it's %d\n",
i, j, i + j, output(i, j));
return -1;
}
}
}
printf("Success!\n");
return 0;
}
A Halide::Buffer is a named shared reference to a Halide::Runtime::Buffer.
Realization realize(std::vector< int32_t > sizes={}, const Target &target=Target(), const ParamMap ¶m_map=ParamMap::empty_map())
Evaluate this function over some rectangular domain and return the resulting buffer or buffers.
A Halide variable, to be used when defining functions.
A fragment of Halide syntax.


Please provide your contact information.
Enter your residential address - that's the address you currently live at in B.C.


|
| static | remove ($instance) |
| | Deletes the object $instance from the database. More...
|
| |
| static | deleteAll ($modelName, $where) |
| | Deletes all instances from $modelName matching the condition $where. More...
|
| |
| static | delete ($modelName, $ids) |
| | Deletes all instances from $modelName corresponding to $ids. More...
|
| |
| static | insert ($instance, $insertMany=false) |
| | Inserts a new instance $instance into the database. More...
|
| |
| static | insertOrUpdateAllManyToMany ($instance) |
| | Met à jour les membres de $instance annotés par un ManyToMany. More...
|
| |
| static | insertOrUpdateManyToMany ($instance, $member) |
| | Updates the $member member of $instance annotated by a ManyToMany. More...
|
| |
| static | update ($instance, $updateMany=false) |
| | Updates an existing $instance in the database. More...
|
| |
| static | save ($instance, $updateMany=false) |
| |
|
| static | removeByKey_ ($className, $tableName, $keyAndValues) |
| |
| static | remove_ ($className, $tableName, $where) |
| |
Definition at line 23 of file DAOUpdatesTrait.php.
◆ delete()
| static delete |
( |
|
$modelName, |
|
|
|
$ids |
|
) |
| |
|
static |
Deletes all instances from $modelName corresponding to $ids.
- Parameters
-
| string | $modelName | |
| array | int | $ids | |
- Returns
- int|boolean
Definition at line 99 of file DAOUpdatesTrait.php.
◆ deleteAll()
| static deleteAll |
( |
|
$modelName, |
|
|
|
$where |
|
) |
| |
|
static |
Deletes all instances from $modelName matching the condition $where.
- Parameters
-
| string | $modelName | |
| string | $where | |
- Returns
- int|boolean
Definition at line 87 of file DAOUpdatesTrait.php.
◆ insert()
| static insert |
( |
|
$instance, |
|
|
|
$insertMany = false |
|
) |
| |
|
static |
Inserts a new instance $instance into the database.
- Parameters
-
| object | $instance | the instance to insert |
| boolean | $insertMany | if true, save instances related to $instance by a ManyToMany association |
Definition at line 115 of file DAOUpdatesTrait.php.
◆ insertOrUpdateAllManyToMany()
| static insertOrUpdateAllManyToMany |
( |
|
$instance | ) |
|
|
static |
Met à jour les membres de $instance annotés par un ManyToMany.
- Parameters
-
Definition at line 156 of file DAOUpdatesTrait.php.
◆ insertOrUpdateManyToMany()
| static insertOrUpdateManyToMany |
( |
|
$instance, |
|
|
|
$member |
|
) |
| |
|
static |
Updates the $member member of $instance annotated by a ManyToMany.
- Parameters
-
| Object | $instance | |
| String | $member | |
Definition at line 172 of file DAOUpdatesTrait.php.
◆ remove()
| static remove |
( |
|
$instance | ) |
|
|
static |
Deletes the object $instance from the database.
- Parameters
-
| object | $instance | instance à supprimer |
Definition at line 30 of file DAOUpdatesTrait.php.
◆ remove_()
| static remove_ |
( |
|
$className, |
|
|
|
$tableName, |
|
|
|
$where |
|
) |
| |
|
staticprivate |
- Parameters
-
| string | $className | |
| string | $tableName | |
| string | $where | |
- Returns
- boolean|int the number of rows that were modified or deleted by the SQL statement you issued
Definition at line 66 of file DAOUpdatesTrait.php.
◆ removeByKey_()
| static removeByKey_ |
( |
|
$className, |
|
|
|
$tableName, |
|
|
|
$keyAndValues |
|
) |
| |
|
staticprivate |
- Parameters
-
| string | $className | |
| string | $tableName | |
| array | $keyAndValues | |
- Returns
- int the number of rows that were modified or deleted by the SQL statement you issued
Definition at line 44 of file DAOUpdatesTrait.php.
◆ save()
| static save |
( |
|
$instance, |
|
|
|
$updateMany = false |
|
) |
| |
|
static |
- Parameters
-
| object | $instance | |
| boolean | $updateMany | |
- Returns
- boolean|int
Definition at line 245 of file DAOUpdatesTrait.php.
◆ update()
| static update |
( |
|
$instance, |
|
|
|
$updateMany = false |
|
) |
| |
|
static |
Updates an existing $instance in the database.
Be careful not to modify the primary key
- Parameters
-
| object | $instance | instance to modify |
| boolean | $updateMany | Adds or updates ManyToMany members |
Definition at line 213 of file DAOUpdatesTrait.php.
The documentation for this class was generated from the following file:


GameStop Black Friday 2019 ad posted: Tons of Switch, PS4, and Xbox One deals
by Jacob SiegalWe’re nearing the end of the current console generation, but if you’re not already saving up for the PlayStation 5 or the Xbox Scarlett, now might be the best time to pick up a game console. Several of the best deals we’ve seen so far on Black Friday come courtesy of GameStop, and if you have old games or hardware to trade in, you can lower these some of these prices even further. At the very least, take a peek at GameStop’s Black Friday ad.
According to the ad, GameStop stores open at 3 PM local time on Thursday, November 28th, but you can get a head start by heading over to GameStop.com beginning at 9 PM ET on Wednesday, November 27th.
Consoles
- Nintendo Switch Mario Kart 8 Bundle + $25 Gift Coupon: $299.99
- PlayStation 4 1TB Bundle w/ Three PS4 Exclusive Games: $199.99 (save $100)
- PlayStation 4 Pro Console (Glacier White) + $25 Gift Coupon: $299.99 (save $100)
- Xbox One S 1TB Star Wars: Jedi Fallen Order Bundle: $199.99 (save $100)
- Certified Refurbished or Pre-Owned 500GB Xbox One: $99 (save $50)
Games
- Gears 5: $29.99 (save $30)
- Red Dead Redemption II: $29.99 (save $30)
- Borderlands 3: $29.99 (save $30)
- Call of Duty: Modern Warfare: $37.99 (save $22)
- Ghost Recon Breakpoint: $27.99 (save $32)
- NBA 2K20: $27.99 (save $32)
- Madden NFL 20: $27.99 (save $32)
- FIFA 20: $27.99 (save $32)
- Sekiro: Shadows Die Twice: $27.99 (save $32)
- Code Vein: $39.99 (save $20)
VR Headsets
- HTC Vive Pro VR Starter Kit w/ 2 Base Stations & 2 VIVE Controllers: $799.99 (save $300)
- HTC Vive Pro VR Headset: $599.99 (save $200)
- HTC Vive Cosmos VR System: $599.99 (save $100)
- PlayStation VR Blood & Truth and Everybody’s Golf VR Bundle: $249.99 (save $100)
- PlayStation VR 5-Game Bundle: $199.99 (save $100)
Accessories
- PlayStation 4 DualShock 4 Wireless Controllers: $38.99 (save up to $26)
- PlayStation Plus 12-Month Subscription: $44.99 (save $15)
- Xbox One Wireless Controllers: $49.99/$59.99 (save $10)
- Xbox Live Gold 3-Month Membership: $14.99 (save $10)
- PowerA Xbox One Wireless Controller Charging Station: $14.99 (save $10)
These are the best deals that we could find in the 17-page ad, but there is plenty that we didn’t get to, including toys and board games and chairs and keyboards. Check out the full ad on GameStop’s website.


"Poke" all the green squares. Don't collide with any squares, a hit will make you grow (harder to navigate in tight spots).


Event Location:
Galvanize
515 E Grant St
Phoenix, Arizona
Abstract:
In this presentation, we’ll review “What is ‘the Cloud’” and then describe the different methods you can use to migrate your on-premise SQLServer databases into this new environment. We’ll cover migrations to both infrastructure and database as a service. We’ll describe in detail how the use of a database replication tool can help you migrate your databases to the cloud with almost no downtime, and reduce the risk of data loss. We’ll also show you how you can use replication after migration to keep on-premise and cloud databases synchronized, which can help you migrate to the cloud in phases, rather than all at once.
Speaker(s): Clay Jackson,
Abstract:
Using the latest version of SQL Server 2017 , we will control a Drone using NodeJS and with the help of Azure SQL DB , IoT Hub and Azure Bots we will create a continuous integration pipeline . Join me in a presentation on how to create your Azure environment for server less Architecture the first ever drone controlled by SQL Server. - creating a template to make Proof of Concepts possible - real world situations and lessons learned in Azure situations - consumption of that data through Power BI. This presentation will include using Azure SQL DB to call commands to the drone through Raspberry Pi 3, then we will use serverless architecture to connect a cortana channel to make those calls to azure bots which write to the azure sql db, producing seemless intergration with out any on-prem solution. Continuous development is done through github and Heroku to provide on demand fixes w the drone is still flying. The future of fast and the furious IoT development coupled wi
Speaker(s): Joseph Barth,
Abstract:
When you have to do something more than once, you should script it! That’s true for SQL Server maintenance tasks. It’s also important for Business Intelligence projects as well. Microsoft has provided web services to manage your reporting service and to download reports in various forms. In this session I demonstrate how to leverage these web services from PowerShell to handle common SSRS administrative tasks: uploading and copying a report; checking the parameter values, setting the parameter defaults, scheduling a cache refresh. I addition, I demonstrate how to download a report top PDF using PowerShell. You will not only come away with a set of PowerShell scripts to manage your SSRS server, you will learn how to work around some of the less intuitive features of PowerShell to use and extend these scripts.
Speaker(s): Russel Loski,
Abstract:
Data is exploding across enterprises. Much of it is semi-structured junk. Or is it junk? What are you going to do with it until you can find out? Microsoft’s Azure Data Lake is a cloud storage and analytical service for parking a variety of data. When you are ready, you can query that semi-structured data using an ANSI SQL language called U-SQL. In this session I will demonstrate the similarities and differences between U-SQL and T-SQL. I will demonstrate how easy it is to build a query against 21 GB of CSV files. Such queries can help you determine whether you have a gold mine in your data or a bunch of garbage before investing in a full data warehouse build.
Speaker(s): Russel Loski,
Abstract:
Looking to find out what is coming next with SQL Server? Thinking about learning a new analytical language to keep up with market demand? You will want to attend this session. SQL Server 2016 added R to the analytical toolset and SQL Server 2017 is adding Python. When looking at various lists of the most popular programming languages, Python always has one of the top positions. This session provides an introduction to Python, including why it is a good choice for analyzing data. If you have not had a chance to review SQL Server 2017 yet, please attend to see some of the new changes coming later this year. One of the features covers will show what is needed to incorporate Python into SQL Server and how Python can be incorporated in stored procedures to provide the ability to analyze data using arguably the most popular programming language to review data.
Speaker(s): Ginger Grant,
Abstract:
ETL (Extract, Transform Load) processes are fundamentally important in any data warehouse environment, and there are many different ways in which to develop the components. In this session I will share the 10 basic principles I follow when developing ETL processes, and also show how the different choices can affect performance. Following these simple guidelines have resulted in many successful projects and happy customers. I'm sure it will work for you too!!
Speaker(s): Martin Schoombee,
Abstract:
This session with cover the basics of setup, architecture, configuration, and a brief demo of a SQL Server Polybase instance utilizing an Azure Blob Storage service for a data repository.
Speaker(s): Nathan Strack,
Abstract:
This session will explore every aspect of Power BI…from the technology used behind the scenes and the tenant/service in Azure, to data refresh options and development best practices. We’ll cover everything you need to know (and more) before you embark on your first Power BI project.
Speaker(s): Martin Schoombee,
Abstract:
You probably have been part of this scenario before...the business needs to answer question Z, without knowing ABC... We will walk you through the steps we follow to efficiently reach the desired outcome. Steps: 1. Identify sources of data 2. Data profiling 3. Data cleansing / Business rules 4. Data visualizations (Tableau) 5. Rinse and repeat P.S - Oh i forgot to say that the business wanted it yesterday. By the end of the session we will outline a frame work that you can adapt to your use case. All are welcomed to attend the session. Ann is a world class data viz creator with many years of experience and I love to share data solutions. We both are open to answering questions related to this topic.
Speaker(s): Ricardo Mawcinitt,
Abstract:
Explore data modeling and process modeling. Enterprise Data Model Conceptual Data Model Logical Data Model Physical Data Model Star Schema Data Model Business Process Model Modeling Tools: IDERA ER/Studio Data Architect ERWin Visual Studio Visio
Speaker(s): Ryan Casey,
Abstract:
Docker has gained a great deal of traction over the past five years, and as of recently, it managed to find a new home in the Microsoft and SQL Server communities. In this session, we will cover the basics of Docker in regard to hosting SQL Server. We will also cover the benefits of Docker in concern to managing your Business Intelligence workloads.
Speaker(s): Chris Myers,
Abstract:
Learn Python and also some of the libraries that make it awesome for Data Science! In this talk we will briefly discuss the Python language and get you started using Python. We will also touch on useful tools, best practices, and libraries specifically for aspiring data scientists.
Speaker(s): Chris Huie,
Abstract:
Since Microsoft incorporated the R language into SQL Server 2016, there has been a lot of interest in learning not only R, but how incorporating R into SQL Server can provide a greater level of analysis through the use of the complex analytical methods R provides. This session will show how to run R on SQL Server 2016, learn about the internals for how R runs within SQL Server, and cover in depth the settings which should be set to optimally run R on SQL Server. This session will also show some R code to handle some tasks which DBAs now use other tools to complete.
Speaker(s): Ginger Grant,
This is a list of speakers from the XML Guidebook records. The details and URLs were valid at the time of the event.
LinkedIn: https://www.linkedin.com/in/ryancaseymba/
Contact: https://www.AimYourData.com/
Microsoft Data Platform MVP, Public Speaker, and Group Moderator SQL Saturday Speaker @ • Houston, TX 2018 • Dallas, TX 2018, 2017 (BI), 2016, 2015 • Phoenix, AZ 2018, 2017 (BI) • Kansas City, MO 2017 • Baton Rouge, LA 2017 • Oklahoma City, OK 2016 • San Antonio, TX 2016 SQL User Group Speaker @ • NTSSUG, Dallas, TX • CACTUSS, Austin, TX • OKCSQL, Oklahoma City, OK • MSBIC, Dallas, TX • SALSSA, San Antonio, TX • FWSSUG, Fort Worth, TX AIM Business Driven Data Solutions combines the collaborative and creative arts included in Technical Communication, the business acumen of a Harvard MBA program, and the technical discipline of object-oriented programming and business intelligence (data warehouses).
LinkedIn: https://www.linkedin.com/in/ginger-grant-3a177b157/
Contact: http://www.DesertIsleSQL.com
Ginger Grant manages the consultancy Desert Isle Group and shares what she has learned while working with data technology to people around the world. As a Microsoft MVP in Data Platform, Microsoft Certified Trainer and an instructor on DataCamp, she focuses on guiding clients to create solutions using the entire Microsoft Data Stack, which includes SQL Server, Power BI, and Azure Data Cloud components. When not working, she protypes the latest pre-release data technologies, maintains her blog http://www.desertislesql.com, and spends time on twitter @desertislesql.
LinkedIn: https://www.linkedin.com/in/sqlda/
Contact: http://sqlda.com
An eight year Microsoft SQL Server Specialist in SQL Server 2005-2016, Azure SQL DB, he has held many development positions, including SQL query tuner, SSIS and SSRS . Joseph's early focus as an SQL tuning professional, fixing long running queries by techniques; join order,use of temporary object, also implementing Index optimization, maintenance and design to fix slowness. Joseph has focused on ETL solutions using SSIS for the last 4 years, data warehousing and cloud architecture using Azure. Currently working on a Modern Data Warehouse project involving Azure Data Lake and Azure SQL DW using external tables. MCSE Data Management and Analytics 2016 MCSA: SQL Server 2012 Co-found CASSUG Albany NY 2 yrs AZSSUG Chapter Leader 3 yrs
LinkedIn: http://www.linkedin.com/in/russloski
Contact: http://www.sqlmovers.com
Russ Loski is a SQL Server BI Developer based in Dallas-Fort Worth. He current works as a Data Analytics Engineer for Navisite, a remote managed IT services company. Twenty years ago, he began working with SQL Server 6.5. He has since continued to develop applications connected to all of the versions of SQL Server. He has worked with clients in industries from insurance to healthcare, from movie theaters to American football. Russ is a regular speaker at SQLSaturday events, as well as the SQL Server Users Groups in the North Texas region. Russ likes working with data in various shapes.
Clay Jackson is a Database Sales Engineer for Quest, specializing in Database Performance Management and Replication Tools. Prior to joining Quest, Jackson was the DBA Manager at Darigold. He also spent over 10 years managing Oracle, SQLServer and DB2 databases and DBAs at Washington Mutual and was employee number 66 at Microsoft, spending time in Product Support, MIS and OS/2 Development. While at WaMu, Jackson was the Enterprise Database Compliance Officer, with responsibility for Database Security and Disaster Recovery. He also worked at Microsoft and Starbucks, is a CISM, and has a Masters in Software Engineering from Seattle University.
LinkedIn: https://www.linkedin.com/in/gsxrsignup/
Contact: http://bloggedbychris.com
Chris started his software development career in the telecommunications industry in 2007 and moved to consulting in 2012 where he has had the opportunity to work with numerous industry verticals, such as Healthcare, Hospitality and Gaming, Finance / Banking, and Intelligent Transportation Solutions. Chris is a custom application developer that specializes in using the Microsoft technology stack to create solutions that run on-premise and in the cloud
LinkedIn: https://www.linkedin.com/in/chris-huie-896936b2/
I hang out at the intersection of coding, math, and nerd culture. He also tries to do cool stuff in the developer community.
LinkedIn: http://www.linkedin.com/in/martinschoombee
Contact: http://www.martinschoombee.com
Martin is an independent Business Intelligence Analytics consultant, helping customers make sense of their data for more than 15 years.
LinkedIn: https://www.linkedin.com/in/ginger-grant-3a177b157/
Contact: http://www.DesertIsleSQL.com
Ginger Grant manages the consultancy Desert Isle Group and shares what she has learned while working with data technology to people around the world. As a Microsoft MVP in Data Platform, Microsoft Certified Trainer and an instructor on DataCamp, she focuses on guiding clients to create solutions using the entire Microsoft Data Stack, which includes SQL Server, Power BI, and Azure Data Cloud components. When not working, she protypes the latest pre-release data technologies, maintains her blog http://www.desertislesql.com, and spends time on twitter @desertislesql.
LinkedIn: https://www.linkedin.com/in/ricardo-mawcinitt-a9b8b38/
Ricardo has over 10 years of technical experience ranging from data modeling and data warehouse design to building custom business intelligence solutions.
LinkedIn: http://www.linkedin.com/in/russloski
Contact: http://www.sqlmovers.com
Russ Loski is a SQL Server BI Developer based in Dallas-Fort Worth. He current works as a Data Analytics Engineer for Navisite, a remote managed IT services company. Twenty years ago, he began working with SQL Server 6.5. He has since continued to develop applications connected to all of the versions of SQL Server. He has worked with clients in industries from insurance to healthcare, from movie theaters to American football. Russ is a regular speaker at SQLSaturday events, as well as the SQL Server Users Groups in the North Texas region. Russ likes working with data in various shapes.
LinkedIn: http://www.linkedin.com/in/martinschoombee
Contact: http://www.martinschoombee.com
Martin is an independent Business Intelligence Analytics consultant, helping customers make sense of their data for more than 15 years.
LinkedIn: https://www.linkedin.com/in/nathan-strack/
With over a decade of technology experience Nathan has architected and delivered on a variety of projects across several technologies and industries. Managing programs as both a technical and program leader he has designed, developed, and led implementations for large scale application and data systems including many for global Fortune 500 companies. Specializing in Information Management Analytics he brings a unique perspective to enterprise data and how to execute successful strategies utilizing it.
The following is a list of sponsors that helped fund the event.


OK ngTodo Hacked apart - 14
Search:
AngularJS Directives
Data binding
$scope
Controllers and Modules
Templates and routes
Filters and Services
Get started with Node/ExpressJS
Setup MongoDB database
Be awesome!


auth-api
About
The server has two api versions:
Version 1 :
Consists of 2 routes, food and clothes with CRUD operations and Mongoose Database.
Version 2:
The server will allow users to sign up and sign in using basic authentication and bearer authentication, RBAC rules are applied on the users.The users have different CRUD permissions depends on their roles in the Mongoose Database.
Author
Amjad Mesmar
Links
Setup
- (.env) file:
PORT=5000
<EMAIL_ADDRESS><EMAIL_ADDRESS>SECRET=55555
- Install the following dependencies
"dependencies": {
"@code-fellows/supergoose": "^1.1.0",
"base-64": "^1.0.0",
"bcrypt": "^5.0.1",
"cors": "^2.8.5",
"dotenv": "^10.0.0",
"eslint": "^7.27.0",
"express": "^4.17.1",
"jsonwebtoken": "^8.5.1",
"mongoose": "^5.12.11",
"morgan": "^1.10.0",
"multer": "^1.4.2",
"supergoose": "^0.2.6"
},
"devDependencies": {
"jest": "^27.0.1",
"supertest": "^6.1.3"
}
Running the app
- clone the repo.
- Enter the command
npm start
- Use endpoints :
API V1
*/api/v1/food
- Method: get, post, put, delete
- Response Body: JSON
- calories should be a number only
- type should be only FRUIT,VEGETABLE or PROTIEN, it will also return all in uppercase.
{
"_id": "60aed7758b6ab734c5f2bcec",
"name": "apple",
"calories": 50,
"type": "FRUIT",
"__v": 0
}
*/api/v1/clothes
- Method: get, post, put, delete
- Response Body: JSON
- All keys are string
{
"_id": "60aed8698b6ab734c5f2bced",
"name": "T-shirt",
"color": "red",
"size": "xl",
"__v": 0
}
API V2
signup
*/signup
- Method: post
- Basic Authentication sign up and will give token
- *Role should be: admin, editor, writer or user, if not filled the difault will always be user
- Response Body: JSON
{
"user": {
"role": "admin",
"_id": "60aed8d48b6ab734c5f2bcee",
"username": "Ainz-Sama",
"password": "$2b$10$M1KGjJQLzXfb.oKqExkVR.cErQTv2oI2aVJHws2b1lk3zbNdMqmha",
"__v": 0
},
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6IkFpbnotU2FtYSIsImlhdCI6MTYyMjA3MTUwOX0.iSnqB9akQgdKJUD1HLEB55kb4iw2z3BaeLeAxVLrKm4"
}
Signin
*/signin
- Method: POST
- Basic Authentication Login
- *With user name and password
- Response Body: JSON
{
"user": {
"role": "admin",
"_id": "60aed8d48b6ab734c5f2bcee",
"username": "Ainz-Sama",
"password": "$2b$10$M1KGjJQLzXfb.oKqExkVR.cErQTv2oI2aVJHws2b1lk3zbNdMqmha",
"__v": 0
},
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6IkFpbnotU2FtYSIsImlhdCI6MTYyMjA3MTk0NX0.oV6CQFwUGonHZ_EZcYuSjk-hF65JVpC_6uE_Z3aMi-I"
}
secret
*/api/v2/secret
- Method: get
- Sign in using bearer authentication using token and secret
- Response Body: Text
Welcome to the secret area, Ainz-Sama !
Users
*/api/v2/users
- Method: get
- Will use the user's token with bearer authentication
- Will return all users in the database, this only works for admins since the user must have delete permission
- Response Body: Array
[
"ainz",
"emran",
"ainz-sama",
"melon",
"Ainz-Sama"
]
Read
*/api/v2/user
- Method: get
- Will use the user's token with bearer authentication
- Will return the user's from database, this works for all users since it's for read permission.
- Response Body: JSON
{
"user": {
"role": "admin",
"_id": "60aed8d48b6ab734c5f2bcee",
"username": "Ainz-Sama",
"password": "$2b$10$M1KGjJQLzXfb.oKqExkVR.cErQTv2oI2aVJHws2b1lk3zbNdMqmha",
"__v": 0
}
}
Create
*/api/v2/create
- Method: post
- Will use the user's token with bearer authentication
- Will return a text if user have permission to create.
- Response Body: TEXT
Hey Ainz-Sama, You can create something!!
Update
*/api/v2/update
- Method: put
- Will use the user's token with bearer authentication
- Will return a text if user have permission to update.
- Response Body: TEXT
Hey Ainz-Sama, You can update something!!
Patch
*/api/v2/patch
- Method: patch
- Will use the user's token with bearer authentication
- Will return a text if user have permission to update.
- Response Body: TEXT
Hey Ainz-Sama, You can patch something!!
Delete
*/api/v2/delete
- Method: delete
- Will use the user's token with bearer authentication
- Will return a text if user have permission to delete.
- Response Body: TEXT
Hey Ainz-Sama, You can delete something!!
What happens If user does not have a permission?
- Method: any except read ('*/api/v1/user') since its for all users.
- Will use the user's token with bearer authentication
- Response Body:JSON
{
"error": "Access Denied"
}
- Test:
- To test the server write in terminal:
npm test


Synthetic lines example.
See the synthetic-lines.js source to see how this is done.
Performance results:
| Device/Browser | 200 lines | 500 lines | 1000 lines | 2000 lines | 5000 lines | 10000 lines | 20000 lines |
|---|---|---|---|---|---|---|---|
| Mac Book Air / Chrome 33 canary | 60 fps | 60 fps | 60 fps | 60 fps | 60 fps | 60 fps | 60 fps |
| Mac Book Air / FireFox 25 | 60 fps | 60 fps | 60 fps | 60 fps | 60 fps | 22 fps | 6 fps |
| Mac Book Air / Safari 7 | 60 fps | 60 fps | 60 fps | 40 fps | 10 fps | N/A | N/A |
| iPhone 4S / iOS 7 / Safari | 60 fps | 33 fps | 15 fps | 5 fps | N/A | N/A | N/A |


A channel to discuss trading. For useful links and more info click the pinned messages to the right.
100 messages
Before 05-Dec-19 12:00 AM
LocoMB29-May-19 06:32 PM
don't sell those IOTA at $1 - they were at $5, and hopefully will go much higher
fekken Cardano and all those pompous windbags(edited)
Tek29-May-19 06:33 PM
is cardano mooning too?
is cardano worth having a bag of?
LocoMB29-May-19 06:34 PM
nope, but they don't even have a product out despite all their boistering and egg wind noises
Tek29-May-19 06:34 PM
yeah i don't invest in whitepapers
i wanna see mainnet first
LocoMB29-May-19 06:34 PM
hoskinson is a drama bicth, I wouldn't touch it with a ten footpole
Tek29-May-19 06:34 PM
then im staying a way
i never trusted cardano
LocoMB29-May-19 06:34 PM
better not- DO YOU EVEN KNOW WHO I AM drama psycho bitch Hoskinson
Tek29-May-19 06:35 PM
i have a hunch that BTC isn't going to be coming down much at all
LocoMB29-May-19 06:35 PM
when it won't go after his whims, he'll throw a temper tanturm and rage quit. and start another world computer with some obscure reference that is supposed to sound cool. and blame everybody else for the failure of the last, esp. that it didn't go as he said it should(edited)
cardano: cant manage to release a product, lead by a guy (hoskinson) who abandons all the projects he has worked on due to conflicts with other devs (he was on both Ethereum and Bitshares, and left both). And still worth over 2B?
Tron: developer sucks and is clueless, as demonstrated by various events like him being unable to fix things in his own project. shilled by tons of noobs, shilled by mcafee, etc.
JimD29-May-19 07:21 PM
When will Mcafee start shilling KMD ?
Tell the world we are going to 5000 a coin !!!
Alexfrog29-May-19 07:22 PM
plz no
2
1
actionslacks29-May-19 07:27 PM
kmd staying in the shadows is for the best right now. join any crypto trading fb group. the collective lack of any sense whatsoever is appalling.


vignettes/simulation.Rmd
simulation.Rmd
In epiffiter
, opposite to the fit_
functions (estimate parameters from fitting models to the data), the sim_
family of functions allows to produce the DPC data given a set of parameters for a specific model. Currently, the same four population dynamic models that are fitted to the data can be simulated.
The functions use the ode()
function of the devolve
package (Soetaert,Petzoldt & Setzer 2010) to solve the differential equation form of the e epidemiological models.
The sim_
functions, regardless of the model, require the same set of six arguments. By default, at least two arguments are required (the others have default values)
r
: apparent infection raten
: number of replicatesWhen n
is greater than one, replicated epidemics (e.g. replicated treatments) are produced and a level of noise (experimental error) should be set in the alpha
argument. These two arguments combined set will generate random_y
values, which will vary randomly across the defined number of replicates.
The other arguments are:
N
: epidemic duration in time unitsdt
: time (fixed) in units between two assessmentsy0
: initial inoculumalpha
: noise parameters for the replicatesLet’s simulate a curve resembling the exponential growth.
exp_model <- sim_exponential( N = 100, # total time units y0 = 0.01, # initial inoculum dt = 10, # interval between assessments in time units r = 0.045, # apparent infection rate alpha = 0.2,# level of noise n = 7 # number of replicates ) head(exp_model)
## replicates time y random_y
## 1 1 0 0.01000000 0.01000000
## 2 1 10 0.01568425 0.01594221
## 3 1 20 0.02459905 0.02477225
## 4 1 30 0.03858028 0.03559417
## 5 1 40 0.06050749 0.07083290
## 6 1 50 0.09489670 0.10802466
A data.frame
object is produced with four columns:
replicates
: the curve with the respective ID numbertime
: the assessment timey
: the simulated proportion of disease intensityrandom_y
: randomly simulated proportion disease intensity based on the noiseUse the ggplot2
package to build impressive graphics!
exp_plot = exp_model %>% ggplot(aes(time, y)) + geom_jitter(aes(time, random_y), size = 3,color = "gray", width = .1) + geom_line(size = 1) + theme_minimal_hgrid() + ylim(0,1)+ labs( title = "Exponential", y = "Disease intensity", x = "Time" ) exp_plot
## Warning: Removed 4 rows containing missing values (geom_point).
The logic is exactly the same here.
mono_model <- sim_monomolecular( N = 100, y0 = 0.01, dt = 5, r = 0.05, alpha = 0.2, n = 7 ) head(mono_model)
## replicates time y random_y
## 1 1 0 0.0100000 0.01181973
## 2 1 5 0.2289861 0.18321739
## 3 1 10 0.3995322 0.48066834
## 4 1 15 0.5323535 0.57142173
## 5 1 20 0.6357949 0.55775762
## 6 1 25 0.7163551 0.71959049
mono_plot = mono_model %>% ggplot(aes(time, y)) + geom_jitter(aes(time, random_y), size = 3, color = "gray", width = .1) + geom_line(size = 1) + theme_minimal_hgrid() + labs( title = "Monomolecular", y = "Disease intensity", x = "Time" ) mono_plot
logist_model <- sim_logistic( N = 100, y0 = 0.01, dt = 5, r = 0.1, alpha = 0.2, n = 7 ) head(logist_model)
## replicates time y random_y
## 1 1 0 0.01000000 0.01000000
## 2 1 5 0.01638216 0.01983962
## 3 1 10 0.02672677 0.02984366
## 4 1 15 0.04331509 0.02364864
## 5 1 20 0.06946352 0.06631386
## 6 1 25 0.10958806 0.11027489
logist_plot = logist_model %>% ggplot(aes(time, y)) + geom_jitter(aes(time, random_y), size = 3,color = "gray", width = .1) + geom_line(size = 1) + theme_minimal_hgrid() + labs( title = "Logistic", y = "Disease intensity", x = "Time" ) logist_plot
gomp_model <- sim_gompertz( N = 100, y0 = 0.01, dt = 5, r = 0.07, alpha = 0.2, n = 7 ) head(gomp_model)
## replicates time y random_y
## 1 1 0 0.01000000 0.01254931
## 2 1 5 0.03896283 0.03637617
## 3 1 10 0.10158896 0.10442916
## 4 1 15 0.19958740 0.22298368
## 5 1 20 0.32122825 0.31664090
## 6 1 25 0.44922018 0.37424327
gomp_plot = gomp_model %>% ggplot(aes(time, y)) + geom_jitter(aes(time, random_y), size = 3,color = "gray", width = .1) + geom_line(size = 1) + theme_minimal_hgrid() + labs( title = "Gompertz", y = "Disease intensity", x = "Time" ) gomp_plot
Use the function plot_grid()
from the cowplot
package to gather all plots into a grid
plot_grid(exp_plot, mono_plot, logist_plot, gomp_plot)
## Warning: Removed 4 rows containing missing values (geom_point).
Karline Soetaert, Thomas Petzoldt, R. Woodrow Setzer (2010). Solving Differential Equations in R: Package deSolve. Journal of Statistical Software, 33(9), 1–25. DOI: 10.18637/jss.v033.i09


 We donÂ´t like to spend more than 5 minutes cooking something while we could be doing something more important like chatting with your friends on freenode.
After spending more time than I wanted in the kitchen, I came with this recipe that is easily modifiable and IMHO itÂ´s delicious and nutritive. So, hereÂ´s what you need:
- olives, IÂ´m using french style olives, but you can use any other one
- balsamic vinegar, preferably an original one from Modena, Italy
- a good quality extra virgin olive oil
- honey
- cheese, you can choose, but I strongly recommend using goat cheese, camembert or brie
- cherry tomatoes
- vegetables, IÂ´m using lettuce and its variants, but Â you can put any other vegetable you like
First, start slicing the vegetables in way you can eat without cutting them.
Then pour honey over the vegetables like drawing lines. Be careful not to add too much honey otherwise will be more a dessert rather than a salad.
Cut the cheese in cubes and add it over the salad. As IÂ´m using goat cheese which is a little bit too strong for my taste, I added less cheese and due to its form factor, IÂ´m using slices of it
Now you add about 1.5 level tablespoons (15ml) of balsamic vinegar over the salad.
The lasts steps are no mistery: you add olives, cherry tomatoes, dress the salad with the extra virgin olive oil and thatÂ´s pretty much of it.
Now the best part: you can try your very new salad ! Bon AppÃ©tit
Just in case youÂ´re wondering about which olive oil and balsamic vinegar I used, here are them:
Venta BarÃ³n, from Spain Ponti, from Italy


STAR
Home
Project
Project Management
My Project
All Project
Create Project
Equipment
Equipment Management
My Equipment
All Equipment
Add Equipment
schedule
STAR
Admin
Profile
Register
Log In
Log Out
Create Project
Project
Target
Participant
Project
Project title
Project Description
Project Type
regular
transient
PI
Aperture Upper Limit
Aperture Lower Limit
Fo V Upper Limit
Fo V Lower Limit
Pixel Scale Upper Limit
Pixel Scale Lower Limit
Mount Type (German, Fork, Theodolite)
german
fork
theodolite
Camera Type (Colored, Mono)
colored
mono
Camera Type (Cooled, Uncooled)
colored
uncooled
Johnson B
y
n
Johnson V
y
n
Johnson R
y
n
SDSS u
y
n
SDSS g
y
n
SDSS r
y
n
SDSS i
y
n
SDSS z
y
n
Allow Join
y
n
special_requirements
Progress (%)
Target
Target
RA (Longitude)
Dec (Latitude)
Add Target
Participant
UID
Name
Email
Add Participant
Create Project


Jeremy Corbyn labels Labour nationalisation plans as 'very modest'
by Stefan BosciaJeremy Corbyn has claimed Labour’s spending and nationalisation plans are “very, very modest” in an attempt to reassure people the party is “not trying to grab hold of the economy”.
Shadow chancellor John McDonnell announced on Thursday the party would part nationalise BT for £20bn and provide free full-fibre broadband across the country.
Read more: Four reasons businesses fear Labour’s free broadband plans
It was met with widespread shock among business groups and BT chief executive Philip Jansen said the cost of the plans would be £100bn.
Labour has also pledged to nationalise water and energy utilities, train companies and the Royal Mail, which the CBI believes would have a joint cost of £196bn.
Corbyn was asked on the BBC this morning if there was any part of the economy that would never be nationalised under a Labour government.
He refused to answer the question, saying: “We’re not trying to grab hold of the economy…the public sector provisions we are making are very, very modest.
“We want to bring out a just, reasonable society where the aspirations of the poorest are met alongside the aspirations of the rest.”
Labour will release its manifest on Thursday, after its Clause V meeting with major party and union figures yesterday.
One issue of contention within the party was whether a Labour manifesto should include freedom of movement in any Brexit deal it negotiates.
Unite the Union boss Len McCluskey recently said Labour needed to end freedom of movement in the EU.
Meanwhile, other major party figures such as Momentum’s Jon Lansman has said the opposite.
Corbyn refused to say explicitly this morning if the party would include freedom of movement in a potential Brexit deal.
However, he did say there would be a “great deal” of immigration under Labour.
“We cannot exist in isolation, therefore there has to be migration into Britain in order to maintain our economy and services,” he said.
“That will be reflected in our policy that you will see on Thursday.”
Foreign secretary Dominic Raab also refused to give concrete details of the Tories’ immigration policy to the BBC this morning.
The party said it would implement a points-based system post-Brexit, which takes into account things like education, employment background and family status when approving immigration applications.
However, Raab would not say what the immigration target would be.
Read more: Labour refuses to rule out unlimited EU immigration in Brexit deal
“We are not going to fix on an arbitrary target,” he said.
“By exercising a points system you bring it down year-by-year.”