|
barelog
0.1
|
#include <barelog_host_mem_manager.h>
Data Fields | |
| uint8_t | initialized |
| barelog_mem_space_t | mem_space [BARELOG_HOST_NB_MEM_SPACE] |
| void *(* | init )(void *address, size_t size, void *data) |
| int8_t(* | read )(const void *address, size_t size, void *buffer) |
| int8_t(* | write )(void *address, size_t size, const void *buffer) |
| int8_t(* | finalize )(void *mem_space) |
Structure used to hold all of the barelog host manager functions. We use pointers to allow the user to use the functions of their choice, depending on the logged platform.
Definition at line 51 of file barelog_host_mem_manager.h.
| int8_t(* barelog_host_mem_manager_t::finalize) (void *mem_space) |
Function used to finalize a previously initialized chunk of shared memory.
| mem_space | the mem_space to finalize. |
Definition at line 88 of file barelog_host_mem_manager.h.
| void*(* barelog_host_mem_manager_t::init) (void *address, size_t size, void *data) |
Function used to initialize a chunk in the shared memory space.
| address | the beginning address of the chunk to initialize. |
| size | the size of the chunk to initialize. |
| data | (optional) parameter that may be used by the initialization function. |
Definition at line 69 of file barelog_host_mem_manager.h.
| int8_t(* barelog_host_mem_manager_t::read) (const void *address, size_t size, void *buffer) |
Function used by the host to read into the shared memory.
| address | the address to read. |
| size | the size of the memory to read. |
| buffer | the buffer in which to store the reading result. |
Definition at line 76 of file barelog_host_mem_manager.h.
| int8_t(* barelog_host_mem_manager_t::write) (void *address, size_t size, const void *buffer) |
Function used by the host to write into the shared memory.
| address | the address to write. |
| size | the size of the memory to write. |
| buffer | the buffer from which to write the reading result. |
Definition at line 83 of file barelog_host_mem_manager.h.


Back
Declaration [Update with Nexus copy]
I confirm that:
- I have read, understood and accept the terms and conditions of the Apply for faster entry to the USA and Canada service, including those about how personal information is used and stored
- the information I have supplied is complete and true to the best of my knowledge
- If I am registering for someone else I have their full consent, or have 'parental responsibility'Opens in new window for them if they are under 18
I understand that:
Regarding this service
- this is an initial registration required by the Canadian and US authorities before I can apply for membership of the Nexus programme
- there is a £42 non-refundable fee to register to apply for the Nexus programme
Regarding Nexus
- my application to the Nexus programme will be through a separate application to the Canadian and US authorities, with an additional fee of $50 USD
- to get Nexus membership I must meet the Canadian and US eligibility requirementsOpens in new window. My future entry to Canada or the US might be affected if the Canadian or US authorities reject my application
- the Canadian and US authorities can end my Nexus membership if I break the terms and conditions
Confirm


