This guide discusses recommendations for triaging bugs in Ruby's bug tracker.
These are the best bug reports. First, consider whether the bug reported is actually an issue or if it is expected Ruby behavior. If it is expected Ruby behavior, update the issue with why the behavior is expected, and set the status to Rejected.
If the bug reported appears to be an actual bug, try reproducing the bug with the master branch. If you are not able to reproduce the issue on the master branch, try reproducing it on the latest version for the branch the bug was reported on. If you cannot reproduce the issue in either case, update the issue stating you cannot reproduce the issue, ask the reporter if they can reproduce the issue with either the master branch or a later release, and set the status to Feedback.
If you can reproduce the example with the master branch, try to figure out what is causing the issue. If you feel comfortable, try working on a patch for the issue, update the issue, and attach the patch. Try to figure out which committer should be assigned to the issue, and set them as the assignee, and set the status to Assigned.
If you cannot reproduce the example with the master branch, but can reproduce the issue on the latest version for the branch, then it is likely the bug has already been fixed, but it has not been backported yet. Try to determine which commit fixed it, and update the issue noting that the issue has been fixed but not yet backported. If the Ruby version is in the security maintenance phase or no longer supported, change the status to Closed. This change can be made without adding a note to avoid spamming the mailing list.
For issues that may require backwards incompatible changes or may benefit from general committer attention or discussion, consider adding them as agenda items for the next committer meeting (bugs.ruby-lang.org/issues/14770).
Many bugs reported have little more than a crash report, often with no way to reproduce the issue. These bugs are difficult to triage as they often do not contain enough information.
For these bugs, if the Ruby version is the master branch or is the latest release for the branch and the branch is in normal maintenance phase, look at the backtrace and see if you can determine what could be causing the issue. If you can guess what could be causing the issue, see if you can put together a reproducible example (this is in general quite difficult). If you cannot guess what could be causing the issue, or cannot put together a reproducible example yourself, please ask the reporter to provide a reproducible example, and change the status to Feedback.
If the Ruby version is no longer current (e.g. 2.5.0 when the latest version on the Ruby 2.5 branch is 2.5.5), add a note to the issue asking the reporter to try the latest Ruby version for the branch and report back, and change the status to Feedback. If the Ruby version is in the security maintenance phase or no longer supported, change the status to Closed. This change can be made without adding a note.
If the crash happens inside a 3rd party C extension, try to figure out inside which C extension it happens, and add a note to the issue to report the issue to that C extension, and set the status to Third Party's Issue.
Any issues in the bug tracker that are not reports of problems should have the tracker changed from Bug to either Feature (new features or performance improvements) or Misc. This change can be made without adding a note.
There are many issues that are stale, with no updates in months or even years. For stale issues in Feedback state, where the feedback has not been received, you can change the status to Closed without adding a note. For stale issues in Assigned state, you can reach out to the assignee and see if they can update the issue. If the assignee is no longer an active committer, remove them as the assignee and change the status to Open.


--- layout: post title: Many Blessings date: 2010-12-25 09:00:40.000000000 -05:00 categories: - Celebrations - Family Life tags: - Christmas - Nativity - Steiner - Waldorf status: publish type: post published: true meta: aktt_notify_twitter: 'no' _edit_last: '1' author: login: cint email<EMAIL_ADDRESS>display_name: Jacinta first_name: Jacinta last_name: '' ---
Wishing you and yours a most blessed and beautiful festive season. May all your hopes and dreams be realised. With love, Jacinta and Family.


On Click...
... add a new Overlay
... re-position the Overlay
What type of overlay to use?
Default HTML Elements
Bootstrap
popover


Make This My Homepage
Sign In
Georgia Standards Home
Advanced Search
Search:
Standards
Resources
Keyword:
Grade:
All
K-2
3-5
6-8
9-12
Subject:
All
Science
Math
English/Language Arts
Social Studies
Career Technical & Agricultural
Modern Languages & Latin
Physical Education
Course:
All
Program Concentration:
All
Career Pathway:
All
CTAE Course:
All
Course Level:
All
Differentiated for:
All
Format:
All
Home
CCRPI
Georgia Standards of Excellence
GPS
Content Area Frameworks
Resources/Videos
Personalized Learning
Archives
Browse GPS Training
Georgia Department of Education Grading & Validation, presented by CASS.
Related Information
On this Website
Related Links
Contact Us
Georgia Department of Education
Webmaster
·
AskDOE
Privacy Policy
·
Terms of Use
·
Site Requirements
Richard Woods, Georgia's School Superintendent
Copyright © 2015 Georgia Department of Education - Atlanta, GA


Profile Information
Employee ID:
E-mail address:
Monthly bill will go to:
Spending limit per month:
R
Available balance for month:
R
Profile type:
Employee
Profile type:
Administration (SuperUser)
Profile type:
Finance Department
Profile type:
Cafeteria Manager
Profile type:
Cashier
Profile type:
Administration (Admin)


RESTful API over WebSockets using the WS3V Protocol
Phil Collins Music Playlist Demo
In this demo we also test the gatekeeper functionality, this case specifically we are using an API key.
The only valid API key is prepopulated below, feel free to try something else and see what happens (either use the developer console or the WS3V WebSocket debug console.)
API Key:
WS3V WebSocket Debug Console:


fun add(element: T): Boolean
Adds an element to the list. If the current size of the list exceeds the max size, the head element of the list will be dropped.


