text:
## Where communities thrive

• Join over 1.5M+ people
• Join over 100K+ communities
• Free without limits
##### Activity
• Jun 22 08:53

schillic on gh-pages

build based on 6c26d09 (compare)

• Jun 22 08:38

schillic on master

• Jun 21 16:29

mforets on gh-pages

build based on 6c729af (compare)

• Jun 21 16:25

mforets on gh-pages

build based on bb98ff2 (compare)

• Jun 21 16:04

github-actions[bot] on v0.14.17

• Jun 21 16:02
JuliaTagBot commented #376
• Jun 21 15:46

github-actions[bot] on gh-pages

delete history (compare)

• Jun 21 15:46
JuliaRegistrator commented #111
• Jun 21 15:46
mforets commented #111
• Jun 21 15:45

mforets on master

Update Project.toml (compare)

• Jun 21 15:45

mforets on common_solve

• Jun 21 15:45

mforets on master

use common solve Merge pull request #522 from Ju… (compare)

• Jun 21 15:45
mforets closed #522
• Jun 21 15:45
mforets closed #417
• Jun 21 14:49

mforets on gh-pages

build based on 7758751 (compare)

• Jun 21 14:21

schillic on gh-pages

build based on 410bdbb (compare)

• Jun 21 14:06
schillic updated the wiki
• Jun 21 14:05
mforets opened #522
• Jun 21 14:03

schillic on 2745

• Jun 21 14:03

schillic on master

complement check for half-spaces conversion from HPolyhedron to … ishyperplanar function and 3 more (compare)

Marcelo Forets
@mforets
yes, i guess that's what i have in mind , that the construction helps with dispatch. for example suppose there's a new operation Foo(A, B, X, ..) where the arguments are arrays or lazysets. if we let Foo <: LazySet and we know how to compute the support function, i.e. implement ρ(d::AbstractVector, F::Foo) where $\rho(d, F) = \max_{x \in Foo(...)} d^T x$, then we can reuse a lot of code that has been written generically using support functions.
This includes, say overapproximate(::Foo, something), or composing eg. $\rho(d, A * Foo(..) \oplus Foo(...))$
note that A * Foo(..) just works and is again a lazyset (the lazy linear map of a Foo object)
Gustavo Goretkin
@goretkin

https://github.com/JuliaReach/LazySets.jl/blob/master/src/Approximations/overapproximate.jl#L1202

I dug into this at https://github.com/goretkin/FixArgs.jl/issues/21#issuecomment-739122718 There are some features that FixArgs.jl needs still, but I hope it helps to see what the composition looks like

Gustavo Goretkin
@goretkin

I am not sure if there are places where the annotation ::LazySet prevents an ambiguity (current or future). For example:

https://github.com/JuliaReach/LazySets.jl/blob/53f21cb9c26355e7f218578e5b4036c3ff0091fe/src/Approximations/overapproximate.jl#L81-L96

overapproximate(S,
::Type{<:HPolygon},
ε::Real=Inf)
Gustavo Goretkin
@goretkin

Binding the value of N is a separate problem, but I think fixable. Same with constraints, like ensuring two LazySets have the same N.

Alternatively, maybe there could be something like

struct LazySet2{N, T<:FixArgs.Fix} <: LazySet{N}
_::T   # it is possible to avoid naming a field when there is only one. access with lazyset2._.
end
Marcelo Forets
@mforets
I am not sure if there are places where the annotation ::LazySet
This sometimes prevents piracy eg Plots and Polyhedra export several names that are also used in LazySets
Gustavo Goretkin
@goretkin

This sometimes prevents piracy eg Plots and Polyhedra export several names that are also used in LazySets

Oh, of course, good point.

Gustavo Goretkin
@goretkin
well, wait. To make sure I understand, it's not because of name collisions, right? We're talking about controlling dispatch, which is the only thing that types in julia are arguably for
So e.g. defining RecipesBase.@recipe function somefunction(arg1::LazySet) end)
Gustavo Goretkin
@goretkin