9. Neural Network
9.1. neuron
a neuron takes input \(x \in \mathbb{R}^{d}\), multiply \(x\) by weights \(w\) and add bias term \(b\), finally use a activation function \(g\).
that is:
\[f(x) = g(w^{T}x + b)\]
it is analogous to the functionality of biological neuron.
some useful activation function:
\[\begin{split}
\begin{equation}
\begin{split}
\text{sigmoid:}\quad &g(z) = \frac{1}{1 + e^{-z}} \\
\text{tanh:}\quad &g(z) = \frac{e^{z}-e^{-z}}{e^{z} + e^{-z}} \\
\text{relu:}\quad &g(z) = max(z,0) \\
\text{leaky relu:}\quad &g(z) = max(z, \epsilon{z})\ ,\ \epsilon\text{ is a small positive number}\\
\text{identity:}\quad &g(z) = z
\end{split}
\end{equation}
\end{split}\]
linear regression’s forward process is a neuron with identity activation function.
logistic regression’s forward process is a neuron with sigmoid activation function.
9.2. neural network
building neural network is analogous to lego bricks: you take individual bricks and stack them together to build complex structures.
we use bracket to denote layer, we take the above as example
\([0]\) denote input layer, \([1]\) denote hidden layer, \([2]\) denote output layer
\(a^{[l]}\) denote the output of layer \(l\), set \(a^{[0]} := x\)
\(z^{[l]}\) denote the affine result of layer \(l\)
we have:
\[z^{[l]} = W^{[l]}a^{[l-1]} + b^{[l]}\]
\[a^{[l]} = g^{[l]}(z^{[l]})\]
where \(W^{[l]} \in \mathbb{R}^{d[l] \times d[l-1]}\), \(b^{[l]} \in \mathbb{R}^{d[l]}\).
9.3. weight decay
recall that to mitigate overfitting, we use \(l_{2}\) and \(l_{1}\) regularization in linear and logistic regression.
weight decay is a alias of \(l_{2}\) regularization, can be generalize to neural network, we concatenate \(W^{[l]}\) and flatten it to get \(w\) in this setting.
first adding \(l_{2}\) norm penalty:
\[J(w,b) = \sum_{i=1}^{n}l(w, b, x^{(i)}, y^{(i)}) + \frac{\lambda}{2}\left \| w \right \|^{2} \]
then by gradient descent, we have:
\[\begin{split}
\begin{equation}
\begin{split}
w:=& w-\eta\frac{\partial}{\partial w}J(w, b) \\
=& w-\eta\frac{\partial}{\partial w}\left(\sum_{i=1}^{n}l(w, b, x^{(i)}, y^{(i)}) + \frac{\lambda}{2}\left \| w \right \|^{2}\right) \\
=& (1 - \eta\lambda)w - \eta\frac{\partial}{\partial w}\sum_{i=1}^{n}l(w, b, x^{(i)}, y^{(i)})
\end{split}
\end{equation}
\end{split}\]
multiply by \((1 - \eta\lambda)\) is weight decay.
often we do not calculate bias term in regularization, so does weight decay.
9.4. dropout
to strength robustness through perturbation, we can deliberately add perturbation in traning, dropout is one of that skill.
we actually do the following in hidden neuron:
\[\begin{split}
a_{dropout} =
\begin{cases}
0 &\text{with probability }p \\
\frac{a}{1-p} &\text{otherwise}
\end{cases}
\end{split}\]
this operation randomly dropout neuron with probability \(p\) and keep the expectation unchanged:
\[E(a_{dropout}) = E(a)\]
depict this process below:
one more thing: we do not use dropout in predicting.
9.5. prerequesities for back-propagation
suppose in forward-propagation \(x \to y \to l\), where \(x \in \mathbb{R}^{n}\), \(y \in \mathbb{R} ^{m}\), loss \(l \in \mathbb{R}\).
then:
\[\begin{split}
\frac{\partial l}{\partial y} = \begin{bmatrix}
\frac{\partial l}{\partial y_{1}} \\
...\\
\frac{\partial l}{\partial y_{m}}
\end{bmatrix}
\quad
\frac{\partial l}{\partial x} = \begin{bmatrix}
\frac{\partial l}{\partial x_{1}} \\
...\\
\frac{\partial l}{\partial x_{n}}
\end{bmatrix}
\end{split}\]
by total differential equation:
\[
\frac{\partial l}{\partial x_{k}} = \sum_{j=1}^{m}\frac{\partial l}{\partial y_{j}}\frac{\partial y_{j}}{\partial x_{k}}
\]
then we can connect \(\frac{\partial l}{\partial x}\) and \(\frac{\partial l}{\partial y}\) by:
\[\begin{split}
\frac{\partial l}{\partial x} = \begin{bmatrix}
\frac{\partial l}{\partial x_{1}} \\
...\\
\frac{\partial l}{\partial x_{n}}
\end{bmatrix}
=
\begin{bmatrix}
\frac{\partial y_{1}}{\partial x_{1}} & ... & \frac{\partial y_{m}}{\partial x_{1}}\\
\vdots & \ddots & \vdots \\
\frac{\partial y_{1}}{\partial x_{n}}& .... & \frac{\partial y_{m}}{\partial x_{n}}
\end{bmatrix}
\begin{bmatrix}
\frac{\partial l}{\partial y_{1}} \\
...\\
\frac{\partial l}{\partial y_{m}}
\end{bmatrix}
=
(\frac{\partial y}{\partial x})^{T}\frac{\partial l}{\partial y}
\end{split}\]
here \(\frac{\partial y}{\partial x}\) is the jacobian matrix.
unlike other activation functions, calculate softmax depend on other neurons, so jacobian of softmax.
\[
\frac{\partial a_{i}}{\partial z_{j}} = \frac{\partial}{\partial z_{j}}\left(\frac{exp(z_{i})}{\sum_{s=1}^{k}exp(z_{s})}\right)
\]
it is easy to check the jacobian of matrix-multiplication:
\[\frac{\partial Mx}{\partial x} = M\]
9.6. back-propagation
gradient descent update rule:
\[W^{[l]} = W^{[l]} - \alpha\frac{\partial{L}}{\partial{W^{[l]}}}\]
\[b^{[l]} = b^{[l]} - \alpha\frac{\partial{L}}{\partial{b^{[l]}}}\]
to proceed, we must compute the gradient with respect to the parameters.
we can define a three-step recipe for computing the gradients as follows:
1.for output layer, we have:
\[
\frac{\partial L(\hat{y}, y)}{\partial z^{[N]}} = (\frac{\partial \hat{y}}{\partial z^{[N]}})^{T}\frac{\partial L(\hat{y}, y)}{\partial \hat{y}}
\]
if \(g^{[N]}\) is softmax.
\[
\frac{\partial L(\hat{y}, y)}{\partial z^{[N]}} = \frac{\partial L(\hat{y}, y)}{\partial \hat{y}} \odot {g^{[N]}}'(z^{[N]})
\]
if not softmax.
the above computations are all straight forward.
2.for \(l=N-1,...,1\), we have:
\[z^{[l + 1]} = W^{[l + 1]}a^{[l]} + b^{[l + 1]}\]
so by our prerequesities:
\[
\frac{\partial L}{\partial a^{[l]}} = (\frac{\partial z^{[l+1]}}{\partial a^{[l]}})^{T}\frac{\partial L}{\partial z^{[l+1]}} = (W^{[l+1]})^{T}\frac{\partial L}{\partial z^{[l+1]}}
\]
we also have:
\[a^{[l]} = g^{[l]}z^{[l]}\]
we do not use softmax activation in hidden layers, so the dependent is direct:
\[\frac{\partial L}{\partial z^{[l]}} = \frac{\partial L}{\partial a^{[l]}} \odot {g^{[l]}}'(z^{[l]})\]
combine two equations:
\[\frac{\partial L}{\partial z^{[l]}} = (W^{[l+1]})^{T}\frac{\partial L}{\partial z^{[l+1]}} \odot {g^{[l]}}'(z^{[l]})\]
3.final step, because:
\[z^{[l]} = W^{[l]}a^{[l - 1]} + b^{[l]}\]
so:
\[\frac{\partial L}{\partial W^{[l]}} = \frac{\partial L}{\partial z^{[l]}}(a^{[l - 1]})^{T}\]
\[\frac{\partial L}{\partial b^{[l]}}=\frac{\partial L}{\partial z^{[l]}}\]
9.7. xavier initialization
to mitigate vanishing and exploding gradient, to insure breaking symmtry, we should carefully initialize weights.
consider a fully connected layer without bias term and activation function:
\[o_{i} = \sum_{j=1}^{n_{in}}w_{ij}x_{j}\]
suppose \(w_{ij}\) draw from a distribution of 0 mean and \(\sigma^{2}\) variance, not necessarily guassian.
suppose \(x_{j}\) draw from a distribution of 0 mean and \(\gamma^{2}\) variance, all \(w_{ij}, x_{j}\) are independent.
then mean of \(o_{i}\) is of course 0, variance:
\[\begin{split}
\begin{equation}
\begin{split}
Var[o_{i}] =& E[o_{i}^{2}] - (E[o_{i}])^{2}\\
=&\sum_{j=1}^{n_{in}}E[w_{ij}^{2}x_{j}^{2}] \\
=&\sum_{j=1}^{n_{in}}E[w_{ij}^{2}]E[x_{j}^{2}] \\
=&n_{in}\sigma^{2}\gamma^{2}
\end{split}
\end{equation}
\end{split}\]
to keep variance fixed, we need to set \(n_{in}\sigma^{2}=1\).
consider back-propagation, we have:
\[\frac{\partial L}{\partial x_{j}} = \sum_{i=1}^{n_{out}}w_{ij}\frac{\partial L}{\partial o_{i}}\]
so by the same inference, we need to set $\(n_{out}\sigma^{2} = 1\)$.
we cannot satisfy both conditions simutaneously, we simply try to satisfy:
\[\frac{1}{2}(n_{in} + n_{out})\sigma^{2} = 1 \ \text{ or }\ \sigma = \sqrt{\frac{n_{in} + n_{out}}{2}}\]
this is the reasoning under xavier initialization.


Parking Spot
Toggle navigation
Call Us:
+94 77 308 1422
Home
Map
About
Availability
Log out
Log Out
WELCOME TO
Parking Spot App
WELCOME TO
Parking Spot App
Find a Parking Slot


This website is for the courageous ones. If you're ready for the journey, let's click the button below and enter the gallery!
ExploreThe gallery was built in 2018, and is still under construction. It is not only for the big thriller fans but also for people who want to start their first thriller in life :)
Get Started!We have comprehensive information of the thrillers chosen!
You can have a quick look of the posters!
We have movie evaluation scores from four mainsteam movie evaluation websites and also the average score!
You can have links to download the thrillers.
If you have any ideas or you want to join us, give us a call or send us an email. We will get back to you as soon as possible!
852-53348243


Class OptionType
Enumeration used to declare a \Peg\Custom\CommandLine\Option type
integer |
STRING
|
1 |
#
Accepts any type of string. |
integer |
INTEGER
|
2 |
#
Only accept numbers. |
integer |
FLAG
|
3 |
#
Doesn't needs a value, just to be present. |


--- title: Aquifer thickness calculated from ~300,000 well logs author: Rich date: '2018-03-15 02:57:45+00:00' slug: aquifer-thickness summary: Data visualization from hundreds of thousands of well completion reports reveals aquifer characteristics in California groundwater basins. external_link: "" links: - icon: github icon_pack: fab name: Github url: https://github.com/richpauloo/junkyard/blob/master/aquifer_thickness/index.Rmd math: false featured: true ---
At the time of writing, the California DWR Online Well Completion Report Database contains ~1,000,000 digitized well logs. About 1/3 of those wells have information on the top and bottom of the perforated interval, which we can use to compute and visualize regional estimates of:
I realize that I’m skipping straight to the results. For how I arrived at these numbers, see the full code here.
library(tidyverse)
library(sp)
library(sf)
library(leaflet)
library(widgetframe)
# pre-computed results
gwb_full <- read_rds("~/Github/rp/static/data/gwb_full.rds")
labels <- read_rds("~/Github/rp/static/data/labels.rds")
bins <- c(0,50, 100,200,300,400,500,600)
pal <- colorBin("inferno", gwb_full$mean_pit, bins = bins)
# make another layer control group name
gwb_full$Basin_Subb_2 <- gwb_full$Basin_Subb
# rename groups for legend
temp <- gwb_full %>%
rename(median_perforated_interval_thickness = Basin_Subb,
mean_perforated_interval_thickness = Basin_Subb_2)
# plot
leaflet(width = "100%") %>%
addProviderTiles(providers$CartoDB.Positron) %>%
addPolygons(data = temp, stroke = FALSE, smoothFactor = 0.2,
color = ~pal(mean_pit),
label = lapply(labels[[1]], htmltools::HTML),
fillOpacity = 0.8,
group = "mean_perforated_interval_thickness") %>%
addPolygons(data = temp, stroke = FALSE, smoothFactor = 0.2,
color = ~pal(median_pit),
label = lapply(labels[[2]], htmltools::HTML),
fillOpacity = 0.8,
group = "median_perforated_interval_thickness") %>%
addLegend(pal = pal, values = temp$mean_pit,
title = ("thickness (ft.)")) %>%
addLayersControl(overlayGroups =
c("median_perforated_interval_thickness",
"mean_perforated_interval_thickness")) %>%
hideGroup("median_perforated_interval_thickness") %>%
frameWidget(height = "400")
bins <- c(0,100,200,300,400,500,600,700, 800, 900, 1000)
pal <- colorBin("viridis", gwb_full$mean_top, bins = bins)
# rename groups for legend
temp <- gwb_full %>%
rename(median_top_perforated_interval = Basin_Subb,
mean_top_perforated_interval = Basin_Subb_2)
# plot
leaflet(width = "100%") %>%
addProviderTiles(providers$CartoDB.Positron) %>%
addPolygons(data = temp, stroke = FALSE, smoothFactor = 0.2,
color = ~pal(mean_top),
label = lapply(labels[[3]], htmltools::HTML),
fillOpacity = 0.8,
group = "mean_top_perforated_interval") %>%
addPolygons(data = temp, stroke = FALSE, smoothFactor = 0.2,
color = ~pal(median_top),
label = lapply(labels[[4]], htmltools::HTML),
fillOpacity = 0.8,
group = "median_top_perforated_interval") %>%
addLegend(pal = pal, values = temp$mean_top,
title = ("depth (ft.)")) %>%
addLayersControl(overlayGroups =
c("median_top_perforated_interval",
"mean_top_perforated_interval")) %>%
hideGroup("median_top_perforated_interval") %>%
frameWidget(height = "400")
bins <- c(0,100,200,300,400,500,600,700, 800, 900, 1000, 1100)
pal <- colorBin("viridis", gwb_full$mean_bot, bins = bins)
# rename groups for legend
temp <- gwb_full %>%
rename(median_bot_perforated_interval = Basin_Subb,
mean_bot_perforated_interval = Basin_Subb_2)
# plot
leaflet(width = "100%") %>%
addProviderTiles(providers$CartoDB.Positron) %>%
addPolygons(data = temp, stroke = FALSE, smoothFactor = 0.2,
color = ~pal(mean_bot),
label = lapply(labels[[5]], htmltools::HTML),
fillOpacity = 0.8,
group = "mean_bot_perforated_interval") %>%
addPolygons(data = temp, stroke = FALSE, smoothFactor = 0.2,
color = ~pal(median_bot),
label = lapply(labels[[6]], htmltools::HTML),
fillOpacity = 0.8,
group = "median_bot_perforated_interval") %>%
addLegend(pal = pal, values = temp$mean_bot,
title = ("depth (ft.)")) %>%
addLayersControl(overlayGroups =
c("median_bot_perforated_interval",
"mean_bot_perforated_interval")) %>%
hideGroup("median_bot_perforated_interval") %>%
frameWidget(height = "400")


Home
Shop
About
Contact Us
Contact Us
Please fill out this form and let us know what went wrong.
Name
Email
Comments
Do Not Fill This Out


Working in an Existent Engine¶
In this section, there are some examples of how to work with an existing engine.
If you don’t have an engine locally, clone one to your local machine
On Python Toolbox environment, set VirtualEnv and get to engine’s path:
$ marvin engine-generateenv /path/to/engine/ $ workon <engine_name>-env
Test your engine:
$ marvin
Bring up the notebook and access it from your browser:
$ marvin notebook
Running a example engine¶
Clone example engine from repository:
$ git clone https://github.com/apache/incubator-marvin
Generate a new marvin engine environment for Iris species engine:
$ workon python-toolbox-env $ marvin engine-generateenv ../engines/iris-species-engine/
Run the Iris species engine:
$ workon iris-species-engine-env $ marvin engine-dryrun
For more examples, access here.


|
Halide
|
The header of a packet in a binary trace. More...
#include <HalideRuntime.h>
Public Attributes | |
| uint32_t | size |
| The total size of this packet in bytes. More... | |
| int32_t | id |
| The id of this packet (for the purpose of parent_id). More... | |
| struct halide_type_t | type |
| The remaining fields are equivalent to those in halide_trace_event_t. More... | |
| enum halide_trace_event_code_t | event |
| The remaining fields are equivalent to those in halide_trace_event_t. More... | |
| int32_t | parent_id |
| The remaining fields are equivalent to those in halide_trace_event_t. More... | |
| int32_t | value_index |
| The remaining fields are equivalent to those in halide_trace_event_t. More... | |
| int32_t | dimensions |
| The remaining fields are equivalent to those in halide_trace_event_t. More... | |
The header of a packet in a binary trace.
All fields are 32-bit.
Definition at line 424 of file HalideRuntime.h.
| uint32_t halide_trace_packet_t::size |
The total size of this packet in bytes.
Always a multiple of four. Equivalently, the number of bytes until the next packet.
Definition at line 428 of file HalideRuntime.h.
| int32_t halide_trace_packet_t::id |
The id of this packet (for the purpose of parent_id).
Definition at line 431 of file HalideRuntime.h.
| struct halide_type_t halide_trace_packet_t::type |
The remaining fields are equivalent to those in halide_trace_event_t.
Definition at line 435 of file HalideRuntime.h.
| enum halide_trace_event_code_t halide_trace_packet_t::event |
The remaining fields are equivalent to those in halide_trace_event_t.
Definition at line 436 of file HalideRuntime.h.
| int32_t halide_trace_packet_t::parent_id |
The remaining fields are equivalent to those in halide_trace_event_t.
Definition at line 437 of file HalideRuntime.h.
| int32_t halide_trace_packet_t::value_index |
The remaining fields are equivalent to those in halide_trace_event_t.
Definition at line 438 of file HalideRuntime.h.
| int32_t halide_trace_packet_t::dimensions |
The remaining fields are equivalent to those in halide_trace_event_t.
Definition at line 439 of file HalideRuntime.h.


--- layout: post title: Aftermath date: 2006-05-02 00:00:00 category: personal ---
I haven't laughed so much in years. But my head hurts and I can never go to the circus again.


Justin Fields Posts Message After Win vs. Penn State
by Andrew McCartyOhio State’s undefeated season rolled on this weekend with a huge win over Penn State.
The Buckeyes defense dominated for much of the day and escaped a late Nittany Lions comeback attempt to walk out with a 28-17 win. With the win, Ohio State clinches the Big Ten East and a spot in the Big Ten title game.
Despite the win, there was a worrisome moment in the final minutes of the fourth quarter. Star quarterback Justin Fields was tackled awkwardly and appeared to be hurt on the play.
However, he bounced right back up and hobbled off the field. After the game, head coach Ryan Day said Fields is “good” and shouldn’t miss any time with an injury.
A few hours after the game ended, Fields sent a message for the Ohio State faithful.
“Love this team and Buckeye Nation. Gotta keep getting better each and everyday! #GoBucks,” Fields said on Twitter.
Fields didn’t have his best performance on Saturday, but still finished the game with over 250 yards of offense and two touchdown passes.
Ohio State improves to 11-0 with the win and sets up a huge game with Michigan next weekend. Can the Wolverines pull off the upset in Ann Arbor?
Stay tuned.


余逢贵过过过过过过过过过过过过过过过过过过个付多所覅US付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付方法反反复复付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付付方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复付付付付付付付付付付方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复付付付付付付付付付付方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复付付付付付付付付付付方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复方法反反复复付付付付付付付付付付


This tests loading of a HTML page with a PNG image when the HTTP content-type is set to "text/html" . Expected : This page should have been RENDERED CORRECTLY .


{% extends "base_generic.html" %} {% load render_bundle from webpack_loader %} {% block content %}
Elena Renken
President, The Brown Daily Herald, Inc.
Editor-in-Chief, The Herald
Kasturi Pananjady
Vice President, The Brown Daily Herald, Inc.
Editor-in-Chief, the Herald
Michael Borrello
Treasurer, The Brown Daily Herald, Inc.
General Manager, The Herald
Matilda Lynton
Secretary, The Brown Daily Herald, Inc.
General Manager, The Herald
Editor-in-Chief: Elena Renken
Editor-in-Chief: Kasturi Pananjady
Managing Editor: Alex Skidmore
Senior Editor: Madison Rivlin
Senior Editor: Julianne Center
Senior Editor: Hattie Xu
Post-: Saanya Jain
Features: Isabel Gensler
University News: Anna Kramer, Eduard Muñoz-Suñé, Priyanka Podugu, Sarah Wang
Metro: Emily Davies, Bella Roberts
Science and Research: Jonathan Douglas, Jackson Wells
Arts & Culture: Connor Sullivan, Mia Pattillo
Sports: Alexandra Russell, Nicholas Wey
Opinions Editors: Connor Cardoso, Anuj Krishnamurthy, Clare Steinman
Design Editors: Kyle Cui, Eduard Muñoz-Suñé
Assistant Design Editors: Julie Wang, Kelvin Yang
Head Photo Editor: Sam Berube, Anita Sheih
Illustrations Editor: Pia Mileaf-Patel
Copy Desk Chief: Abby Borges
Director of Web Development: Eli White
General Managers: Michael Borrello, Matilda Lynton
Office Manager: Diane Silvia
Sales: Shreya Raghunandan
Finance: Ravi Betzig
Strategy: Caroline Ziegler


Florida authorities arrest girl, 12, for posting kill list
by Associated PressTALLAHASSEE, Fla. (AP) — Florida authorities arrested a 12-year-old girl after discovering at least two social media posts that threatened to kill fellow students at her middle school.
In one Snapchat post, the Broward County Sheriff's Office said, the girl listed the names of potential victims.
FLORIDA NEWS | The latest headlines from Florida
A later post warned that the students were not safe and that they would be killed on Monday.
Investigators were made aware of the threats on Friday night by a parent and student at Falcon Cove Middle School north of Miami.
The girl was later taken into custody and taken to a juvenile center. Authorities said they arrested the girl on two counts of making a written threat to kill and making a false report about a firearm.


{% extends "single-column.html" %} {% block title %}Crunch.io - Error Page{% endblock %} {% block content %} The page you have requested is not present. Please return to the main page. {% endblock %}


Park It Right!
Home
Documentation
Contact
Contact us
Keerthana Nandanavanam
Krishna Manoj Maddipatla
Nidhi Chaudhary
Sumanth Mothkuri


"""Entropy functions"""
import numpy as np
from numba import jit
from math import factorial, log
from sklearn.neighbors import KDTree
from scipy.signal import periodogram, welch
from .utils import _embed
all = ['perm_entropy', 'spectral_entropy', 'svd_entropy', 'app_entropy',
'sample_entropy', 'lziv_complexity', 'num_zerocross', 'hjorth_params']
[docs]def perm_entropy(x, order=3, delay=1, normalize=False):
"""Permutation Entropy.
Parameters
----------
x : list or np.array
One-dimensional time series of shape (n_times)
order : int
Order of permutation entropy. Default is 3.
delay : int
Time delay (lag). Default is 1.
normalize : bool
If True, divide by log2(order!) to normalize the entropy between 0
and 1. Otherwise, return the permutation entropy in bit.
Returns
-------
pe : float
Permutation Entropy.
Notes
-----
The permutation entropy is a complexity measure for time-series first
introduced by Bandt and Pompe in 2002.
The permutation entropy of a signal :math:`x` is defined as:
.. math:: H = -\\sum p(\\pi)\\log_2(\\pi)
where the sum runs over all :math:`n!` permutations :math:`\\pi` of order
:math:`n`. This is the information contained in comparing :math:`n`
consecutive values of the time series. It is clear that
:math:`0 ≤ H (n) ≤ \\log_2(n!)` where the lower bound is attained for an
increasing or decreasing sequence of values, and the upper bound for a
completely random system where all :math:`n!` possible permutations appear
with the same probability.
The embedded matrix :math:`Y` is created by:
.. math::
y(i)=[x_i,x_{i+\\text{delay}}, ...,x_{i+(\\text{order}-1) *
\\text{delay}}]
.. math:: Y=[y(1),y(2),...,y(N-(\\text{order}-1))*\\text{delay})]^T
References
----------
Bandt, Christoph, and Bernd Pompe. "Permutation entropy: a
natural complexity measure for time series." Physical review letters
88.17 (2002): 174102.
Examples
--------
Permutation entropy with order 2
>>> import numpy as np
>>> import entropy as ent
>>> import stochastic.processes.noise as sn
>>> x = [4, 7, 9, 10, 6, 11, 3]
>>> # Return a value in bit between 0 and log2(factorial(order))
>>> print(f"{ent.perm_entropy(x, order=2):.4f}")
0.9183
Normalized permutation entropy with order 3
>>> # Return a value comprised between 0 and 1.
>>> print(f"{ent.perm_entropy(x, normalize=True):.4f}")
0.5888
Fractional Gaussian noise with H = 0.5
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
>>> print(f"{ent.perm_entropy(x, normalize=True):.4f}")
0.9998
Fractional Gaussian noise with H = 0.9
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
>>> print(f"{ent.perm_entropy(x, normalize=True):.4f}")
0.9926
Fractional Gaussian noise with H = 0.1
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
>>> print(f"{ent.perm_entropy(x, normalize=True):.4f}")
0.9959
Random
>>> rng = np.random.default_rng(seed=42)
>>> print(f"{ent.perm_entropy(rng.random(1000), normalize=True):.4f}")
0.9997
Pure sine wave
>>> x = np.sin(2 * np.pi * 1 * np.arange(3000) / 100)
>>> print(f"{ent.perm_entropy(x, normalize=True):.4f}")
0.4463
Linearly-increasing time-series
>>> x = np.arange(1000)
>>> print(f"{ent.perm_entropy(x, normalize=True):.4f}")
-0.0000
"""
x = np.array(x)
ran_order = range(order)
hashmult = np.power(order, ran_order)
# Embed x and sort the order of permutations
sorted_idx = _embed(x, order=order, delay=delay).argsort(kind='quicksort')
# Associate unique integer to each permutations
hashval = (np.multiply(sorted_idx, hashmult)).sum(1)
# Return the counts
_, c = np.unique(hashval, return_counts=True)
# Use np.true_divide for Python 2 compatibility
p = np.true_divide(c, c.sum())
pe = -np.multiply(p, np.log2(p)).sum()
if normalize:
pe /= np.log2(factorial(order))
return pe
[docs]def spectral_entropy(x, sf, method='fft', nperseg=None, normalize=False,
axis=-1):
"""Spectral Entropy.
Parameters
----------
x : list or np.array
1D or N-D data.
sf : float
Sampling frequency, in Hz.
method : str
Spectral estimation method:
* ``'fft'`` : Fourier Transform (:py:func:`scipy.signal.periodogram`)
* ``'welch'`` : Welch periodogram (:py:func:`scipy.signal.welch`)
nperseg : int or None
Length of each FFT segment for Welch method.
If None (default), uses scipy default of 256 samples.
normalize : bool
If True, divide by log2(psd.size) to normalize the spectral entropy
between 0 and 1. Otherwise, return the spectral entropy in bit.
axis : int
The axis along which the entropy is calculated. Default is -1 (last).
Returns
-------
se : float
Spectral Entropy
Notes
-----
Spectral Entropy is defined to be the Shannon entropy of the power
spectral density (PSD) of the data:
.. math:: H(x, sf) = -\\sum_{f=0}^{f_s/2} P(f) \\log_2[P(f)]
Where :math:`P` is the normalised PSD, and :math:`f_s` is the sampling
frequency.
References
----------
- Inouye, T. et al. (1991). Quantification of EEG irregularity by
use of the entropy of the power spectrum. Electroencephalography
and clinical neurophysiology, 79(3), 204-210.
- https://en.wikipedia.org/wiki/Spectral_density
- https://en.wikipedia.org/wiki/Welch%27s_method
Examples
--------
Spectral entropy of a pure sine using FFT
>>> import numpy as np
>>> import entropy as ent
>>> sf, f, dur = 100, 1, 4
>>> N = sf * dur # Total number of discrete samples
>>> t = np.arange(N) / sf # Time vector
>>> x = np.sin(2 * np.pi * f * t)
>>> np.round(ent.spectral_entropy(x, sf, method='fft'), 2)
0.0
Spectral entropy of a random signal using Welch's method
>>> np.random.seed(42)
>>> x = np.random.rand(3000)
>>> ent.spectral_entropy(x, sf=100, method='welch')
6.980045662371389
Normalized spectral entropy
>>> ent.spectral_entropy(x, sf=100, method='welch', normalize=True)
0.9955526198316071
Normalized spectral entropy of 2D data
>>> np.random.seed(42)
>>> x = np.random.normal(size=(4, 3000))
>>> np.round(ent.spectral_entropy(x, sf=100, normalize=True), 4)
array([0.9464, 0.9428, 0.9431, 0.9417])
Fractional Gaussian noise with H = 0.5
>>> import stochastic.processes.noise as sn
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
>>> print(f"{ent.spectral_entropy(x, sf=100, normalize=True):.4f}")
0.9505
Fractional Gaussian noise with H = 0.9
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
>>> print(f"{ent.spectral_entropy(x, sf=100, normalize=True):.4f}")
0.8477
Fractional Gaussian noise with H = 0.1
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
>>> print(f"{ent.spectral_entropy(x, sf=100, normalize=True):.4f}")
0.9248
"""
x = np.asarray(x)
# Compute and normalize power spectrum
if method == 'fft':
_, psd = periodogram(x, sf, axis=axis)
elif method == 'welch':
_, psd = welch(x, sf, nperseg=nperseg, axis=axis)
psd_norm = psd / psd.sum(axis=axis, keepdims=True)
se = -(psd_norm * np.log2(psd_norm)).sum(axis=axis)
if normalize:
se /= np.log2(psd_norm.shape[axis])
return se
[docs]def svd_entropy(x, order=3, delay=1, normalize=False):
"""Singular Value Decomposition entropy.
Parameters
----------
x : list or np.array
One-dimensional time series of shape (n_times)
order : int
Order of SVD entropy (= length of the embedding dimension).
Default is 3.
delay : int
Time delay (lag). Default is 1.
normalize : bool
If True, divide by log2(order!) to normalize the entropy between 0
and 1. Otherwise, return the permutation entropy in bit.
Returns
-------
svd_e : float
SVD Entropy
Notes
-----
SVD entropy is an indicator of the number of eigenvectors that are needed
for an adequate explanation of the data set. In other words, it measures
the dimensionality of the data.
The SVD entropy of a signal :math:`x` is defined as:
.. math::
H = -\\sum_{i=1}^{M} \\overline{\\sigma}_i log_2(\\overline{\\sigma}_i)
where :math:`M` is the number of singular values of the embedded matrix
:math:`Y` and :math:`\\sigma_1, \\sigma_2, ..., \\sigma_M` are the
normalized singular values of :math:`Y`.
The embedded matrix :math:`Y` is created by:
.. math::
y(i)=[x_i,x_{i+\\text{delay}}, ...,x_{i+(\\text{order}-1) *
\\text{delay}}]
.. math:: Y=[y(1),y(2),...,y(N-(\\text{order}-1))*\\text{delay})]^T
Examples
--------
SVD entropy with order 2
>>> import numpy as np
>>> import entropy as ent
>>> import stochastic.processes.noise as sn
>>> x = [4, 7, 9, 10, 6, 11, 3]
>>> # Return a value in bit between 0 and log2(factorial(order))
>>> print(ent.svd_entropy(x, order=2))
0.7618909465130066
Normalized SVD entropy with order 3
>>> x = [4, 7, 9, 10, 6, 11, 3]
>>> # Return a value comprised between 0 and 1.
>>> print(ent.svd_entropy(x, order=3, normalize=True))
0.6870083043946692
Fractional Gaussian noise with H = 0.5
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
>>> print(f"{ent.svd_entropy(x, normalize=True):.4f}")
1.0000
Fractional Gaussian noise with H = 0.9
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
>>> print(f"{ent.svd_entropy(x, normalize=True):.4f}")
0.9080
Fractional Gaussian noise with H = 0.1
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
>>> print(f"{ent.svd_entropy(x, normalize=True):.4f}")
0.9637
Random
>>> rng = np.random.default_rng(seed=42)
>>> print(f"{ent.svd_entropy(rng.random(1000), normalize=True):.4f}")
0.8527
Pure sine wave
>>> x = np.sin(2 * np.pi * 1 * np.arange(3000) / 100)
>>> print(f"{ent.svd_entropy(x, normalize=True):.4f}")
0.1775
Linearly-increasing time-series
>>> x = np.arange(1000)
>>> print(f"{ent.svd_entropy(x, normalize=True):.4f}")
0.0053
"""
x = np.array(x)
mat = _embed(x, order=order, delay=delay)
W = np.linalg.svd(mat, compute_uv=False)
# Normalize the singular values
W /= sum(W)
svd_e = -np.multiply(W, np.log2(W)).sum()
if normalize:
svd_e /= np.log2(order)
return svd_e
def _app_samp_entropy(x, order, metric='chebyshev', approximate=True):
"""Utility function for `app_entropy`` and `sample_entropy`.
"""
_all_metrics = KDTree.valid_metrics
if metric not in _all_metrics:
raise ValueError('The given metric (%s) is not valid. The valid '
'metric names are: %s' % (metric, _all_metrics))
phi = np.zeros(2)
r = 0.2 * np.std(x, ddof=0)
# compute phi(order, r)
_emb_data1 = _embed(x, order, 1)
if approximate:
emb_data1 = _emb_data1
else:
emb_data1 = _emb_data1[:-1]
count1 = KDTree(emb_data1, metric=metric).query_radius(emb_data1, r,
count_only=True
).astype(np.float64)
# compute phi(order + 1, r)
emb_data2 = _embed(x, order + 1, 1)
count2 = KDTree(emb_data2, metric=metric).query_radius(emb_data2, r,
count_only=True
).astype(np.float64)
if approximate:
phi[0] = np.mean(np.log(count1 / emb_data1.shape[0]))
phi[1] = np.mean(np.log(count2 / emb_data2.shape[0]))
else:
phi[0] = np.mean((count1 - 1) / (emb_data1.shape[0] - 1))
phi[1] = np.mean((count2 - 1) / (emb_data2.shape[0] - 1))
return phi
@jit('f8(f8[:], i4, f8)', nopython=True)
def _numba_sampen(x, order, r):
"""
Fast evaluation of the sample entropy using Numba.
"""
n = x.size
n1 = n - 1
order += 1
order_dbld = 2 * order
# Define threshold
# r *= x.std()
# initialize the lists
run = [0] * n
run1 = run[:]
r1 = [0] * (n * order_dbld)
a = [0] * order
b = a[:]
p = a[:]
for i in range(n1):
nj = n1 - i
for jj in range(nj):
j = jj + i + 1
if abs(x[j] - x[i]) < r:
run[jj] = run1[jj] + 1
m1 = order if order < run[jj] else run[jj]
for m in range(m1):
a[m] += 1
if j < n1:
b[m] += 1
else:
run[jj] = 0
for j in range(order_dbld):
run1[j] = run[j]
r1[i + n * j] = run[j]
if nj > order_dbld - 1:
for j in range(order_dbld, nj):
run1[j] = run[j]
m = order - 1
while m > 0:
b[m] = b[m - 1]
m -= 1
b[0] = n * n1 / 2
a = np.array([float(aa) for aa in a])
b = np.array([float(bb) for bb in b])
p = np.true_divide(a, b)
return -log(p[-1])
[docs]def app_entropy(x, order=2, metric='chebyshev'):
"""Approximate Entropy.
Parameters
----------
x : list or np.array
One-dimensional time series of shape (n_times).
order : int
Embedding dimension. Default is 2.
metric : str
Name of the distance metric function used with
:py:class:`sklearn.neighbors.KDTree`. Default is to use the
`Chebyshev <https://en.wikipedia.org/wiki/Chebyshev_distance>`_
distance.
Returns
-------
ae : float
Approximate Entropy.
Notes
-----
Approximate entropy is a technique used to quantify the amount of
regularity and the unpredictability of fluctuations over time-series data.
Smaller values indicates that the data is more regular and predictable.
The tolerance value (:math:`r`) is set to :math:`0.2 * \\text{std}(x)`.
Code adapted from the `mne-features <https://mne.tools/mne-features/>`_
package by Jean-Baptiste Schiratti and Alexandre Gramfort.
References
----------
Richman, J. S. et al. (2000). Physiological time-series analysis
using approximate entropy and sample entropy. American Journal of
Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.
https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.DistanceMetric.html
Examples
--------
Fractional Gaussian noise with H = 0.5
>>> import numpy as np
>>> import entropy as ent
>>> import stochastic.processes.noise as sn
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
>>> print(f"{ent.app_entropy(x, order=2):.4f}")
2.1958
Same with order = 3 and metric = 'euclidean'
>>> print(f"{ent.app_entropy(x, order=3, metric='euclidean'):.4f}")
1.5120
Fractional Gaussian noise with H = 0.9
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
>>> print(f"{ent.app_entropy(x):.4f}")
1.9681
Fractional Gaussian noise with H = 0.1
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
>>> print(f"{ent.app_entropy(x):.4f}")
2.0906
Random
>>> rng = np.random.default_rng(seed=42)
>>> print(f"{ent.app_entropy(rng.random(1000)):.4f}")
1.8177
Pure sine wave
>>> x = np.sin(2 * np.pi * 1 * np.arange(3000) / 100)
>>> print(f"{ent.app_entropy(x):.4f}")
0.2009
Linearly-increasing time-series
>>> x = np.arange(1000)
>>> print(f"{ent.app_entropy(x):.4f}")
-0.0010
"""
phi = _app_samp_entropy(x, order=order, metric=metric, approximate=True)
return np.subtract(phi[0], phi[1])
[docs]def sample_entropy(x, order=2, metric='chebyshev'):
"""Sample Entropy.
Parameters
----------
x : list or np.array
One-dimensional time series of shape (n_times).
order : int
Embedding dimension. Default is 2.
metric : str
Name of the distance metric function used with
:py:class:`sklearn.neighbors.KDTree`. Default is to use the
`Chebyshev <https://en.wikipedia.org/wiki/Chebyshev_distance>`_
distance.
Returns
-------
se : float
Sample Entropy.
Notes
-----
Sample entropy is a modification of approximate entropy, used for assessing
the complexity of physiological time-series signals. It has two advantages
over approximate entropy: data length independence and a relatively
trouble-free implementation. Large values indicate high complexity whereas
smaller values characterize more self-similar and regular signals.
The sample entropy of a signal :math:`x` is defined as:
.. math:: H(x, m, r) = -\\log\\frac{C(m + 1, r)}{C(m, r)}
where :math:`m` is the embedding dimension (= order), :math:`r` is
the radius of the neighbourhood (default = :math:`0.2 * \\text{std}(x)`),
:math:`C(m + 1, r)` is the number of embedded vectors of length
:math:`m + 1` having a
`Chebyshev distance <https://en.wikipedia.org/wiki/Chebyshev_distance>`_
inferior to :math:`r` and :math:`C(m, r)` is the number of embedded
vectors of length :math:`m` having a Chebyshev distance inferior to
:math:`r`.
Note that if ``metric == 'chebyshev'`` and ``len(x) < 5000`` points,
then the sample entropy is computed using a fast custom Numba script.
For other distance metric or longer time-series, the sample entropy is
computed using a code from the
`mne-features <https://mne.tools/mne-features/>`_ package by Jean-Baptiste
Schiratti and Alexandre Gramfort (requires sklearn).
References
----------
Richman, J. S. et al. (2000). Physiological time-series analysis
using approximate entropy and sample entropy. American Journal of
Physiology-Heart and Circulatory Physiology, 278(6), H2039-H2049.
https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.DistanceMetric.html
Examples
--------
Fractional Gaussian noise with H = 0.5
>>> import numpy as np
>>> import entropy as ent
>>> import stochastic.processes.noise as sn
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
>>> print(f"{ent.sample_entropy(x, order=2):.4f}")
2.1819
Same with order = 3 and using the Euclidean distance
>>> print(f"{ent.sample_entropy(x, order=3, metric='euclidean'):.4f}")
2.6806
Fractional Gaussian noise with H = 0.9
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
>>> print(f"{ent.sample_entropy(x):.4f}")
1.9078
Fractional Gaussian noise with H = 0.1
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
>>> print(f"{ent.sample_entropy(x):.4f}")
2.0555
Random
>>> rng = np.random.default_rng(seed=42)
>>> print(f"{ent.sample_entropy(rng.random(1000)):.4f}")
2.2017
Pure sine wave
>>> x = np.sin(2 * np.pi * 1 * np.arange(3000) / 100)
>>> print(f"{ent.sample_entropy(x):.4f}")
0.1633
Linearly-increasing time-series
>>> x = np.arange(1000)
>>> print(f"{ent.sample_entropy(x):.4f}")
-0.0000
"""
x = np.asarray(x, dtype=np.float64)
if metric == 'chebyshev' and x.size < 5000:
return _numba_sampen(x, order=order, r=(0.2 * x.std(ddof=0)))
else:
phi = _app_samp_entropy(x, order=order, metric=metric,
approximate=False)
return -np.log(np.divide(phi[1], phi[0]))
@jit("uint32(uint32[:])", nopython=True)
def _lz_complexity(binary_string):
"""Internal Numba implementation of the Lempel-Ziv (LZ) complexity.
https://github.com/Naereen/Lempel-Ziv_Complexity/blob/master/src/lziv_complexity.py
- Updated with strict integer typing instead of strings
- Slight restructuring based on Yacine Mahdid's notebook:
https://github.com/BIAPT/Notebooks/blob/master/features/Lempel-Ziv%20Complexity.ipynb
"""
# Initialize variables
complexity = 1
prefix_len = 1
len_substring = 1
max_len_substring = 1
pointer = 0
# Iterate until the entire string has not been parsed
while prefix_len + len_substring <= len(binary_string):
# Given a prefix length, find the largest substring
if (
binary_string[pointer + len_substring - 1]
== binary_string[prefix_len + len_substring - 1]
):
len_substring += 1 # increase the length of the substring
else:
max_len_substring = max(len_substring, max_len_substring)
pointer += 1
# Since all pointers have been scanned, pick largest as the
# jump size
if pointer == prefix_len:
# Increment complexity
complexity += 1
# Set prefix length to the max substring size found so far
# (jump size)
prefix_len += max_len_substring
# Reset pointer and max substring size
pointer = 0
max_len_substring = 1
# Reset length of current substring
len_substring = 1
# Check if final iteration occurred in the middle of a substring
if len_substring != 1:
complexity += 1
return complexity
[docs]def lziv_complexity(sequence, normalize=False):
"""
Lempel-Ziv (LZ) complexity of (binary) sequence.
.. versionadded:: 0.1.1
Parameters
----------
sequence : str or array
A sequence of character, e.g. ``'1001111011000010'``,
``[0, 1, 0, 1, 1]``, or ``'Hello World!'``.
normalize : bool
If ``True``, returns the normalized LZ (see Notes).
Returns
-------
lz : int or float
LZ complexity, which corresponds to the number of different
substrings encountered as the stream is viewed from the
beginning to the end. If ``normalize=False``, the output is an
integer (counts), otherwise the output is a float.
Notes
-----
LZ complexity is defined as the number of different substrings encountered
as the sequence is viewed from begining to the end.
Although the raw LZ is an important complexity indicator, it is heavily
influenced by sequence length (longer sequence will result in higher LZ).
Zhang and colleagues (2009) have therefore proposed the normalized LZ,
which is defined by
.. math:: \\text{LZn} = \\frac{\\text{LZ}}{(n / \\log_b{n})}
where :math:`n` is the length of the sequence and :math:`b` the number of
unique characters in the sequence.
References
----------
* Lempel, A., & Ziv, J. (1976). On the Complexity of Finite Sequences.
IEEE Transactions on Information Theory / Professional Technical
Group on Information Theory, 22(1), 75–81.
https://doi.org/10.1109/TIT.1976.1055501
* Zhang, Y., Hao, J., Zhou, C., & Chang, K. (2009). Normalized
Lempel-Ziv complexity and its application in bio-sequence analysis.
Journal of Mathematical Chemistry, 46(4), 1203–1212.
https://doi.org/10.1007/s10910-008-9512-2
* https://en.wikipedia.org/wiki/Lempel-Ziv_complexity
* https://github.com/Naereen/Lempel-Ziv_Complexity
Examples
--------
>>> from entropy import lziv_complexity
>>> # Substrings = 1 / 0 / 01 / 1110 / 1100 / 0010
>>> s = '1001111011000010'
>>> lziv_complexity(s)
6
Using a list of integer / boolean instead of a string
>>> # 1 / 0 / 10
>>> lziv_complexity([1, 0, 1, 0, 1, 0, 1, 0, 1, 0])
3
With normalization
>>> lziv_complexity(s, normalize=True)
1.5
This function also works with characters and words
>>> s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> lziv_complexity(s), lziv_complexity(s, normalize=True)
(26, 1.0)
>>> s = 'HELLO WORLD! HELLO WORLD! HELLO WORLD! HELLO WORLD!'
>>> lziv_complexity(s), lziv_complexity(s, normalize=True)
(11, 0.38596001132145313)
"""
assert isinstance(sequence, (str, list, np.ndarray))
assert isinstance(normalize, bool)
if isinstance(sequence, (list, np.ndarray)):
sequence = np.asarray(sequence)
if sequence.dtype.kind in 'bfi':
# Convert [True, False] or [1., 0.] to [1, 0]
s = sequence.astype("uint32")
else:
# Treat as numpy array of strings
# Map string characters to utf-8 integer representation
s = np.fromiter(map(ord, "".join(sequence.astype(str))),
dtype="uint32")
# Can't preallocate length (by specifying count) due to string
# concatenation
else:
s = np.fromiter(map(ord, sequence), dtype="uint32")
if normalize:
# 1) Timmermann et al. 2019
# The sequence is randomly shuffled, and the normalized LZ
# is calculated as the ratio of the LZ of the original sequence
# divided by the LZ of the randomly shuffled LZ. However, the final
# output is dependent on the random seed.
# sl_shuffled = list(s)
# rng = np.random.RandomState(None)
# rng.shuffle(sl_shuffled)
# s_shuffled = ''.join(sl_shuffled)
# return _lz_complexity(s) / _lz_complexity(s_shuffled)
# 2) Zhang et al. 2009
n = len(s)
base = sum(np.bincount(s) > 0) # Number of unique characters
base = 2 if base < 2 else base
return _lz_complexity(s) / (n / log(n, base))
else:
return _lz_complexity(s)
###############################################################################
# OTHER TIME-DOMAIN METRICS
###############################################################################
[docs]def num_zerocross(x, normalize=False, axis=-1):
"""Number of zero-crossings.
.. versionadded: 0.1.3
Parameters
----------
x : list or np.array
1D or N-D data.
normalize : bool
If True, divide by the number of samples to normalize the output
between 0 and 1. Otherwise, return the absolute number of zero
crossings.
axis : int
The axis along which to perform the computation. Default is -1 (last).
Returns
-------
nzc : int or float
Number of zero-crossings.
Examples
--------
Simple examples
>>> import numpy as np
>>> import entropy as ent
>>> ent.num_zerocross([-1, 0, 1, 2, 3])
1
>>> ent.num_zerocross([0, 0, 2, -1, 0, 1, 0, 2])
2
Number of zero crossings of a pure sine
>>> import numpy as np
>>> import entropy as ent
>>> sf, f, dur = 100, 1, 4
>>> N = sf * dur # Total number of discrete samples
>>> t = np.arange(N) / sf # Time vector
>>> x = np.sin(2 * np.pi * f * t)
>>> ent.num_zerocross(x)
7
Random 2D data
>>> np.random.seed(42)
>>> x = np.random.normal(size=(4, 3000))
>>> ent.num_zerocross(x)
array([1499, 1528, 1547, 1457])
Same but normalized by the number of samples
>>> np.round(ent.num_zerocross(x, normalize=True), 4)
array([0.4997, 0.5093, 0.5157, 0.4857])
Fractional Gaussian noise with H = 0.5
>>> import stochastic.processes.noise as sn
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
>>> print(f"{ent.num_zerocross(x, normalize=True):.4f}")
0.4973
Fractional Gaussian noise with H = 0.9
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
>>> print(f"{ent.num_zerocross(x, normalize=True):.4f}")
0.2615
Fractional Gaussian noise with H = 0.1
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
>>> print(f"{ent.num_zerocross(x, normalize=True):.4f}")
0.6451
"""
x = np.asarray(x)
# https://stackoverflow.com/a/29674950/10581531
nzc = np.diff(np.signbit(x), axis=axis).sum(axis=axis)
if normalize:
nzc = nzc / x.shape[axis]
return nzc
[docs]def hjorth_params(x, axis=-1):
"""Calculate Hjorth mobility and complexity on given axis.
.. versionadded: 0.1.3
Parameters
----------
x : list or np.array
1D or N-D data.
axis : int
The axis along which to perform the computation. Default is -1 (last).
Returns
-------
mobility, complexity : float
Mobility and complexity parameters.
Notes
-----
Hjorth Parameters are indicators of statistical properties used in signal
processing in the time domain introduced by Bo Hjorth in 1970. The
parameters are activity, mobility, and complexity. EntroPy only returns the
mobility and complexity parameters, since activity is simply the variance
of :math:`x`, which can be computed easily with :py:func:`numpy.var`.
The **mobility** parameter represents the mean frequency or the proportion
of standard deviation of the power spectrum. This is defined as the square
root of variance of the first derivative of :math:`x` divided by the
variance of :math:`x`.
The **complexity** gives an estimate of the bandwidth of the signal, which
indicates the similarity of the shape of the signal to a pure sine wave
(where the value converges to 1). Complexity is defined as the ratio of
the mobility of the first derivative of :math:`x` to the mobility of
:math:`x`.
References
----------
- https://en.wikipedia.org/wiki/Hjorth_parameters
- https://doi.org/10.1016%2F0013-4694%2870%2990143-4
Examples
--------
Hjorth parameters of a pure sine
>>> import numpy as np
>>> import entropy as ent
>>> sf, f, dur = 100, 1, 4
>>> N = sf * dur # Total number of discrete samples
>>> t = np.arange(N) / sf # Time vector
>>> x = np.sin(2 * np.pi * f * t)
>>> np.round(ent.hjorth_params(x), 4)
array([0.0627, 1.005 ])
Random 2D data
>>> np.random.seed(42)
>>> x = np.random.normal(size=(4, 3000))
>>> mob, com = ent.hjorth_params(x)
>>> print(mob)
[1.42145064 1.4339572 1.42186993 1.40587512]
>>> print(com)
[1.21877527 1.21092261 1.217278 1.22623163]
Fractional Gaussian noise with H = 0.5
>>> import stochastic.processes.noise as sn
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.5, rng=rng).sample(10000)
>>> np.round(ent.hjorth_params(x), 4)
array([1.4073, 1.2283])
Fractional Gaussian noise with H = 0.9
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(10000)
>>> np.round(ent.hjorth_params(x), 4)
array([0.8395, 1.9143])
Fractional Gaussian noise with H = 0.1
>>> rng = np.random.default_rng(seed=42)
>>> x = sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(10000)
>>> np.round(ent.hjorth_params(x), 4)
array([1.6917, 1.0717])
"""
x = np.asarray(x)
# Calculate derivatives
dx = np.diff(x, axis=axis)
ddx = np.diff(dx, axis=axis)
# Calculate variance
x_var = np.var(x, axis=axis) # = activity
dx_var = np.var(dx, axis=axis)
ddx_var = np.var(ddx, axis=axis)
# Mobility and complexity
mob = np.sqrt(dx_var / x_var)
com = np.sqrt(ddx_var / dx_var) / mob
return mob, com


Dynamic Education Foundation (DEF) is a Co-Educational English Medium School. It came into existence in the year 2007. DEF was established as a Pre-Primary School (Nursery and K.G.) and Primary School (I-V) for children following the module under Board of Secondary Education Manipur (BOSEM). The School has been upgraded by a class every year till class ten (X, 2013). Now, it has classes from Pre-Nursery to Class X. DEF is run under the aegis of Public Charitable Trust- "Rural Education Foundation" bearing Register No. 250 of 2008 under Indian Trust Act. 1882, Registration Act. 1908 under Government of Manipur.
The school provide the manifold facilities like adequate class room, computer lab with Internet, well trained and experienced teachers, school bus/van services, adequate playground etc. Boarding Cum Tutorial Classes is also available
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right .
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right .
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right .
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right .
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right .
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in Bookmarksgrove right .
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts.
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts.
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts.


Nagpur has an extremely limited number of public places which are easily accessible by wheelchair. Sometimes, this could be one of the limiting factors why wheelchair users in the city don't come out from their homes. This group is for everyone who uses a wheelchair, and would like to connect with similar people to share their experiences, discuss tips on day-to-day living activities, motivate each other and last but not the least come out and have fun with people who share similar situations.
In Chennai Understanding a Disability is by not how you can get in other person's shoes but by understanding their real life problems and taking a step to create awareness in society. Anyone who is proud owner of 'understanding heart and logical brain' wanting to make a change in the world we see today to a brighter future where inclusion is everywhere are welcome here..
I am a very simple card. I am good at containing small bits of information. I am convenient because I require little markup to use effectively.
I am a very simple card. I am good at containing small bits of information. I am convenient because I require little markup to use effectively.


Chapter 5 of Search Inside Yourself looked at how to use self-awareness to master our emotions. This doesn't mean supressing emotions but being skillful in how we handle them or "making friends with our emotions". There were a few suggested methods that I would like to futher explore...
STOP-BREATHE-NOTICE-REFLECT-RESPOND. This idea of pausing, taking a moment to breathe and notice what's going on. I think it is super easy to be too hard on ourselves and feel bad about feeling bad so I like the idea of starting every thought with kindness and compassion for both oneself and others. Having humour and curiosity is another fun idea.
I found the mindfulness meditation this week really beneficial in gaining more clarity in my thoughts - although I do find I keep getting somewhat distracted and have to constantly bring my attention back to my breathing.


Performing a Quality Analysis
To start a Caliper session, Select Tools > Caliper. This begins a new, blank Caliper session. During your session, you can run queries, examine results, view individual instances, flag hits, and group results for tracking purposes. More information on these activities is presented in the books that follow.
Sessions can be stored and accessed through the Session menu. This enables you to access previously generated Caliper data or retrieve information about grouped or flagged hits that you recorded in an earlier session. For more information, see Caliper Sessions.
Caliper has two notebook pages: Quality Filters and Output. The Quality Filters notebook page allows you to run filters, view quality scores, and generate QARs. If a query fails during processing, Caliper displays error information on the Output page.
You can run Caliper’s quality filter sets on projects and files. Filter sets (at any level) can contain subsets and queries. When you double-click a filter set, you see all of the subsets and queries contained in that set.
The current filter set appears in the Filter Set box. To navigate to a higher-level set, click the Up button.
Note: The list of available filter sets and queries is determined by a mechanism called the task file. The task file contains the default list of filter lists, queries, and files they are run against.
Related Topics


HEAD Click to go to game page Click to go to homepage ======= Game Page Index Page >>>>>>> 5759a9aced0e384b2169885ce0a14dd10c727752


FoodTO
About us
Contact us
Sign Up
Login
Ryerson University
350 Victoria St
Toronto
ON
M5B 2K3
Jian Li
Jia
Jenny Wong
Mayhay Wong
FoodTO
About us
Contact us
Popular restaurants
Puck 'N Wings
Facebook
twitter
© 2016 FoodTO.
Terms of Service
Privacy


Course Description
TensorFlow is a powerful open-source software library for machine learning developed by researchers at Google. It has many pre-built functions to ease the task of building different neural networks. TensorFlow allows distribution of computation across different computers, as well as multiple CPUs and GPUs within a single machine. TensorFlow provides a Python API, as well as a less documented C++ API. For this course, we will be using Python.
This course will cover the fundamentals and contemporary usage of the
Tensorflow library for deep learning research. We aim to help students understand the graphical computational model of TensorFlow, explore the functions it has to offer, and learn how to build and structure models best suited for a deep learning project. Through the course,
students will use TensorFlow to build models of different complexity, from
simple linear/logistic regression to convolutional neural network and recurrent
neural networks to solve tasks such as word embedding,
translation, optical character recognition, reinforcement learning. Students will also learn best
practices to structure a model and manage research experiments.
Class Time and Location
January - March, 2018
Lecture: Wednesday, Friday 3:30-4:20
Location: Gates B12
Office Hours by appointment
Email<EMAIL_ADDRESS>Grading Policy
There are 3 assignments, each graded on the check-, check, check+ scale. You pass if:
+ You average check in all 3 assignments
+ and you're reasonably active in class.
I won't be taking attendance because it's really boring. But I expect to see you often in class.
FAQ
Is this a student initiated course?
Yes. Therefore, the teaching might not be as professional as the teaching of other courses. Your feedback will be greatly appreciated.
Will lectures be recorded?
Unfortunately, the lectures won't be recorded.
Is attendance mandatory?
I won't be taking attendance but I expect to see you often in class. I love talking to students to get feedback to improve the class and understand how I can make the class most helpful for them. The class is relatively small so we will probably get to know each other well.
What is the format of the class?
It will be lecture + discussion. All students in the class are really smart, so I believe the class will an excellent opportunity for us to learn from each other. We will often have guest lecturers who are TensorFlow experts.
Will the course be in Python 2 or 3?
The code examples are in Python 3. You can do assignments in either Python 2 or 3. There is really not much difference.
The course seems to focus on NLP?
The syllabus currently cover natural language processing, computer vision, and a little bit of reinforcement learning.
Can I follow along from the outside?
We'd be happy if you join us! All the slides and lecture notes will be posted on this website. You can also subscribe to the
guest mailing list to get updates from the course.
Can I audit or sit in?
In general, we are open to sitting-in guests if you are a member of the Stanford community (registered student, staff, and/or faculty). Out of courtesy, we would appreciate that you first email us or talk to the instructor after the first class you attend.
Can I work in groups for the assignment?
Yes, in groups of up to two people.
I have a question about the class. What is the best way to reach the course staff?
Stanford students please use an internal class forum on
Piazza so that other students may benefit from your questions and our
answers. If you have a personal matter, please email the staff at cs20-win1718-staff@lists.stanford.edu.


--- layout: post title: A Thought! date: 2019-07-03 22:24:06.000000000 +05:30 type: post parent_id: '0' published: true password: '' status: publish tags: [Gratitude] meta: timeline_notification: '1562172848' _publicize_job_id: '32452214924' _oembed_beb529da85dafc24ea18e5ce334da12c: "{{unknown}}" author: login: priyankasaggu119 email<EMAIL_ADDRESS>display_name: priyankasaggu119 first_name: '' last_name: '' permalink: "/2019/07/03/a-thought/" ---
July 3, 2019
Good night :)