Polygon Sponsor
|
Polygon 90 Set Concept
The polygon_90_set concept tag is
polygon_90_set_concept
The semantic of a
polygon_90_set is zero or more Manhattan geometry regions.
The motivation for providing
the polygon_90_set_concept is that it is a very common special case of
planar geometry which afford the implementation of a variety of
optimizations on the general planar geometry algorithms.
Manhattan geometry processing by the polygon_90_set_concept can be 100X
faster than arbitrary angle polygon manipulation. Because the
performance benefits are so large and the special case is important
enough, the library provides these performance benefits for those
application domains that require them.
Users are recommended to use std::vector and std::list of user
defined polygons or library provided
polygon_90_set_data<coordinate_type> objects. Lists and
vectors of models of polygon_90_concept or
polygon_90_with_holes_concept or rectangle_concept are automatically
models of polygon_90_set_concept.
Operators
The return type of some operators is the polygon_90_set_view operator template
type. This type is itself a model of the polygon_90_set concept,
but furthermore can be used as an argument to the polygon_90_set_data constructor and
assignment operator. The operator template exists to eliminate
temp copies of intermediate results when Boolean operators are chained
together.
Operators are declared inside the namespace boost::polygon::operators.
template
<typename T1, typename T2>
polygon_90_set_view operator|(const T1& l, const T2& r) |
Boolean OR operation (polygon set union). Accepts
two objects that model polygon_90_set or one of its refinements.
Returns an operator template that performs the operation on demand when
chained or or nested in a library function call such as assign().
O( n log n) runtime complexity and O(n) memory wrt vertices +
intersections. |
template
<typename T1, typename T2>
polygon_90_set_view operator+(const T1& l, const T2& r) |
Same as operator|. The plus sign is also used for
OR operations in Boolean logic expressions. O( n log n) runtime
complexity and O(n) memory wrt vertices + intersections. |
template
<typename T1, typename T2>
polygon_90_set_view operator&(const T1& l, const
T2& r) |
Boolean AND operation (polygon set intersection).
Accepts two objects that model polygon_90_set or one of its
refinements. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T1, typename T2>
polygon_90_set_view operator*(const T1& l, const T2& r) |
Same as operator&. The multiplication symbol
is also used for AND operations in Boolean logic expressions. O(
n log n) runtime complexity and O(n) memory wrt vertices +
intersections. |
template
<typename T1, typename T2>
polygon_90_set_view operator^(const T1& l, const T2& r) |
Boolean XOR operation (polygon set
disjoint-union). Accepts two objects that model polygon_90_set or
one of its refinements. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. O( n log n) runtime
complexity and O(n) memory wrt vertices + intersections. |
template
<typename T1, typename T2>
polygon_90_set_view operator-(const T1& l, const T2& r) |
Boolean SUBTRACT operation (polygon set
difference). Accepts two objects that model polygon_90_set or one
of its refinements. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T1, typename T2>
T1& operator|=(const T1& l, const T2& r) |
Same as operator|, but with self assignment, left
operand must model polygon_90_set and not one of it's
refinements. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T1, typename T2>
T1& operator+=(T1& l, const T2& r) |
Same as operator+, but with self assignment, left
operand must model polygon_90_set and not one of it's
refinements. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T1, typename T2>
T1& operator&=(const T1& l, const T2& r) |
Same as operator&, but with self assignment, left
operand must model polygon_90_set and not one of it's
refinements. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T1, typename T2>
T1& operator*=(T1& l, const T2& r) |
Same as operator*, but with self assignment, left
operand must model polygon_90_set and not one of it's
refinements. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T1, typename T2>
T1& operator^=(const T1& l, const T2& r) |
Same as operator^, but with self assignment, left
operand must model polygon_90_set and not one of it's
refinements. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T1, typename T2>
T1& operator-=(T1& l, const T2& r) |
Same as operator-, but with self assignment, left
operand must model polygon_90_set and not one of it's
refinements. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T1>
T1 operator+(const T1&, coordinate_type bloating) |
Performs resize operation, inflating by bloating
ammount. If negative the result is a shrink instead of
bloat. Note: returns result by value. O( n log n) runtime
complexity and O(n) memory wrt vertices + intersections. |
template
<typename T1, typename T2>
T1 operator-(const T1&, coordinate_type shrinking) |
Performs resize operation, deflating by bloating
ammount. If negative the result is a bloat instead of
shrink. Note: returns result by value. O( n log n) runtime
complexity and O(n) memory wrt vertices + intersections. |
template
<typename T1, typename T2>
T1& operator+=(const T1&, coordinate_type bloating) |
Performs resize operation, inflating by bloating
ammount. If negative the result is a shrink instead of
bloat. Returns reference to modified argument. O( n log n)
runtime complexity and O(n) memory wrt vertices + intersections. |
template
<typename T1, typename T2>
T1& operator-=(const T1&, coordinate_type shrinking) |
Performs resize operation, deflating by bloating
ammount. If negative the result is a bloat instead of
shrink. Returns reference to modified argument. O( n log n)
runtime complexity and O(n) memory wrt vertices + intersections. |
Functions
template
<typename T1, typename T2>
T1& assign(T1& lvalue, const T2& rvalue) |
Eliminates overlaps in geometry and copies from an
object that models polygon_90_set or any of its refinements into an
object that models polygon_90_set. O( n log n) runtime complexity
and O(n) memory wrt vertices + intersections. |
template
<typename T1, typename T2>
bool equivalence(const T1& lvalue, const T2& rvalue) |
Returns true if an object that models polygon_90_set or
one of its refinements covers the exact same geometric regions as
another object that models polygon_90_set or one of its
refinements. For example: two of polygon_90 objects. O( n
log n) runtime complexity and O(n) memory wrt vertices + intersections. |
template
<typename output_container_type, typename T>
void get_rectangles(output_container_type& output,
const T& polygon_set) |
Output container is expected to be a standard
container. Slices geometry of an object that models
polygon_90_set or one of its refinements into non overlapping
rectangles and appends them to the output. O( n log n) runtime
complexity and O(n) memory wrt vertices + intersections. |
template
<typename output_container_type, typename T>
void get_max_rectangles(output_container_type& output,
const T& polygon_set) |
Output container is expected to be a standard
container. Given an object that models polygon_90_set or one of
its refinements finds all overlapping rectangles that are maximal in
area and appends them to the output. Expected n log n runtime,
worst case quadratic rutnime. |
template
<typename polygon_set_type>
void clear(polygon_set_type& polygon_set) |
Makes the object empty of geometry. |
template
<typename polygon_set_type>
bool empty(const polygon_set_type& polygon_set) |
Checks whether the object is empty of geometry.
Polygons that are completely covered by holes will result in empty
returning true. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
template
<typename T, typename rectangle_type>
bool extents(rectangle_type& extents_rectangle,
const T& polygon_set) |
Computes bounding box of an object that models
polygon_90_set and stores it in an object that models rectangle.
If the polygon set is empty returns false. If there are holes
outside of shells they do not contribute to the extents of the polygon
set. O( n log n) runtime complexity and O(n) memory wrt vertices
+ intersections. |
template
<typename T>
manhattan_area_type area(const T& polygon_set) |
Computes the area covered by geometry in an object that
models polygon_90_set. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T1, typename T2>
T1& interact(T1& a, const T2& b) |
Given an object that models polygon_90_set and an
object that models polygon_90_set or one of its refinements, modifies a
to retain only regions that overlap or touch regions in b. O( n
log n) runtime complexity and O(n) memory wrt vertices + intersections.
|
template
<typename T>
T& self_intersect(T& polygon_set) |
Given an object that models polygon_90_set that has
self overlapping regions, modifies the argument to contain only the
regions of overlap. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T>
T& self_xor(T& polygon_set) |
Given an object that models polygon_90_set that has
self overlapping regions, modifies the argument to contain only the
regions that do not overlap. O( n log n) runtime complexity and
O(n) memory wrt vertices + intersections. |
template
<typename T>
T& bloat(T& polygon_set, unsigned_area_type bloating) |
Same as getting all the rectangles, bloating them and
putting them back. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
template
<typename T>
T& bloat(T& polygon_set, orientation_2d orient,
unsigned_area_type
bloating) |
Same as getting all the rectangles, bloating them and
putting them back. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
template
<typename T>
T& bloat(T& polygon_set, orientation_2d orient,
unsigned_area_type
low_bloating,
unsigned_area_type
high_bloating) |
Same as getting all the rectangles, bloating them and
putting them back. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
template
<typename T>
T& bloat(T& polygon_set, direction_2d dir,
unsigned_area_type
bloating) |
Same as getting all the rectangles, bloating them and
putting them back. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
template
<typename T>
T& bloat(T& polygon_set,
unsigned_area_type
west_bloating,
unsigned_area_type
east_bloating,
unsigned_area_type
south_bloating,
unsigned_area_type
north_bloating) |
Same as getting all the rectangles, bloating them and
putting them back. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
template
<typename T>
T& shrink(T& polygon_set, unsigned_area_type shrinking) |
Same as getting all the rectangles of the inverse,
bloating them and overwriting the polygon set with the resulting
regions then negating. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T>
T& shrink(T& polygon_set, orientation_2d orient,
unsigned_area_type shrinking) |
Same as getting all the rectangles of the inverse,
bloating them and overwriting the polygon set with the resulting
regions then negating. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T>
T& shrink(T& polygon_set, orientation_2d orient,
unsigned_area_type low_shrinking,
unsigned_area_type high_shrinking) |
Same as getting all the rectangles of the inverse,
bloating them and overwriting the polygon set with the resulting
regions then negating. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T>
T& shrink(T& polygon_set, direction_2d dir,
unsigned_area_type shrinking) |
Same as getting all the rectangles of the inverse,
bloating them and overwriting the polygon set with the resulting
regions then negating. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T>
T& shrink(T& polygon_set,
unsigned_area_type west_shrinking,
unsigned_area_type east_shrinking,
unsigned_area_type south_shrinking,
unsigned_area_type north_shrinking) |
Same as getting all the rectangles of the inverse,
bloating them and overwriting the polygon set with the resulting
regions then negating. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T, typename coord_type>
T& resize(T& polygon_set, coord_type resizing) |
Same as bloat if resizing is positive, same as shrink
if resizing is negative. |
template
<typename T, typename coord_type>
T& resize(polygon_set_type& polygon_set,
coord_type west,
coord_type east,
coord_type
south, coord_type north) |
Same as bloat if resizing is positive, same as shrink
if resizing is negative. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T>
T& grow_and(T& polygon_set, unsigned_area_type bloating) |
Same as bloating non-overlapping regions and then
applying self intersect to retain only the overlaps introduced by the
bloat. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T>
T& grow_and(T& polygon_set, orientation_2d orient,
unsigned_area_type bloating) |
Same as bloating non-overlapping regions and then
applying self intersect to retain only the overlaps introduced by the
bloat. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T>
T& grow_and(T& polygon_set, orientation_2d orient,
unsigned_area_type low_bloating,
unsigned_area_type high_bloating) |
Same as bloating non-overlapping regions and then
applying self intersect to retain only the overlaps introduced by the
bloat. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T>
T& grow_and(T& polygon_set, direction_2d dir,
unsigned_area_type bloating) |
Same as bloating non-overlapping regions and then
applying self intersect to retain only the overlaps introduced by the
bloat. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T>
T& grow_and(T& polygon_set,
unsigned_area_type west_bloating,
unsigned_area_type east_bloating,
unsigned_area_type south_bloating,
unsigned_area_type north_bloating) |
Same as bloating non-overlapping regions and then
applying self intersect to retain only the overlaps introduced by the
bloat. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T>
T& scale_up(T& polygon_set, unsigned_area_type factor) |
Scales geometry up by unsigned factor. O( n log
n) runtime complexity and O(n) memory wrt vertices + intersections. |
template
<typename T>
T& scale_down(T& polygon_set, unsigned_area_type factor) |
Scales geometry down by unsigned factor. O( n log
n) runtime complexity and O(n) memory wrt vertices + intersections. |
template
<typename T, typename scaling_type>
T& scale(polygon_set_type& polygon_set,
const
scaling_type& scaling) |
Scales geometry by applying scaling.scale() on all
vertices. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T, typename coord_type>
T& move(T& polygon_set,
orientation_2d orient,
coord_type displacement) |
Moves geometry by displacement amount in the
orientation. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template
<typename T, typename coord_type>
T& move(T& polygon_set, coord_type x_displacement,
coord_type y_displacement) |
Moves the geometry by x_dispacement in x and
y_displacement in y. Note: for consistency should be
convolve(polygon_set, point). O( n log n) runtime complexity and
O(n) memory wrt vertices + intersections. |
template
<typename T, typename transformation_type>
T& transform(T& polygon_set,
const transformation_type& transformation) |
Applies transformation.transform() on all
vertices. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
template
<typename T>
T& keep(T& polygon_set,
unsigned_area_type min_area,
unsigned_area_type max_area,
unsigned_area_type min_width,
unsigned_area_type max_width,
unsigned_area_type
min_height,
unsigned_area_type
max_height) |
Retains only regions that satisfy the min/max criteria
in the argument list. Note: useful for visualization to cull too
small polygons. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
Polygon 90 Set Data Object
The polygon 90 set data type encapsulates the internal data
format that serves as the input to the sweep-line algorithm that
implements polygon-clipping boolean operations. It also
internally keeps track of whether that data has been sorted or scanned
and maintains the invariant that when its flags indicate that the data
is sorted or scanned the data has not been changed to violate that
assumption. Using the Polygon 90 Set Data type directly can be
more efficient than using lists and vectors of polygons in the
functions above because of the invariants it can enforce which provide
the opportunity to maintain the data is sorted form rather than going
all the way out to polygons then resorting those vertices for a
subsequent operation.
The declaration of Polygon 90 Set Data is the following:
template <typename T>
class polygon_90_set_data;
The class is parameterized on the coordinate data type.
Algorithms that benefit from knowledge of the invariants enforced by
the class are implemented as member functions to provide them access to
information about those invariants.
Member Functions
| polygon_90_set_data() |
Default constructor. Scanning orientation
defaults to HORIZONTAL |
| polygon_90_set_data(orientation_2d
orient) |
Construct with scanning orientation. |
template
<typename iT>
polygon_90_set_data(orientation_2d orient,
iT input_begin, iT input_end) |
Construct with scanning orientation from an iterator
range of insertable objects. |
| polygon_90_set_data(const
polygon_90_set_data& that) |
Copy construct. |
template
<typename l, typename r, typename op>
polygon_90_set_data(const
polygon_90_set_view<l,r,op>& t) |
Copy construct from a Boolean operator template. |
polygon_90_set_data(orientation_2d orient,
const polygon_90_set_data& that) |
Construct with scanning orientation and copy from
another polygon set. |
polygon_90_set_data&
operator=(const polygon_90_set_data& that) |
Assignment from another polygon set, may change
scanning orientation. |
template
<typename l, typename r, typename op>
polygon_90_set_data&
operator=(const polygon_90_set_view<l, r,
op>& that) |
Assignment from a Boolean operator template. |
template
<typename geometry_object>
polygon_90_set_data& operator=(const geometry_object&
geo) |
Assignment from an insertable object. |
template <typename iT>
void insert(iT input_begin, iT input_end) |
Insert objects of an iterator range. Linear wrt.
inserted vertices. |
|
void insert(const polygon_90_set_data& polygon_set) |
Insert a polygon set. Linear wrt. inserted
vertices. |
template <typename geometry_type>
void insert(const geometry_type& geometry_object,
bool
is_hole = false) |
Insert a geometry object, if is_hole is true then the
inserted region is subtractive rather than additive. Linear wrt.
inserted vertices. |
template
<typename output_container>
void get(output_container& output) const |
Expects a standard container of geometry objects.
Will scan and eliminate overlaps. Converts polygon set geometry
to objects of that type and appends them to the container.
Polygons will be output with counterclockwise winding, hole polygons
will be output with clockwise winding. The last vertex of an
output polygon is not the duplicate of the first, and the number of
points is equal to the number of edges. O( n log n) runtime
complexity and O(n) memory wrt vertices + intersections. |
template
<typename output_container>
void get_polygons(output_container& output) const |
Expects a standard container of polygon objects.
Will scan and eliminate overlaps. Converts polygon set geometry
to polygons and appends them to the container. Polygons will have
holes fractured out to the outer boundary along the positive direction
of the scanline orientation of the polygon set. O( n log n)
runtime complexity and O(n) memory wrt vertices + intersections. |
template
<typename output_container>
void get_rectangles(output_container& output) const |
Expects a standard container of rectangle
objects. Will scan and eliminate overlaps. Slices polygon
set geometry to rectangles along the scanning orientation and appends
them to the container. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
template <typename output_container>
void get_rectangles(output_container& output,
orientation_2d slicing_orientation) const |
Expects a standard container of rectangle
objects. Will scan and eliminate overlaps. Slices polygon
set geometry to rectangles along the given orientation and appends them
to the container. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
|
bool operator==(const polygon_90_set_data& p) const |
Once scanned the data representation of geometry within
a polygon set is in a mathematically canonical form. Comparison
between two sets is therefore a linear time operation once they are in
the scanned state. Will scan and eliminate overlaps in both polygon
sets. O( n log n) runtime complexity and O(n) memory wrt vertices
+ intersections the first time, linear subsequently. |
| bool operator!=(const
polygon_90_set_data& p) const |
Inverse logic of equivalence operator. |
| void clear() |
Make the polygon set empty. Note: does not
de-allocate memory. Use shrink to fit idiom and assign default
constructed polygon set to de-allocate. |
| bool empty()
const |
Check whether the polygon set contains no
geometry. Will scan and eliminate overlaps because subtractive
regions might make the polygon set empty. O( n log n) runtime
complexity and O(n) memory wrt vertices + intersections the first time,
linear subsequently. |
| orientation_2d orient()
const |
Get the scanning orientation. Depending on the
data it is sometimes more efficient to scan in a specific
orientation. This is particularly true of Manhattan geometry
data. Constant time. |
| void clean()
const |
Scan and eliminate overlaps. O( n log n) runtime
complexity and O(n) memory wrt vertices + intersections the first time,
constant time subsequently. |
template
<typename input_iterator_type>
void set(input_iterator_type input_begin,
input_iterator_type
input_end,
orientation_2d orient)
|
Overwrite geometry in polygon set with insertable
objects in the iterator range. Also sets the scanning orientation
to that specified. |
template
<typename rectangle_type>
bool extents(rectangle_type& extents_rectangle) const |
Given an object that models rectangle, scans and
eliminates overlaps in the polygon set because subtractive regions may
alter its extents then computes the bounding box and assigns it to
extents_rectangle. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections the first time, linear subsequently. |
polygon_90_set_data&
bloat(unsigned_area_type west_bloating,
unsigned_area_type east_bloating,
unsigned_area_type south_bloating,
unsigned_area_type north_bloating) |
Scans to eliminate overlaps and subtractive
regions. Inserts rectangles of width specified by bloating values
to the indicated side of geometry within the polygon set and fills
corners with rectangles of the length and width specified for the
adjacent sides. O( n log n) runtime complexity and O(n) memory
wrt vertices + intersections. |
polygon_90_set_data&
shrink(unsigned_area_type west_shrinking,
unsigned_area_type east_shrinking,
unsigned_area_type south_shrinking,
unsigned_area_type north_shrinking) |
Scans to eliminate overlaps and subtractive
regions. Inserts subtractiive rectangles of width specified by
bloating values to the indicated side of geometry within the polygon
set and subtractive rectangle at convex corners of the length and width
specified for the adjacent sides. Scans to eliminate overlapping
subtractive regions. O( n log n) runtime complexity and O(n)
memory wrt vertices + intersections. |
polygon_90_set_data&
resize(coordinate_type west, coordinate_type east,
coordinate_type south,
coordinate_type north) |
Call bloat or shrink or shrink then bloat depending on
whether the resizing values are positive or negative. O( n log n)
runtime complexity and O(n) memory wrt vertices + intersections. |
polygon_90_set_data&
move(coordinate_type x_delta,
coordinate_type y_delta) |
Add x_delta to x values and y_delta to y values of
vertices stored within the polygon set. Linear wrt. vertices. |
template
<typename transformation_type>
polygon_90_set_data&
transform(const transformation_type&
transformation) |
Applies transformation.transform() on vertices stored
within the polygon set. Linear wrt. vertices. |
| polygon_90_set_data&
scale_up(unsigned_area_type factor) |
Scales vertices stored within the polygon set up by
factor. Linear wrt. vertices. |
|
polygon_90_set_data& scale_down(unsigned_area_type
factor)
|
Scales vertices stored within the polygon set down by
factor. Linear wrt. vertices. |
template
<typename scaling_type>
polygon_90_set_data&
scale(const
anisotropic_scale_factor<scaling_type>& f) |
Scales vertices stored within the polygon set by
applying f.scale(). Linear wrt. vertices. |
| polygon_90_set_data&
scale(double factor) |
Scales vertices stored within the polygon set by
floating point factor. Linear wrt. vertices. |
| polygon_90_set_data&
self_xor() |
Retain only non-overlapping regions of geometry within
polygon set. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
| polygon_90_set_data&
self_intersect() |
Retain only overlapping regions of geometry within a
polygon set. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
polygon_90_set_data&
interact(const polygon_90_set_data& that) |
Retain only regions that touch or overlap regions in
argument. O( n log n) runtime complexity and O(n) memory wrt
vertices + intersections. |
|


