from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
from math import fabs
from compas.utilities import pairwise
from compas.geometry._core import add_vectors
from compas.geometry._core import add_vectors_xy
from compas.geometry._core import subtract_vectors
from compas.geometry._core import subtract_vectors_xy
from compas.geometry._core import scale_vector
from compas.geometry._core import normalize_vector
from compas.geometry._core import length_vector
from compas.geometry._core import length_vector_xy
from compas.geometry._core import length_vector_sqrd
from compas.geometry._core import length_vector_sqrd_xy
from compas.geometry._core import cross_vectors
from compas.geometry._core import cross_vectors_xy
from compas.geometry._core import dot_vectors
from compas.geometry._core import vector_component
from compas.geometry._core import vector_component_xy
__all__ = [
'distance_point_point',
'distance_point_point_xy',
'distance_point_point_sqrd',
'distance_point_point_sqrd_xy',
'distance_point_line',
'distance_point_line_xy',
'distance_point_line_sqrd',
'distance_point_line_sqrd_xy',
'distance_point_plane',
'distance_point_plane_signed',
'distance_line_line',
'closest_point_in_cloud',
'closest_point_in_cloud_xy',
'closest_point_on_line',
'closest_point_on_line_xy',
'closest_point_on_segment',
'closest_point_on_segment_xy',
'closest_point_on_polyline',
'closest_point_on_polyline_xy',
'closest_point_on_plane',
'closest_line_to_point',
]
[docs]def distance_point_point(a, b):
"""Compute the distance bewteen a and b.
Parameters
----------
a : sequence of float
XYZ coordinates of point a.
b : sequence of float
XYZ coordinates of point b.
Returns
-------
float
Distance bewteen a and b.
Examples
--------
>>> distance_point_point([0.0, 0.0, 0.0], [2.0, 0.0, 0.0])
2.0
See Also
--------
distance_point_point_xy
"""
ab = subtract_vectors(b, a)
return length_vector(ab)
[docs]def distance_point_point_xy(a, b):
"""Compute the distance between points a and b, assuming they lie in the XY plane.
Parameters
----------
a : sequence of float
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
b : sequence of float
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
Returns
-------
float
Distance between a and b in the XY-plane.
Examples
--------
>>> distance_point_point_xy([0.0, 0.0], [2.0, 0.0])
2.0
>>> distance_point_point_xy([0.0, 0.0, 0.0], [2.0, 0.0, 0.0])
2.0
>>> distance_point_point_xy([0.0, 0.0, 1.0], [2.0, 0.0, 1.0])
2.0
"""
ab = subtract_vectors_xy(b, a)
return length_vector_xy(ab)
[docs]def distance_point_point_sqrd(a, b):
"""Compute the squared distance bewteen points a and b.
Parameters
----------
a : sequence of float
XYZ coordinates of point a.
b : sequence of float
XYZ coordinates of point b.
Returns
-------
d2 : float
Squared distance bewteen a and b.
Examples
--------
>>> distance_point_point_sqrd([0.0, 0.0, 0.0], [2.0, 0.0, 0.0])
4.0
See Also
--------
distance_point_point_sqrd_xy
"""
ab = subtract_vectors(b, a)
return length_vector_sqrd(ab)
[docs]def distance_point_point_sqrd_xy(a, b):
"""Compute the squared distance between points a and b lying in the XY plane.
Parameters
----------
a : sequence of float
XY(Z) coordinates of the first point.
b : sequence of float)
XY(Z) coordinates of the second point.
Returns
-------
float
Squared distance between a and b in the XY-plane.
Examples
--------
>>> distance([0.0, 0.0], [2.0, 0.0])
4.0
>>> distance([0.0, 0.0, 0.0], [2.0, 0.0, 0.0])
4.0
>>> distance([0.0, 0.0, 1.0], [2.0, 0.0, 1.0])
4.0
"""
ab = subtract_vectors_xy(b, a)
return length_vector_sqrd_xy(ab)
[docs]def distance_point_line(point, line):
"""Compute the distance between a point and a line.
Parameters
----------
point : list, tuple
Point location.
line : list, tuple
Line defined by two points.
Returns
-------
float
The distance between the point and the line.
Notes
-----
This implementation computes the *right angle distance* from a point P to a
line defined by points A and B as twice the area of the triangle ABP divided
by the length of AB [1]_.
References
----------
.. [1] Wikipedia. *Distance from a point to a line*.
Available at: https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line
Examples
--------
>>>
"""
a, b = line
ab = subtract_vectors(b, a)
pa = subtract_vectors(a, point)
pb = subtract_vectors(b, point)
length = length_vector(cross_vectors(pa, pb))
length_ab = length_vector(ab)
return length / length_ab
[docs]def distance_point_line_xy(point, line):
"""Compute the distance between a point and a line, assuming they lie in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of the point.
line : list, tuple
Line defined by two points.
Returns
-------
float
The distance between the point and the line.
Notes
-----
This implementation computes the orthogonal distance from a point P to a
line defined by points A and B as twice the area of the triangle ABP divided
by the length of AB [1]_.
References
----------
.. [1] Wikipedia. *Distance from a point to a line*.
Available at: https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line.
"""
a, b = line
ab = subtract_vectors_xy(b, a)
pa = subtract_vectors_xy(a, point)
pb = subtract_vectors_xy(b, point)
length = fabs(cross_vectors_xy(pa, pb)[2])
length_ab = length_vector_xy(ab)
return length / length_ab
[docs]def distance_point_line_sqrd(point, line):
"""Compute the squared distance between a point and a line.
Parameters
----------
point : sequence of float
XYZ coordinates of the point.
line : list, tuple
Line defined by two points.
Returns
-------
float
The squared distance between the point and the line.
Notes
-----
For more info, see [1]_.
References
----------
.. [1] Wikipedia. *Distance from a point to a line*.
Available at: https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line.
"""
a, b = line
ab = subtract_vectors(b, a)
pa = subtract_vectors(a, point)
pb = subtract_vectors(b, point)
length = length_vector_sqrd(cross_vectors(pa, pb))
length_ab = length_vector_sqrd(ab)
return length / length_ab
[docs]def distance_point_line_sqrd_xy(point, line):
"""Compute the squared distance between a point and a line lying in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
line : list, tuple
Line defined by two points.
Returns
-------
float
The squared distance between the point and the line.
Notes
-----
This implementation computes the orthogonal squared distance from a point P to a
line defined by points A and B as twice the area of the triangle ABP divided
by the length of AB [1]_.
References
----------
.. [1] Wikipedia. *Distance from a point to a line*.
Available at: https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line.
"""
a, b = line
ab = subtract_vectors_xy(b, a)
pa = subtract_vectors_xy(a, point)
pb = subtract_vectors_xy(b, point)
length = cross_vectors_xy(pa, pb)[2]**2
length_ab = length_vector_sqrd_xy(ab)
return length / length_ab
[docs]def distance_point_plane(point, plane):
r"""Compute the distance from a point to a plane defined by origin point and normal.
Parameters
----------
point : list
Point coordinates.
plane : tuple
A point and a vector defining a plane.
Returns
-------
float
Distance between point and plane.
Notes
-----
The distance from a point to a plane can be computed from the coefficients
of the equation of the plane and the coordinates of the point [1]_.
The equation of a plane is
.. math::
Ax + By + Cz + D = 0
where
.. math::
:nowrap:
\begin{align}
D &= - Ax_0 - Bx_0 - Cz_0 \\
Q &= (x_0, y_0, z_0) \\
N &= (A, B, C)
\end{align}
with :math:`Q` a point on the plane, and :math:`N` the normal vector at
that point. The distance of any point :math:`P` to a plane is the
absolute value of the dot product of the vector from :math:`Q` to :math:`P`
and the normal at :math:`Q`.
References
----------
.. [1] Nykamp, D. *Distance from point to plane*.
Available at: http://mathinsight.org/distance_point_plane.
Examples
--------
>>>
"""
return fabs(distance_point_plane_signed(point, plane))
def distance_point_plane_signed(point, plane):
r"""Compute the signed distance from a point to a plane defined by origin point and normal.
Parameters
----------
point : list
Point coordinates.
plane : tuple
A point and a vector defining a plane.
Returns
-------
float
Distance between point and plane.
Notes
-----
The distance from a point to a plane can be computed from the coefficients
of the equation of the plane and the coordinates of the point [1]_.
The equation of a plane is
.. math::
Ax + By + Cz + D = 0
where
.. math::
:nowrap:
\begin{align}
D &= - Ax_0 - Bx_0 - Cz_0 \\
Q &= (x_0, y_0, z_0) \\
N &= (A, B, C)
\end{align}
with :math:`Q` a point on the plane, and :math:`N` the normal vector at
that point. The distance of any point :math:`P` to a plane is the
value of the dot product of the vector from :math:`Q` to :math:`P`
and the normal at :math:`Q`.
References
----------
.. [1] Nykamp, D. *Distance from point to plane*.
Available at: http://mathinsight.org/distance_point_plane.
Examples
--------
>>>
"""
base, normal = plane
vector = subtract_vectors(point, base)
return dot_vectors(vector, normal)
[docs]def distance_line_line(l1, l2, tol=0.0):
r"""Compute the shortest distance between two lines.
Parameters
----------
l1 : tuple
Two points defining a line.
l2 : tuple
Two points defining a line.
Returns
-------
float
The distance between the two lines.
Notes
-----
The distance is the absolute value of the dot product of a unit vector that
is perpendicular to the two lines, and the vector between two points on the lines ([1]_, [2]_).
If each of the lines is defined by two points (:math:`l_1 = (\mathbf{x_1}, \mathbf{x_2})`,
:math:`l_2 = (\mathbf{x_3}, \mathbf{x_4})`), then the unit vector that is
perpendicular to both lines is...
References
----------
.. [1] Weisstein, E.W. *Line-line Distance*.
Available at: http://mathworld.wolfram.com/Line-LineDistance.html.
.. [2] Wikipedia. *Skew lines Distance*.
Available at: https://en.wikipedia.org/wiki/Skew_lines#Distance.
Examples
--------
>>>
"""
a, b = l1
c, d = l2
ab = subtract_vectors(b, a)
cd = subtract_vectors(d, c)
ac = subtract_vectors(c, a)
n = cross_vectors(ab, cd)
length = length_vector(n)
if length <= tol:
return distance_point_point(closest_point_on_line(l1[0], l2), l1[0])
n = scale_vector(n, 1.0 / length)
return fabs(dot_vectors(n, ac))
# ==============================================================================
# closest
# ==============================================================================
def sort_points(point, cloud):
"""Sorts points of a pointcloud based on their distance from a given point.
Parameters
----------
point : tuple
The XYZ coordinates of the base point.
cloud : sequence
A sequence locations in three-dimensional space.
Returns
-------
list
A list containing the points of the cloud sorted by their distance to the base points.
Each item in the list contains the distance to the base point, the XYZ coordinates
of the point in the cloud, and the index of the point in the original cloud.
Notes
-----
Check kdTree class for an optimized implementation (MR).
Examples
--------
>>> sort_points()
"""
minsq = [distance_point_point_sqrd(p, point) for p in cloud]
return sorted(zip(minsq, cloud, range(len(cloud))), key=lambda x: x[0])
def sort_points_xy(point, cloud):
"""Sorts points of a pointcloud based on their distance from a given point,
assuming all points lie in the XY plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a point.
cloud : sequence
A list of points represented by their XY(Z) coordinates.
Returns
-------
list
A list containing the points of the cloud sorted by their distance to the base points.
Each item in the list contains the distance to the base point, the XYZ coordinates
of the point in the cloud, and the index of the point in the original cloud.
Notes
-----
Check kdTree class for an optimized implementation (MR).
Examples
--------
>>>
"""
minsq = [distance_point_point_sqrd_xy(p, point) for p in cloud]
return sorted(zip(minsq, cloud, range(len(cloud))), key=lambda x: x[0])
[docs]def closest_point_in_cloud(point, cloud):
"""Calculates the closest point in a pointcloud.
Parameters
----------
point : tuple
XYZ coordinates of the base point.
cloud : sequence
A sequence locations in three-dimensional space.
Returns
-------
tuple
The distance to the closest point.
XYZ coordinates of the closest point.
The index of the closest point in the original list.
Notes
-----
Check kdTree class for an optimized implementation (MR).
Examples
--------
>>>
"""
data = sort_points(point, cloud)
return data[0]
def closest_points_in_cloud_numpy(points, cloud, threshold=10**7, distances=True, num_nbrs=1):
"""Find the closest points in a point cloud to a set of sample points.
Parameters
----------
points : array, list
The sample points (n,).
cloud : array, list
The cloud points to compare to (n,).
threshold : float
Points are checked within this distance.
distances : bool
Return distance matrix.
Returns
-------
list
Indices of the closest points in the cloud per point in points.
array
Distances between points and closest points in cloud (n x n).
Notes
-----
Items in cloud further from items in points than threshold return zero
distance and will affect the indices returned if not set suitably high.
Examples
--------
>>> a = np.random.rand(4, 3)
>>> b = np.random.rand(4, 3)
>>> indices, distances = closest_points(a, b, distances=True)
[1, 2, 0, 3]
array([[ 1.03821946, 0.66226402, 0.67964346, 0.98877891],
[ 0.4650432 , 0.54484186, 0.36158995, 0.60385484],
[ 0.19562088, 0.73240154, 0.50235761, 0.51439644],
[ 0.84680233, 0.85390316, 0.72154983, 0.50432293]])
"""
from numpy import asarray
from numpy import argmin
from numpy import argpartition
from scipy.spatial import distance_matrix
points = asarray(points).reshape((-1, 3))
cloud = asarray(cloud).reshape((-1, 3))
d_matrix = distance_matrix(points, cloud, threshold=threshold)
if num_nbrs == 1:
indices = argmin(d_matrix, axis=1)
else:
indices = argpartition(d_matrix, num_nbrs, axis=1)
if distances:
return indices, d_matrix
return indices
[docs]def closest_point_in_cloud_xy(point, cloud):
"""Calculates the closest point in a list of points in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a the base point.
cloud : sequence
A list of points forming the cloud, with each point represented by its XY(Z) coordinates.
Returns
-------
tuple
The distance to the closest point.
The XYZ coordinates of the closest point (with Z = 0).
The index of the closest point in the cloud.
Notes
-----
Check kdTree class for an optimized implementation (MR).
"""
data = sort_points_xy(point, cloud)
return data[0]
[docs]def closest_point_on_line(point, line):
"""Computes closest point on line to a given point.
Parameters
----------
point : sequence of float
XYZ coordinates.
line : tuple
Two points defining the line.
Returns
-------
list
XYZ coordinates of closest point.
Examples
--------
>>>
See Also
--------
:func:`basic.transformations.project_point_line`
"""
a, b = line
ab = subtract_vectors(b, a)
ap = subtract_vectors(point, a)
c = vector_component(ap, ab)
return add_vectors(a, c)
[docs]def closest_point_on_line_xy(point, line):
"""Compute closest point on line (continuous) to a given point lying in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a point.
line : tuple
Two XY(Z) points defining a line.
Returns
-------
list
XYZ coordinates of closest point (Z = 0.0).
"""
a, b = line
ab = subtract_vectors_xy(b, a)
ap = subtract_vectors_xy(point, a)
c = vector_component_xy(ap, ab)
return add_vectors_xy(a, c)
[docs]def closest_point_on_segment(point, segment):
"""Computes closest point on line segment (p1, p2) to test point.
Parameters
----------
point : sequence of float
XYZ coordinates.
saegment : tuple
Two points defining the segment.
Returns
-------
list
XYZ coordinates of closest point.
Examples
--------
>>>
"""
a, b = segment
p = closest_point_on_line(point, segment)
d = distance_point_point_sqrd(a, b)
d1 = distance_point_point_sqrd(a, p)
d2 = distance_point_point_sqrd(b, p)
if d1 > d or d2 > d:
if d1 < d2:
return a
return b
return p
[docs]def closest_point_on_segment_xy(point, segment):
"""Compute closest point on a line segment to a given point lying in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a point.
segment : tuple
Two 2D or 3D points defining the line segment (Z components will be ignored).
Returns
-------
list
XYZ coordinates of closest point (Z = 0.0).
"""
a, b = segment
p = closest_point_on_line_xy(point, segment)
d = distance_point_point_sqrd_xy(a, b)
d1 = distance_point_point_sqrd_xy(a, p)
d2 = distance_point_point_sqrd_xy(b, p)
if d1 > d or d2 > d:
if d1 < d2:
return a
return b
return p
[docs]def closest_point_on_polyline(point, polyline):
"""Find the closest point on a polyline to a given point.
Parameters
----------
point : list
XYZ coordinates of a 2D or 3D point (Z will be ignored).
polygon : sequence
A sequence of XYZ coordinates representing the locations of the corners of a polygon.
The vertices are assumed to be in order. The polygon is assumed to be closed:
the first and last vertex in the sequence should not be the same.
Returns
-------
list
XYZ coordinates of closest point.
"""
cloud = []
for segment in pairwise(polyline):
cloud.append(closest_point_on_segment(point, segment))
return closest_point_in_cloud(point, cloud)[1]
[docs]def closest_point_on_polyline_xy(point, polyline):
"""Compute closest point on a polyline to a given point,
assuming they both lie in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
polygon : sequence
A sequence of XY(Z) coordinates of 2D or 3D points
(Z will be ignored) representing the locations of the corners of a polygon.
The vertices are assumed to be in order. The polygon is assumed to be closed:
the first and last vertex in the sequence should not be the same.
Returns
-------
list
XYZ coordinates of closest point (Z = 0.0).
"""
cloud = []
for segment in pairwise(polyline):
cloud.append(closest_point_on_segment_xy(point, segment))
return closest_point_in_cloud_xy(point, cloud)[1]
def closest_point_on_polygon_xy(point, polygon):
"""Compute closest point on a polygon to a given point lying in the XY-plane.
Parameters
----------
point : sequence of float
XY(Z) coordinates of a 2D or 3D point (Z will be ignored).
polygon : sequence
A sequence of XY(Z) coordinates of 2D or 3D points
(Z will be ignored) representing the locations of the corners of a polygon.
The vertices are assumed to be in order. The polygon is assumed to be closed:
the first and last vertex in the sequence should not be the same.
Returns
-------
list
XYZ coordinates of closest point (Z = 0.0).
"""
points = []
for i in range(len(polygon)):
segment = polygon[i - 1], polygon[i]
points.append(closest_point_on_segment_xy(point, segment))
return closest_point_in_cloud_xy(point, points)[1]
[docs]def closest_point_on_plane(point, plane):
"""Compute closest point on a plane to a given point.
Parameters
----------
point : sequenceof float
XYZ coordinates of point.
plane : tuple
The base point and normal defining the plane.
Returns
-------
list
XYZ coordinates of the closest point.
Notes
-----
For more info, see [1]_.
References
----------
.. [1] Wikipedia. *Distance from a point to a plane*.
Available at: https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_plane
Examples
--------
>>> plane = ([0.0, 0.0, 0.0], [0.0, 0.0, 1.0])
>>> point = [1.0, 2.0, 3.0]
>>> closest_point_on_plane(point, plane)
"""
base, normal = plane
x, y, z = base
a, b, c = normalize_vector(normal)
x1, y1, z1 = point
d = a * x + b * y + c * z
k = (a * x1 + b * y1 + c * z1 - d) / (a**2 + b**2 + c**2)
return [x1 - k * a,
y1 - k * b,
z1 - k * c]
def closest_line_to_point(point, lines):
"""Compute closest line to a point from a list of lines.
Parameters
----------
point : sequenceof float
XYZ coordinates of point.
lines : sequence of lines (tuples of points).
The lines to be checked for distance.
Returns
-------
tuple
the closest line.
"""
cloud = []
for segment in lines:
cloud.append(closest_point_on_segment(point, segment))
return lines[closest_point_in_cloud(point, cloud)[2]]
# ==============================================================================
# Main
# ==============================================================================
if __name__ == "__main__":
pass