Specifies the cloud provider to use and the credentials for accessing the cloud environment.
Important - The cloud account used to set up the container must have the privileges to create new server instances.


Material on this site was presented as part of the 2017 ARNOVA pre-conference workshop designed to introduce participants to useful data science applications and open data resources for nonprofit scholarship.
The workshop was organized by Jesse Lecy -@- and Nathan Grasse -@- in collaboration with The Urban Institute's Center on Nonprofits and Philanthropy -@-, as well as generous assistance by Brice McKeever and Francisco Santamarina.


Toolset: Acquia BLT, Acquia Dev Desktop, Acquia Pipelines
Toolset: Acquia BLT, Drupal VM, Travis CI, Acquia Cloud Site Factory
Toolset: None.


==== Buffer Overflows ====
Buffer overflows occur due to improper coding techniques. Specifically this usually occurs when a program writes data to a buffer and then overruns the buffer's boundary and begins to overwrite portions of memory. In buffer overflow exploits the attackers goal is to control a crash and gain code execution on the given system. In a buffer overflow exploit, one of the more common techniques is to overwrite a given register and "jump" to the shellcode.


Hazard brothers shine as Belgium thump Russia 4-1
ST PETERSBURG, Nov 17 — Belgium secured top spot in Euro 2020 qualifying Group I and stretched their perfect record to nine wins after two goals from Eden Hazard and one by his brother Thorgan inspired them to a sparkling 4-1 win in Russia yesterday.
With one round of games remaining, Belgium have a maximum 27 points and second-placed Russia 21, both sides having booked their places at next year’s 24-nation tournament.
Although there was only pride to play for, the game got off to a pacy start and Thorgan Hazard fired the visitors ahead with a superb 19th-minute goal when he side-stepped his marker and blasted an unstoppable shot into the top corner.
Eden Hazard made it 2-0 in the 33rd with another fine effort, volleying a low drive past Russia’s Brazilian-born goalkeeper Guilherme after striker Romelu Lukaku headed a lofted pass into his captain’s stride.
The livewire forward doubled his tally shortly before halftime from a brilliant move, with midfielder Kevin De Bruyne squaring the ball unselfishly for Hazard to stroke into an empty net from 12 metres.
Only poor finishing by Lukaku and two good saves by Guilherme denied the Belgians a bigger lead in the opening hour as Russia failed to create anything in front of a partisan home crowd.
Ruthless Belgium struck again in the 72nd minute as Lukaku made amends for his early miss, rifling a scorcher inside the near post from 16 metres with Guilherme clutching nothing but thin air.
Georgi Dzhikiya finally gave the subdued home fans something to cheer about when he swept home a close-range rebound in the 79th, but it was scant consolation for a crushing defeat by last year’s World Cup semi-finalists. — Reuters