module RubyRegex
Constants
- CreditCard
CreditCard Validates Credit Card numbers, Checks if it contains 16 numbers in groups of 4 separated by -, space or nothing
- DBDate
Date DB format YYYY-MM-DD I know it will validate 2001-02-31 but is I think we are focusing in formats more than in parsing
- DBDateTime
Date Time DB format YYYY-MM-DD hh:mm:ss
- DeliciousUsername
Del.icio.us username
- Dni
Dni (spanish ID card)
- Domain
Email From the email regex research: fightingforalostcause.net/misc/2006/compare-email-regex.php Authors: James Watts and Francisco Jose Martin Moreno
- GeneralPostalCode
General postal code Validates a 5 digits postal code
- GithubUsername
Github username
- IBAN
IBAN Source: snipplr.com/view/15322/iban-regex-all-ibans/ You have to remove spaces or any separator character from the original field before use this regex
- MacAddress
- MasterCard
MasterCard credit card
Slideshare username
- SpanishBankAccountNumber
- TwitterUsername
Twitter username
- USSocialSecurity
US Social Security
- UUID
UUID Validates a UUID as defined: en.wikipedia.org/wiki/Universally_unique_identifier
- Url
URL
- Username
Username This regular expression doesn't validate username's length
- Visa
Visa credit card
- ZIPCode
US ZIP code Validates US ZIP Code (basic and extended format)