Fruit List
Banana
Apple
/* exits 2 links at same line with same slash style */
Orange
Grape
Manogo
/* exits 2 links at same line with different slash style */
Meron


This is a brief introduction to the flashr
package. The examples here will suffice for many users. For more advanced usage, see the other vignettes.
The flashr
package fits the model \[Y = LF' + E\] where \(Y\) is an \(n \times p\) matrix, \(L\) is an \(n \times k\) matrix, and \(F\) is a \(p \times k\) matrix, and \(E\) is an \(n \times p\) matrix of residuals which (by default) are assumed to have column-specific variances:
\[E_{ij} \sim N(0,\sigma_{j}^2).\]
The columns of \(L\) are called the “loadings” and columns of \(F\) are called the “factors”. Unlike some other methods (e.g. singular value decomoposition) these columns are not required to be orthogonal.
The key idea behind flashr
is to use Empirical Bayes methods to estimate a “prior” distribution for each factor and each loading. This can induce sparsity on either/or factors and loadings if the data support this.
The scaling of the factors and loadings in the above model is arbitrary. Often it is convenient to scale the loadings and columns to have unit norm. In this case we can write
\[Y = LDF' + E,\]
where \(D\) is a diagonal matrix of “weights” that capture the strength of each factor/loading. The flash function flash_get_ldf
returns the values of \(L, D\) and \(F\) in this model (with \(D\) returned as a vector of the diagonal values).
First we will simulate some data for illustration (in this case the loadings and factors are not at all sparse, so the benefits of flash over other methods might be limited.)
library(flashr)
set.seed(1)
n = 100
p = 500
k = 7
LL = matrix(rnorm(n*k),nrow=n)
FF = matrix(rnorm(p*k),nrow=p)
Y = LL %*% t(FF) + rnorm(n*p)
When running flash
, usually you will run one command to fit the model, and a second to extract results you want from the fit. The flash
function is the one most users will want to start with to fit the model. The flash_get_ldf
function can then be used to get the values of \(L,D\) and \(F\).
By default flash
runs the greedy algorithm from Wang and Stephens. This is usually the quickest approach. It simply adds factors one at a time, until adding a new factor doesn’t improve the fit:
f = flash(Y)
# fitting factor/loading 1
# fitting factor/loading 2
# fitting factor/loading 3
# fitting factor/loading 4
# fitting factor/loading 5
# fitting factor/loading 6
# fitting factor/loading 7
# fitting factor/loading 8
ldf = flash_get_ldf(f)
ldf$d
# [1] 292.3761 253.6873 233.4289 210.8591 204.2400 203.0717 182.1317
Note that flash correctly stopped at 7 factors for these data. (Although it tries to fit an 8th factor, from the results we can see that this does not appear: this is because it turned out to be 0.)
Sometimes the backfitting algorithm can improve the fit (but it takes longer). To do backfitting on a previous flash fit you can provide that fit as the f_init
parameter, and set backfit=TRUE
. Here we use the fit obtained from the greedy function as our initialization.
f.b = flash(Y, f_init = f, backfit=TRUE, greedy=FALSE)
ldf.b = flash_get_ldf(f.b)
ldf.b$d
# [1] 303.7844 263.2466 241.8200 217.4748 209.0290 206.0587 183.2006
If you know you are going to want to do backfitting anyway, you can do greedy+backfitting it in one command without saving the intermediate result:
f.gb = flash(Y, backfit=TRUE, greedy=TRUE)
# fitting factor/loading 1
# fitting factor/loading 2
# fitting factor/loading 3
# fitting factor/loading 4
# fitting factor/loading 5
# fitting factor/loading 6
# fitting factor/loading 7
# fitting factor/loading 8
ldf.gb = flash_get_ldf(f.gb)
ldf.gb$d
# [1] 303.7844 263.2466 241.8200 217.4748 209.0290 206.0587 183.2006
Suppose your matrix has some missing entries and you want to fill them in. You can do this by first running flash on your matrix and then using flash_fill
. (This function fills in the missing entries using the relevant elements of the estimated LDF’ matrix).
To illustrate, we add a little missing data to \(Y\) here before running.
Ymiss=Y
Ymiss[1:20,1] = NA
f = flash(Ymiss)
# fitting factor/loading 1
# fitting factor/loading 2
# fitting factor/loading 3
# fitting factor/loading 4
# fitting factor/loading 5
# fitting factor/loading 6
# fitting factor/loading 7
# fitting factor/loading 8
Ynew = flash_fill(Ymiss,f)
plot(Y[1:20,1],Ynew[1:20,1])


Hush has been building the first ever open source private messenger service based on Zcash technology. Hush & Komodo not only share core developers, but coinciding views on the importance of independent right to privacy.
100 messages
Before 05-Dec-19 12:00 AM
GatewayBOT07-Jun-19 02:04 PM
[dscrd-hush] <dukeleto> @Inevitability you are right, to think, that it's not profitable to mine Hush and immediately resell right now. Hush is not a cash crop
[dscrd-hush] <dukeleto> Hush is a fruit tree, that needs some care and love and then produces amazing things for a long time
[dscrd-hush] <dukeleto> Some pear trees are known to produce fruit for over 400 years. But they produced nothing for the first few years, some long-term-thinking people had to plant the tree and care for it for years, before ever seeing a return
[dscrd-hush] <dukeleto> Just something to think about.
[dscrd-hush] <dukeleto> I would rather Hush be a fruit tree than a cash crop.
[dscrd-hush] <dukeleto> And that means a stable price instead of crazy price spikes and volatility. We are slowing increasing the value of Hush, which is much healthier than marketing gimmicks without substance, that cause the price to crash after the buzz is over
GatewayBOT07-Jun-19 02:17 PM
[dscrd-hush] <Akira X> im mining on solar as well so sellingmy gpus and buying the a9 will actually reduce my energy costs
GatewayBOT07-Jun-19 02:28 PM
[dscrd-hush] <penguin> Direct or battery-cycling ?
[dscrd-hush] <penguin> Am looking to do the same, but finding a bit of conflicting info on base requirements for the hardware, in terms of the management of the setup
[dscrd-hush] <penguin> and there's also the possibility of direct supply to the mining-machine
[dscrd-hush] <Akira X> My solar is connected to the grid
[dscrd-hush] <penguin> supplementary supply only or batteries as well ?
Selling, buying and/or mining cryptocurrencies will be considered a non-bailable offence, according to the new bill.
[dscrd-hush] <dukeleto> I am sorry for a lot of Indian people, that could benefit from cryptocoins. Their government rightly sees that it would lose too much control, allowing it to be legal
[dscrd-hush] <dukeleto>
“mine, generate, hold, sell, transfer, dispose, issue or deal in cryptocurrencies directly or indirectly.”
[dscrd-hush] <dukeleto> that is draconian, it doesn't even allow for India people to be paid in fiat to work on cryptocoins, if I read correctly
[dscrd-hush] <dukeleto> they even made it illegal to dispose/destroy cryptocoins, kind of bizarre
GatewayBOT07-Jun-19 06:44 PM
[dscrd-hush] <penguin> I think it's propaganda season..
[dscrd-hush] <penguin> Following China's play perhaps.
Analysis of the Paid Bloomberg Article reporting '10 years Jail for Crypto investors'
1. No source
2. Clickbait article that's kept Paid
3. Even if it is true, it's only a suggestion to govt, not official notice
I refuse to share the article link as it isn't worth promot...
Likes
272
[dscrd-hush] <dukeleto> Good points. Hard to say if the India article is FUD. I assume most news stories are FUD, anyway
[dscrd-hush] <dukeleto> It's interesting to know which direction the FUD is going, and who is saying it
[dscrd-hush] <Luffy> The channel is very alive now ... maybe we need an "offtopic" to complain about shitty days, recommend horrible music and do movie spoilers
[dscrd-hush] <Luffy> Oh okay, I've seen it
GatewayBOT07-Jun-19 10:26 PM
[dscrd-hush] <Akira X> I think general is off topic
[dscrd-hush] <Akira X> And the important stuff should be pinned to other channels
[dscrd-hush] <Akira X> That way it’s actually easier to find
[dscrd-hush] <Akira X> Looking for something important. Go to #announcements
GatewayBOT07-Jun-19 11:40 PM
[dscrd-hush] <franciscana23> good evening friends
GatewayBOT08-Jun-19 12:06 AM
[dscrd-hush] <RunningMantheCoin> Hi @franciscana23 !
[dscrd-hush] <dukeleto> interesting read for those that want to know what radix42 is up to
GatewayBOT08-Jun-19 12:39 PM
[dscrd-hush] <franciscana23> morning
GatewayBOT08-Jun-19 02:09 PM
[dscrd-hush] <Mr_Billion> What programing language do I need to know to help design a new looking hush wallet?
GatewayBOT08-Jun-19 02:21 PM
[dscrd-hush] <dukeleto> @Mr_Billion you don't need to know how to code to help with graphics, docs, translation, UI/UX and probably other things. Our main wallet, SilentDragon, is written in C++ and uses QT5 for graphics
GatewayBOT08-Jun-19 03:35 PM
[dscrd-hush] <Mr_Billion> Ok thanks, I’ll look into it. I want to be involved. What is the difference between the HUSHmate wallet and the SilentDragon?
GatewayBOT08-Jun-19 03:48 PM
[dscrd-hush] <dukeleto> HUSHmate is designed to replace the old HUSH-Swing wallet, basically a direct replacement, to make sure people had a GUI wallet when HUSH v3 mainnet launched
[dscrd-hush] <Mr_Billion> Ok I’m looking for the silent dragon wallet now
[dscrd-hush] <dukeleto> HUSHmate is meant to be a basic wallet, and HushList features or other large features are not planned for it currently, it's meant to be a basic GUI full node wallet for people, and was our first windows wallet binary
[dscrd-hush] <dukeleto> SilentDragon is based on ZecWallet, and has many modern features
[dscrd-hush] <dukeleto> and we will put all our new HushList chat + file upload/download features into SilentDragon
[dscrd-hush] <dukeleto> SilentDragon is currently compile-only, no binaries yet
[dscrd-hush] <dukeleto> We are finalizing some branding, mostly. It has all the basic features for beta testers to use
If a user selects an address, then writes a memo and clicks "Include Reply Address" THEN goes and changes the address where funds are coming from, the included reply address is no...
If you only want to send to 1 address and you accidentally click "Add Recipient" on the "Send" screen, there is no way to undo the operation, and no way to send ...
[dscrd-hush] <Mr_Billion> Thanks, I’m checking it out
[dscrd-hush] <dukeleto> @Mr_Billion what kind of skills are you interested to help with?
[dscrd-hush] <Mr_Billion> Graphic design and marketing mostly
[dscrd-hush] <dukeleto> @Mr_Billion we need that to look less boring
[dscrd-hush] <Mr_Billion> Yes I totally agree, the user experience is just as important as the technology behind the project.
[dscrd-hush] <Mr_Billion> That’s why I was asking what software I needed to learn to help.
[dscrd-hush] <Mr_Billion> Or if I can just creat mockups of layouts and someone else can make the adjustments
GatewayBOT08-Jun-19 04:12 PM
[dscrd-hush] <dukeleto> mockups and graphics will be easier for you
[dscrd-hush] <dukeleto> learning linux CLI and C++ to do that is not reasonable
[dscrd-hush] <dukeleto> graphics and icons are most useful
[dscrd-hush] <dukeleto> to make the UI less boring
[dscrd-hush] <dukeleto> rendering the UI is actually writing a lot of code, so changing the way it looks is not easy
[dscrd-hush] <dukeleto> but tweaking colors or adding images is relatively simple
[dscrd-hush] <Mr_Billion> Ok great, Ill get on it. where should i upload my suggestions?
[dscrd-hush] <dukeleto> making a free github.com account is simple and easy
GatewayBOT08-Jun-19 05:38 PM
[dscrd-hush] <Roxin> @dukeleto so hushMate or SilentDragon ?
[dscrd-hush] <jspook16> I was out of touch and I see hush migrated. I am trying to move my hush funds and get an error that says my address is not a valid pub hush address. Do I need to do something to enable the new hush coins?
[dscrd-hush] <penguin> @jspook16 See the pinned msgs in this channel, April 30 - How to claim your hush
GatewayBOT08-Jun-19 06:14 PM
[dscrd-hush] <Akira X> @Roxin havent used either, but i say silentdragon
[dscrd-hush] <jspook16> Ok so where is this wif to wif tool in Agama desktop? Im using Verus Agama
[dscrd-hush] <jspook16> disregard
GatewayBOT08-Jun-19 06:42 PM
[dscrd-hush] <jspook16> I cant figure this out. The WIF to WIF tool returns the same key
GatewayBOT08-Jun-19 06:55 PM
[dscrd-hush] <heguli97> @jspook16 try set the coin to "Komodo", it should give out a different key
[dscrd-hush] <jspook16> trying that now
[dscrd-hush] <Roxin> @Akira X and where you keep your hush coins ?
[dscrd-hush] <jspook16> Ok I got a different key. I logged into verus_agama with that key. I see my balance but it still shows a t address
[dscrd-hush] <Akira X> right now they are in verus agama 5.7
[dscrd-hush] <Akira X> what i found is that dexstats.info can help you keep track of all your coin in your addresses
[dscrd-hush] <Akira X> as long as you have your private key saved you are good


Maximum voltage
Maximum battery voltage. If the battery voltage is exceeded, the controller won't turn on.
Also, the controller will not exceed this limit when regeneratively braking.
Important: If the battery has upper-voltage cutoff, it is recommended to set this value below maximum to protect the controller, as braking with cut-off battery may cause severe damage to controller parts.


This paragraph is 300 pixels wide and uses CSS absolute positioning to be placed 200 pixels in from the left and 100 pixels down from the top of the browser window.


Welcome to Capital IQ Python Excel Downloader Documentation!¶
To get started, look here.
An overview¶
For usage, see Getting started with capiq_excel. The main functions are highlighted here.
|
Downloads data from Capital IQ given arbitrary ids such as name, ticker, CUSIP, ISIN, etc. |
Downloads data from Capital IQ given the capital IQ ids and chosen variables |


Once a new technology starts rolling, if you're not part of the steamroller, you're part of the road. --Stewart Brand [ source]


A program that finds a path from entry to exit around an image of a maze. Simulates the path taken by making random decisions at each fork in the maze, all shown in an outputted image that visually displays the path taken and the decisions made.
Using a public API, fetches and displays info from upcoming matches in different regions of a major e-sport. All from the command line, all made with Go. Uses the extensive Cobra CLI framework, and is easily deployed with a simple go get
command.
First full-stack web job. Used the Bootstrap framework for most of the dirty work. Hosted in a private server run entirely on my Raspberry Pi (apache2).


Web accessibility demo
Tabindex is not inherited
Accessible link
|
Not accessible link
Accessible link
|
Not accessible link
The needs that Web accessibility aims to address include:
Visual
Motor/Mobility
Auditory
Seizures
Cognitive/Intellectual


BLACK BLUE GREEN CYAN RED MAGENTA BROWN LIGHTGRAY DARKGRAY LIGHTBLUE LIGHTGREEN LIGHTCYAN LIGHTRED LIGHTMAGENTA YELLOW WHITE
A function, converttorgb, and several other functions (RED_VALUE, GREEN_VALUE, BLUE_VALUE, IS_BGI_COLOR, and IS_RGB_COLOR) are explained in the examples below.
RGB Examples:
setcolor(BLUE); // Change drawing color to BLUE. setcolor(COLOR(255,100,0)); // Change drawing color to reddish-green. setpalette(4, BLUE); // Change palette entry 4 to BLUE. setpalette(4, COLOR(9,9,9));// Change palette entry 4 to nearly black. int current = getcolor( ); // Set current to current drawing color. if (IS_BGI_COLOR(current)) // Check whether it is a BGI color. cout << "Current BGI drawing color is: " << current << endl; if (IS_RGB_COLOR(current)) // Check whether it is an RGB color. cout << "Current RGB drawing color has these components:\n" << "Red: " << RED_VALUE(current) << '\n' << "Green: " << GREEN_VALUE(current) << '\n' << "Blue: " << BLUE_VALUE(current) << '\n'; cout << "The usual Windows RGB color int value is:\n" << converttorgb(current) << endl;


[§93-4.5] Notification when electronic publications posted. Every state and county agency shall immediately notify the state publications distribution center with identification and location information for each electronic publication made available on a public networked information system such as the Internet. [L 2012, c 63, §2]


This is the full URL to the remote server that will open the links.
Use %s as a placeholder for the URL of the page to open.
Example: http://<IP_ADDRESS>:8080/openurl?url=%s
This is the text to display in the context menu when you right click on a link.
Use %s as a placeholder for the context of the URL to open (eg. Image, Link or Page).
The default is 'Open %s in Remote Browser'


| Fit Measures | |||
| Measure | Name | Description | Cut-off for good fit |
| Χ2 | Model Chi-Square | Assess overall fit and the
discrepancy between the sample and fitted covariance matrices. Sensitive to sample size. H0: The model fits perfectly. |
p-value< 0.05 |
| (A)GFI | (Adjusted) Goodness of Fit | GFI is the proportion of variance accounted for by the estimated population covariance. Analogous to R2. AGFI favors parsimony. | GFI ≥ 0.95 AGFI ≥0.90 |
| CFI | Comparative Fit Index | A revised form of NFI. Not very sensitive to sample size. Compares the fit of a target model to the fit of an independent, or null, model. If the CFI is less than one, then the CFI is always greater than the TLI. CFI pays a penalty of one for every parameter estimated. Because the TLI and CFI are highly correlated, only one of the two should be reported. The CFI is reported more often than the TLI, but I think the CFI’s penalty for complexity of just 1 is too low and so I prefer the TLI even though the CFI is reported much more frequently than the TLI. | CFI ≥.90 |
| NFI TLI |
Normed-Fit Index Tucker Lewis Index |
An NFI of .95, indicates the model of interest improves the fit by 95% relative to the null model. NNFI is preferable for smaller samples. Sometimes the NNFI is called the Tucker Lewis index (TLI) | NFI ≥ 0.95 TLI/NNFI ≥ 0.95 |
| RMSEA | Root Mean Square Error
of Approximation |
A parsimony-adjusted
index. Values closer to 0 represent a good fit. |
RMSEA <0.08 |
| AIC | Akaike Information Criterion | The AIC is a comparative measure of fit and so it is meaningful only when two different models are estimated. Lower values indicate a better fit and so the model with the lowest AIC is the best fitting model. The AIC makes the researcher pay a penalty of two for every parameter that is estimated. | Lower values are ideal |
| BIC | Bayersian Information Criterion | Whereas the AIC has a penalty of 2 for every parameter estimated, the BIC increases the penalty as sample size increases | Lower values are ideal |


A helper is someone who does some of the worker's job for or with them.
Example - if a lecturer was hired by a university to write and deliver a study module:


Image
STVIOD
Home
Register
Vote For Options
Newbie Info
Directions
Gallery
About
July 16-18, 2021
Cost
$150/2 people
Cost Breakdown


Column: Bills fans can shout about No. 1 TV ratings for second straight week
For the second straight week, Buffalo Bills fans can shout "We're No.1."
Ratings for Buffalo Bills games are routinely hitting season highs every week largely due to the team’s 7-3 record.
The Bills’ 37-20 victory over the Miami Dolphins Sunday had a season-high 43.9 rating on WIVB-TV, the local CBS affiliate. Buffalo ranked No. 1 among all CBS markets carrying NFL games Sunday.
The rating Sunday was seven-tenths of a point higher than the previous high 43.2 rating for the Bills’ 19-16 loss to the Cleveland Browns a week earlier when the Buffalo market also had the highest-rated game on CBS that Sunday.
The rating for the Cleveland game was a point higher than the previous high of 42.2 for the Bills’ 24-9 victory over Washington and their 31-13 loss to Philadelphia. Both games were carried on WUTV, the local Fox affiliate.
Bills games are easily the highest-rated programs in Western New York at a time few prime-time entertainment programs get double digit-ratings.
By comparison, the Bills-Dolphins game had an 11.3 rating on the CBS affiliate in Miami.
However, Buffalo is one of the smallest markets in the NFL, which means lower ratings in bigger markets can have considerably more viewers.
The Buffalo market is No. 52 in the country, with each rating point equaling 5,767 households. The Miami-Fort Lauderdale market is No. 16, with each point equaling 16,422 households.
That means about 253,700 households watched the game in the Buffalo market and about 185, 570 households watched in the Miami market.
email: apergament@buffnews.com


Nicolas Kim Coppola born January 7, 1964. Known professionally as Nicolas Cage, is an American actor and filmmaker. Cage has been nominated for numerous major cinematic awards, and won an Academy Award, a Golden Globe, and Screen Actors Guild Award for his performance in Leaving Las Vegas (1995).During his early career, Cage starred in a variety of films such as Rumble Fish, Valley Girl, etc.
Cage was born in Long Beach, California, to August Coppola, a professor of literature, and Joy Vogelsang, a dancer and choreographer. He was raised in a Catholic family. His father was of Italian descent and his mother was of German and Polish ancestry. Through his father, he is a nephew of director Francis Ford Coppola and of actress Talia Shire, and the cousin of directors Roman Coppola and Sofia Coppola, film producer Gian-Carlo Coppola, and actors Robert Carmine and Jason Schwartzman.
Cage's two brothers are New York radio personality Marc "The Cope" Coppola and director Christopher Coppola. He attended Beverly Hills High School, which is known for its many alumni who became entertainers. He aspired to act from an early age and also attended UCLA School of Theater, Film and Television. His first non-cinematic acting experience was in a school production of Golden Boy. He said he started acting because he "wanted to be James Dean. I saw him in Rebel Without a Cause, East of Eden. Nothing affected me—no rock song, no classical music—the way Dean affected me in Eden. It blew my mind. I was like, 'That's what I want to do'."
At fifteen years old he tried to convince his uncle, Francis Ford Coppola, to give him a screen test, telling him "I'll show you acting." His outburst was met with "silence in the car".[13] By this stage of his career, Coppola had already directed Marlon Brando, Al Pacino, Gene Hackman and Robert De Niro. To avoid the appearance of nepotism as Coppola's nephew, he changed his name early in his career to Nicolas Cage, inspired in part by the Marvel Comics superhero Luke Cage.
Since his film debut with a minor role in Fast Times at Ridgemont High, opposite Judge Reinhold and Sean Penn, Cage has appeared in a wide range of films, both mainstream and offbeat. He auditioned for the role of Dallas Winston in his uncle's film The Outsiders, based on S.E. Hinton's novel, but lost to Matt Dillon.[15] He was also in Coppola's films Rumble Fish and Peggy Sue Got Married.


index
|
up
|
prev
|
next
OpenPunctuationParser Class
Definition at line
239
of
Primitive.hpp
Constructors
OpenPunctuationParser
()
Member Functions
void
Accept
(
Visitor
& visitor)
override
Match
Parse
(
Scanner
& scanner,
ObjectStack
& stack,
ParsingData
* parsingData)
override
Constructor Details
OpenPunctuationParser Constructor
cmajor::parsing::OpenPunctuationParser::OpenPunctuationParser()
Definition at line
612
of
Primitive.cpp
:
612
:
Parser
(
U"open_punctuation"
,
U"open_punctuation"
)
613
{
614
}
Declaration at line
242
of
Primitive.hpp
Member Function Details
Accept Member Function
void
cmajor::parsing::OpenPunctuationParser::Accept(
Visitor
& visitor)
override
Definition at line
629
of
Primitive.cpp
:
630
{
631
visitor
.
Visit
(
*
this
)
;
632
}
Declaration at line
244
of
Primitive.hpp
Base class overridden functions:
cmajor::parsing::ParsingObject::Accept
Calls:
cmajor::parsing::Visitor::Visit
Parse Member Function
Match
cmajor::parsing::OpenPunctuationParser::Parse(
Scanner
& scanner,
ObjectStack
& stack,
ParsingData
* parsingData)
override
Definition at line
616
of
Primitive.cpp
Declaration at line
243
of
Primitive.hpp
Base class overridden functions:
cmajor::parsing::Parser::Parse
Calls:
cmajor::parsing::Match::Nothing
,
cmajor::parsing::Match::One
,
cmajor::parsing::Scanner::AtEnd
,
cmajor::parsing::Scanner::GetChar
,
cmajor::unicode::IsOpenPunctuation
index
|
up
|
prev
|
next


bio_rtd.uo.surge_tank¶
Surge tanks.
Unit operations that accept various flow rate profiles and provide constant or box-shaped profile.
CSTR¶
-
class
bio_rtd.uo.surge_tank.
CSTR
(t, uo_id, gui_title='CSTR')[source]¶ Bases:
bio_rtd.core.UnitOperation
Simulation of CSTR with ideal mixing.
Accepts constant, box-shaped or box-shaped periodic flow rate profiles.
Provides constant or box-shaped flow rate profile.
- Parameters
t (
ndarray
) – Simulation time vector. Starts with 0 and has a constant time step.uo_id (str) – Unique identifier.
gui_title (str) – Readable title for GUI. Default = “CSTR”.
Notes
Target upper fill volume can be defined via:
Initial fill volume can be defined via:
starts_empty
-> If True it overridesv_init
andv_init_ratio
The concentration of pre-filled part is defined by
c_init
. Empty array (default) means that all components are 0.Examples
>>> t = _np.linspace(0, 100, 1001) # min >>> cstr = CSTR(t, uo_id="sample_cstr") >>> # Size of the surge tank. >>> cstr.v_void = 140 # mL >>> cstr.starts_empty = True # optional >>> f_in = _np.zeros_like(t) >>> f_in[0:800] = 12.5 # mL/min >>> c_in = _np.zeros([1, t.size]) >>> c_in[0][0:800] = 2.5 # mg/mL >>> f_out, c_out = cstr.evaluate(f_in, c_in) >>> f_out array([0., 0., 0., ..., 0., 0., 0.]) >>> f_out[105:115] array([ 0. , 0. , 0. , 0. , 0. , 0. , 12.5, 12.5, 12.5, 12.5]) >>> c_out array([[0., 0., 0., ..., 0., 0., 0.]]) >>> c_out[0][105:115] array([0. , 0. , 0. , 0. , 0. , 0. , 2.5, 2.5, 2.5, 2.5]) >>> # Pre-filled with buffer (and no product). >>> cstr.starts_empty = False >>> cstr.v_init_ratio = 1 # starts completely pre-filled (default) >>> f_out, c_out = cstr.evaluate(f_in, c_in) >>> f_out array([12.5, 12.5, 12.5, ..., 0. , 0. , 0. ]) >>> c_out array([[0.02232143, 0.04444445, 0.06637082, ..., 0.42450783, 0.42073445, 0.41699166]])
-
v_void
: float¶ Target upper fluid volume (max fill level) in the CSTR.
-
rt_target
: float¶ Target mean residence time in the CSTR.
Max fill level = rt_target * outlet flow rate.
-
v_min
: float¶ Target lowest fill level in the CSTR.
Only valid for periodic inlet flow rate profile.
Upper fill level is calculated at runtime.
-
v_min_ratio
: float¶ Ratio between max and min fill levels in the CSTR.
Only valid for periodic inlet flow rate profile.
Absolute fill levels are calculated at runtime.
-
v_init
: float¶ Initial pre-fill level - absolute value.
-
v_init_ratio
: float¶ Initial pre-fill level as a share of max fill level.
-
starts_empty
: bool¶ CSTR has a 0 initial fill level.
If True it overrides v_init and v_init_ratio.
-
c_init
¶ Pre-fill buffer composition. Default = array([]) = all 0
-
evaluate
(f_in, c_in)¶ Evaluate the propagation throughout the unit operation.
- Parameters
c_in (
ndarray
) – Inlet concentration profile with shape (n_species, n_time_steps).f_in (
array
) – Inlet flow rate profile with shape (n_time_steps,).
- Return type
Tuple
[ndarray
,ndarray
]- Returns
f_out – Outlet flow rate profile.
c_out – Outlet concentration profile.
-
get_result
()¶ Returns existing flow rate and concentration profiles.
- Return type
Tuple
[ndarray
,ndarray
]- Returns
f_out – Outlet flow rate profile.
c_out – Outlet concentration profile.
-
property
log
¶ Reference of the RtdLogger instance.
Setter also plants instance data tree into passed logger.
If logger is requested, but not yet set, then a
bio_rtd.logger.DefaultLogger
is instantiated.- Return type
-
set_logger_from_parent
(parent_id, logger)¶ Inherit logger from parent.
- Parameters
parent_id (
str
) – Unique identifier of parent instance.logger (
RtdLogger
) – Logger from parent instance.
-
uo_id
: str¶ Unique identifier of the instance
-
gui_title
: str¶ Readable title for GUI
Hide the of the unit operation (default False).
-
discard_inlet_until_t
: float¶ Discard inlet until given time.
-
discard_inlet_until_min_c
: _np.ndarray¶ Discard inlet until given concentration is reached.
-
discard_inlet_until_min_c_rel
: _np.ndarray¶ Discard inlet until given concentration relative to is reached.
Specified concentration is relative to the max concentration.
-
discard_inlet_n_cycles
: int¶ Discard first n cycles of the periodic inlet flow rate profile.
-
discard_outlet_until_t
: float¶ Discard outlet until given time.
-
discard_outlet_until_min_c
: _np.ndarray¶ Discard outlet until given concentration is reached.
-
discard_outlet_until_min_c_rel
: _np.ndarray¶ Discard outlet until given concentration relative to is reached.
Specified concentration is relative to the max concentration.
-
discard_outlet_n_cycles
: int¶ Discard first n cycles of the periodic outlet flow rate profile.
-
adj_par_list
¶ List of adjustable parameters exposed to the GUI.
- Type
TwoAlternatingCSTRs¶
-
class
bio_rtd.uo.surge_tank.
TwoAlternatingCSTRs
(t, uo_id, gui_title='TwoAlternatingCSTRs')[source]¶ Bases:
bio_rtd.core.UnitOperation
Simulation of Two alternating CSTRs with ideal mixing.
Accepts constant, box-shaped or periodic box-shaped flow rate profiles.
Provides constant or box-shaped flow rate profile.
- Parameters
t (
ndarray
) – Simulation time vector. Starts with 0 and has a constant time step.uo_id (str) – Unique identifier.
gui_title (str) – Readable title for GUI. Default = “TwoAlternatingCSTRs”.
Notes
Define how many periods a CSTR collects in one cycle (applies to periodic inlet only):
collect_n_periods
- default = 1
Define when the switch occurs for periodic inlet:
relative_role_switch_time
- default = 0.9
Define when the switch occurs for constant inlet (one should be defined):
Define leftover volume after discharge (optional, max one):
-
collect_n_periods
: int¶ How many periods of a periodic inlet a surge tank collects.
Default = 1.
Only relevant for periodic inlet flow rate profile.
-
relative_role_switch_time
: float¶ When CSTRs switch roles within the inlet flow rate off time.
Default = 0.9.
This is valid for the first cycle. In case of leftover material, the first two cycles are shorter, thus the switch occurs earlier in following cycles.
In case of inlet periodic box-shaped flow rate profile, the CSTRs can their switch role (providing or collecting) at any time when the inlet flow rate if off.
In terms of RTD it is desirable to start releasing material as soon as collection phase ends. However additional safety margin might be applied in order to allow some cycle-to-cycle variability in a real process.
-
evaluate
(f_in, c_in)¶ Evaluate the propagation throughout the unit operation.
- Parameters
c_in (
ndarray
) – Inlet concentration profile with shape (n_species, n_time_steps).f_in (
array
) – Inlet flow rate profile with shape (n_time_steps,).
- Return type
Tuple
[ndarray
,ndarray
]- Returns
f_out – Outlet flow rate profile.
c_out – Outlet concentration profile.
-
get_result
()¶ Returns existing flow rate and concentration profiles.
- Return type
Tuple
[ndarray
,ndarray
]- Returns
f_out – Outlet flow rate profile.
c_out – Outlet concentration profile.
-
property
log
¶ Reference of the RtdLogger instance.
Setter also plants instance data tree into passed logger.
If logger is requested, but not yet set, then a
bio_rtd.logger.DefaultLogger
is instantiated.- Return type
-
set_logger_from_parent
(parent_id, logger)¶ Inherit logger from parent.
- Parameters
parent_id (
str
) – Unique identifier of parent instance.logger (
RtdLogger
) – Logger from parent instance.
-
uo_id
: str¶ Unique identifier of the instance
-
gui_title
: str¶ Readable title for GUI
Hide the of the unit operation (default False).
-
discard_inlet_until_t
: float¶ Discard inlet until given time.
-
discard_inlet_until_min_c
: _np.ndarray¶ Discard inlet until given concentration is reached.
-
discard_inlet_until_min_c_rel
: _np.ndarray¶ Discard inlet until given concentration relative to is reached.
Specified concentration is relative to the max concentration.
-
discard_inlet_n_cycles
: int¶ Discard first n cycles of the periodic inlet flow rate profile.
-
discard_outlet_until_t
: float¶ Discard outlet until given time.
-
discard_outlet_until_min_c
: _np.ndarray¶ Discard outlet until given concentration is reached.
-
discard_outlet_until_min_c_rel
: _np.ndarray¶ Discard outlet until given concentration relative to is reached.
Specified concentration is relative to the max concentration.
-
discard_outlet_n_cycles
: int¶ Discard first n cycles of the periodic outlet flow rate profile.
-
adj_par_list
¶ List of adjustable parameters exposed to the GUI.
- Type
-
t_cycle
: float¶ The duration (time) of cycle after which CSTRs switch roles.
In case of constant inlet profile, one of t_cycle and
v_cycle
needs to be defined.In case of periodic inlet flow rate, this value should not be defined.
-
v_cycle
: float¶ Collected volume after which CSTRs switch roles.
In case of constant inlet profile, one of v_cycle and
t_cycle
needs to be defined.In case of periodic inlet flow rate, this value should not be defined.
-
v_leftover
: float¶ What amount of fluid stays in CSTR after discharge.
Only one of v_leftover and
v_leftover_rel
should be defined. If none are defined, then the leftover is set to 0.
-
v_leftover_rel
: float¶ Relative amount of fluid that stays in CSTR after discharge.
Relative to the amount of collected material in one cycle.
Only one of v_leftover_rel and
v_leftover
should be defined. If none are defined, then the leftover is set to 0.


a
New Password
Please provide a valid password.
Confirm Password
Your password does not matched.
Submit form


Date is interpreted using the Server Timezone.
Cron Expressions are interpreted using the Server Timezone.


| kalmanFilter {pomp} | R Documentation |
The basic Kalman filter for multivariate, linear, Gaussian processes.
kalmanFilter(object, X0 = rinit(object), A, Q, C, R, tol = 1e-06)
object |
a pomp object containing data; |
X0 |
length-m vector containing initial state. This is assumed known without uncertainty. |
A |
|
Q |
|
C |
|
R |
|
tol |
numeric;
the tolerance to be used in computing matrix pseudoinverses via singular-value decomposition.
Singular values smaller than |
If the latent state is X
, the observed variable is Y
,
X_t \in R^m
, Y_t \in R^n
, and
X_t \sim \mathrm{MVN}(A X_{t-1}, Q)
Y_t \sim \mathrm{MVN}(C X_t, R)
where \mathrm{MVN}(M,V)
denotes the multivariate normal distribution with mean M
and variance V
.
Then the Kalman filter computes the exact likelihood of Y
given A
, C
, Q
, and R
.
A named list containing the following elements:
the ‘pomp’ object
as in the call
E[X_t|y^*_1,\dots,y^*_t]
E[X_t|y^*_1,\dots,y^*_{t-1}]
E[Y_t|y^*_1,\dots,y^*_{t-1}]
f(y^*_t|y^*_1,\dots,y^*_{t-1})
f(y^*_1,\dots,y^*_T)
# takes too long for R CMD check
if (require(dplyr)) {
gompertz() -> po
po |>
as.data.frame() |>
mutate(
logY=log(Y)
) |>
select(time,logY) |>
pomp(times="time",t0=0) |>
kalmanFilter(
X0=c(logX=0),
A=matrix(exp(-0.1),1,1),
Q=matrix(0.01,1,1),
C=matrix(1,1,1),
R=matrix(0.01,1,1)
) -> kf
po |>
pfilter(Np=1000) -> pf
kf$logLik
logLik(pf) + sum(log(obs(pf)))
}


| Title | {{ selectedWorkload.name }} | ||
|---|---|---|---|
| Microsoft Lead |
|
Business Sponsor |
|
| Service(s) | {{ getServices(selectedWorkload) }} Not Specified | Technical Contact |
|
| Opportunity Status |
Completed
|
Deployed Status | {{ selectedWorkload.deployedStatus }} Not Deployed |
| Consumption (Estimated) |
$ {{ selectedWorkload.consumption | number }}/month TBD | Go Live Estimate (By Fiscal Month) |
{{ selectedWorkload.estimateGoLive | date:'MM/dd/yyyy' }} TBD |
| Created On | {{ selectedWorkload.creationTime | date:'MM/dd/yyyy hh:mm:ssa Z' }} | Last Updated | {{ selectedWorkload.lastUpdatedTime | date:'MM/dd/yyyy hh:mm:ssa Z' }} |


Do you mean fewer, and not less?
|
Less stuff. Use with singulars: less string |
Fewer things. Use with plurals: fewer fish (Things that can be counted). |
|
Less stuff. Use with singulars: less string |
Fewer things. Use with plurals: fewer fish (Things that can be counted). |


Visual Place Recognition in Changing Environments
The picture below illustrates the idea of place recognition: An autonomous robot that operates in an environment (for example our university campus) should be able to recognize different places when it comes back to them after some time. This is important to support reliable navigation, mapping, and localisation. Robust place recognition is therefore a crucial capability for an autonomous robot.
The problem of visual place recognition gets challenging if the visual appearance of these places changed in the meantime. This usually happens due to changes in the lighting conditions (think day vs. night or early morning vs. late afternoon), shadows, different weather conditions, or even different seasons. We develop algorithms for vision-based place recognition that can deal with these changes in visual appearance.
A general overview of the topic can be found in our survey paper:
-
Visual Place Recognition: A Survey Transactions on Robotics (TRO), 2015. This paper presents a survey of the visual place recognition research landscape. We start by introducing the concepts behind place recognition – the role of place recognition in the animal kingdom, how a “place” is defined in a robotics context, and the major components of a place recognition system. We then survey visual place recognition solutions for environments where appearance change is assumed to be negligible. Long term robot operations have revealed that environments continually change; consequently we survey place recognition solutions that implicitly or explicitly account for appearance change within the environment. Finally we close with a discussion of the future of visual place recognition, in particular with respect to the rapid advances being made in the related fields of deep learning, semantic scene understanding and video description.
Convolutional Networks for Place Recognition under Challenging Conditions (ongoing since 2014)
In two papers published at RSS and IROS 2015 we explored how Convolutional Networks can be utilized for robust visual place recognition. We found that the features from middle layers of these networks are robust against appearance changes and can be used as change-robust landmark descriptors. Since then, Sourav Garg has pushed the topic forward with publications at ICRA and RSS 2018.
Publications
-
Probabilistic Appearance-Invariant Topometric Localization with New Place Awareness IEEE Robotics and Automation Letters (RA-L), 2021. We present a new probabilistic topometric localization system which incorporates full 3-dof odometry into the motion model and furthermore, adds an “off-map” state within the state-estimation framework, allowing query traverses which feature significant route detours from the reference map to be successfully localized. We perform extensive evaluation on multiple query traverses from the Oxford RobotCar dataset exhibiting both significant appearance change and deviations from routes previously traversed. [arXiv]
-
Probabilistic Visual Place Recognition for Hierarchical Localization IEEE Robotics and Automation Letters (RA-L), 2021. We propose two methods which adapt image retrieval techniques used for visual place recognition to the Bayesian state estimation formulation for localization. We demonstrate significant improvements to the localization accuracy of the coarse localization stage using our methods, whilst retaining state-of-the-art performance under severe appearance change. Using extensive experimentation on the Oxford RobotCar dataset, results show that our approach outperforms comparable state-of-the-art methods in terms of precision-recall performance for localizing image sequences. In addition, our proposed methods provides the flexibility to contextually scale localization latency in order to achieve these improvements. [arXiv]
-
Semantic–geometric visual place recognition: a new perspective for reconciling opposing views The International Journal of Robotics Research (IJRR), 2022. We propose a hybrid image descriptor that semantically aggregates salient visual information, complemented by appearance-based description, and augment a conventional coarse-to-fine recognition pipeline with keypoint correspondences extracted from within the convolutional feature maps of a pre-trained network. Finally, we introduce descriptor normalization and local score enhancement strategies for improving the robustness of the system. Using both existing benchmark datasets and extensive new datasets that for the first time combine the three challenges of opposing viewpoints, lateral viewpoint shifts, and extreme appearance change, we show that our system can achieve practical place recognition performance where existing state-of-the-art methods fail.
-
Look No Deeper: Recognizing Places from Opposing Viewpoints under Varying Scene Appearance using Single-View Depth Estimation In Proc. of IEEE International Conference on Robotics and Automation (ICRA), 2019. We present a new depth-and temporal-aware visual place recognition system that solves the opposing viewpoint, extreme appearance-change visual place recognition problem. Our system performs sequence-to-single matching by extracting depth-filtered keypoints using a state-of-the-art depth estimation pipeline, constructing a keypoint sequence over multiple frames from the reference dataset, and comparing those keypoints to those in a single query image. We evaluate the system on a challenging benchmark dataset and show that it consistently outperforms state-of-the-art techniques. We also develop a range of diagnostic simulation experiments that characterize the contribution of depth-filtered keypoint sequences with respect to key domain parameters including degree of appearance change and camera motion. [arXiv]
-
LoST? Appearance-Invariant Place Recognition for Opposite Viewpoints using Visual Semantics In Proc. of Robotics: Science and Systems (RSS), 2018. In this paper we develop a suite of novel semantic- and appearance-based techniques to enable for the first time high performance place recognition in the challenging scenario of recognizing places when returning from the opposite direction. We first propose a novel Local Semantic Tensor (LoST) descriptor of images using the convolutional feature maps from a state-of-the-art dense semantic segmentation network. Then, to verify the spatial semantic arrangement of the top matching candidates, we develop a novel approach for mining semantically-salient keypoint correspondences.
-
Don’t Look Back: Robustifying Place Categorization for Viewpoint- and Condition-Invariant Place Recognition In Proc. of IEEE International Conference on Robotics and Automation (ICRA), 2018. In this work, we develop a novel methodology for using the semantics-aware higher-order layers of deep neural networks for recognizing specific places from within a reference database. To further improve the robustness to appearance change, we develop a descriptor normalization scheme that builds on the success of normalization schemes for pure appearance-based techniques.
-
Place Recognition with ConvNet Landmarks: Viewpoint-Robust, Condition-Robust, Training-Free In Proc. of Robotics: Science and Systems (RSS), 2015. Here we present an approach that adapts state-of-the-art object proposal techniques to identify potential landmarks within an image for place recognition. We use the astonishing power of convolutional neural network features to identify matching landmark proposals between images to perform place recognition over extreme appearance and viewpoint variations. Our system does not require any form of training, all components are generic enough to be used off-the-shelf. We present a range of challenging experiments in varied viewpoint and environmental conditions. We demonstrate superior performance to current state-of-the-art techniques. [Poster]
-
On the Performance of ConvNet Features for Place Recognition In Proc. of IEEE International Conference on Intelligent Robots and Systems (IROS), 2015. This paper comprehensively evaluates and compares the utility of three state-of-the-art ConvNets on the problems of particular relevance to navigation for robots; viewpoint-invariance and condition-invariance, and for the first time enables real-time place recognition performance using ConvNets with large maps by integrating a variety of existing (locality-sensitive hashing) and novel (semantic search space partitioning) optimization techniques. We present extensive experiments on four real world datasets cultivated to evaluate each of the specific challenges in place recognition. The results demonstrate that speed-ups of two orders of magnitude can be achieved with minimal accuracy degradation, enabling real-time performance. We confirm that networks trained for semantic place categorization also perform better at (specific) place recognition when faced with severe appearance changes and provide a reference for which networks and layers are optimal for different aspects of the place recognition problem.
Predicting Appearance Changes (2013 – 2015)
In earlier work, conducted at TU Chemnitz with colleagues Peer Neubert and Peter Protzel, we explored the possibilities of predicting the visual changes in appearance between different seasons.
This is a more active approach to robust place recognition, since it aims at reaching robustness not by becoming invariant to changes, but rather learn them from experience, and use the learned model to predict how a place would appear under different conditions (e.g. in winter or in summer).
Coming from the pre-deep learning era, our results look rather coarse. A number of groups have applied generative adverserial networks (GANs) to this problem and achieved far more superior results.
Publications
-
Superpixel-based appearance change prediction for long-term navigation across seasons Robotics and Autonomous Systems, 2015. The goal of our work is to support existing approaches to place recognition by learning how the visual appearance of an environment changes over time and by using this learned knowledge to predict its appearance under different environmental conditions. We describe the general idea of appearance change prediction (ACP) and investigate properties of our novel implementation based on vocabularies of superpixels (SP-ACP). This paper deepens the understanding of the proposed SP-ACP system and evaluates the influence of its parameters. We present the results of a largescale experiment on the complete 10 hour Nordland dataset and appearance change predictions between different combinations of seasons.
-
Appearance Change Prediction for Long-Term Navigation Across Seasons In Proceedings of European Conference on Mobile Robotics (ECMR), 2013.
-
Are We There Yet? Challenging SeqSLAM on a 3000 km Journey Across All Four Seasons. In Proceedings of Workshop on Long-Term Autonomy, IEEE International Conference on Robotics and Automation (ICRA), 2013.
-
Predicting the Change – A Step Towards Life-Long Operation in Everyday Environments In Proceedings of Robotics: Science and Systems (RSS) Robotics Challenges and Vision Workshop, 2013.
BRIEF-Gist (2011)
-
BRIEF-Gist – Closing the Loop by Simple Means In Proc. of IEEE Intl. Conf. on Intelligent Robots and Systems (IROS), 2011.


Six killed as avalanche buries Indian patrol on disputed glacier
SRINAGAR, Nov 19 — An avalanche yesterday hit an Indian patrol in the world's highest militarised zone in the Himalayas, killing four soldiers and two porters, an army spokesman said.
The disaster was the latest on the Siachen Glacier at more than 5,000 metres that is claimed by India and rival Pakistan.
Hundreds of troops from both sides have died in avalanches and from the fierce climate in the region over the past three decades.
An Indian military spokesman told AFP that the avalanche engulfed eight people in the patrol at the northern end of the glacier in the Karakoram mountain range.
Rescue teams managed to dig the patrol members out of the snow, and they were taken by helicopter to hospital.
“Despite best efforts, six casualties which includes four soldiers and two civilian porters succumbed to extreme hypothermia,” said the spokesman, Colonel Rajesh Kalia.
Avalanches are common on the 700-square-kilometreglacier, where temperatures regularly fall to minus 60 degrees Celsius (-76 Fahrenheit).
In 2016, 10 Indian soldiers were buried and killed.
About 900 Indian soldiers alone have died on the glacier since 1984, when Indian forces took complete control of Siachen.
The glacier is located at the northern end of the Line of Control that divides Kashmir, which India and Pakistan have fought over since 1947. — AFP


Small in numbers, Thai Catholics preserve centuries-old traditions
BANGKOK: The last time Vararunee Khonchanath was in the presence of a pope was before she was born just over 35 years ago, but when Pope Francis visits Bangkok later this week to bless Thailand's tiny Catholic minority she will be singing in the choir.
A sixth-generation Catholic of Portuguese-Thai ancestry, Vararunee lives in a 250-year-old community that is as old as the Thai capital itself. During the previous papal visit, back in 1984, Vararunee's pregnant mother was among the congregation.
"I was in my mum's tummy as she attended the mass when His Holiness John Paul II visited Thailand the last time," Vararunee said, adding how honoured she felt to be in the choir this time, when Pope Francis offers mass at the National Stadium.
During his visit from Nov. 20-23, Pope Francis will also celebrate mass at Assumption Cathedral in central Bangkok.
In overwhelmingly Buddhist Thailand, Catholics number just a little more than 380,000 in a country of more than 65 million.
MISSIONARIES, TRADERS
Historians say more than 70 per cent of Catholics in Thailand, like Vararunee, have foreign ancestry.
Catholicism first arrived in Siam, the old name for Thailand, in the mid 1500s with Portuguese missionaries and traders.
The Vatican formally established its "Mission de Siam" 350 years ago during the reign of King Narai, an anniversary that coincides with the visit of Pope Francis that begins on Wednesday.
While missionaries failed to achieve mass conversions, they were largely tolerated by the Buddhist majority and particularly the royal court.
"In the past, many Catholics from places like Japan and Vietnam, migrated to this land to escape religious persecution," said Puttipong Puttansri, a historian at the Archdiocese of Bangkok Historical Archive.
Catholics have over the years built schools and hospitals, some of which are still well known and respected today.
"For many Thais, Catholicism is synonymous with schools," Puttipong said.
MARTYRDOM
There were also spells of religious persecutions. In the late 1600s, Catholic priests were arrested and some killed out of suspicion they were working with France to colonize the country.
Similar hostility stirred in the 1940s when a nationalistic Thai government was at war with France in Indochina.
The tension resulted in the closing down of schools, confiscation of properties and the arrest of some clergy.
In 1940, seven Catholics, including three teenage girls, were killed by Thai police in the northeastern province of Nakhon Phanom. Pope John Paul II later declared them martyrs.
PEACE AND PASTRIES
In the modern era, Thailand remains largely tolerant to Catholics.
Catholics in Bangkok's historic Kudi Chin community along the Chao Praya River have mostly lived peacefully while maintaining their unique traditions and beliefs.
The district is known locally not only for Santa Cruz Church, that is the focal point for its Catholic community, but for the traditional Portuguese-influenced cupcake that is still baked there.
For the faithful such as Vararunee, the papal visit casts a light on their community and faith.
"I am very proud that we manage to hold on to our roots," Vararunee said.


Fancy a burger?
Best burgers here! With every burger you get a set off fries.
{{ burger.name }}
- {{ burger.kCal }}
- {{ 'Gluten' }}
Please enter the following fields in the form
- {{ error }}
Thank you love!
Here is your confirmation
Name: {{ fullname }}
Email: {{ email }}
Payment: {{ payment }}
Gender: {{ gender }}
Burgers: {{ burgers.join(', ') }}


details
and summary
Published:
details
without summary
details
with summary
, but no child contentdetails
with summary
, with title
but no child contentdetails
with title
and summary
with no child contentVO + Safari will announce the accName of summary
as the value of the details
title
attribute.
VO + Chrome will announce the details
as a group with title
as the accName. summary
will be given no accName.


1. defaultStyling: "inside" (default)
2. defaultStyling: "outside" (looks the same, but isn't - see 3)
3. defaultStyling: "outside" (with gap added)
4. defaultStyling: "none" (with completely custom styling)


What land is on my map?  My eyes reject its colours—it's grey and blue in blotches. I keep a vinegar-stained map rolled up in my little suitcase. Proud, majestic, grand, I leapfrog in the darkness.  One day I'll lose my thread. I'll stumble in the bracken, catch fire, blaze, then smoulder. That land was just a rumour.


Enter API-KEY
Continue
Mandatory roles for your API Key : DATA_PROCESSING_R, DATA_PROCESSING_W,DEVICE_R,DEVICE_W,API_KEY_R, DATA_R
Create an HTTP Push
Enter name
Enter url
Add header
Content
Payload
value
location
Push
List your rules
HP name
Button to delete the rule


Device ID:
Get this from the core area when logged in
31=Raspberry PI, 6=Photon
Direct microprocessor looped control
Can also use on and off or 1 and 0
Note that Advanced users can also use the pin numbers, so D7 = pin 7 on Photon but D7 = GPIO 19 on the Raspberry PI
Photon Direct Analog input, PI uses capactive Input both returns 0-4095
Photon Direct Analog input, PI uses capactive Input both returns 0-4095
Powerful
Medium
Off, These are PWM 0-255


How to use Driver
Overview
COINS Compiler Driver
The design
Structure
How to Use CLI Driver
CLI Driver
Command Syntax
Options
-coins Options
Input Files
Exit Status
Examples
Driver API
User Interface
Implementation
Compile Specification
Tracer API
Warning API
Library Directory
Property File
Suffix Rules
`settings' File
Known Bugs & Restrictions
Known bugs
Restrictions
→ top


Function call()
fun.call(thisArg[, arg1[, arg2[, ...]]])
fun.apply(thisArg[, argsArray])
The call() method calls a function with a given this value and arguments provided individually.
Note:
While the syntax of this function is almost identical to that of apply(),
the fundamental difference is that call() accepts an argument list,
while apply() accepts a single array of arguments.
Syntax
fun.call(thisArg[, arg1[, arg2[, ...]]])
Parameters
thisArg
The value of this provided for the call to fun.
Note that this may not be the actual value seen by the method:
if the method is a function in non-strict mode code,
null and undefined will be replaced with the global object and primitive values will be converted to objects.
arg1, arg2, ...
Arguments for the object.
Return value
The result of calling the function with the specified this value and arguments.
注意：该方法的作用和 apply() 方法类似，只有一个区别:
call()方法接受的是若干个 参数的列表，
apply()方法接受的是一个包含多个 参数的数组.


Upload files to this server folder:
Browse...
Replace existing files:
Always
Only if older
Never
Unpack jar/zip file:
Add files
Reset
Upload


Welcome code ninjas!!!
You have successfully created retrieved this source application from an GitHub and deployed it to Amazon EC2 instances using AWS CodeDeploy.
For next steps, read the AWS CodeDeploy Documentation.


Avakash IDE
A flexible IDE
Final Project of CSD 328-Software Engineering Lab for the Session 2020-2021
Made by equal contributions of Wable Sanket, Harry, Shubhang


Select from presets or enter custom text to filter
Leave a field blank for all related data
Large quantities of data might take time to load
Pivot a categorical column against a numerical row
Select filters on the left for a more refined search
Missing selections defaults to loading filtered data
We see a pretty even distribution, with Fridays and Saturdays having slightly higher averages.
More people tend to go out during the weekend.
Collisions with vehicles seem the most common of the accident types.
More people are injured and killed when colliding with fixed objects.
Trees and concrete structures can prove to be fatal to speeding vehicles.
Contrary to beliefs, most accidents happen during the daytime.
This might be so since most people prefer to drive during the day.
It is also possible that people exercise more caution during the night.
Complicated road structures like intersections have higher average incident rates
However, most of the incidents involve drivers away from intersections.
Bad road conditions of non-city roads may be a factor causing this.
There is an increasing trend as more people are involved at higher speed zones.
Driving faster causes more likelyhood to be involved in an accident.
Legend :
Yellow : Northern Region
Blue : Eastern Region
Red : Western Region
Green : North Eastern Region
Sky Blue : Metropolitan North West Region
Orange : South Western Region
Turquoise : Metropolitan South East Region
A total of 142573 accidents have been recorded from 2006 till 2016.
From the map, most accidents are concentrated around the metropolitan areas.
This could be due to the higher volume of traffic present in Melbourne and its surrounding suburbs.