{% extends 'disturbance/emails/base_email.html' %} {% block content %} {% if proposal.approval.reissued %}
Approval {{proposal.approval.lodgement_number}} for Proposal {{proposal.lodgement_number}} has been reissued.
{% else %}Proposal {{proposal.lodgement_number}} has been approved
{% endif%} {% endblock %}


Hello World!
This is a web page.
This is an html unordered list of the days of the week
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday


Downloads
Support
Community
Development
Latest stable release
Get the latest stable release of openSUSE
Latest development release
Get the latest development release of openSUSE
Search for packages
Get additional software from openSUSE Build Service
Derivatives
Get one of the specialized distributions built on openSUSE


class="active">About Communications | Join ACM | Renew | Subscribe | Sign In | For Authors | For Advertisers | Privacy | Site Map | Help | Contact Us
Copyright © by the ACM. All rights reserved.


A jQuery based color picker component that enables you to pick colors from a restricted palette defined in an HTML template.


Fabric8-analytics QA dashboard
Services liveness and readiness
Environment
Core API
Jobs API
Auth.token
to core API
Auth.token
to jobs API
Smoketests
Smoketests
history
Stage
✓
✓
✓
✓
?
Production
✓
✓
✓
✓
×
link
0/100
SLA
Benchmark
Stack analysis
Component analysis for known component
Component analysis for unknown component
Test type
Sequential
Parallel
Sequential
Parallel
Sequential
Parallel
Results
duration (s)
limit (s)
status
duration (s)
limit (s)
status
duration (s)
limit (s)
status
duration (s)
limit (s)
status
duration (s)
limit (s)
status
duration (s)
limit (s)
status
Max.time
68.39
60.00
×
75.08
60.00
×
0.96
1.50
✓
2.86
5.00
✓
1.64
1.50
×
4.88
5.00
✓
Avg.time
45.03
45.00
×
35.35
45.00
✓
0.89
1.00
✓
1.56
2.00
✓
1.25
1.00
×
3.07
2.00
×
Total time
225.17
250.00
✓
209.70
200.00
×
8.92
12.00
✓
7.20
12.00
✓
12.54
12.00
×
13.31
12.00
×
Code quality
Repository
Source files
Linter results
Pydocstyle results
Code coverage
Dead code
Common issues
Cyclomatic
Complexity
Maintainabi-
lity Index
Overall
status
Remark
Files
Total lines
Pass
Fail
Pass %
Pass
Fail
Pass %
Stmts.
Missed
Covered
A
B
C
D
E
F
A
B
C
fabric8-analytics-common
108
14415
108
0
100%
108
0
100%
ok
ok
966
57
0
0
0
0
108
0
0
×
unit tests has not been setup
fabric8-analytics-server
60
6296
60
0
100%
60
0
100%
1964
948
52%
1
ok
292
25
12
0
0
0
58
2
0
×
improve code coverage
improve maintainability index
remove dead code
fabric8-analytics-worker
162
16812
162
0
100%
161
0
100%
6025
2211
63%
15
2
849
90
15
1
0
1
162
0
0
×
improve code coverage
1 file ignored by pydocstyle
reduce cyclomatic complexity
remove dead code
fix common errors
fabric8-analytics-jobs
41
4059
41
0
100%
41
0
100%
1982
1590
20%
1
ok
190
31
5
1
0
0
41
0
0
×
improve code coverage
reduce cyclomatic complexity
remove dead code
fabric8-analytics-tagger
43
4107
43
0
100%
43
0
100%
887
36
96%
ok
ok
237
31
14
0
0
0
43
0
0
✓
fabric8-analytics-stack-analysis
91
5460
91
0
100%
91
0
100%
2118
1029
51%
ok
ok
256
17
3
0
0
0
91
0
0
×
improve code coverage
fabric8-analytics-license-analysis
29
3825
29
0
100%
29
0
100%
827
49
94%
ok
ok
213
27
13
1
0
0
27
2
0
×
reduce cyclomatic complexity
improve maintainability index
fabric8-analytics-data-model
25
3402
24
0
100%
24
0
100%
896
64
93%
ok
1
132
28
8
2
1
0
24
1
0
×
not all source files are checked by linter
not all source files are checked by pydocstyle
reduce cyclomatic complexity
improve maintainability index
fix common errors
fabric8-analytics-recommender
16
981
16
0
100%
16
0
100%
ok
2
58
4
0
0
0
0
16
0
0
×
unit tests has not been setup
fix common errors
fabric8-analytics-api-gateway
9
378
9
0
100%
9
0
100%
149
69
54%
ok
ok
23
1
0
0
0
0
9
0
0
×
improve code coverage
fabric8-analytics-nvd-toolkit
33
5043
33
0
100%
33
0
100%
1042
85
92%
ok
ok
219
23
2
0
0
0
33
0
0
✓
fabric8-analytics-auth
7
666
7
0
100%
6
1
86%
149
33
78%
ok
ok
46
1
1
0
0
0
7
0
0
×
improve code coverage
pydocstyle check failed
fabric8-gemini-server
19
1669
19
0
100%
19
0
100%
409
23
94%
ok
ok
90
7
0
0
0
0
19
0
0
✓
fabric8-analytics-version-comparator
8
1054
8
0
100%
8
0
100%
217
0
100%
ok
ok
49
10
2
0
0
0
8
0
0
✓
fabric8-analytics-ingestion
13
852
13
0
100%
13
0
100%
228
137
40%
ok
ok
39
1
0
0
0
0
13
0
0
×
improve code coverage
fabric8-analytics-npm-insights
24
1195
24
0
100%
24
0
100%
241
25
90%
ok
ok
55
0
1
0
0
0
24
0
0
✓
fabric8-analytics-jenkins-plugin
10
1001
N/A
N/A
N/A
N/A
N/A
N/A
336
109
67%
×
×
0
0
0
0
0
0
0
0
0
×
linter is not setup
docstyle checker is not setup
improve code coverage
setup dead code detection tool
setup common errors detection tool
fabric8-analytics-notification-scheduler
11
1466
11
0
100%
11
0
100%
392
28
93%
ok
ok
41
2
3
0
0
0
11
0
0
✓
fabric8-analytics-utils
4
312
4
0
100%
4
0
100%
58
0
100%
ok
ok
18
4
0
0
0
0
4
0
0
✓
f8a-server-backbone
11
2114
11
0
100%
11
0
100%
665
200
70%
ok
ok
56
14
4
1
0
0
11
0
0
×
improve code coverage
reduce cyclomatic complexity
f8a-hpf-insights
23
1084
23
0
100%
23
0
100%
242
3
99%
ok
ok
77
3
2
0
0
0
23
0
0
✓
cvejob
25
1791
21
0
100%
21
0
100%
448
199
56%
ok
ok
78
13
3
0
0
0
21
0
0
×
improve code coverage
Summary
CI jobs
Repository
Build job
Test job
Pylint job
Pydocstyle job
fabric8-analytics-common
×
fabric8-analytics-server
fabric8-analytics-worker
fabric8-analytics-jobs
fabric8-analytics-tagger
×
fabric8-analytics-stack-analysis
fabric8-analytics-license-analysis
fabric8-analytics-data-model
fabric8-analytics-recommender
×
×
fabric8-analytics-api-gateway
×
fabric8-analytics-nvd-toolkit
×
fabric8-analytics-auth
×
fabric8-gemini-server
fabric8-analytics-version-comparator
×
fabric8-analytics-ingestion
×
fabric8-analytics-npm-insights
fabric8-analytics-jenkins-plugin
×
×
×
fabric8-analytics-notification-scheduler
fabric8-analytics-utils
f8a-server-backbone
f8a-hpf-insights
×
cvejob
×
Author: Pavel Tisnovsky <
<EMAIL_ADDRESS>>
Generated on: 2018-09-24 11:04:07