| 1 | /* | |
| 2 | * To change this license header, choose License Headers in Project Properties. | |
| 3 | * To change this template file, choose Tools | Templates | |
| 4 | * and open the template in the editor. | |
| 5 | */ | |
| 6 | package dev.kumpulatd.objects; | |
| 7 | ||
| 8 | import java.awt.image.BufferedImage; | |
| 9 | ||
| 10 | /** | |
| 11 | * Implementation of Tower | |
| 12 | * | |
| 13 | * @author kummi | |
| 14 | */ | |
| 15 | public class Tutor implements Tower { | |
| 16 | ||
| 17 | private TowerLocation location; | |
| 18 | private int range; | |
| 19 | private int damageType; | |
| 20 | private BufferedImage img; | |
| 21 | private int damage; | |
| 22 | private String name; | |
| 23 | ||
| 24 | /** | |
| 25 | * | |
| 26 | * @param location | |
| 27 | */ | |
| 28 | public Tutor(TowerLocation location, BufferedImage img) { | |
| 29 | this.location = location; | |
| 30 | range = 150; | |
| 31 | damageType = 1; | |
| 32 | this.img = img; | |
| 33 | damage = 8; | |
| 34 | name = "Tutor"; | |
| 35 | } | |
| 36 | ||
| 37 | /** | |
| 38 | * | |
| 39 | * @return | |
| 40 | */ | |
| 41 | @Override | |
| 42 | public int range() { | |
| 43 |
1
1. range : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return range; |
| 44 | } | |
| 45 | ||
| 46 | /** | |
| 47 | * | |
| 48 | * @return | |
| 49 | */ | |
| 50 | @Override | |
| 51 | public int damage() { | |
| 52 |
1
1. damage : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return damage; |
| 53 | } | |
| 54 | ||
| 55 | /** | |
| 56 | * | |
| 57 | * @return | |
| 58 | */ | |
| 59 | @Override | |
| 60 | public int damageType() { | |
| 61 |
1
1. damageType : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return damageType; |
| 62 | } | |
| 63 | ||
| 64 | /** | |
| 65 | * | |
| 66 | * @return | |
| 67 | */ | |
| 68 | @Override | |
| 69 | public BufferedImage getImg() { | |
| 70 |
1
1. getImg : mutated return of Object value for dev/kumpulatd/objects/Tutor::getImg to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return img; |
| 71 | } | |
| 72 | ||
| 73 | /** | |
| 74 | * | |
| 75 | * @return | |
| 76 | */ | |
| 77 | @Override | |
| 78 | public TowerLocation getLocation() { | |
| 79 |
1
1. getLocation : mutated return of Object value for dev/kumpulatd/objects/Tutor::getLocation to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return location; |
| 80 | } | |
| 81 | /** | |
| 82 | * | |
| 83 | * @return | |
| 84 | */ | |
| 85 | @Override | |
| 86 | public String getName() { | |
| 87 |
1
1. getName : mutated return of Object value for dev/kumpulatd/objects/Tutor::getName to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return name; |
| 88 | } | |
| 89 | ||
| 90 | /** | |
| 91 | * | |
| 92 | */ | |
| 93 | @Override | |
| 94 | public void upgrade() { | |
| 95 |
1
1. upgrade : Replaced integer addition with subtraction → NO_COVERAGE |
range += 5; |
| 96 |
1
1. upgrade : Replaced integer addition with subtraction → NO_COVERAGE |
damage += 5; |
| 97 | } | |
| 98 | ||
| 99 | @Override | |
| 100 | public int getRadius() { | |
| 101 |
1
1. getRadius : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return 1; |
| 102 | } | |
| 103 | ||
| 104 | } | |
Mutations | ||
| 43 |
1.1 |
|
| 52 |
1.1 |
|
| 61 |
1.1 |
|
| 70 |
1.1 |
|
| 79 |
1.1 |
|
| 87 |
1.1 |
|
| 95 |
1.1 |
|
| 96 |
1.1 |
|
| 101 |
1.1 |