So, yes, I agree.

So assuming that something like LazySet2 (but with a better name) is the right solution (I am not sure), then there is still a need to encode the information that is encoded by the type hierarchy now, e.g.

abstract type AbstractAffineMap{N, S<:LazySet{N}} <: LazySet{N} end

and

struct LinearMap{N<:Real, S<:LazySet{N}, NM, MAT<:AbstractMatrix{NM}} <: AbstractAffineMap{N, S}

Gustavo Goretkin
@goretkin
I mentioned them before. The only solution to this is "traits". In fact, if plot recipes used traits, then you probably don't even need LazySets. I'm not sure if LazySets.jl uses anything traits-like already. I (and lots of other julia people) use "traits" specifically to mean things that can control dispatch. So
isoperationtype(::Type{<:AbstractAffineMap}) = true is not a trait by this definition, since julia can't dispatch on true or false. But it can, however, dispatch on Val{true} and Val{false} (and for that matter, Val{true}() and Val{false}() as well)
Gustavo Goretkin
@goretkin
Marcelo Forets
@mforets
:thumbsup: LazySets does not use traits, but we have planned to do so for extending the type hierarchy with sets representations which are not convex
Marcelo Forets
@mforets
what is a good way to write a list of equations with documenter?
it uses aligned
Marcelo Forets
@mforets
Christian Schilling
@schillic
:+1:
Marcelo Forets
@mforets
FYI yesterday I added some mathematical details on LGG09 algorithm : https://juliareach.github.io/ReachabilityAnalysis.jl/dev/lib/algorithms/LGG09/#Homogeneous-case-1
Marcelo Forets
@mforets
Christian Schilling
@schillic
:+1:
Peng Yu
@yupbank
hello firends, wondering if i get some help around understanding this operation
Marcelo Forets
@mforets
hi
Peng Yu
@yupbank

For a discrete set $G \subset \mathbb{R}^n$ .
It is testing condition: $\forall z \in G$ if $z$ spans a ray of $\operatorname{cone}(G)$.

Isn't it always true for all elements of $G$ ?

Marcelo Forets
@mforets
im not familiar with all the details of the paper (i think we have it referenced in a LazySets issue, but the method hasn't been implemented)
i see that line 8 comes from applying Proposition 4.3
what is $\xi(x)$ by the way
it is the subset of $G$ that sums to $x$
Peng Yu
@yupbank
yeah, in the every first iteration, it would be $\emptyset$
it’s picking $y \in x+G$ and then test $y-x$, which can be simiplified into $z \in G$ and then test $z$
Christian Schilling
@schillic
Marcelo Forets
@mforets
interesting, thx
. The ultimate goal is to scale up to large NeuralODE controllers for complicated CPS or biological tasks
i think there are some Julia people interested in these topics
Marcelo Forets
@mforets
theyseem to consider only singleton initial conditions?
Christian Schilling
@schillic
i haven't checked it. could be
Marcelo Forets
@mforets
nice thing is that we have almost every model in the benchmark already in Julia
Christian Schilling
@schillic
:)
Marcelo Forets
@mforets
r: initial radius in each dimension
that should be the specification of X0 around the points in the Appendix
im surprised that some of the results of Flow* are so coarse
that's what i get for the Brusselator example in their setting
Christian Schilling
@schillic
with Flow*?
Marcelo Forets
@mforets
with JuliaReach


text:
# 2014-09-23_vimperator

A cheat list for vimperator, a vim plugin for firefox / thunderbird.

# 2014-05-15 Vim commands for moving around

## Basics commands in Vim

Sometimes, it's good to go back to the basics.

In command mode, typing :help usr_02.txt (or simplier something like :h usr_<TAB>02<TAB><ENTER>), you learn the letters for navigating a file:

• these letters are HJKL - glad it works on an international keyboard.
• letters on the borders (HL) are for horizontal movements- obviously H for left, L for right
• letters on the inside are for vertical movements - J for down, K for up; a nice feature is that these keys are now quite widely used in the community, take for example in the gmail interface when switching to the next message.

I was still using the arrows keys, but taking this habit makes thinks easier, especially when switching often keyboards.

Simalarly, to scroll the text - you can use:

• <CTRL-U> to scroll a half-page up
• <CTRL-D> to scroll a half-page down

Here, the :h ctrl-u page will give you more info (or :help usr_03.txt).

Note that to follow a link (think "searching a tag"), you can press * (or # to go backwards).

# 2014-01-15 Vim folding commands

## Using folds in Vim

Folds are useful when having long files to have a good perspective on its structure. Especially useful in LaTeX mode.

To install, I recommend using the python-mode described in http://unlogic.co.uk/2013/02/08/vim-as-a-python-ide/

The magical shortcut all begin with z. Type :hep fold to learn more about them.

These are the most common shortcuts in my personal order of preference.

• zo opens a fold at the cursor.
• zc closes a fold at the cursor.
• zM closes all open folds.
• zO opens all folds at the cursor.
• [z move to start of open fold.
• ]z move to end of open fold.
• zj moves the cursor to the next fold.
• zk moves the cursor to the previous fold.
• zf#j creates a fold from the cursor down # lines.
• zf/string creates a fold from the cursor to string .
• zm increases the foldlevel by one.
• zr decreases the foldlevel by one.
• zR decreases the foldlevel to zero -- all folds will be open.
• zd deletes the fold at the cursor.
• zE deletes all folds.

format: plain


text:
### Session P24: Focus Session: What is Computational Physics? II followed by Computational Methods: Numerical Methods for Strongly Correlated Systems II

8:00 AM–11:00 AM, Wednesday, March 23, 2011
Room: D167

Chair: Bernd Berg, Florida State University, and Frank Harris, University of Forida

Abstract ID: BAPS.2011.MAR.P24.6

### Abstract: P24.00006 : Quo Vadis Computational Physics?

9:00 AM–9:36 AM

Preview Abstract MathJax On | Off   Abstract

#### Author:

Richard Scalettar
(University of California, Davis)

In this Focus Session, and in the preceding DCOMP Invited Symposium, Great Advances of Computational Physics: Past, Present and Future," we have heard about the vision for our field, reviewed (and previewed) cutting-edge numerical work, and considered where the resources might come to support our endeavors. In this talk I will summarize some of the common themes of this discussion, as well as open up the floor for further thoughts on where our APS Division is heading.

To cite this abstract, use the following reference: http://meetings.aps.org/link/BAPS.2011.MAR.P24.6


text:
# qml.math.is_independent¶

is_independent(func, interface, args, kwargs=None, num_pos=5, seed=9123, atol=1e-06, rtol=0, bounds=(- 3.141592653589793, 3.141592653589793))[source]

Test whether a function is independent of its input arguments, both numerically and analytically.

Parameters
• func (callable) – Function to be tested

• interface (str) – Autodiff framework used by func. Must correspond to one of the supported PennyLane interface strings, such as "autograd", "tf", "torch", "jax".

• args (tuple) – Positional arguments with respect to which to test

• kwargs (dict) – Keyword arguments for func at which to test; the keyword arguments are kept fixed in this test.

• num_pos (int) – Number of random positions to test

• seed (int) – Seed for the random number generator

• atol (float) – Absolute tolerance for comparing the outputs

• rtol (float) – Relative tolerance for comparing the outputs

• bounds (tuple[float]) – 2-tuple containing limits of the range from which to sample

Returns

Whether func returns the same output at randomly chosen points and is numerically independent of its arguments.

Return type

bool

Warning

This function is experimental. As such, it might yield wrong results and might behave slightly differently in distinct autodifferentiation frameworks for some edge cases. For example, a currently known edge case are piecewise functions that use classical control and simultaneously return (almost) constant output, such as

def func(x):
if abs(x) <1e-5:
return x
else:
return 0. * x

The analytic and numeric tests used are as follows.

• The analytic test performed depends on the provided interface, both in its method and its degree of reliability.

• For the numeric test, the function is evaluated at a series of random positions, and the outputs numerically compared to verify that the output is constant.

Warning

Currently, no analytic test is available for the PyTorch interface. When using PyTorch, a warning will be raised and only the numeric test is performed.

Note

Due to the structure of is_independent, it is possible that it errs on the side of reporting a dependent function to be independent (a false positive). However, reporting an independent function to be dependent (a false negative) is highly unlikely.

Example

Consider the (linear) function

def lin(x, weights=None):
return np.dot(x, weights)

This function clearly depends on x. We may check for this via

>>> x = np.array([0.2, 9.1, -3.2], requires_grad=True)
>>> weights = np.array([1.1, -0.7, 1.8], requires_grad=True)
>>> qml.math.is_independent(lin, "autograd", (x,), {"weights": weights})
False

However, the Jacobian will not depend on x because lin is a linear function:

>>> jac = qml.jacobian(lin)
>>> qml.math.is_independent(jac, "autograd", (x,), {"weights": weights})
True

Note that a function f = lambda x: 0.0 * x will be counted as dependent on x because it does depend on x functionally, even if the value is constant for all x. This means that is_independent is a stronger test than simply verifying functions have constant output.


text:
## Gradient Descent for Multiple Features

The gradient descent equation for $n$ features (variables) can be written as:

repeat until convergence: {

$\,\,\,\,\,\, \theta_j := \theta_j - \alpha \frac{\partial}{\partial \theta_j} J(\theta) \,\,\,\,\,\,$ (simultaneously update $\theta_j$ for every $j \in 0,...,n$)

}

On calculating the value of $\frac{\partial}{\partial \theta_j} J(\theta)$, the above algorithm converts to:

repeat until convergence: {

$\,\,\,\,\,\, \theta_j := \theta_j - \alpha \frac{1}{m} \sum\limits_{i=1}^{m}\left((h_\theta(x^{(i)}) - y^{(i)}) x^{(i)}_{j}\right) \,\,\, \\$ $\quad \quad \quad \quad \quad$ (simultaneously update $\theta_j$ for every $j \in 0,...,n$)
}

Vectorized implementation:

$\theta := \theta - \alpha \space \delta$

where $\theta,\delta \in \mathbb{R}^{n+1}$ are vectors as shown below

\begin{aligned} \delta = \frac{1}{m} \sum\limits_{i=1}^{m} \left((h_\theta(x^{(i)}) - y^{(i)}) x^{(i)}\right) = \frac{1}{m}X^T(X\theta - y) \end{aligned}

$\theta = \begin{bmatrix} \theta_0 \\ \theta_1 \\ \vdots \\ \theta_n \end{bmatrix} \in \mathbb{R}^{n+1}$

$x^{(i)} = \begin{bmatrix} x^{(i)}_0 \\ x^{(i)}_1 \\ \vdots \\ x^{(i)}_n \end{bmatrix} \in \space \mathbb{R}^{n+1}$

$X = \begin{bmatrix} ... \space (x^{(1)})^T \space ... \\ ... \space (x^{(2)})^T \space ... \\ \vdots \\ ... \space (x^{(m)})^T \space ... \end{bmatrix}$ $($m x (n+1) matrix$)$

$y = \begin{bmatrix} y^{(1)} \\ y^{(2)} \\ \vdots \\ y^{(m)} \end{bmatrix} \in \mathbb{R}^{m}$

Derivation: Vectorized implementation

Let $\space c^{(i)} = (h_\theta(x^{(i)}) - y^{(i)})$

$m \space \delta = m \begin{bmatrix} \delta_0 \\ \delta_1 \\ \vdots \\ \delta_n \end{bmatrix} = \begin{bmatrix} \sum\limits_{i=1}^m c^{(i)}x^{(i)}_0 \\ \sum\limits_{i=1}^m c^{(i)}x^{(i)}_1 \\ \vdots \\ \sum\limits_{i=1}^m c^{(i)}x^{(i)}_n \end{bmatrix} = c^{(1)}x^{(1)} + c^{(2)}x^{(2)} + ... + c^{(m)}x^{(m)} = \sum\limits_{i=1}^m c^{(i)}x^{(i)}$


text:
orb:parachute_testing

# Oscillation of a Parachute

Pvs stands for parachute vortex shedding. The pvs is the cause of resonance of the system. At high altitudes, the free-stream density is sufficiently low to result in a relatively small ratio of apparent mass to payload mass, causing the system center of gravity to be located very close to the payload. This result in a long momentum arm between the canopy and the system center of gravity, such that the pvs can dominate the dynamics of the complete system.

$f_{pvs}= \frac{S_t . V_{term}}{d_{ratio} . d_o}$

$S_t$ stands for Strouhal number and $d_o$ is the nominal diameter of the parachute.

# Constraints

• In our modelisation we won't consider the PVS oscillation due to the mass of the rover 2Kg and the altitude.
• The parachute that we'll implement will reduce the terminal velocity in 90%.
• For an altitude smaller than 1,6 Km we can apply the general dragging formula $2.W=c.\rho.V_{term}^2.A$ where W stands for the weight, $\rho$ is the air density, c the dragging coefficient, $V_{term}$ the terminal velocity and A the area of the parachute.
• The recomending $V_{term}$ or landing velocity is between $3.5{m}{s}$ to $4.5{m}{s}$.
• The dragging coefficient for a half-sphere $c$ is 0.47.
• The density of the air increase with low temperatures; at -10°C $\rho=1.34 {Kg}{m^3}$
• The area of the parachute can be obtained: $A=\frac{2.g.M_{rover}}{c.\rho.V_{term}^2}$
• For a round parachute the diameter is obtained: $d=\sqrt{\frac{4.A}{\pi}}$
• The spill hole to gain stability should have a diameter of 20% of the total diameter of the canopy.
• If the area and/or the diameter of the canopy are fixed, we can change the diameter of the spill hole in function of the terminal velocity, reducing the total area in the formula above.
• Dynamics of free fall with air resistance, says that a body will arrive to the terminal velocity after 5 seconds, with out depending on the altitude.

References:

• F. M. WHITE and D. F. WOLF. “A theory of three-dimensional parachute dynamic stability.” Journal of Aircraft, Vol. 5, No. 1 (1968), pp. 86-92. doi: 10.2514/3.43912
• A Method to Characterize Parachute System Instability Modes by Michael Bernatovich Dr. Ian Clark 5/6/2013
• orb/parachute_testing.txt


text:
Second derived subgroup

The second derived subgroup of a group $G$, denoted $\! G''$, is defined in the following equivalent ways:
1. It is the subgroup generated by all elements of the form $[[x,y],[z,w]]$, where $[,]$ denotes the commutator and $x,y,z,w \in G$.
2. It is the normal closure of the subgroup generated by all elements of the form $[[x,y],[z,w]]$ where $[,]$ denotes the commutator and $x,y,z,w \in G$.
3. It is the derived subgroup of the derived subgroup of $G$.
4. It is the intersection of all subgroups $H$ of $G$ for which $G/H$ is a metabelian group, i.e., a solvable group of derived length two.


text:
There are three categories of CCCs:

1. 1.Broadcast Write – A Broadcast Write CCC is seen by all I3C targets on the bus. The Target module inspects every received Broadcast command, even if it then chooses to ignore the CCC (for example, an unsupported CCC is ignored). ENEC is an example of a Broadcast Write CCC.
2. 2.Direct Write – A Direct Write CCC writes data to a Target module directly by selecting its Dynamic Address. Other targets on the bus can also be addressed by the Controller in the same transaction by selecting the appropriate Dynamic Addresses. SETMRL is an example of a Direct Write CCC.
3. 3.Direct Read – A Direct Read CCC reads data from the Target module directly by selecting its Dynamic Address. Other targets on the bus can also be addressed by the Controller in the same transaction by selecting the appropriate Dynamic Addresses. GETPID is an example of a Direct Read CCC.

Each CCC has its own unique 8-bit command code. The command code space is divided into Broadcast CCC and Direct CCC codes. Broadcast CCCs have command codes 0x00 through 0x7F. Direct CCCs have command codes 0x80 through 0xFE. Consequently, the targets can inspect the Most Significant bit (bit 7) of the command code to differentiate between the two types of CCCs. Table 1 lists the command codes for all the supported CCCs.

The frame format for Broadcast CCCs is shown in Figure 1. All the Broadcast CCCs share the same general frame format and has the following sequence:

2. 2.Broadcast CCC value, followed by any required defining byte or data.
3. 3.End of command.
Figure 1. Broadcast CCC General Frame Format

The frame format for Direct CCCs is shown in Figure 2. All the Direct CCCs share the same general frame format and has the following sequence:

2. 2.Direct CCC value, followed by any required defining byte or data.
3. 3.Restart, followed by the address of the targeted Target, followed by any required defining byte or data.(1)
4. 4.Repeat step 3 if the Controller wants to address multiple targets in the same CCC transaction.
5. 5.End of command.
Figure 2. Direct CCC General Frame Format

The frame field definitions are explained in Table 1.

Important:
1. 1.In the case of Direct Read CCCs, if the Target is not ready with the data for the Controller to read, the Target module automatically NACKs when it is addressed. The Controller will then emit a Restart and transmit the Target’s address once more, providing the Target additional time to prepare its result. If the Target still does not have the data ready and NACKs the request again, the Controller will not re-attempt a read.
Table 1. CCC Frame Field Definitions
Field Definition
S or Sr A CCC always begins with either Start or Restart condition
• Broadcast Address – The CCC Frame starts with Controller transmitting the global I3C Broadcast Address (7’h7E), so that all the I3C targets on the bus will see the CCC code that follows.
• W – The R/W bit is always clear (0 = Write) indicating that the Controller is writing a message to the targets.
• ACK – The collective ACK by at least one I3C target on the bus. If there are no I3C targets on the bus, this will be a passive NACK and the Controller will terminate the transaction.
Broadcast or Direct CCC/T The Controller then sends an 8-bit code corresponding to the CCC being sent. All supported CCC codes are defined in Table 1. This is followed by a Parity T-bit.
Defining Byte (Optional)/T Some CCCs require an additional defining byte to be sent. Refer to the individual CCC definition for more information. This is followed by a Parity T-bit.
Data (Optional)/T Some CCCs require additional data (one or more bytes) to be sent. Refer to the individual CCC definition for more information. This is followed by a Parity T-bit.

R/W
/ACK

This field is used by Direct CCCs to address an individual target on the bus. This field has three parts:


text:
# Hyperbolic Sine in terms of Sine

## Theorem

Let $z \in \C$ be a complex number.

Then:

$i \sinh z = \map \sin {i z}$

where:

$\sin$ denotes the complex sine
$\sinh$ denotes the hyperbolic sine
$i$ is the imaginary unit: $i^2 = -1$.

## Proof

 $\displaystyle \map \sin {i z}$ $=$ $\displaystyle \frac {e^{i \paren {i z} } - e^{i \paren {-i z} } } {2 i}$ Sine Exponential Formulation $\displaystyle$ $=$ $\displaystyle \paren {-i} \frac {e^{-z} - e^z} 2$ $i^2 = -1$ $\displaystyle$ $=$ $\displaystyle i \frac {e^z - e^{-z} } 2$ $i^2 = -1$ $\displaystyle$ $=$ $\displaystyle i \sinh z$ Definition of Hyperbolic Sine

$\blacksquare$