The basis of the main screen is to show you a list of all repositories you have access to in a given user or organization account. Click on the "Refresh" button to perform the search. This screen will list you all repositories which the account token you entered can access from the selected user or organization.


Provider Directory
v2.0
Create Provider
Last Name
Frist Name
Email Address
Specitity
Practice
Provider List
Sort By
Last name
Specitity
Name of practice
Remove


- Loading -
- Loading -
- Loading -
- Loading -
×
Model:
Variant:
Years:
-
Fuel:
Engine Size:
0
ccm
ECU Type:
Available
Services
Stages
Request quote
Specs
Original
Modified
Difference
Power
(
)
Torque
(
)
Quote request
×
Car
Make:
- Loading -
Model:
- Loading -
Fuel:
- Loading -
Variant:
- Loading -
Selected stage
Options
DPF Removal
EGR Removal
VMax Removal
Rev Limiter Removal
Launch control
Name
*
E-mail
*
Telephone
Vehicle year
*
- Please select -
Address
Town/city
*
Country/State
ZIP
Additional comments


Always a pleasure scaffolding your apps.
Splendid!
{{ portfolio.updated_at }}
{{portfolio.description}}
{{portfolio.url}}


Application deployed successfully at {0}
App(id=C:\samples\Calculator-new\hello-addservice.jar)
EjbJar(id=hello-addservice.jar, path=C:\samples\Calculator-new\hello-addservice.jar)
Ejb(ejb-name=HelloBean, id=HelloBean)
Jndi(name=HelloBean)
Jndi(name=HelloBeanLocal)
Ejb(ejb-name=AddServiceBean, id=AddServiceBean)
Jndi(name=AddServiceBean)
Jndi(name=AddServiceBeanLocal)
Deploy Tool
NAME
openejb deploy - OpenEJB Deploy Tool
SYNOPSIS
openejb deploy options <file> [<file> …]
NOTE
The OpenEJB Deploy tool is an OPTIONAL tool that allows you to deploy into a running server and get feedback as if the app was deployed and how it was deployed (deploymentIds, jndi names, etc.).
It can be used to deploy into an offline server, however in this
scenario it simply copies the archive into the deployment directory (by
default openejb.base/apps
) which is something that can be done
manually with a simple copy command or drag and drop.
The OpenEJB Deploy tool can be executed from any directory as long as
openejb.home/bin
is in the system PATH. openejb.home
is the
directory where OpenEJB was installed or unpacked. For for the remainder
of this document we will assume you unpacked OpenEJB into the directory
C:\openejb-3.0
under Windows.
In Windows, the deploy tool can be executed as follows:
C:-3.0> bindeploy --help
In UNIX, Linux, or Mac OS X, the deploy tool can be executed as follows:
user@host# bin/openejb deploy --help
Depending on your OpenEJB version, you may need to change execution bits to make the scripts executable. You can do this with the following command.
user@host# chmod +x bin/openejb
From here on out, it will be assumed that you know how to execute the right openejb script for your operating system and commands will appear in shorthand as show below.
openejb deploy --help
DESCRIPTION
The files passed to the Deploy Tool can be any combination of the following:
-
EJB 1.1, 2.0, 2.1, 3.0 or 3.1 jar
-
application client jar
-
EAR file containing only libraries, EJBs and application clients — everything else will be ignored.
The type of the files passed is determined as follows:
-
Archives ending in
.ear
or containing aMETA-INF/application.xml
are assumed to be EAR files. -
Archives containing a
META-INF/ejb-jar.xml
file or any classes annotated with@Stateless
,@Stateful
or@MessageDriven
, are assumed to be EJB applications. EJB applications older that EJB 3.0 should contain a completeMETA-INF/ejb-jar.xml
inside the jar, however we do not strictly enforce that — the act of it being incomplete makes it an EJB 3.0 application by nature. -
Archives containing a
META-INF/application-client.xml
or with aMETA-INF/MANIFEST.MF
containing theMain-Class
attribute, are assumed to be Application Client archives.
OPTIONS
-d, --debug
Increases the level of detail on validation errors and deployment summary.
--dir
Sets the destination directory where the app will be deployed. The default is /apps/ directory. Note when changing this setting make sure the directory is listed in the openejb.xml via a tag or the app will not be picked up again on restart.
-conf file
Sets the OpenEJB configuration to the specified file.
-h, --help
Lists these options and exit.
-o, --offline
Deploys the app to an offline server by copying the archive into the server’s apps/ directory. The app will be deployed when the server is started. The default is online.
-q, --quiet
Decreases the level of detail on validation and skips the deployment summary.
-s, --server-url <url>
Sets the url of the OpenEJB server to which the app will be deployed. The value should be the same as the JNDI Provider URL used to lookup EJBs. The default is 'ejbd://localhost:4201'.
-v, --version
Prints the OpenEJB version and exits.
EXAMPLES
Deploying multiple jar files
openejb deploy myapp.jar myapp.jar
Deploys the beans in the fooEjbs.jar first, then deploys the beans in the barEjbs.jar. Wildcards can be used as well.
openejb deploy myapp*.jar
OUTPUT
On running the deploy tool with a valid EJB jar the following output is printed on the console
Note: In the above case the command used is: > openejb deploy hello-addservice.jar
The JAR file contains two EJBs: AddServiceBean and HelloBean.