Your browser doesn't support the features required by impress.js, so you are presented with a simplified version of this presentation.
For the best experience please use the latest Chrome, Safari or Firefox browser.
Idea Generation
Rich Hildred -<EMAIL_ADDRESS>-<PHONE_NUMBER>
Example 1. The other Gore
For Instance Take High Performance Windsurfing
No one wants an innovation from someone who is behind them.
Zero-K a game for the Spring engine.
Mountain Biking.
Google began in January 1996 as a research project by Larry Page and Sergey Brin when they were both PhD students at Stanford University in Stanford, California.
While conventional search engines ... the two theorized about a better system that analyzed the relationships between websites.
These people took something that they were already passionately involved in and innovated to make it better.
Role Playing: Role playing involves designers acting
out scenarios.
Active Search: Active search refers to designers
hunting for a particular solution
Attribute List: Attribute listing refers to taking an
existing product or system, breaking it into parts and
then recombining these to identify new forms of the
product or system
Brainstorm: Brainstorming involves generating a large
number of solutions to a problem (idea) with a focus
on the quantity of ideas.
Collaborate: Collaboration refers to two or more
people working together towards a common goal
Concrete Stimuli: Concrete stimuli are used when
designers want to gain new perspectives on a problem
by manipulating physical materials
Critique: Critique refers to receiving input on current
design ideas.
Documenting: Documenting refers to designers writing
down ideas (physically or electronically)
Expert Opinion: Designers often elicit opinions from
experts to identify potential problems with products or
services before more comprehensive evaluations
. Empathy/User Research: User research requires the
designer to observe people in everyday situations in
order to develop empathy for them.
Encompass: Encompassing is an inspirational technique
which involves designers immersing themselves in
information relevant to the current project
Forced Analogy: Forced analogy involves comparing
the current problem with something else that has little or
nothing in common in order to gain new insights and
results.
Incubate: Incubation refers to stepping back from the
problem to let the subconscious mind work
Passive Searching: Passive searching refers to designers
looking through material (web, magazines, books) for
inspiration without searching for a particular solution to
a problem
Prototyping: Prototyping, in this study, refers to a lowfidelity
model of an idea
Reflect: Reflection occurs when designers review their
previous work (sketches, documents, prototypes, etc.)
Sketching: Sketching refers to a rough drawing of an
idea
Socializing: Socializing refers to talking with others
about topics unrelated to the current project.
Storyboards: Storyboards are a way for designers to
represent information gained in the research phase of
the design process
A big gap in problem solving is failure to generate enough alternatives