SCARY MOVIE A film review by Christopher Null Copyright 2000 filmcritic.com filmcritic.com
A cynic would say any filmmaker is looking for trouble by trying to make a spoof out of another spoof.
Scary Movie is just that spoof, a Wayans brothers special that's a flat-out parody of Scream -- both of which ironically were produced by Dimension Films. Studio spoofs itself -- now that's comedy!
Oddly, I have very little to say about this picture at all. There's not much point to discussing the plot of Scary Movie (mercifully renamed from Scream If You Know What I Did Last Halloween). If you've seen Scream (and Scream 2), I Know What You Did Last Summer (and its sequel), The Sixth Sense, The Blair Witch Project, and, delving into more curious spoof choices like The Matrix, The Usual Suspects, and the Budweiser "Whassup" commercials -- then you'll "get" Scary Movie.
Not that there's much to it to "get." As usual with this genre, there's no story; the Wayanses simply pummel the audience with gag after gag. My humor-o-meter pegs the success rate of these jokes at about one in three, including (at best count) three fart jokes, two penis jokes, one testicle joke, and at least three jokes about Scary Movie not being real, but, you know, actually being a movie instead.  Yeah, one in three is about right.
Ironically, Scary Movie spoofs the teen horror genre but is so raunchy it's shocking it isn't rated NC-17. I guess the old phallus-through-the-head gag is a-ok these days.
While this is the best film Keenan Ivory Wayans has been involved with since his first film, 1987's Hollywood Shuffle, that isn't saying much (did you see The Glimmer Man?). Still, if you're looking for a little gross-out raunchiness and you've already seen Me, Myself & Irene, Scary Movie may be the perfect late-night fix. Just consider yourself warned.

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Mandor Mountains [ar25], mountain, in Mandoria, wilderness
Last updated Turn #140
Mandor Mountains [ar25], mountain, in Mandoria, wilderness
------------------------------------------------------------------------
7: Pack of wolves [bf9a], wolves, number: 6, arrived from the south.
9: Pack of wolves [bf9a], wolves, number: 6, went south.
14: Stack of savages [ia7g], savages, number: 16, arrived from the south.
16: Stack of savages [ia7g], savages, number: 16, went south.
Routes leaving Mandor Mountains:
North, forest, to Great Forest [aq25], 8 days
Garrison [ck6m], garrison, uncontrolled, with four peasants
East, forest, to Great Forest [ar26], 8 days
Garrison [fz5i], garrison, uncontrolled, with two soldiers
South, mountain, to Mandor Mountains [as25], 10 days
Seen here:
Stack of giants [ir4b], giants, number: 7


Log in/Sign up
Complaint
Self Defense
Sessions
Home
REGISTER YOUR COMPLAINTS HERE
×
Name
Email
Phone number
Message
Submit


Digital Audio
Digital audio can be represented in a variety of different formats. In digital audio, sound is represented by an array or numbers. Increasing array indices corresponding to various times, and the value of each array index corresponds to the volume at that particular time. A common format is a 16-bit array with values ranging from -1 to 1. The human hearing range is from about 20 Hz to 20 kHz. The Nyquist-Shannon Theorem states that a sample rate of 2x the highest frequency is possible to represent audio, so 22,050 * 2 = 44,100 samples per second. 44.1k is called the sample rate. Putting the bit depth (16 bit) and the sample rate (44.1 kHz) together, we can represent audio in a pretty accurate manner.
The Web Audio API
The Web Audio API is native browser code that allows users to render audio in the browser and create audio tools from within the browser. The types of audio tools the Web Audio API can create are waveforms (relates amplitude to time), ferquency bar graphs (mapping amplitude over frequency), and spectrograms (maps frequency and amplitude over time).
Waveforms
Waveforms are probably the most common way of visually representing audio data. Here is what the beginning of Such Great Heights by The Postal Service looks like
Time is on the x-domain, each sample of time represents a speaker's position between -1 and 1. Samples with a higher magnitude relate to louder noises.
Frequency Bar Graphs
Another popular audio tool provided by the Web Audio API is the frequency bar graph. This is similar to EQ tools found in programs like Logic and Pro Tools.
Click here for a frequency bar graph demo.
Frequencies from 20 Hz to 20 kHz (log scale) are on the x-domain, and the corresponding amplitude of those frequencies are represented by the height of the bar.
Spectrograms
The last audio tool we'll be looking at is a spectrogram. This is one of my favorite ways to represent digital audio, because it shows both frequency and amplitude in relation to time.
Click here for a spectrogram demo.
Unfortunately, the Web Audio API cannot render spectrograms faster than real-time. This is a problem I am working on, because it would be nice to show the spectrogram without having to listen to the entire audio file.
Sound eXchange (sox)
sox (short for sound eXchange) is a command-line tool that is the "Swiss Army Knife of sound processing programs". It can efficiently convert audio file types, change characters of audio files (such as sample rate and bit depth), or can simply gather statistics about audio files. I use sox primarily for the last purpose.
If I run sox suchgreatheights.wav -n stat
, I see this:
| Samples read | 3652062 |
| Length (seconds) |<PHONE_NUMBER>.0 |
| Maximum amplitude | 0.980316 |
| Minimum amplitude | -0.992493 |
| Midline amplitude | -0.006088 |
| Mean norm | 0.111005 |
| Mean amplitude | -0.000524 |
| RMS amplitude | 0.150947 |
| Maximum delta | 0.856506 |
| Minimum delta | 0.000000 |
| Mean delta | 0.072774 |
| RMS delta | 0.101534 |
| Rough frequency | 4721 |
| Volume adjustment | 1.008 |
The first 40 seconds of Such Great Heights uses panning (imaging from left to right) to fill the space in the listener's aural spectrum. We can see that the left channel has a higher peak than the right channel by comparing the amplitude of the min and max levels.
Now let's say that the left channel isn't working for whatever reason. This is what we would expect to see from the above commands:
$ sox suchgreatheights-noL.wav -n stat
| Samples read: | 3652062 |
| Length (seconds): | 41.406599 |
| Scaled by: |<PHONE_NUMBER>.0 |
| Maximum amplitude: | 0.935638 |
| Minimum amplitude | -0.974030 |
| Midline amplitude | -0.019196 |
| Mean norm | 0.055051 |
| Mean amplitude | -0.000273 |
| RMS amplitude | 0.106304 |
| Maximum delta | 0.974060 |
| Minimum delta | 0.000000 |
| Mean delta | 0.110054 |
| RMS delta | 0.150337 |
| Rough frequency | 9925 |
| Volume adjustment | 1.027 |
$ sox suchgreatheights-noL-.wav -n stats
| Overall | Left | Right | |
| DC offset | -0.000546 | -0.000000 | -0.000546 |
| Min level | -0.974030 | -0.000305 | -0.974030 |
| Max level | 0.935638 | 0.000305 | 0.935638 |
| Pk lev dB | -0.23 | -70.31 | -0.23 |
| RMS lev dB | -19.47 | -84.13 | -16.46 |
| RMS Pk dB | -9.64 | -83.44 | -9.64 |
| RMS Tr dB | -84.79 | -84.79 | -76.39 |
| Crest factor | - | 4.91 | 6.48 |
| Flat factor | 0.00 | 0.00 | 0.00 |
| Pk count | 2 | 2 | 2 |
| Bit-depth | 16/16 | 5/16 | 16/16 |
| Num samples | 1.83M | ||
| Length s | 41.407 | ||
| Scale max | 1.000000 | ||
| Window s | 0.050 |
Note that -70 dB is close to silent. The noise in the left channel is probably just post-processing noise.
Comparing Two Audio Files
One way of verifying ad playback is by comparing the expected file to the audio that was actually played. There are a few factors that affect the version that actually played:
- the station's DJ could have been talking over the advertisement
- the audio levels on the mixing board may have been too high or too low (levels that are too high will result in clipping)
- the ad may have not played at the correct time
Any of the above factors will result in an ad that was not played correctly, and the radio station will not be paid for the incorrect playback of that advertisement.
Radio Advertisements
Advertisements drive the radio industry. Radio stations include advertisements in their broadcasts to make money to cover costs of running the radio station. Radio advertisements reach a surprisingly large amount of people. Unlike online ads, users cannot use an ad-block program on the radio. Additionally, the majority of commuters still listen to FM radio on their way to and from work. By its nature, radio has a huge reach.
Using the Web Audio API and Sox to Track Radio Advertisements
Now let's put this in the context of radio advertisements. In my case, advertising agencies provide us with the advertisements, and when the radio station wishes to play an ad, all they have to do is press a button and a program will programmatically decide which ad to play in order to reach the target audience.
But what if the ad wasn't played correctly? What if the DJ was talking over the first 15 seconds of the ad? What if the faders were too high or too low? This is where SoX comes in.
By comparing the characteristics of the expected audio file to the characteristics of the played audio file, we can determine if the ad was correctly played, and in turn, if the radio station will be played for the playback of the ad.
In the above example, we can clearly see that the left channel of Such Great Heights differs from the right channel. Stereo sound has a left and a right channel that are not necessarily the same, but in this case, it is clear that the audio simply did not play in the left channel. Had this been an advertisement, the radio station would not have been paid.
But doing sanity checks like above is not easy when you play tens of thousands of ads per day. Thus, we need a programmatic solution.
I am currently working on building a training set with the SoX data. The dataset has a combination of good and bad audio, and I am building models to more efficiently decide what is good and bad audio. Unfortunately, I am not at liberty to expose this information.
The skills I have learned in Data Science have very cool applications in my life. Being an audio engineer means a lot of miniscule tweaks to get just the right sound, and if I can do this programmatically, it makes my job easier.