Kurukshetra University, India
2011-2015
GPA: 3.4
National Informatics Center
Ministry of Electronics Information Technology, India
June 2015-July 2016
Illinois Institute of Technology
Chicago-Illinois, United States
August 2016- Present
GPA: 3.6
Graduating in May 2018
Technologies: Node/Express/MongoDB application using Semantic UI.
This website lists the blogs on various festivals celebrated in India. It is built using technologies: Node.js, Express, MongoDB, HTML5 and CSS3. The Users are authorized to perform CRUD (Create, Read, Update, Delete) operations over the blogs model.
LIVE DEMO GITHUBTechnologies: Angular, MongoDB, Bootstrap
Designed and Developed a responsive website listing recipes and selling the ingredients listed in recipes.
GITHUBTechnologies: JavaScript (MVC Arch.), ECMAScript 6, JSON, HTML5, CSS3, Chart.js, Dataframe.js
A single page application using MVC Architecture that loads the data as tables on the page and then visualizes the data as charts (Bar Chart, Pie Chart, Line Chart, Doughnut Chart).
GITHUB


Practical CSS makes everything better
Color wheels: HSL
Complementary colors stimulate eyes
Natalya's Complementary Color Scheme BuilderDesign for accessibility and audience
:lang(language)
Hello. My name is Codi.
こんにちは。わたしわ こーでいー。
:lang(jp) {
font-family: serif;
writing-mode: vertical-rl
}
::after and ::before
my name is codi.
わたしわ こーでいー。
::before {
content: attr(data-content);
color: yellow;
}
::first-letter
Cupcake ipsum dolor. Sit amet candy
canes bear claw. Sweet roll tiramisu
cheesecake cake tart cake brownie.
Marshmallow drops wafer cookie gummies.
::first-letter { font-size: 2m; }
Cupcake ipsum dolor. Sit amet candy canes bear claw. Sweet roll tiramisu cheesecake cake tart cake brownie. Marshmallow lemon drops wafer cookie gummies.
::first-line
Cupcake ipsum dolor. Sit amet candy
canes bear claw. Sweet roll tiramisu
cheesecake cake tart cake brownie.
Marshmallow drops wafer cookie gummies.
::first-line { font-variant: small-caps; }
Cupcake ipsum dolor. Sit amet candy canes bear claw. Sweet roll tiramisu cheesecake cake tart cake brownie. Marshmallow lemon drops wafer cookie gummies.
Child and Type Selectors
:first-child {
background-color: red;}I'm an only child!:last-child {background-color: orange; }background-color: grey;First of type!
Last of child/type (⌐■_■)
:only-child {I'm the last child.}I'm an only child!First of type!
Last (⌐■_■)
I'm the last child.:not(selector)
:not(:empty) { background-color: green; } :not(:first-child):not(:empty) { background-color: yellow; }
1235:nth-of-type(x), :nth-child(x)
:nth-child(even) { background-color: yellow; } :nth-of-type(2n + 1) { background-color: teal; }
12345Accessible Forms
Communicate clearly
Don't Ask for unneccessary or confusing data
Be device-friendly
Communicate Clearly: Error Handling
Don't show validation errors while typing
Don't show validation errors after form submission
Do show validation errors on blur
Be clear with what's required (or what isn't)
Be upfront about format requirements
Communicate Clearly: Options
Don't put a two-option input in a dropdown
If there are only a few options, use a radio group
Bacon SausageCollapse groups of options into option-groups to save label space
Communicating Clearly: Labels vs. Placeholders
Don't use placeholders as labels
Use placeholders to show sample input
(required)(optional)Be Device Friendly
- Mobile Friendly
- Screen-reader Friendly
Flipping tables
Don't ever, ever, ever, ever use a table for layout.
CSS Pre- + Post-processing
Useful together!
- Autoprefixer
- Cleanup
- Linting
- Polyfills
SVG: So Very Good
Slide decks, etc
Natalya Shellburn: Practical color theory for people who code Natalya's Complementary Scheme Builder Justin McDowell: Bauhaus in the Browser Mike Kivikoski: CSS Pseudo – :hover, ::after and beyond Clarissa Peterson: Creating Beautiful, Accessible, and User-Friendly Forms James Steinbach: Using Sass & PostCSS Together Tyler Sticka: SVG: So Very Good Lourdes Montano: Learning and feeling overwhelmed: methods to organize your learning process in CSSBrowser Day
The web is evolving (slowly)
Web Workers and Service Workers
// index.js var worker = new Worker('worker.js'); worker.postMessage('ping'); worker.onmessage = function(e) { console.log(e.data); // 'pong' };
// worker.js self.onmessage = function(e) { console.log(e.data); // 'ping' self.postMessage('pong'); };
// index.js if ('serviceWorker' in navigator) { navigator.serviceWorker.register( '/service-worker.js'); }
// service-worker.js self.addEventListener('fetch', function(e) { e.respondWith(fetch(e.request)); } };
What's the difference? Web Workers Service Workers Tab control Many per tab One for all tabs Lifespan Same as tab Independent Good for Parallelism Caching Web Components
// hexagon-svg.html
HTTP/2 Server Push
https://http2.github.io/faq/Accessibility
- Keyboard Support
- ARIA attributes
- Color contrast
There are tools to help test accessibility
Slide decks, etc
Rebecca Murphey: Making it Better Without Making it Over Nolan Lawson: Demystifying Web Workers and Service Workers Seth Samuel: Arbitrary Computation on the GPU Using WebGL Liz Abinante: In Defense of Static Sites Thomas Wilburn: Custom Elements in Production Marcy Sutton: Where in the Stack is Carmen Sanfrancisco?Node Day
JavaScript is for more than just websites.
Overcoming Latency: Compounding
- Keep everything in slow storage
- Cache frequently-accessed things in fast storage
- Cache as much as you can in the browser: IndexedDB
Dependency Management: Greenkeeper
Slide decks, etc