There are a great number of project ideas in my mind right now, but personally, app developing is what I am interested in at the moment. Not only does it help me build up my knowledge about coding and solving problem, but also help serve the society as well.
Overview: The project is called “SOS”. It is an application for mobile which has two interfaces, one for the emergency services (mainly for hospital and healthcare services) and one for the user. This app allows the user to call for emergency service as well as their family for many emergency cases such as a heart attack or a stroke. Moreover, the app has the GPS build in so that other family members and emergency services can locate and find the position where the help is needed. On the other hand, the emergency services’ device has the ability to receive a signal and trigger an alarm that show the location and what kind of service they need.
Motivation: CVDs or Cardiovascular diseases are the number one cost of death, and it takes to 17.9 million lives every year (WHO 2020). Furthermore, the famous comedian, actor, and singe Chi Tai has passed away recently due to a stroke and nobody was there to help or to call the emergency services even though the building was highly secure with many cameras to monitor every activity of the citizen. For that reason, this app can call for the emergency service immediately without any delay of dialling number, which can save a great amount of time because the victim only has 15 to 45 minutes or else the chance of survival is really low.
Description:
The app is quite like any ordinary apps that you would fine on Google Play or Appstore. This is a family app, which means that all the family should download so that all family member can register the app by claiming that which user is the user in the family.
Each user must register to this app to verify that they are responsible enough to use the app. If a user tries to prank call or fake an emergency incident, he or she will be fined for a reasonable amount or may have to face with the law so they have to agree with the terms and rules of this app.
When you open this app, it would lead to the user interface like Figure 1. It can be seen that there are three buttons on the screen of your phone. The first button allows you to call for the ambulance immediately, which is then transfer to a map of your current location where you can see the path of the ambulance heading to you and the path leads to the nearest hospital. The second button does not call for the ambulance, however, it triggers the alarm for all the family member who have register for the app and notify which family member is in needed of health care and show the current location of that person. The third button is for a more serious problem, it both triggers the alarm for all the family member and also call the ambulance for the victim, what is more, the app will display a screen showing where the current family members are and the current location of the ambulance.
Figure 1: example of app’s interface
There is also a shortcut to this app. There will be a always display notification function build in this app, which means that whenever a user open his or her phone, there always a notification bar that has all three buttons which server the same function as the three buttons when opening the application
Figure 1: example of app’s interface
As for the healthcare services, the application runs on a main computer which notify the healthcare services and from there, they will send or the system will automatically choose the nearest hospital and choose a path for the ambulance to arrive to the location where the help is needed.
Tools and Technologies: This app is compatible with IOS, Android, Window, and Raspberry and it always have a simple and easy to use interface for the user. However, it is necessary that the app need to be able to connect to Wi-fi or to the phone signal so that it can contact the Emergency Service and all other family member. Moreover, only phones, tablets which support GPS and Location Services can download and use this app, or else it would be impossible for the app to track down the current location of the user or the victim. To make it clearer, the app work best on smartphones and any other tablets, as long as they have a GPS system build in.
Skills required: For this project, because it is an app for all smartphones, it is very important that all team members can use Android Studio, built by Google, or some other coding language such as Kotlin or Jarva so that it is possible to develop an android app (mopinion 2020). As for IOS, team members also have to learn C or Swift so that they can successfully develop an IOS app. For IOS, it is recommended that developers use Xcode 11, which is free and has a user-friendly interface. However, we only need to focus on one software first such as Android Studio for Android or Xcode 11 for IOS, but if we want to utilize our app and make it work well with both Android and IOS, then the two software should be learned by every member.
Outcome: If we successfully develop our app, it is possible that it could help save many people, as a matter of fact, many people right now might be having trouble without the notice of the others, so not only can it safe lives, it can also notify the family members. Moreover, it is not only for healthcare services but also can be expand to many more Emergency Services such as fire department and Police Station in the future.
“First of all, I think this is a great innovation and a great idea. It is not only new to the app development industry, but also it could benefit greatly for many people. It can help save many lives and could help and raise awareness among the family member, however, there are few things that need to be fixed. First of all, this app is for smartphone, which is for younger generation, older people are the one who need this service the most, then, it should be easier to download and use so that all generation can use the most out of this app, one other thing, it should be able to connect to the SIM so that the user won’t have to download the app but still can use the service.”
Nguyen Luu Quoc Bao
“From my perspective, it is an app that can really help a lot of people, especially the elderly, however, I think that this idea can go a little bit further by not only making an app, maybe try to make a device that can all for emergency service and monitor your health at same time and predict what is your risk of having which problem. But for a start, the overview is quite clear and surely it would help prevent the rising number of incidents.”
Nguyen Dang Nhat
"Thank you for all your feedback on the project idea for our group. Overall, these feedbacks do prove out some of the shortcomings of the project idea. Moreover, these feedbacks also state the benefit of this app for both the community and for ourselves which help the daily life more healthy. As for Bao’s feedback, I agree that it should be an easier way for the elderly to install such a complicated app, for most people do not know how to use smartphone, and to fix this problem, in the near future, if the app is successfully launched, I would get the authorize from Apple and Google to have the app installed as the default app in the phone, which means that the app is automatically installed when a client buys a phone. On the other hand, I would disagree with the feedback of Nhat, because our idea is focusing on making a free app, providing a free service that everybody could use, and to make that device is clearly would cost a lot of money for the users, but what we could do is we improve the app so that it will be capable to work on smartwatches so that smartwatch can monitor the health, having daily check-up for our body."
created with
HTML Website Builder .


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/Leo's.20slides.20on.20Lean.204.html ---
Apropos Lean 4: Leo gave a new talk at Galois inc. You find the slides on leanprover.github.io: http://leanprover.github.io/talks/LeanAtGalois.pdf Some new information about Lean4!
What do the colors mean on slide 29?
I guess blue are things implemented in C++, green for Lean, and red is external
(deleted)
On the second slide it says: "Lean is a platform for software verification and formalized mathematics"
while software verification is highlighted mathematics is still mentioned...
but he was talking in front of people doing software verification
He mentions Mario's ring tactic
he hardly ever talks about mathlib
Kevin, he even mentions you!
The future of Lean 4 depends on you (-;
He mentioned me in his Oxford talk. He believes in using Lean for education so it gets a mention. He is more skeptical about mathlib (he thinks it's too early) and in his Oxford talk he barely mentioned it at all.
On the other hand, ring
is a really nice tactic, and Mario's recent edits to the tactic show that it really is not a trivial matter at all to get it working in Lean.
Well, I think that mentioning education is worth a lot more then pointing out: "Hey we've got our mathlib, which contains not even half of the stuff contained in other provers stdlibs"
If he were to mention mathlib I think he'd do better by talking about the derivative of the size rather than the size.
The education thingy is pretty spectacular. And if it is a success, then a successful mathlib is a corollary.
And in some sense I'd like to take issue with this "maths library too small" comment. So we don't have Godel's incompleteness theorem. But we do have schemes and hence we have stuff taught at MSc level in a normal mathematics department. And soon we'll have perfectoid spaces and hence we will have stuff taught at PhD level in a strong mathematics department. I would be interested to see a list of topics which are in other theorem provers and which are introduced only at beginning graduate student level in a strong mathematics department in a mainstream (i.e. geometry, number theory, topology, algebra, analysis) course.
External contributors can prove the new compiler is correct
See, he did mention me
Leo told me I need to go into schools. He is really serious about the idea. I have one school talk in my calendar in October and I will almost certainly be doing another one before the end of the year.
also, he's revealing quite a bit about lean 4 internals stuff, like the new lean IR. This is the first public appearance of it, so I guess he thinks it's pretty stable at this point
@Mario Carneiro What do you think of the promise of better support for proofs by reflection?
I think it's great. Jeremy and I have talked before about an analogue to Coq's vm_compute
, i.e. using #eval
to prove theorems. This is sorely needed in many places, i.e. you can easily prove primality of 10 digit numbers using #eval
but it is nearly impossible to use the decidable instance in the kernel. Obviously using #eval
to prove things means that your trusted code base must include the entire compiler and associated things, but lean 4 is opening up the possibility of proving that all correct anyway, plus even an unverified computation is far more trustworthy than a human calculation, so I'm not particularly worried about inconsistency.
One thing you can do today to emulate vm_compute
is to normalize a term in the VM, then assert the equality as an axiom or use sorry. This has some obvious downsides though, since you can exploit these axioms to prove false things if you circumvent the tactic, i.e. it's not really checked for correctness. Doing this inside Lean would prevent the possibility for exploitation outside bugs in lean itself.
What worries me is that if we use this kind of feature, we may not have a choice to trust a lot of software. If one of our libraries use it, everything downstream won't be able to check using a small kernel
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


×
Hello there, thanks for visiting!
It’s a simple JSON formatter, I just made it because I needed it, I hope you’ll find it handy. :)
You know, paste an API result on the huge editor and click on the button. Simple as finding that button.
Maybe I’ll add some functionality later, it’s really just a quick copy/paste code from several places.
The main idea comes from the old version of jsonlint.com.
Keep it simple. \m/o.O\m/
Don’t worry, it's client-side only, I send nothing to my backend, hosted on GitHub.
However, even I try to make it for good please use it at your own risk.
2017-20, @SubZtep