-
Up-to-the-minute Calendar for Thursday Classes in West Oakland, CA
-
Ellen Webb Studio
2822A Union St, Oakland, CA
-
Spring Session April 13- May 25
6:15-7:45pm Stretch, Drill, Basics, Layering, and RockaProv
-
$15 drop in, Class cards available
Call, email or Text to let us know you are coming<PHONE_NUMBER>
-
Come to class in clothes you feel good and comfortable in.
-
FREE CLASS FOR BAY AREA DANCE WEEK
Thursday April 27
6:00-7:30pm
Ellen Webb Studio, 2822A Union St., Oakland, CA
-
Sign up for our sorta-monthly mailing list
-
Find us on facebook:
-
We believe in building Dancers
-
Our classes include a full warmup including stretching, strengthening, and drilling.
-
RockaBelly wants to help dancers build their skills and grow.
-
Class topics include understanding music, ethnic/folkloric dance styles, playing finger cymbals, and using props such as veils and swords. Check back here for special workshops!


IPP stages annual bazaar
International Proxy Parents (IPP) staged its annual bazaar at Jamaica Pegasus hotel in New Kingston last Saturday.
The event is used to raise funds for scholarships to selected students, with a proven track record of excellence but who are in dire financial need, primarily at non-traditional high schools islandwide.
The bazaar is a collaboration between IPP, the diplomatic community, corporate Jamaica, and local providers of goods and services to create a vibrant cultural atmosphere with art, craft, food, dance and other cultural activities.
Among the countries that participated in this year's event are Russia, United Kingdom, Mexico, Spain, South Africa, Nigeria, Japan, Barbados, and Trinidad and Tobago.


|
Fig. 1
|
A schematic visualization of the algorithm. Using a set of r ... |
|
Fig. 2
|
Parameters related to the local environment of S-atoms. d 1 ... |
|
Fig. 3
|
Validation of structure prediction for Au-clusters. Comparis ... |
|
Fig. 4
|
Determination of the true structure of Au-clusters using CSE ... |
|
Fig. 5
|
Validation of structure prediction for Ag-clusters. Comparis ... |
|
Fig. 6
|
Determination of the true structure of Ag-clusters using CSE ... |
|
Fig. 7
|
CSE correlates with DFT total energy. CSE as a function of t ... |
|
Fig. 8
|
Size of the ligands affects the structure. Predicted model s ... |


Surely our security model will evolve as Cosmos evolves. However we need something simple, efficient, and with minimal impact to the users. I feel this is something most operating systems today fail greatly at.
Cosmos will be divided into rings. In some senses they are similar to traditional operating system rings however they are not enforced by hardware and thus do not have the runtime overhead. Instead they are enforced by the compiler and later by the installation system which will verify assemblies are part of installation.
A new assembly level attribute will be created for processing by IL2CPU. If the attribute is not present User Ring is the default.
Rings from highest to lowest:
Rings can only access assemblies in the same ring, or the next lower ring.
Core <-- Hardware <-- System <-- User
For example, System can consume classes in Hardware but not Kernel.
In the core ring, "anything goes". This also means that code which does not require such privileges should not exist in the core ring. The core ring should be restricted to code which truly needs such unfettered access.
Priviliges that exist only in the core ring:
The core ring includes functionality such as:
Assemblies which are part of the core are restricted.
The core ring exposes objects which allow the hardware ring to access memory indirectly, and in a controlled restricted fashion. For example to allow a driver to acccess video RAM, a memory object can be created by the core ring which allows access to only the specific block of memory needed by the video driver.
The hardware ring contains drivers and code for accessing hardware via more generic objects exposed by the kernel ring.
The hardware ring includes functionality such as:
The hardware ring may be further split into two levels at a later date. For example, a driver may exist for the USB Controller and it would require access to the core ring. But drivers implementing USB devices do not need to talk to hardware directly, but instead talk to the USB Controller driver.
The system ring contains code which builds functionality on top of hardware or other system assemblies.
The system ring includes functionality such as:
The user ring is compromised of all user code including applications and services.


Benchmarks¶
We compare
a Fortran implementation due to Sébastien Motsch using the Verlet list method with double precision float numbers, run on the NextGen compute cluster at Imperial College London.
the CPU version of SiSyPHE with double precision tensors (float64) and the blocksparse-reduction method (BSR), run on an Intel MacBook Pro (2GHz Intel Core i5 processor with 8 Go of memory) ;
the GPU version of SiSyPHE with single precision tensors (float32) with and without the blocksparse-reduction method (BSR), run on a GPU cluster at Imperial College London using an nVidia GTX 2080 Ti GPU ;
the GPU version of SiSyPHE with double precision tensors (float64) with and without the blocksparse-reduction method (BSR), run on a GPU cluster at Imperial College London using an nVidia GTX 2080 Ti GPU.
We run a Vicsek
model in a square periodic box with fixed parameters \(L=100\), \(\nu=5\), \(\sigma=1\), \(c=R\), \(dt=0.01\) and various choices of \(N\) and \(R\). The simulation is run for 10 units of time (i.e. 1000 iterations).
For each value of \(N\), three value of \(R\) are tested which correspond to a dilute regime, a moderate regime and a dense mean-field regime. When the particles are uniformly scattered in the box, the average number of neighbours in the three regimes is respectively \(\sim3\), \(\sim30\) and \(\sim300\). The regime has a strong effect on the efficiency of the Verlet list and blocksparse reduction methods.
In the table below, the total computation times are given in seconds except when they exceed 12 hours. The best times are indicated in bold and the worst times in italic.
Fortran
|
sisyphe64
CPU BSR
|
sisyphe32
GPU
|
sisyphe32
GPU BSR
|
sisyphe64
GPU
|
sisyphe64
GPU BSR
|
||
|---|---|---|---|---|---|---|---|
N = 10k |
R = 1 |
19s |
26s |
2.1s |
3.3s |
13s |
3.6s |
R = 3 |
59s |
29s |
3.4s |
3.9s |
|||
R = 10 |
494s |
69s |
3.4s |
7.9s |
|||
N = 100k |
R = 0.3 |
309s |
323s |
29s |
4.3s |
973s |
9.3s |
R = 1 |
1522s |
384s |
4.5s |
11s |
|||
R = 3 |
3286s |
796s |
4.9s |
28s |
|||
N = 1M |
R = 0.1 |
>12h |
6711s |
2738s |
22s |
>12h |
120s |
R = 0.3 |
>12h |
6992s |
23s |
135s |
|||
R = 1 |
>12h |
9245s |
26s |
194s |
The GPU implementation is at least 5 times faster in the dilute regime and outperform the other methods by three orders of magnitude in the mean-field regime with large values of \(N\). Without the block-sparse reduction method, the GPU implementation does suffer from the quadratic complexity. The block-sparse reduction method is less sensitive to the density of particles than the traditional Verlet list method. It comes at the price of a higher memory cost (see Tutorial 04: Block-sparse reduction) but allows to run large scale simulations even on a CPU. On a CPU, the performances are not critically affected by the precision of the floating-point format so only simulations with double precision tensors are shown.


9 yr ago assembling the shelves, I ended up with stitches. Taking them down only scraped my knuckle till it bled. #alwaysimproving #nothandy
9/16/2017, 5:43:25 PM
Favs: 3
Retweets: 0
link--- layout: tweet ---
9 yr ago assembling the shelves, I ended up with stitches. Taking them down only scraped my knuckle till it bled. #alwaysimproving #nothandy
9/16/2017, 5:43:25 PM
Favs: 3
Retweets: 0
linkWill admit was reluctant to post before fully finished but they're down now!
9/16/2017, 6:13:06 PM
Favs: 2
Retweets: 0
link


Across: 1. Thai train Al in e-news (8,7) 9. Briefly, plate let core move (7) 10. Cottonhead and canola deployed in ship battles (7) 11. In day, gull moves without zest (9) 13. To a degree, you add Southern background (5) 14. Come in on a velocipede, with zest (5) 15. Original C tune a hit (9) 18. A psychologist to support by backward play environment? (6,3) 20. Such storms bring no (zero) rain (5) 21. Ranger amongst later individiuals (5) 23. Regardless of a treaty, an arrangement ... (2,3,4) 24. ... with number one some find offensive (7) 25. It keeps you going in irate rage (7) 27. Finaly, I ... (5,10) Down: 1. ... trip, eg (1-Across) (8,7) 2. 88N 99E (3) 3. Toll: fun is (7-Down) (3,4) 4. If Pop ... (1,4,4) 5. ... is one among the scribes saying stuff? (5) 6. Story of realistic golf-course possibly (7) 7. My pet is (3-Down) (5) 8. Clan, no party (15) 12. Actor working nine to (about) five (5) 16. Is tin a PMP-beater? (9) 17. Bad air at half-a-crown (5) 19. Cowboy seals so? (7) 20. Bark-sheet flavourer (3,4) 22. Farewell to God! (5) 23. Romans saw men's end in this area? (5) 26. Long-running TV show character (3)


What metrics did you use to measure the successful launch of your product?
Wednesday, July 15, 2020
I'm using today's question to provide a little "insider baseball" and to practice thinking through my presentation of this project as a learning experience on my road to becoming a product manager. Since I don't have any official product management experience, and therefore very little experience with some of the common tools and data platforms PMs use, I built pminterviewquestion.com to act as a laboratory for learning a little bit more about everything. In addition to inviting you to send me any question responses you come up with, I'd love to hear your "customer path" for how you ended up on pminterviewquestion.com.
My response
When I launched PM Interview Question, I measured metrics from the web application itself and the social platforms where I initially promoted the product. As a product, while I consider the web app to be the bread and butter of what I've built, the real "sale" is acquiring newsletter subscribers. Since this is all just for personal educational purposes there is no financial incentive one way or the other. But, the most valuable users to me are those who want to engage with the newsletter and who will also send me some feedback on these daily answers.
For the website, I added Google Analytics and collected information on user session times and source of origin. I've also promoted the project on LinkedIn, Twitter, and Hacker News. Each social platform provides some of its own metrics which are very interesting when considering the reach those platforms provide. However, the ultimate goal is to see those social metrics convert into user acquisitions within the Google Analytics metrics and then as newsletter subscribers.
During the past month, 46% of visitors entered the site through my single LinkedIn post, 32% entered through my Hacker News post, and 20% entered through one of the daily Tweets I've posted so far. The LinkedIn post has received about 1000 "impressions" and the Tweets have collectively received about 3000 "impressions." This provides a pretty interesting contrast in terms of impressions-to-visits between those two platforms. In terms of return on investment, the LinkedIn post clearly provided the most attention followed by Hacker News. However, LinkedIn provided the least amount of conversions to newsletter subscribers. I attribute this to the fact that most of my connections and colleagues were interested in the project but are not necessarily in my target audience demographic (aspiring or current product managers). Hacker News and Twitter, on the other hand, provide a platform that generally contains a self-selected population of that segment.
Finally, daily usage of the app has dropped by about 75% since the first week of its release, however there has been gradual growth of newsletter subscribers. This indicates to me that, while many of the original audience has not returned or committed to the product, those who have returned are engaging with the newsletter at the same rate as during the big launch week.
Some takeaways from what I've learned so far is that I will continue to experiment with the app itself. At the moment, the link to subscribe to the newsletter is below the fold. My initial thought process was to keep the initial experience as clean and distraction-free as possible. But, I may experiment with moving that link above the fold. I have also started to post some of the newsletters onto a blog at https://blog.pminterviewquestion.com. I'm not posting every day's newsletters but I do think there is some value in building up some material to potentially drive some search traffic.
Respond on Twitter