About Me
Education & Experience
- B.A. Liberal Arts, business minor: Utah State University, 2013
- Permaculture Design Course, Punta Mona, Costa Rica: 2018
- 200 hr Yoga Teacher Training, SYI, Peru: 2015
- 8 years managing outdoor cannabis farm, Northern California
- Solar Photovoltaics 100, 2017, Solar Living Institute, Hopland, California
- Aspiring software developer, Epicodus, 2020
Hobbies & Interests
- Botany, mycology, gardening, foraging
- Travel
- Adventuring with my wolf dogs
- Guitar, piano, drums, singing, music production, dancing, concerts
- Yoga, meditation, massage
- Wild nature, simple beauty, diverse landscapes
- The Grateful Dead
- Health, wellness, exploring human potential
Places I Have Lived & Visited (Chronological Order)
- Chicago, Illinois: 13 years
- Lindon & Logan, Utah: 7 years
- Paris & Annecy, France: 2 weeks
- Arcata, California: 10 years
- Nelson, B.C., Canada: 1 month
- Valparaiso, Chile: 2 months
- Anchorage, Homer, Fairbanks, Alaska: 1 week
- Sacred Valley, Peru: 6 weeks
- Kauai, Big Island, Hawaii: 3 weeks
- Lake Atitlan, Tikal, Guatemala: 2 weeks
- Punta Mona, Puerto Viejo, Uvita, Costa Rica: 1 month
- Yucatan, Mexico: 2 weeks
- Portland, Oregon: 2 months


Our STEM program offers a total of three pathways for students to choose from. These are: Biotechnology, Aerospace Engineering, and Computer Science. Upon their first year in the STEM program, students will take the course Introduction to Engineering Design, or IED. After, that they can choose to participate in one or more of the three pathways for their next three years of high school.
CURRICULUM


Module stick/helpers
A collection of helper functions that makes working with Stick middleware easier.
Functions
- htmlResponse (string...)
- jsonResponse (object)
- linkTo (app, bindings, text)
- redirectTo (app, bindings)
- resolveApp (app)
- urlFor (app, bindings)
- xmlResponse (xml)
htmlResponse (string...)
Create a JSGI response with content-type 'text/html' with the string or binary arguments as response body.
Parameters
| string | string... | a variable number of strings to send as response body |
jsonResponse (object)
Create a JSGI response with content-type 'application/json' with the JSON representation of the given object as response body.
Parameters
| object | object | the object whose JSON representation to return |
linkTo (app, bindings, text)
Return a link to an action configured using the route
middleware.
The link's URL is generated from the bindings argument as described for the urlFor helper.
Parameters
| object|string | app | the application to link to |
| object | bindings | an object containing the bindings for the target URL. |
| string | text | the link text. |
redirectTo (app, bindings)
Create a response that redirects the client to a different URL.
Parameters
| string|object | app | either the URL as string or an app to be passed to `urlFor` |
| bindings | bindings | to pass to `urlFor` if first argument is an app. |
Returns Type
| object | a JSGI response that will redirect the client to the specified target |
urlFor (app, bindings)
Return a URL for an action configured using the mount
and route
middlewares.
The app
argument specifies the Stick application to link to, either as reference
to the app itself or as module id of a module exporting the app as app
.
The bindings
argument contains information needed to determine the target
action within that application. Properties in the bindings argument are interpreted
as follows:
The
action
property, if present, identifies the name of the action to link to. Action names are determined from the path arguments provided to theroute
middleware by removing all placeholders and the leading slash. For example, the name for an action routed with/edit/:id
is "edit".Properties in the bindings object that have a placeholder with the same name in the target route are used to provide the value for this placeholder. For example, to URI path to an action in application
app
routed with "/edit/:id" with id5
can be generated as follows:urlFor(app, {action: "edit", id: 5})
All other properties in the bindings object are set as query parameters in the generated URL. For example, if "index" is a route with no placeholders then calling
urlFor("index", {do: "search"})
will generate the URL "/?do=search".
Note that the values for the current request are used as default values for action
and route placehoders, so if you want to use to a different action or placeholder value
you need to make that explicit.
Parameters
| object|string | app | the application to link to |
| object | bindings | an object containing the bindings for the target URL. |
xmlResponse (xml)
Create a JSGI response with content-type 'application/xml' with the given XML document as response body.
Parameters
| xml|string | xml | an XML document |


Cartographer is responsible for generating _sitemap.md
, which is used by the osu! website for its table of contents for the wiki.
Q: Can I use it?
Unfortunately, it's configured exclusively for osu!wiki and only osu!wiki. However, the wehook itself is Open Source.


source “rubygems.org”
# Declare your gem's dependencies in bing-ads-api.gemspec. # Bundler will treat runtime dependencies like base dependencies, and # development dependencies will be added by default to the :development group. gemspec
# jquery-rails is used by the dummy application gem “jquery-rails”
# Declare any dependencies that are still in development here instead of in # your gemspec. These might include edge Rails or gems from your path or # Git. Remember to move these dependencies to your gemspec before releasing # your gem to rubygems.org.
# To use debugger # gem 'ruby-debug19', :require => 'ruby-debug'


Data from the {% if object.is_private %} IPEDS Data Center and the THECB PREP enrollment report {% else %} IPEDS Data Center and the THECB PREP enrollment report and Accountability System {% endif %}


Responsive Template Canvas UI
A Responsive Template User Interface to be used with the HTML Canvas. The Input Elements inside the Menu can be customized to fit your preference.
Joran de Boer (RanDByyp)
Input-Radio


Crossword Creation Set-up:
Dictionary options:
ospd.txt
web2.txt
Starting file:
Load File
Crossword Creation:
Loading word lists. Please be patient.


SCR chief inspects passenger amenities
by Special CorrespondentGeneral Manager of South Central Railway, Gajanan Mallya on Tuesday undertook inspection of Parli-Vikarabad section on Secunderabad division and also inaugurated several works and passenger amenities like 30 KWP on grid solar power plant, auto chlorinator and 100% energy efficient station, new health unit, etc.
Starting his inspection at Parli Vaijnath station, he went round the circulating area, inspected passenger amenities, crew lobby etc. A rear window inspection was taken up between Parli Vaijnath and Ghat Nandur section for safety and maintenance aspects of track, curves and level crossings. The Pangaon-Udgir section and Udgir railway station were also checked as also the major bridge across Manjeera river between Kalgupur-Bhalki stations. He also went around Bidar station and inaugurated new railway quarters and also took up a speed test on 110 kmph between Bidar-Matalkunta stations.


First Class Tickets
At Go Fly First, we provide exclusive services for First Class travelers that match their highly dynamic and spontaneous travel requirements. From top class inflight entertainment to an entire luxurious trip for your family, we can give you a complete itinerary within a few clicks. So whether it’s a weekend getaway with your friends, or a long vacation with family, we guarantee to give you the best discounted fares on first class travel.
Go Fly First is your personal concierge that helps you select the perfect travel route for you that best fits your budgets and needs. Our unique online booking system has received much appreciation from all our first class and business class clients. We assure you a pleasurable travel experience with Go Fly First, because we believe in providing you the best and the lowest airfares that fit seamlessly with your travel requirements.
Discounted First Class Airline Tickets
We specialize in offering discounted airline tickets for first class travelers through our amazing travel deals that meet dynamic travel requirements in a defined budget. With our efficient online booking system, we are able to offer travelers airline tickets on competitive rates, which often turn out to be the lowest fares available when compared to our competitors’. The unique system has enabled Go Fly First to offer first class tickets at amazing discounts and desired services to first class and budget travelers.
With a huge array of commercial flights, and a variety of options, it can become quite exhausting to search and select the route that best fits your requirements.  From your desired date and time of travel, lodging, leisure trips and everything in between, we take care of everything and provide you with the lowest fares and discount airfares.
We also offer amazing last minute airfare deals for clients who have to travel urgently or on a short notice. Whether you plan to travel in a day or the same day, you can count on Go Fly First’s unique online booking system to help you select the best airfares on discounted rates. Just enter all the required information on the online portal on our website and get best matched results; fast, accurate and up to date.
Looking for great discounts on first class tickets? Let our team at Go Fly First make your travel experience a pleasurable and smooth one! Use our online booking system to get a FREE QUOTE or call today at<PHONE_NUMBER> (USA) or 852-8192-5250 (Hong Kong) for more information.


Depei Zhang
P1: LC203. Remove Linked List Elements
Time complexity: O(n)
Leetcode runtime & memory (cpp): 24 ms (95.60%) & 10.9 MB
Solution:
Time complexity: O(m + n)
Leetcode runtime & memory (cpp): 20 ms (88.71%) & 10.7 MB
Solution:
P3: LC142. Linked List Cycle II
Time complexity: O(n)
Leetcode runtime & memory (cpp): 4 ms (99.93%) & 9.9 MB
Solution:
P4: LC83. Remove Duplicates from Sorted List
Time complexity: O(n)
Leetcode runtime & memory (cpp): 8 ms (97.77%) & 9.1 MB
Solution:
P5: LC23. Merge k Sorted Lists
Time complexity: O(n * log(k))
Leetcode runtime & memory (cpp): 12 ms (99.99%) & 11.2 MB
Solution:
P6: LC146. LRU Cache
Time complexity: O(1)
Leetcode runtime & memory (cpp): 76 ms (99.91%) & 38 MB
Solution:


Noe Monsivais
Homepage
Portfolio
Contact Me
Noe "Tro" Monsivais
Click below to see my resume.
Resume
Hello. I am Noe. It's a pleasure to have you visit.
I am a former teacher turned software developer with a background in both, backend and frontend programming. If you have an idea, I can help it come to life.
Linked In
GitHub
Email Me
Call Now


- get() - Method in class com.kauailabs.navx.ftc.navXPIDController
-
Returns the current output value calculated by the navXPIDController based upon the
last navX-Model device data sample received.
- getActualUpdateRate() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the navX-Model device's currently configured update
rate.
- getAltitude() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current altitude, based upon calibrated readings
from a barometric pressure sensor, and the currently-configured
sea-level barometric pressure [navX Aero only].
- getBoardYawAxis() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns information regarding which sensor board axis (X,Y or Z) and
direction (up/down) is currently configured to report Yaw (Z) angle
values.
- getByteCount() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the count in bytes of data received from the
sensor.
- getCompassHeading() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current tilt-compensated compass heading
value (in degrees, from 0 to 360) reported by the sensor.
- getCurrentTransferRate() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current number of data samples being transferred
from the navX-Model device in the last second.
- getDeliveredRateHz() - Method in class com.kauailabs.navx.ftc.navXPerformanceMonitor
-
The delivered rate is the rate at which samples are delivered
to the Android-based FTC robotics control application.
- getDeviceDataType() - Method in class com.kauailabs.navx.ftc.AHRS
-
- getDimI2cPort() - Method in class com.kauailabs.navx.ftc.AHRS
-
- getDimStateTrackerInstance() - Method in class com.kauailabs.navx.ftc.AHRS
-
- getDimTransferRateHz() - Method in class com.kauailabs.navx.ftc.navXPerformanceMonitor
-
The rate at which the Core Device Interface Module (DIM) is currently
delivering data samples to the navx_ftc library IO thread.
- getDuplicateDataCount() - Method in class com.kauailabs.navx.ftc.AHRS
-
- getError() - Method in class com.kauailabs.navx.ftc.navXPIDController
-
Returns the current amount of error calculated by the navXPIDController
based upon the last navX-Model device data sample.
- getFirmwareVersion() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the version number of the firmware currently executing
on the sensor.
- getFusedHeading() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the "fused" (9-axis) heading.
- getInstance(DeviceInterfaceModule, int, AHRS.DeviceDataType) - Static method in class com.kauailabs.navx.ftc.AHRS
-
Returns the single instance (singleton) of the AHRS class.
- getInstance(DeviceInterfaceModule, int, AHRS.DeviceDataType, byte) - Static method in class com.kauailabs.navx.ftc.AHRS
-
Returns the single instance (singleton) of the AHRS class.
- getLastSensorTimestampDeltaMS() - Method in class com.kauailabs.navx.ftc.navXPerformanceMonitor
-
The last sensor timestamp delta indicates the period of time between
reception of the last two samples from the navX-Model device, for those
data samples which are timestamped with a sensor timestamp.
- getLastSystemTimestampDeltaMS() - Method in class com.kauailabs.navx.ftc.navXPerformanceMonitor
-
The last system timestamp delta indicates the period of time between
reception of the last two samples from the navX-Model device, for those
data samples which do not provide a corresponding sensor timestamp and
are instead timestamped using the Android OS system timestamp.
- getLogging() - Static method in class com.kauailabs.navx.ftc.AHRS
-
- getNumEstimatedMissedUntimestampedSamples() - Method in class com.kauailabs.navx.ftc.navXPerformanceMonitor
-
The number of samples which were expected to be received from the
navX-Model device which are believed to have not arrived based upon
the Android OS system timestamp.
- getNumMissedSensorTimestampedSamples() - Method in class com.kauailabs.navx.ftc.navXPerformanceMonitor
-
The number of samples which were expected to be received from the
navX-Model device which never arrived, since the last time the
navXPerformanceMonitor's statistics were reset.
- getOutput() - Method in class com.kauailabs.navx.ftc.navXPIDController.PIDResult
-
Returns the output value calculated by the navXPIDController which
corresponds to the most recent input data sample.
- getPitch() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current pitch value (in degrees, from -180 to 180)
reported by the sensor.
- getPressure() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current barometric pressure (in millibar) [navX Aero only].
- getQuaternionW() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the imaginary portion (W) of the Orientation Quaternion which
fully describes the current sensor orientation with respect to the
reference angle defined as the angle at which the yaw was last "zeroed".
- getQuaternionX() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the real portion (X axis) of the Orientation Quaternion which
fully describes the current sensor orientation with respect to the
reference angle defined as the angle at which the yaw was last "zeroed".
- getQuaternionY() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the real portion (X axis) of the Orientation Quaternion which
fully describes the current sensor orientation with respect to the
reference angle defined as the angle at which the yaw was last "zeroed".
- getQuaternionZ() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the real portion (X axis) of the Orientation Quaternion which
fully describes the current sensor orientation with respect to the
reference angle defined as the angle at which the yaw was last "zeroed".
- getRawAccelX() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) X-axis acceleration rate (in G).
- getRawAccelY() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) Y-axis acceleration rate (in G).
- getRawAccelZ() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) Z-axis acceleration rate (in G).
- getRawGyroX() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) X-axis gyro rotation rate (in degrees/sec).
- getRawGyroY() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) Y-axis gyro rotation rate (in degrees/sec).
- getRawGyroZ() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) Z-axis gyro rotation rate (in degrees/sec).
- getRawMagX() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) X-axis magnetometer reading (in uTesla).
- getRawMagY() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) Y-axis magnetometer reading (in uTesla).
- getRawMagZ() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current raw (unprocessed) Z-axis magnetometer reading (in uTesla).
- getReadBuffer() - Method in class com.kauailabs.navx.ftc.AHRS.DimI2cDeviceReader
-
- getRoll() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current roll value (in degrees, from -180 to 180)
reported by the sensor.
- getSensorRateHz() - Method in class com.kauailabs.navx.ftc.navXPerformanceMonitor
-
The sensor tate is the rate at which the navX-Model device sensor
is currently configured to deliver sample.
- getSetpoint() - Method in class com.kauailabs.navx.ftc.navXPIDController
-
Returns the currently configured setpoint.
- getState() - Method in class com.kauailabs.navx.ftc.AHRS.DimStateTracker
-
- getTempC() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current temperature (in degrees centigrade) reported by
the sensor's gyro/accelerometer circuit.
- getTimestamp() - Method in class com.kauailabs.navx.ftc.navXPIDController.PIDResult
-
Returns the timestamp of the last data sample processed by the
navXPIDController.
- getUpdateCount() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the count of valid updates which have
been received from the sensor.
- getValue() - Method in enum com.kauailabs.navx.ftc.AHRS.BoardAxis
-
- getValue() - Method in enum com.kauailabs.navx.ftc.AHRS.DeviceDataType
-
- getWorldLinearAccelX() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current linear acceleration in the X-axis (in G).
- getWorldLinearAccelY() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current linear acceleration in the Y-axis (in G).
- getWorldLinearAccelZ() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current linear acceleration in the Z-axis (in G).
- getYaw() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns the current yaw value (in degrees, from -180 to 180)
reported by the sensor.
- IDataArrivalSubscriber - Interface in com.kauailabs.navx.ftc
-
The IDataArrivalSubscriber interface provides a method for consumers
of navX-Model device data to be rapidly notified whenever new data
has arrived.
- isAltitudeValid() - Method in class com.kauailabs.navx.ftc.AHRS
-
Indicates whether the current altitude (and barometric pressure) data is
valid.
- isBusy() - Method in class com.kauailabs.navx.ftc.AHRS.DimI2cDeviceReader
-
- isCalibrating() - Method in class com.kauailabs.navx.ftc.AHRS
-
Returns true if the sensor is currently performing automatic
gyro/accelerometer calibration.
- isConnected() - Method in class com.kauailabs.navx.ftc.AHRS
-
Indicates whether the sensor is currently connected
to the host computer.
- isDone() - Method in class com.kauailabs.navx.ftc.AHRS.DimI2cDeviceWriter
-
- isEnabled() - Method in class com.kauailabs.navx.ftc.navXPIDController
-
Returns true if the navXPIDController is currently enabled, otherwise
return false.
- isMagneticDisturbance() - Method in class com.kauailabs.navx.ftc.AHRS
-
Indicates whether the current magnetic field strength diverges from the
calibrated value for the earth's magnetic field by more than the currently-
configured Magnetic Disturbance Ratio.
- isMagnetometerCalibrated() - Method in class com.kauailabs.navx.ftc.AHRS
-
Indicates whether the magnetometer has been calibrated.
- isModeCurrent(boolean, int, int, int) - Method in class com.kauailabs.navx.ftc.AHRS.DimStateTracker
-
- isMoving() - Method in class com.kauailabs.navx.ftc.AHRS
-
Indicates if the sensor is currently detecting motion,
based upon the X and Y-axis world linear acceleration values.
- isNewUpdateAvailable(navXPIDController.PIDResult) - Method in class com.kauailabs.navx.ftc.navXPIDController
-
isNewUpdateAvailable() should be called by clients of the navXPIDController
which need to "poll" to determine whether new navX-Model device data has
been received.
- isOnTarget() - Method in class com.kauailabs.navx.ftc.navXPIDController
-
Indicates whether the navXPIDController has determined that it is "on_target" based upon
whether the current error is within the range defined by the tolerance.
- isOnTarget() - Method in class com.kauailabs.navx.ftc.navXPIDController.PIDResult
-
Returns true if the navXPIDController indicated that it is currently
"on target" as defined by the configured tolerances and the most
recent input data sample.
- isRotating() - Method in class com.kauailabs.navx.ftc.AHRS
-
Indicates if the sensor is currently detecting yaw rotation,
based upon whether the change in yaw over the last second
exceeds the "Rotation Threshold."
- valueOf(String) - Static method in enum com.kauailabs.navx.ftc.AHRS.BoardAxis
-
Returns the enum constant of this type with the specified name.
- valueOf(String) - Static method in enum com.kauailabs.navx.ftc.AHRS.DeviceDataType
-
Returns the enum constant of this type with the specified name.
- valueOf(String) - Static method in enum com.kauailabs.navx.ftc.navXPIDController.navXTimestampedDataSource
-
Returns the enum constant of this type with the specified name.
- valueOf(String) - Static method in enum com.kauailabs.navx.ftc.navXPIDController.navXUntimestampedDataSource
-
Returns the enum constant of this type with the specified name.
- valueOf(String) - Static method in enum com.kauailabs.navx.ftc.navXPIDController.TimestampType
-
Returns the enum constant of this type with the specified name.
- valueOf(String) - Static method in enum com.kauailabs.navx.ftc.navXPIDController.ToleranceType
-
Returns the enum constant of this type with the specified name.
- values() - Static method in enum com.kauailabs.navx.ftc.AHRS.BoardAxis
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- values() - Static method in enum com.kauailabs.navx.ftc.AHRS.DeviceDataType
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- values() - Static method in enum com.kauailabs.navx.ftc.navXPIDController.navXTimestampedDataSource
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- values() - Static method in enum com.kauailabs.navx.ftc.navXPIDController.navXUntimestampedDataSource
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- values() - Static method in enum com.kauailabs.navx.ftc.navXPIDController.TimestampType
-
Returns an array containing the constants of this enum type, in
the order they are declared.
- values() - Static method in enum com.kauailabs.navx.ftc.navXPIDController.ToleranceType
-
Returns an array containing the constants of this enum type, in
the order they are declared.


Status
{{transaction.success | success}}
Gas Used
{{transaction.gasUsed }}
Gas Price
{{transaction.gasPrice }}
Amount
{{transaction.amount | amount}}
Contract Balance
{{transaction.contractBalance | amount}}
From Address
{{transaction.fromAddress}}
Contract Address
{{transaction.contractAddress}}
Error
{{transaction.error}}


My Profile
Notifications
13
Settings
Logout
9
You have 1 Message
You have 2 Message
You have 2 Message
5
You have 1 Notification
You have 2 Notification
You have 2 Notification
Upload New Product
Product name
Cost
Profit
Total order
Total revinue
Alexa Rank
Oppotunity level
select product Type
Health & Beauty
Baby & Kids
Fitness
Car & Accessories
Home & Garden
Pet Accessories
Others
Image link


Home
Committee
Faculty Core Committee
Students Core Committee
Technical Core Committee
Other Core Committee
Events
Events - CSE/IT
Club Events
Technical Events
Events - Civil
Club Events
Technical Events
Events - EE
Club Events
Technical Events
Events - EEE
Club Events
Technical Events
Events - ETC
Club Events
Technical Events
Events - Mechanical
Club Events
Technical Events
Agenda
IETE Events
Hackathon
Sponsors
Agenda
Register Now
Contact Us
Meet the developers


{% extends "cctbx/header.html" %} {% load static %} {% block content %}
Learn how to work with a part of a map. In particular, this involves keeping track of coordinate shifts and symmetry.
It is often convenient to work with just a part of a map. For example, if your structure contains identical 24 copies of a molecule, you might want to work with just one copy and then duplicate it to create the other 23 later. In this section we are going to create a new map that represents part of the map_data map we have been working with. For this example, we are going to just look at the raw boxed map that results so that we can see how it works. In a real situation you would not only cut out the box but shift its origin using the map_model_manager
(see further below).
Cutting out part of a map is referred to here as boxing
. The key step in cutting out a part of a map is specifying the part of the map to cut out. The grid point with the smallest indices in each direction in the cut-out map is called the “lower bounds” and the grid point with the highest indices is the “upper bounds”. If the lower_bounds is (la,lb,lc) and the upper_bounds is (ua,ub,uc) then the resulting box will have (1+ua-la, 1+ub-lb, 1+uc-lc) grid points along a, b and c. This is the value of all
for the boxed map. The box will start at lower_bounds, which will be the value of origin
for the boxed map.
First, lets set up a map:
from iotbx.map_model_manager import map_model_manager # load map_model_manager
mmm=map_model_manager() # get initialized instance of the map_model_manager
mmm.generate_map() # get a model and calculate a map for it
map_data = mmm.map_data() # our 3D map object
Let’s set some lower and upper bounds:
lower_bounds = (10,10,10) # lower bounds for boxed map
upper_bounds = (21,31,21) # upper bounds for boxed map
Now let’s cut out a part of our map. In this example we are going to use maptbx.copy() to do this. Normally you will instead use the map_model_manager but using maptbx.copy() shows exactly what is happening:
from cctbx import maptbx # import maptbx
box_map_data = maptbx.copy(map_data, lower_bounds, upper_bounds) # box the map
Let’s look at the origin and dimensions of this boxed map. We expect the origin to be at our lower_bounds (10,10,10) and the dimensions to be (12, 22, 12), and the last available point is (21,31,21):
print( box_map_data.origin()) # prints (10, 10, 10)
print( box_map_data.all()) # prints (12, 22, 12)
print( box_map_data.last(False)) # prints (21, 31, 21)
This boxed map is defined for any grid points from lower_bounds to upper_bounds, inclusive. We can get the value at grid point (11,12,13) just like we did before and we will get the same answer:
print( box_map_data[11,12,13]) # prints 0.0416163499881
The boxed map is not defined at grid point (0,0,0) or any other points outside of the bounds. The boxed map is also a different size than the original (which had a size of 38400):
print( box_map_data.size() ) # prints 3168
One final point: the boxed map is a copy, not a pointer to part of the original map. So if you change a value in your boxed map, the original map is unchanged.
Notice that indices of grid points in the boxed map we just created are still in the same reference frame as our original map (i.e., the grid point (11, 12, 13) has the same value in the original map as it has in the boxed map. However the origin of the boxed map (10,10,10) is different from the original origin (0,0,0).
In cctbx, almost all work with maps is carried out after shifting the origin of the map to (0,0,0). If there is a model associated with a map, the coordinates of atoms in the model are also shifted. Normally this is done for you with the map_model_manager
. In this section we are going to do an origin shift directly so that we can see how it works.
Let’s shift the origin of our boxed map (box_map_data) to (0,0,0) with the shift_origin() function to see what happens:
shifted_box_map_data = box_map_data.shift_origin() # shift origin to (0,0,0)
Note that the shift_origin()
function does not change the original object but rather returns a new object with shifted origin but the same data. Note also that if you change data in the shifted map you are changing the data in the unshifted map as well.
Let’s look at the origin and dimensions of our boxed map after shifting the origin. The size should not change but the origin should be at (0,0,0) and the last available point should be (11,21,11) instead of (21,31,21):
print(shifted_box_map_data.origin()) # prints (0, 0, 0)
print(shifted_box_map_data.all()) # prints (12, 22, 12)
print(shifted_box_map_data.last(False)) # prints (11, 21, 11)
This shifted version of our boxed map data is defined from (0,0,0) to (11,21,11). There has been an origin shift of (10,10,10). If we want to see the value at the grid point that used to be called (11,12,13), we now have to look at the grid point (1,2,3):
print(shifted_box_map_data[1,2,3]) # prints 0.0416163499881
The dimensions of our boxed map (12,22,12) in grid units and in Angstrom units are different from our original map. That means that the crystal_symmetry of our boxed map has changed. We need a way to keep track of several things:
Here is the convention for keeping track of origins, gridding and dimensions:
The number of grid points and crystal_symmetry corresponding to the full original map (the full map from cryo-EM or the crystallographic unit cell map for crystallography) are referred to as the unit_cell_grid and unit_cell_crystal_symmetry. Here unit_cell
is intended to mean the full unit cell of the map.
The origin shift between original and boxed maps is recorded in grid units as origin_shift_grid_units
, where the origin shift is the shift needed to move the origin back to its original position. That means that if the origin of the boxed map was at (10,10,10) and it was moved to (0,0,0), the origin shift was (10,10,10).
At the same time the origin shift is recorded as a shift in Cartesian coordinates called shift_cart
. The value of shift_cart is the shift that has been applied to any coordinates. It has the opposite sign of origin_shift_grid_units.
The crystal_symmetry of the boxed map is referred to as crystal_symmetry
. This is the crystal_symmetry that is used for any calculations that are done with a boxed map and model.
Now that we have seen how boxing and shifting origins works, we can appreciate how the map_model_manager
(mmm
) has methods to take care of everything for us. Let’s start from the beginning and box our original map and the model that goes with it using the map_model_manager
. Let’s use the same lower and upper bounds we did before and create a new map_model_manager
that is boxed and origin-shifted, but that knows all about how to put everything back where it was:
boxed_mmm = mmm.extract_all_maps_with_bounds( # create box
lower_bounds = lower_bounds, # lower bounds
upper_bounds = upper_bounds) # upper bounds
If we look at the map_data object from this boxed map_model_manager we will find that it looks just like the boxed, origin-shifted one we created a moment ago:
new_shifted_box_map_data = boxed_mmm.map_manager().map_data() #
print(new_shifted_box_map_data.origin()) # prints (0, 0, 0)
print(new_shifted_box_map_data.all()) # prints (12, 22, 12)
print(new_shifted_box_map_data.last(False)) # prints (11, 21, 11)
print(new_shifted_box_map_data[1,2,3]) # prints 0.0416163499881
However the map_model_manager
knows how to write out this boxed map so that it superimposes on the original:
boxed_mmm.write_map('boxed_map.ccp4') # superimposes on orig
Similarly, if you write out your map with the DataManager
it will superimpose on the original.
The map_model_manager
shifts the origin of your map and it also shifts the origin of any model that is part of the map_model_manager. That means that the model in our new map_model_manager
(boxed_mmm) matches the map in that map_model_manager. The way this happens is that the coordinates of atoms in the model were all shifted by the value of shift_cart()
(calculated from the origin_shift_grid_units
) that was set when the origin of the map was shifted. When you write out your model, the reverse shift is automatically applied by the DataManager
.
When your working map has been extracted from a larger map with a map_model_manager, the manager will shift the origin of all maps, models, and associated reconstruction symmetry (ncs_spec
) objects to (0,0,0) before working with them.
Then you do work with the origin at (0,0,0). You automatically get coordinates from your models that are relative to this origin if the model came from the map_model_manager
where the origin was automatically shifted. For example you might say:
working_sites_cart = boxed_mmm.model().get_sites_cart() # sites
Note that when you are working with your boxed model, the values of coordinates that you get from your model with the function get_sites_cart()
will not be the coordinates in the original reference frame of your model. They were shifted to match your boxed, shifted map.
Finally when writing out maps, models, or ncs objects, the shift origin is shifted back. This shift back is automatic so you do not need to do anything.
If you have created amap_model_manager
with one map and model, and you have a new map that you want to match, just shift the origin of the new map with shift_origin()
. If the maps are compatible, they will now match. You can check that with the is_similar()
function.
If for some reason you just create a map_manager
and want to work with it and do not want to combine it with a model, you should shift the origin of your map_manager to (0,0,0) using the shift_origin()
method before working with it.
The map_model_manager
has two sets of methods for creating boxed versions of itself. One set extracts a new copy that is boxed, and the other changes itself by boxing. These two methods have different properties. The extracted version is a completely new object. In contrast, boxing a map_model_manager
in place changes the map_model_manager
itself. Its map is boxed,creating a new (differently-sized) map, but its model is changed in place, with new, shifted coordinates but keeping the same model object.
To extract a boxed version of a map_model_manager
, you use a method such as the extract_all_maps_with_bounds()
method that we used above.
boxed_mmm = mmm.extract_all_maps_with_bounds( # create box
lower_bounds = lower_bounds, # lower bounds
upper_bounds = upper_bounds) # upper bounds
The extracted map and model are deep copies, not pointers to the originals. This means that if you change the extracted map or model, you do not change the original. Let’s do this just to see. Here are the current coordinates of a site in the model and a position in the map in the map_model_manager:
print (mmm.model().get_sites_cart()[0]) # 14.476000000000003, 10.57, 8.342)
print (mmm.map_manager().map_data()[11,12,13]) # prints 0.0416163499881
The coordinates for the extracted map_model_manager are shifted:
print(boxed_mmm.model().get_sites_cart()[0])# (7.005666666666668, 3.339250000000002, 0.967625000000001)
The indices of the map in the extracted map_model_manager
are offset by (10,10,10) so now the index (1,2,3) corresponds to the index (11,12,13) in the original map:
print (boxed_mmm.map_manager().map_data()[1,2,3]) # prints 0.0416163499881
Now we change the value of a coordinate or a value in the map for our extracted map_model_manager
. (Note that the procedure for changing coordinates in a model has three steps: get the sites_cart, change something in sites_cart, set the sites cart in the model with the changed sites_cart):
boxed_sites_cart = boxed_mmm.model().get_sites_cart() # get boxed sites
boxed_sites_cart[0] = (10,10,10) # set value of one coordinate in boxed sites
boxed_mmm.model().set_sites_cart(boxed_sites_cart) # set coordinates in model
boxed_mmm.map_manager().map_data()[1,2,3] = 77. # change map value
Nothing happens to the original because the extracted map_model_manager was a deep copy:
print (mmm.model().get_sites_cart()[0]) # 14.476000000000003, 10.57, 8.342)
print (mmm.map_manager().map_data()[11,12,13]) # prints 0.0416163499881
On the other hand, to box a map_model_manager
in place, you use a method such as the box_all_maps_with_bounds_and_shift_origin
method. Let’s make references to the model and map in our map_model_manager
so that we can track what happens to them when we box the map_model_manager in place:
mmm_model_ref = mmm.model() # reference to model in mmm
mmm_map_manager_ref = mmm.map_manager() # reference to model in mmm
Now let’s instead box the map_model_manager in place. This is going to produce a new map but will alter the model and it will not create a new model:
mmm.box_all_maps_with_bounds_and_shift_origin( # change mmm in place
lower_bounds = lower_bounds, # lower bounds
upper_bounds = upper_bounds) # upper bounds
The map_model_manager
is changed in place( nothing is returned). The new map will be a new copy (its size has changed and changing it does not change the original), but the new model is the same model as the original, with shifted coordinates. If you change the model in this map_model_manager
, any references to the original model also change.
Let’s do this just to see. The current coordinates of the first site in the model are now shifted:
print (mmm.model().get_sites_cart()[0]) # (7.005666666666668, 3.339250000000002, 0.967625000000001)
and the indices of the map in the map_model_manager
are offset by (10,10,10) so now the index (1,2,3) corresponds to the index (11,12,13) in the original map:
print (mmm.map_manager().map_data()[1,2,3]) # prints 0.0416163499881
Now we change the value of a coordinate or a value in the map for our (now-shifted) map_model_manager:
sites_cart = mmm.model().get_sites_cart() # get boxed sites
sites_cart[0] = (20,20,20) # set value of one coordinate in sites_cart
mmm.model().set_sites_cart(sites_cart) # set coordinates in model
mmm.map_manager().map_data()[1,2,3] = 222. # change map value
The value in our original model now changes because the model in our map_model_manager was shifted in place:
print (mmm_model_ref.get_sites_cart()[0]) # (20.0, 20.000000000000004, 20.0)
However nothing happens to the original map because the map_model_manager
made a fresh copy of the map:
print (mmm_map_manager_ref.map_data()[11,12,13]) # prints 0.0416163499881
If you have a map_manager
and you have a new model that you want to match, use the function shift_model_to_match_map(new_model)
which will shift the new model (in place, changing new_model) to match this map.
shift_any_model_to_match
and when to use set_model_symmetries_and_shift_cart_to_match_map
When you work with a model and a map_model_manager, you may want to adjust the origin for the model (the reference frame that it is in) to match the origin of the map_model_manager.
If you load the model into the map_model_manager, this will happen automatically. Suppose we take the model from our boxed map_model_manager:
m = boxed_mmm.model() # get the model
print(m) # prints info about the model including origin shift
Now let's shift this model back to its original location (as we would have when we read in a model with the DataManager):
shift_cart = m.shift_cart() # current origin shift
shift_to_apply = tuple([-x for x in shift_cart]) # opposite shift (to apply()
m.shift_model_and_set_crystal_symmetry(shift_to_apply) # shift the model
print(m) # now the origin shift is zero (original location)
Let's put this model into our boxed map_model_manager:
boxed_mmm.add_model_by_id(model_id = 'model', model = m) # load the model in
print(m) # automatically shifted to match the map_model_manager origin
We could have shifted the model without loading it into the map_model_manager if we wanted to. We use the function:shift_any_model_to_match
:
First let's create a model with an origin shift of zero:
m.shift_model_and_set_crystal_symmetry(shift_to_apply) # shift the model again
print(m) # now the origin shift is zero (original location)
Now let's use shift_any_model_to_match
to shift it to match the
boxed_mmm
map_model_manager:
boxed_mmm.shift_any_model_to_match(m) # shift this model to match the map_model_manager
print(m) # automatically shifted to match the map_model_manager origin
There are some situations where we we want to keep the coordinates in a model exactly the same, but specify that there is an origin shift that matches a particular map_manager. This could happen if we use the map_data from a map_manager to create some coordinates (relative to the origin of that map) and create a model from these coordinates. Now that model has an origin of (0,0,0) but the map_manager may have some other origin. We just want to say that the model refers to the same origin as the map_manager. We can use the set_model_symmetries_and_shift_cart_to_match_map
method to do this:
mm = boxed_mmm.map_manager() # get a map manager
mm.set_model_symmetries_and_shift_cart_to_match_map(m) # set the symmetry and origin
Keep in mind that the set_model_symmetries_and_shift_cart_to_match_map
function should rarely be used. Most of the time you want to shift the origin and the coordinates at the same time with shift_any_model_to_match
unit cell
. On the other hand, cryo-EM maps are only defined inside the region occupied by the original map. The parameter called wrapping
is used to specify whether values at a grid point outside the boundaries of a map are to be calculated by wrapping
the grid point back into the original map using unit cell translations. In general, crystallographic maps that are full size can be wrapped in this way, but cryo-EM maps and any parts of crystallographic maps cannot. Wrapping is normally guessed from the way a map is created, but it can be specified as part of the initialization of map_manager objects and map_model_manager objects.
The map_model_manager
and tools that check to see whether the map and model are compatible by comparing their crystal_symmetry
values, and if present, unit_cell_crystal_symmetry
values. The crystal_symmetry
values reflect the dimensions of the boxed map or model, and the unit_cell_crystal_symmetry
values (if present) reflect the dimensions of the original map and model unit cells.
In most cases, as long as the map_model_manager
has been used to keep track of origin shifts and unit_cell_crystal_symmetry
, a map and model that have gone through the same boxing steps will be compatible and nothing further needs to be done.
However in some cases the crystal_symmetry of a model (for example) might be changed outside the map_model_manager
, in which case an attempt to combine that model with a map that is otherwise compatible would fail with an error message that says that the symmetry of a map does not match that of a model and that they therefore cannot be combined successfully.
If the model coordinates really are compatible with the map and the crystal symmetry of the model is incorrect, the map_model_manager
can be instructed to ignore the symmetry of the model with the ignore_symmetry_conflicts=True
keyword.
If you have a map_manager
and a model that is in the same frame of reference as the map_manager
but for some reason has a different crystal_symmetry
or unit_cell_crystal_symmetry
, you can match the symmetry of the map_manager
(without changing any coordinates in the model) with the map_manager
member function set_model_symmetries_and_shift_cart_to_match_map()
.


South Africa dismisses reported Ebola outbreak
by Agency ReportSouth African National Institute for Communicable Diseases on Thursday said they have not confirmed any Ebola cases in the country or neighbouring countries.
This follows media reports that a South African woman, staying in Ficksburg not far from neighbouring country Lesotho, was confirmed as the first case of Ebola in the country.
“We have not had any positive Ebola cases in South Africa or neighbouring countries.
“This was the first small scale field simulation exercise to test preparedness.
“The biosafety level-4 Lab has not been requested to test suspected Ebola cases for any neighbouring countries.
“As such, we have not had a positive Ebola case,’’ said NICD on its twitter account.
They stated that the incident was a field simulation exercise to test Lesotho’s preparedness to handle the disease.
“Chances of reaching South Africa are very slim, Nonetheless, South Africa has strong Ebola response systems that are in place, should there be a suspected case.
“ If anything changes, we will report its findings to alert the public,’’ the NICD said.
(Xinhua/NAN)


RYMED- dexchlorpheniramine maleate and phenylephrine hydrochloride tablet, coated
EDWARDS PHARMACEUTICALS, INC.
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
Active Ingredients (in each tablet) |
Purpose |
| Dexchlorpheniramine Maleate 2 mg |
Antihistamine |
| Phenylephrine HCl 10 mg |
Nasal Decongestant |
Uses
temporarily relieves these symptoms due to the common cold, hay fever (allergic rhinitis) or other upper respiratory allergies:
- runny nose
- sneezing
- itching of the nose or throat
- itchy, watery eyes
- nasal congestion
- reduces swelling of nasal passages
Warnings
- Do not exceed recommended dosage.
Do not use this product
- if you are now taking a prescription monoamine oxidase inhibitor (MAOI) (certain drugs for depression, psychiatric, or emotional conditions, or Parkinson's disease), or for 2 weeks after stopping the MAOI drug. If you do not know if your prescription drug contains an MAOI, ask a doctor or pharmacist before taking this product.
Ask a doctor before use if you have
- a breathing problem such as emphysema or chronic bronchitis
- glaucoma
- heart disease
- high blood pressure
- thyroid disease
- diabetes mellitus
- difficulty in urination due to enlargement of the prostate gland
Ask a doctor or pharmacist before use if you are taking sedatives or tranquilizers
When using this product
- excitability may occur, especially in children
- may cause drowsiness
- alcohol, sedatives and tranquilizers may increase the drowsiness effect
- avoid alcoholic beverages
- use caution when driving a motor vehicle or operating machinery
Stop use and ask a doctor if
- nervousness, dizziness, or sleeplessness occur
- symptoms do not improve within 7 days or are accompanied by a fever
- new symptoms occur
If pregnant or breast-feeding, ask a health professional before use.
Keep out of reach of children. In case of accidental overdose, seek professional help or contact a Poison Control Center immediately.
Directions
Do not exceed recommended dosage.
| Adults and children 12 years of age and over: |
1 tablet every 4 hours, not to exceed 6 tablets in 24 hours, or as directed by a doctor |
| Children 6 to under 12 years of age: |
1/2 tablet every 4 hours, not to exceed 3 tablets in 24 hours, or as directed by a doctor |
| Children under 6 years of age: |
Consult a doctor. |
Inactive ingredients
Magnesium Stearate, Microcrystalline Cellulose, Sodium Starch Glycolate
Questions or Comments?
Call 1-800-543-9560
PRINCIPAL DISPLAY PANEL - 100 Tablet Bottle Label
E
NDC 0485-0080-01
RYMED TABLETS
Antihistamine • Nasal Decongestant
Each tablet contains:
Dexchlorpheniramine Maleate 2 mg
Phenylephrine HCl 10 mg
This bottle is not to be dispensed to consumer.
Dispense in a tight, light-resistant container
with a child-resistant cap.
Store at 59°-86° (15°-30°C) [see USP Controlled Room Temperature].
Tamper evident by foil seal under cap.
Do not use if foil seal is broken or missing.
Manufactured for:
EDWARDS
Pharmaceuticals, Inc.
Ripley, MS 38663
100 tablets
EDWARDS PHARMACEUTICALS, INC.


Example surrogate modelling in 1d (vkikriging.example1d)¶
Class to do surrogate modelling and plotting of a function f of one variable, with derivative, another function df.
-
class
vkikriging.example1d.
Example1d
(f, df, xi_samples, gamma, sigma_d, sigma_dg, xi_min, xi_max)[source]¶ Bases:
object
Example demonstrating how to use kriging and gek, versions v1,v2 and v3, in 1d. For a function f (e.g. analytically defined), with gradient df.
Parameters: - f (function) – Function to approximate.
- df (function) – Gradient of f.
- xi_samples (ndarray) – Locations xi at which to sample f and df.
- gamma (float) – Correlation length in prior.
- sigma_dg (sigma_d,) – Standard errors in observations and gradients.
- xi_max (xi_min,) – Extreme values in independent variable, for reconstruction and plotting.
Example usage:
# 1. Initialize the function to approxiate, samples and Kriging paramters ex1d = Example1d(np.sin, np.cos, np.linspace(0, 1, 8), gamma, sigma_d, sigma_dg, xi_min=-.5, xi_max=1.5) # 2. Build the Kriging model, v1, v2 or v3. For v1, v2 GEK model is also built. ex1d.build_surrogate_v1() # 3. Plot the model, use any of all of the plot_* functions fig = plt.figure(figsize=(10, 6)) ax = fig.add_subplot(111) ex1d.plot_kriging(ax) ex1d.plot_posterior_samples_kriging(ax) ex1d.plot_reference(ax)
-
vkikriging.example1d.
plot1d_stddevregion
(ax, xi, mu, mse, label=None, color='r')[source]¶ Plot mean, and nice shaded regions representing +- 1,2,3-sigma for 1d plots.
Parameters: - ax (Axis) – Matplotlib axis object in which to plot.
- xi (ndarray) – Reconstruction locations, shape n_r.
- mu (ndarray) – Surrogate mean, shape n_r.
- mse (ndarray) – Surrogate stddev, shape n_r.
- facecolor (Color) – Matplotlib color of the mean-line and stddev regions, e.g. ‘r’ for red, etc.


Hallo! (Dutch) [interjection, noun]
I'm Christiaan, a senior front-end UX developer with a strong emphasis on user experience and accessibility.
I have over 15 years of professional experience with designing and developing for web and mobile. I currently hold a fulltime engineering position at The Learning Network, helping to improve education in The Netherlands and Belgium. Previously, I worked in a similar role at an agency called New Story and before that, I ran my own business for years working as a freelancer for numerous clients domestic and abroad.
Projects I worked on (more on request)
Fulltime position at The Learning Network
Bundle
API-driven learning environment for secondary and higher education. I helped developing the SPA in React, NodeJS and Redux.Fulltime position at New Story
Van der Valk Hotels
Renowned hotel chain. I built the front-end for their booking engine SPA from scratch in Angular (implementing the Redux pattern using @ngrx/store).Freelance
Oceanwide Expeditions
Expedition cruises to the (Ant)arctic. I designed, prototyped and built the entire front-end for their website and booking engine.Freelance
Mom in Balance
Worldwide outdoor workouts for (pregnant) women. I did user and identity research and designed and built their website from scratch.Freelance
Engie / GDF Suez / Electrabel
Multinational electric utility company. I helped setting up a new start-up for (cross) selling home automation devices and designed and build the website's front-end.Freelance
NAPA
Dutch association for physician assistants. I did user research, interviewing and prototyped, designed and built their website from scratch.My typical day (in no particular order)
Almost every day
- Connect (remotely) with my team to see if anyone needs help
- Create reusable, consistent BEM HTML/CSS components
- Build reusable React components for our design system
- Document and improve our coding standards and conventions
- Commit my code through Git, sticking to our Git flow I helped creating
- Write and run unit (RTL, Jest) and E2E (Cypress) tests
- Review my team's code and pull requests
- Sketch user interfaces with pen and paper and gain feedback from users and stakeholders
- Promote the principle of 'human centered design'
- Demo real functioning (HTML/CSS/JavaScript) prototypes rather than boring, static mockups
- Spin up Docker containers, hook up pipelines to either our servers or the cloud
- Discuss APIs and GraphQL schemas with our back-end developers
- Hike at least 5km on my favourite nearby trails
Every now and then
- Write React and Angular components in TypeScript for our latest projects
- Meet (remotely) with front-end developers from other teams to discuss design system progress
- Improve my skills following workshops and courses, consuming newsletters, blogs and podcasts
- Explore areas of expertise I'm not familiar with (currently: Vue.js)
With time to spare
- Hike longer distances through nature in both my region (the northeastern Netherlands) or in nearby Germany. You can even watch me do this
- Take my motorcycle or my bicycle for spontaneous rides
- Mess around making (electronic) music and actually release a single every now and then
- Work on hobby design- and development side projects
- Get my hands dirty in our garden
- Dump my thoughts in my personal stream
- Play the horse in my (3) kids' riding games
From past to present
What I've been up to in the most recent years (more on request)
-
1981Leiden, NL
Birth
Close to the sea, Randstad Metropolitain area and means of international travel. Grew up in its vicinity. School and life. Gained a lifelong love for hiking during Italian holidays. -
2006 - 2018Leiden & Lisse, NL
Works4sure
My own business, for which I started freelancing, often in close collaboration with other freelancers. Gained lots of experience, working for clients domestic and abroad. Expanded my network. Embraced 'human centered design'. -
2009 - 2011Leiden, NL
Whoooz! Webmedia
Became a partner. Helped organizing a successful series of our own EECI-conferences in Leiden, San Francisco and Brooklyn. Lots and lots of travel. Awesome times. Quit because I wanted to focus on client work. -
2011 - 2012Amsterdam, NL
TravelBird
Online travel agency. Start-up at the time. Joined the then-small team as their web designer. Helped optimizing conversion and kick-start (extreme) rapid growth, eventually to 14 countries. -
2016 - 2018Noordwijk, NL
New Story
Design agency (previously known as Aan Zee). Best location ever: overlooking the North Sea. Did lots of React and Angular development in SCRUM-collaboration with our clients. -
2018Drenthe province, NL
Moved cross country
To my wife's roots in beautiful Drenthe. No regrets thus far. Love nature, space and the quiet, miss the sea. Quit my job because of the distance. -
2018 ~Kampen, NL
The Learning Network
The wondrous world of secondary and higher education. Working fulltime as a front-end developer on our own education themed React and Angular applications.
Me in a nutshell
- Over 15 years of experience designing and developing online products for web and mobile. Specialised in semantic, accessible HTML and CSS and JavaScript (expert in React, but nothing wrong with vanilla).
- Worked in a variety of branches, primarily Travel, Leisure, Education, Publishing and Pharma for clients like Engie, Van der Valk, Nutricia, Leiden University, Sunny Cars, DAS, Oceanwide Expeditions, Malmberg, Vakantieveilingen.nl, Myshortlease.nl, Mom in Balance and many more.
- I consider websites first and foremost just means to an end. They're tools, helping people achieve their goals in a pleasant manner, not works of art (although they can be both - which is what I aim for).
- Expert at rapid prototyping; working, testable HTML + CSS + JavaScript always supersedes static mockups in Sketch or Photoshop.
- Teamplayer: eager to teach, eager to learn.
- Outdoorsman. I spend much time deliberately getting lost in distant woodlands and on hill ridges. And not just in nice weather.
- Bearded since I forgot to bring my shaving gear on a trip to London in 2005.


Winner
Dundalk woman wins big on RTÉ's Winning Streak
RTE
by David LynchA Dundalk accountant went on a Winning Streak of her own when she appeared on the National Lottery TV game show and won a cool €51,000 on the RTÉ One show, last Saturday (2nd November).
Fiona O’Hanlon from Dundalk, won €48,000 in cash as well as a holiday to Venice, Italy which is worth €3,000, bringing her winnings to an impressive €51,000.
Fiona O’Hanlon from Dundalk wasn’t watching Winning Streak when her name was called out two weeks ago, but she said that all three phones in the house began ringing with friends congratulating her. Neighbours were rushing into the house, some in their pyjamas, hugging her too and Fiona was overcome with excitement and nerves.
Fiona is Dundalk born and bred and lives with her family, husband Sean – to whom she has been married for 23 years, and her two kids, Shannon (20) and Dylan (11) who are both excited to cheer her on this coming Saturday. They were in the audience alongside Fiona’s parents Breige and Harry and sister Yvonne.
Fiona is an accountant by day and works for SAI Global in Dundalk, where she has worked for more than seven years. Her daughter Shannon is following in her mums footsteps and is studying actuarial maths in DCU. Fiona has no set plan for her winnings from the show but says some of it will go towards a few bills and she will treat the rest of the family.


A generic interface for creating and comparing hash values.
More...
#include <Utils/Hash/Hash.hpp>
A generic interface for creating and comparing hash values.
Definition at line 24 of file Hash.hpp.
◆ Hash()
◆ ~Hash()
◆ addFileExtension()
Add the extension for the supported hash type
- Parameters
-
| baseName | The base name |
| extendedName | The extended name |
Definition at line 11 of file HashCommon.cpp.
◆ final() [1/2]
Finalize an incremental computation and return the result
- Parameters
-
Definition at line 63 of file CRC32.cpp.
◆ final() [2/2]
| void Utils::Hash::final |
( |
U32 & |
hashvalue | ) |
|
Finalize an incremental computation and return the result
Definition at line 73 of file CRC32.cpp.
◆ getFileExtensionLength()
Get the length of the file extension string
Definition at line 19 of file HashCommon.cpp.
◆ getFileExtensionString()
| const char * Utils::Hash::getFileExtensionString |
( |
void |
| ) |
|
|
static |
Get the file extension for the supported hash type E.g., could return "SHA256"
Definition at line 5 of file HashCommon.cpp.
◆ hash()
Create a hash value all at once from raw data
- Parameters
-
| len | Pointer to start of data |
| buffer | Length of the data Resulting hash value |
Definition at line 28 of file CRC32.cpp.
◆ init()
| void Utils::Hash::init |
( |
void |
| ) |
|
Initialize a Hash object for incremental hash computation
Definition at line 46 of file CRC32.cpp.
◆ setHashValue()
| void Utils::Hash::setHashValue |
( |
HashBuffer & |
value | ) |
|
Set hash value to specified value
- Parameters
-
Definition at line 81 of file CRC32.cpp.
◆ update()
| void Utils::Hash::update |
( |
const void *const |
data, |
|
|
const NATIVE_INT_TYPE |
len |
|
) |
| |
Update an incremental computation with new data
- Parameters
-
| len | Pointer to start of data Length of the data |
Definition at line 52 of file CRC32.cpp.
The documentation for this class was generated from the following files:


Chem 125 is an intensive physical chemistry course that is designed to help students learn not only techniques specific for experimental physical chemistry (spectroscopy, microscopy, calorimetry, etc.) but also to help students develop scientific writing and presentation skills. The class is set up into three units: Spectroscopy, Kinetics/Thermodynamics, Condensed Phase Structure and Dynamics. In each unit, the student is required to perform two experiments (from a list of 4-6 options), culminating in either a written formal report or an oral exam/presentation. At the end of the semester, there is a final exam based on lecture material.
Formal: Two of the following: Chem 120A and 120B, C130, or 130B (one of which may be taken concurrently).
Additional Notes: In my opinion, only conceptual/general knowledge of physical chemistry is required because the experiments are extremely well prepared and self-contained. Some lecture topics may be easier to understand with some (very general) background in solid state inorganic (Chem 104A) or materials (Chem C150) chemistry, though it is not assumed that students will know it.
Unit I: Spectroscopy
Unit II: Kinetics and Thermodynamics
Unit III: Condensed Phase Structure and Dynamics
Unit I: Spectroscopy
Unit II: Kinetics and Thermodynamics
Unit III: Condensed Phase Structure and Dynamics
All
One hour lab lecture each week. 4-5 hours of lab every other week (roughly, depending on when you sign up for lab sections). 15-30 hours per lab write up/oral exam (typically oral presentations take less time to finish).
You can choose to take this course in the fall or spring, either while taking 120B (in the fall) or after taking 120A and 120B (in the spring). It is unfavorable to take both this class and 120A at the same time, since both have quite a heavy workload associated with it.
Unlike what many students do, I highly suggest against taking this course during your last semester. No matter how you slice it, you will have to do at least some work in this class to pass it, so you might as well try to do the best you can. Also, saving this class for last only increases your own misery.
Unfortunately, there is no directly related course for those who may be interested in performing more physical chemistry experiments. The best option would be to join a physical chemistry lab. The following is a list of some potential options, though they are not directly related to all aspects of the course:
The difficulty of the class highly depends on the experiments you choose to perform. Those who wish to spend less time in lab should avoid Physical Adsorption of Gaseous (Unit 2B) and Nuclear Magnetic Resonance Spectra by Fourier Transform (Unit 3C).
The lab reports are a lot of work, but the lab manual is a pretty complete and all-encompassing guide on what to include for the introduction and how to perform the data analysis. I highly suggest finding some time to go to office hours/reaching out to GSIs for help with more difficult or less obvious discussion questions to maximize your grades on the reports. This is also a great opportunity to try your hand at using LaTEX to create nice looking lab reports.
Chem 125 differs from any other physical chemistry lab course because the labs are extremely interesting. The tradeoff, however, is that they are not exactly as straightforward as other analytical or physical chemistry labs, which makes them more difficult. Student should keep this in mind when preparing to take the course. Good luck!
Written by: Angela Lee
Last edited: Spring 2018


| Overview | Module | Use | Devguide | Index |
| uses of interface XStream |
back to interface XStream |
| Derived Interfaces |
::com::sun::star::embed::XExtendedStorageStream XTempFile |
| Services which Support this Interface |
| ::com::sun::star::embed::StorageStream TempFile |
| Uses as Return Type |
| ::com::sun::star::embed::XStorage2::cloneEncryptedStream() ::com::sun::star::embed::XStorage::cloneEncryptedStreamElement() ::com::sun::star::embed::XStorage::cloneStreamElement() XActiveDataStreamer::getStream() ::com::sun::star::embed::XStorage2::openEncryptedStream() ::com::sun::star::embed::XStorage::openEncryptedStreamElement() ::com::sun::star::ucb::XSimpleFileAccess::openFileReadWrite() ::com::sun::star::embed::XStorage::openStreamElement() |
| Uses as Parameter |
| ::com::sun::star::embed::XPersistanceHolder::connectPersistance() ::com::sun::star::embed::XOptimizedStorage::copyStreamElementData() ::com::sun::star::embed::OLESimpleStorage::createFromStream() XActiveDataStreamer::setStream() ::com::sun::star::security::XDocumentDigitalSignatures::signDocumentContent() ::com::sun::star::security::XDocumentDigitalSignatures::signPackage() ::com::sun::star::security::XDocumentDigitalSignatures::signScriptingContent() ::com::sun::star::embed::XOptimizedStorage::writeAndAttachToStream() |
| Uses as Data Type |
| ::com::sun::star::graphic::MediaProperties::OutputStream |
| References in Developers Guide |
| Basic - File IO |
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


| Modifier and Type | Field and Description |
|---|---|
java.lang.String[][] |
dis |
LeafTile |
dog |
int |
maxDepth |
int |
minDepth |
Tile |
root |
LeafTile |
walker |
| Constructor and Description |
|---|
GameBoard(int maxDepth,
int minDepth) |
| Modifier and Type | Method and Description |
|---|---|
Tile |
createTree()
Creates a quadtree with Internal and Leaf Tiles based on values
for the maximum and minimum tile depth.
|
InternalTile |
findParent(Tile toFind,
Tile startingTile)
Finds the parent tile of any tile
|
java.lang.String[][] |
getDis() |
Tile |
placeDog(Tile root)
Randomly places the dog in a
tile
|
Tile |
placeWalker(InternalTile root)
Randomly places the walker in a
tile
|
void |
populateDis()
Helper method for console printing
|
void |
printBoard()
Traverses the tree and prints the game board
|
void |
traverseTree(Tile tile)
Recursively calls updateDisplay on all children leaf tiles
of the input param tile.
|
void |
updateDisplay(LeafTile leaf)
Updates display based on depth and starting points of leaf
|
void |
wipeDisplay()
Clears display on console.
|
public Tile root
public int maxDepth
public int minDepth
public LeafTile walker
public LeafTile dog
public java.lang.String[][] dis
public java.lang.String[][] getDis()
public Tile createTree()
Game
createTree
in interface Game
public void updateDisplay(LeafTile leaf)
Game
updateDisplay
in interface Game
public void populateDis()
Game
populateDis
in interface Game
public void printBoard()
Game
printBoard
in interface Game
public InternalTile findParent(Tile toFind, Tile startingTile)
Game
findParent
in interface Game
toFind
- the tile of which to find the parentstartingTile
- either the root or some tile above toFind in
quadtree hierarchypublic Tile placeDog(Tile root)
Game
public Tile placeWalker(InternalTile root)
Game
placeWalker
in interface Game
root
- of quadtreepublic void wipeDisplay()
Game
wipeDisplay
in interface Game
public void traverseTree(Tile tile)
Game
traverseTree
in interface Game
tile
- - the tile to be traversed


30°C
Partly Cloudy
Overcast
Ghana Accra
SUN
Light rain in the morning and afternoon.
10°C
-5°C
MON
Mostly cloudy throughout the day.
-2°C
-5°C
WED
Windy in the evening and overnight
10°C
-5°C
SUN
Light rain in the morning and afternoon.
10°C
-5°C
SUN
Light rain in the morning and afternoon.
10°C
-5°C


moize
moize
is a blazing fast memoization library for JavaScript. It handles multiple parameters (including default values) without any additional configuration, and offers options to help satisfy a number of implementation-specific needs. It has no dependencies, and is ~3.2kb when minified and gzipped.
Table of contents
- Upgrade notification
- Installation
- Usage
- Advanced usage
- Usage with shortcut methods
- Composition
- Introspection
- Benchmarks
- Direct cache manipulation
- Browser support
- Development
Upgrade notification
Users of moize
2.x.x may experience breaking changes, especially if using a custom cache or using moize.react
in a mutative way. Please see the changelog for more details about how to manage the upgrade.
Installation
$ npm i moize --save
Usage
import moize from 'moize';
const method = (a, b) => {
return a + b;
};
const memoized = moize(method);
memoized(2, 4); // 6
memoized(2, 4); // 6, pulled from cache
All parameter types are supported, including circular objects, functions, etc. There are also a number of shortcut methods to easily create memoization for targeted use-cases. You can even memoize functional React
components based on their props
+ context
combination (see the isReact
option, or the moize.react
shortcut method)!
Advanced usage
moize
optionally accepts an object of options as either the second parameter or as the first step in a curried function:
// inline
moize(fn, options);
// curried
moize(options)(fn);
The full shape of these options:
{
equals: Function, // custom method to compare equality between two objects
isPromise: boolean, // is the result a promise
isReact: boolean, // is the result a React component
maxAge: number, // amount of time in milliseconds before the cache will expire
maxArgs: number, // maximum number of arguments to use as key for caching
maxSize: number, // maximum size of cache for this method
promiseLibrary: Function|Object, // promise library to use when isPromise is true, if not using native promises
serialize: boolean, // should the parameters be serialized instead of directly referenced
serializeFunctions: boolean, // should functions be included in the serialization of multiple parameters
serializer: Function // method to serialize the arguments to build a unique cache key
}
equals
defaults to strict equality
Custom method used to compare equality of keys for cache purposes.
// using fast-equals's deep equal comparison method
import {deepEqual} from 'fast-equals';
const fn = ({foo, bar}) => {
return [foo, bar];
};
const memoized = moize(fn, {
equals: deepEqual
});
memoized({foo: 'foo', bar: 'bar'});
memoized({foo: 'foo', bar: 'bar'}); // pulls from cache
The equals
method receives two parameters (cache key values) and should return a boolean
. Please note that this will be slower than the default strict equality comparison, however how much slower is based on the efficiency of the method passed.
isPromise
defaults to false
Is the computed value in the function a Promise
, and should we cache the resolved value from that Promise
. This is also available via the shortcut method of moize.promise
.
const fn = async (item) => {
return await item;
};
const memoized = moize(fn, {
isPromise: true
});
The resolved value of the Promise
will be stored in cache as a Promise
itself, so that cached returns will always be in the form of a Promise
. For common usage reasons, if the Promise
is rejected, the cache entry will be deleted. Also, if a maxAge
is provided, the countdown of that TTL will begin upon the resolution of the promise rather than at the instantiation of it.
isReact
defaults to false
Is the function passed a stateless functional React
component. This is also available via the shortcut method of moize.react
.
const Foo = ({bar, baz}) => {
return (

{bar}: {baz}

);
};
export default moize(Foo, {
isReact: true
});
The method will do a shallow comparison of both props
and context
of the component based on strict equality. If you have mutative props and instead want to do a deep equals comparison, provide a custom equals
option.
maxAge
defaults to Infinity
The maximum amount of time in milliseconds that you want a computed value to be stored in cache for this method. This is also available via the shortcut method of moize.maxAge
.
const fn = (item) => {
return item;
};
const memoized = moize(fn, {
maxAge: 1000 * 60 * 5 // five minutes
});
maxArgs
defaults to the length of arguments passed to the method
The maximum number of arguments used in creating the key for the cache. This is also available via the shortcut method of moize.maxArgs
.
const fn = (item1, item2, item3) => {
return item1 + item2 + item3;
};
const memoized = moize(fn, {
maxArgs: 2
});
memoize('foo', 'bar', 'baz');
memoize('foo', 'bar', 'quz'); // pulls from cache, as the first two args are the same
Please note that if maxArgs
is combined with either serialize
or transformArgs
, the following order is used:
- limit by
maxArgs
- transform by
transformArgs
(if applicable) - serialize by
serializer
(if applicable)
maxSize
defaults to Infinity
The maximum number of values you want stored in cache for this method. Clearance of the cache once the maxSize
is reached is on a Least Recently Used basis. This is also available via the shortcut method of moize.maxSize
.
const fn = (item) => {
return item;
};
const memoized = moize(fn, {
maxSize: 5
});
onExpire
A callback that is called when one of cache item expires. Note that maxAge must also be set because by default keys never expire.
const fn = (item) => {
return item;
};
const memoized = moize(fn, {
maxAge: 10000,
onExpire(key) {
console.log(key);
},
});
If you return false
from this method, it will prevent the key's removal, instead refreshing the expiration in the same vein as updateExpire
based on maxAge
:
const fn = (item) => {
return item;
};
let expirationAttempts = 0;
const memoized = moize(fn, {
maxAge: 1000 * 10, // 10 seconds
onExpire(key) {
expirationAttempts++;
return expirationAttempts < 2;
},
});
memoized('foo'); // will expire key after 30 seconds, or 3 expiration attempts
promiseLibrary
defaults to native Promise
The promise library to use for resolution / rejection of promises.
const fn = (foo) => {
return new Bluebird((resolve) => {
resolve(foo);
});
};
const memoized = moize(fn, {
isPromise: true,
promiseLibrary: Bluebird
});
Please note that for this option to work isPromise
must be set to true
.
You can use any library where the following aspects of the specification are included:
- It is thenable (the generated promise has a
.then()
function) - The
Promise
object itself has.resolve()
and.reject()
functions on it
Most modern libraries (bluebird
, q
, etc.) include these by default, however if you are using a custom library that does not meet these requirements then you will need to implement them yourself. An example of a wrapper that creates the .resolve()
and .reject()
methods:
import foo from 'my-promise-library';
// create a wrapper so as not to touch the library itself
const customPromise = (fn) => {
return foo(fn);
};
// lets pretend foo has a .result() method that has the first
// parameter as successful, second as failure
customPromise.resolve = function(value) {
return foo.result(value);
};
customPromise.reject = function(error) {
return foo.result(undefined, error);
};
const fn = (foo) => {
return customPromise((resolve) => {
resolve(foo);
});
};
const memoized = moize(fn, {
isPromise: true,
promiseLibrary: customPromise
});
serialize
defaults to false
Serializes the parameters passed into a string and uses this as the key for cache comparison. This is also available via the shortcut method of moize.serialize
.
const fn = (mutableObject) => {
return mutableObject.foo;
};
const memoized = moize(fn, {
serialize: true
});
const object = {
foo: 'foo'
};
memoized(object); // 'foo'
object.foo = 'bar';
memoized(object); // 'bar'
Please note that this is slower than the default key storage (see benchmarks). Also note that if serialize
is combined with either maxArgs
or transformArgs
, the following order is used:
- limit by
maxArgs
(if applicable) - transform by
transformArgs
(if applicable) - serialize by
serializer
serializeFunctions
defaults to false
A custom replacer is used when serializing to ensure functions are included in the key serialization.
const FunctionalComponent = ({onClickFoo}) => {
return (
<button
onClick={onClickFoo}
type="button"
>
Click me!
</button>
)
};
const MemoizedFunctionalComponent = moize(FunctionalComponent, {
serialize: true,
serializeFunctions: true
});
Please note that you must also set serialize
to true
for this setting to take effect.
serializer
defaults to serializeArguments in utils.js
Overrides the internal serializer when serializing the parameters for cache key comparison. The value returned from the function must be a valid value of keys for a Map
; it does not need to a string, but should be unique from a strict equality perspective.
const serializer = (args) => {
return JSON.stringify(args[0]);
};
const memoized = moize(fn, {
serialize: true,
serializer
});
Please note that you must also set serialize
to true
for this setting to take effect.
transformArgs
Transform the arguments passed before it is used as a key. The function accepts a single argument, the Array
of args
, and must also return an Array
.
const fn = (one, two, three) => {
return [two, three];
};
const ignoreFirstArg = (args) => {
return args.slice(1);
};
const moized = moize(fn, {
transformArgs: ignoreFirstArg
});
moize('foo', 'bar', 'baz');
moize(null, 'bar', 'baz'); // pulled from cache
Please note that if transformArgs
is combined with either maxArgs
or serialize
, the following order is used:
- limit by
maxArgs
(if applicable) - transform by
transformArgs
- serialize by
serializer
(if applicable)
updateExpire
When a maxAge
is set, clear out the scheduled expiration of the key whenever that key is retrieved, updating the new expiration to be based on the last retrieval from cache.
const fn = (item) => {
return item;
};
const memoized = moize(fn, {
maxAge: 1000 * 60 * 5, // five minutes
updateExpire: true
});
memoized('foo');
setTimeout(() => {
memoized('foo'); // hits cache, which updates the expire to be 5 minutes from this run instead of the first
}, 1000 * 60);
Usage with shortcut methods
moize.maxAge
Pre-applies the maxAge
option as a curriable method.
import moize from 'moize';
const foo = (bar, baz) => {
return `${bar} ${baz}`;
};
export default moize.maxAge(5000)(foo);
moize.maxArgs
Pre-applies the maxArgs
option as a curriable method.
import moize from 'moize';
const foo = (bar, baz) => {
return `${bar} ${baz}`;
};
export default moize.maxArgs(1)(foo);
moize.maxSize
Pre-applies the maxSize
option as a curriable method.
import moize from 'moize';
const foo = (bar, baz) => {
return `${bar} ${baz}`;
};
export default moize.maxSize(5)(foo);
moize.promise
Pre-applies the isPromise
option.
import moize from 'moize';
const foo = async (bar, baz) => {
return await someApiCall(bar, baz);
};
export default moize.promise(foo);
Please note that if you want to provide a custom promiseLibrary
, you must do so with additional options:
const additionalOptions = {
promiseLibrary: Bluebird
};
moize.promise(fn, additionalOptions);
// or
moize.promise(additionalOptions)(fn);
moize.react
Shortcut for memoizing functional components in React. This uses a special cache key that will do a shallow equal comparison of changes to both props and context.
import moize from 'moize';
const Foo = ({bar, baz}) => {
return (

{bar} {baz}

);
};
export default moize.react(Foo);
Also, it should be noted that in usages that involve a lot of variety in the parameter changes, this has the potential for excessive memory consumption, as the cache will retain the history of all elements. It is therefore recommended to apply a maxSize
, or to use the shortcut method moize.reactSimple
, which automatically sets the maxSize
to 1
.
Please note moize.react
will not operate with components made via the class
instantiation, as they do not offer the same referential transparency.
moize.reactSimple
Shortcut for memoizing functional components in React, with the cache size limited to a single entry. This mimics the PureComponent
optimization, where the cache will only contain the component with the most recent props
and context
combination.
import moize from 'moize';
const Foo = ({bar, baz}) => {
return (

{bar} {baz}

);
};
export default moize.reactSimple(Foo);
Please note moize.reactSimple
will not operate with components made via the class
instantiation, as they do not offer the same referential transparency.
moize.serialize
Pre-applies the serialize
option.
import moize from 'moize';
const foo = (bar, baz) => {
return `${bar} ${baz}`;
};
export default moize.serialize(foo);
Please note that if you want to serializeFunctions
or provide a custom serializer
, you must do so with additional options:
const additionalOptions = {
serializeFunctions: true
};
moize.serialize(fn, additionalOptions);
// or
moize.serialize(additionalOptions)(fn);
moize.simple
Pre-applies the maxSize
option with 1
.
import moize from 'moize';
const foo = (bar, baz) => {
return `${bar} ${baz}`;
};
export default moize.simple(foo);
Composition
Starting with version 2.3.0
, you can compose moize
methods. This will create a new memoized method with the original function that shallowly merges the options of the two setups. Example:
import moize from 'moize';
const Foo = (props) => {
return (

);
};
// memoizing with react, as since 2.0.0
const MemoizedFoo = moize.react(Foo);
// creating a separately-memoized method that has maxSize of 5
const LastFiveFoo = moize.maxSize(5)(MemoizedFoo);
You can also create an options-first curriable version of moize
if you only pass the options:
import moize from 'moize';
// creates a function that will memoize what is passed
const limitedSerializedMoize = moize({
maxSize: 5,
serialize: true
});
const foo = (bird) => {
return `${bird} is the word`;
};
const moizedFoo = limitedSerializedMoize(foo);
You can also combine all of these options with moize.compose
to create moize
wrappers with pre-defined options.
import moize from 'moize';
// creates a moizer that will have the options of
// {isReact: true, maxAge: 5000, maxSize: 5}
const superLimitedReactMoize = moize.compose(moize.react, moize.maxSize(5), moize.maxAge(5000));
Introspection
There currently is only one method to introspect objects specific to moize, but if you want more just ask!
isMoized
Is the function passed a moized function.
const fn = () => {};
const moizedFn = moize(fn);
moize.isMoized(fn); // false
moize.isMoized(moizedFn); // true
Benchmarks
All values provided are the number of operations per second (ops/sec) calculated by the Benchmark suite. Note that underscore
, lodash
, and ramda
do not support mulitple-parameter memoization, so they are not included in those benchmarks.
Each benchmark was performed using the default configuration of the library, with a fibonacci calculation based on a starting parameter of 35
, and in the case of multiple parameters a second parameter (boolean
for primitives, object
for complex objects) was used.
Single parameter
| Operations / second | Relative margin of error | |
|---|---|---|
| moize | 44,547,124 | 0.64% |
| fast-memoize | 30,048,291 | 0.97% |
| moize (serialized) | 14,877,726 | 0.63% |
| underscore | 13,821,853 | 0.61% |
| memoizee | 11,494,292 | 0.90% |
| lodash | 10,020,324 | 0.52% |
| lru-memoize | 10,017,832 | 1.30% |
| Addy Osmani | 4,423,578 | 0.76% |
| memoizerific | 2,174,503 | 1.31% |
| ramda | 1,171,053 | 0.71% |
Multiple parameters (primitives only)
| Operations / second | Relative margin of error | |
|---|---|---|
| moize | 24,947,214 | 0.77% |
| moize (serialized) | 10,982,454 | 0.84% |
| memoizee | 8,602,634 | 0.59% |
| lru-memoize | 7,667,460 | 1.58% |
| Addy Osmani | 2,039,761 | 0.86% |
| memoizerific | 1,336,321 | 0.81% |
| fast-memoize | 844,633 | 0.76% |
Multiple parameters (complex objects)
| Operations / second | Relative margin of error | |
|---|---|---|
| moize | 24,146,198 | 1.16% |
| memoizee | 8,324,025 | 0.86% |
| lru-memoize | 7,986,555 | 1.15% |
| moize (serialized) | 1,798,895 | 0.95% |
| memoizerific | 1,416,617 | 1.15% |
| Addy Osmani | 1,097,775 | 0.78% |
| fast-memoize | 746,371 | 1.03% |
Direct cache manipulation
There are a few methods provided on the moize
d function which allow for programmatic manipulation of the cache:
add(key, value)
This will manually add the value at key in cache if key does not already exist. key is an Array
of values, meant to reflect the arguments passed to the method.
// single parameter is straightforward
const memoized = moize((item) => {
return item;
});
memoized.add(['foo'], 'bar');
// pulls from cache
memoized('foo');
clear()
This will clear all values in the cache, resetting it to an empty state.
const memoized = moize((item) => {
return item;
});
memoized.clear();
has(key)
This will return true
if a cache entry exists for the key passed, else will return false
. key is an Array
of values, meant to reflect the arguments passed to the method.
const memoized = moize((first, second) => {
return [first, second];
});
memoized('foo', 'bar');
console.log(memoized.has(['foo', 'bar'])); // true
console.log(memoized.has(['bar', 'baz'])); // false
keys()
This will return a list of the current keys in cache
.
const memoized = moize((item) => {
return item;
});
const foo = 'foo';
memoized(foo);
const bar = {
baz: 'baz'
};
memoized(bar);
const keys = memoized.keys(); // ['foo', {baz: 'baz'}]
remove(key)
This will remove the provided key from cache. key is an Array
of values, meant to reflect the arguments passed to the method.
const memoized = moize((item) => {
return item;
});
const foo = {
bar: 'baz'
};
memoized(foo);
memoized.remove([foo]);
// will re-execute, as it is no longer in cache
memoized(foo);
values()
This will return a list of the current values in cache
when the native Cache
.
const memoized = moize((item) => {
return {
item
};
});
const foo = 'foo';
memoized(foo);
const bar = {
baz: 'baz'
};
memoized(bar);
const values = memoized.values(); // [{item: 'foo'}, {item: {baz: 'baz'}}]
Browser support
- Chrome (all versions)
- Firefox (all versions)
- Edge (all versions)
- Opera 15+
- IE 9+
- Safari 6+
- iOS 8+
- Android 4+
Development
Standard stuff, clone the repo and npm install
dependencies. The npm scripts available:
build
=> run webpack to build developmentdist
file with NODE_ENV=developmentbuild:minifed
=> run webpack to build productiondist
file with NODE_ENV=productiondev
=> run webpack dev server to run example app (playground!)dist
=> runsbuild
andbuild-minified
docs
=> builds the docs viajsdoc
lint
=> run ESLint against all files in thesrc
folderprepublish
=> runscompile-for-publish
prepublish:compile
=> runlint
,test
,transpile:es
,transpile:lib
,dist
test
=> run AVA test functions withNODE_ENV=test
test:coverage
=> runtest
but withnyc
for coverage checkertest:watch
=> runtest
, but with persistent watchertranspile:lib
=> run babel against all files insrc
to create files inlib
transpile:es
=> run babel against all files insrc
to create files ines
, preserving ES2015 modules (forpkg.module
)


Vue + TypeScript + Webpack Example
Simple component
Let me say: {{ message }}
Say something else
Self-contained component


data class UpgradeCommand : CommandData
Indicates that this transaction replaces the inputs contract state to another contract state
| <init> |
UpgradeCommand(upgradedContractClass: Class<out UpgradedContract<*, *>>)
Indicates that this transaction replaces the inputs contract state to another contract state |
| upgradedContractClass |
val upgradedContractClass: Class<out UpgradedContract<*, *>> |


For who-knows-how-many years, a single great blue heron has come to balance on the old piling here. The heron flies into Denise Levertov's poem "A Reward". And yes, seeing that "widewinged" bird wings the spirit wide open.


Zabby
Zabby[http://zabby.org] is a Ruby library and client for Zabbix[http://www.zabbix.com/]. It provides a simple and clean interface to the Web Services[http://www.zabbix.com/documentation/1.8/api].
Goals
There already are Ruby Zabbix libraries but some of them are unfinished (and apparently abandonned) and some other’s code is too complicated or poorly designed. This is why I decided to write another tool for which my primary goal is to keep the code design, the user interaction and application interface clean and simple.
Zabby has the following caracteristics:
- Works both as a Ruby API and a command line tool.
- Uses an internal Ruby DSL (Domain Specific Langage) that give access to the full power of Ruby scripting in your configurarion files. No need for a specific configuration language.
- Simple design: avoids spaghetti code, WTF and facepalm, unlike some other Ruby Zabbix libraries.
Features
- Low level Ruby API that maps every Zabbix API (JSON RPC) to Ruby hashes.
- Higher level Ruby DSL, both available in pure Ruby and for writing configuration files.
- Supports SSL and authenticated HTTP proxies.
- Full featured IRB like shell included with Readline support. You can mix Zabbix instructions with Ruby calls transparently.
Examples
API use
The barebone API can be used in Ruby like this:
require "rubygems" require "zabby" require "pp" z = Zabby.init do server "https://monitoring.example.com" user "api_user" password "s3cr3t" proxy_host "http://<IP_ADDRESS>" proxy_user "john" proxy_password "D0e" end z.login pp z.connection.perform_request("host", "get", { "filter" => { "host" => "master.example.com" } }) pp z.connection.perform_request("item", "get", { "host" => "master.example.com", "output" => "shorten" })
- The server, user and passord are necessary.
- If you don’t provide the path to the JSON-RPC script "/api_jsonrpc.php" is appended to the URI automatically.
- The proxy_* settings are optionnal.
Shell
zabbysh is an simple Zabbix Shell. It runs either interactively or can be used to execute a command file with the "-f CMD_FILE" option.
If the command file does not end with "exit" then the program drops into the shell after executing the file.
zabbysh provides Readline support but does no support advanced IRB features likes multi-lines instructions.
zabbyrb is another Zabbix Shell based on IRB. It provides the whole power of IRB but may be less stable than zabbysh because the IRB API is poorly documented and hard to use.
Interactive shell
# zabbysh zabby> set server "https://monitoring.example.com" zabby> set user "api_user" zabby> set password "s3cr3t" zabby> set proxy_host "http://<IP_ADDRESS>" zabby> set proxy_user "john" zabby> set proxy_password "D0e" zabby> login zabby> puts logged_in? zabby> host.get "filter" => { "host" => "monitor.example.com" }, "output" => "extend" zabby> item.get "host" => "monitor.example.com", "output" => "refer" zabby> [...] zabby> logout zabby> exit
Execute a command script
Create a file and put the same instructions as above in it, then execute zabbysh:
# zabbysh --file my_zabbix_commands.txt
Requirements
- Ruby 1.8.5. IT BASICALLY RUNS ANYWHERE!
- JSON library: ‘json’ or ‘json_pure’
- OptionParser
- Readline (optionnal, used by the interactive shell)
References
- Main web site: http://zabby.org
- GitHub projet: https://github.com/Pragmatic-Source/zabby
- RubyGems.org homepage: https://rubygems.org/gems/zabby
- Author’s company: http://www.pragmatic-source.com
Contributing
All contributions are welcome. You can either open a ticket on Github, send a pull request with a patch or send an email to the author.
Author
Farzad FARID<EMAIL_ADDRESS>Thanks to
- Jean-Hadrien Chabran (jhchabran): Advices on code design.
- Nicolas Blanco (slainer68): Advices on code design and Triple Facepalming after reading other Ruby/Zabbix code.
- Renaud Chaput (renchap): For suggesting the "zabby" name.
Sources of inspiration
- Adam Wiggins’s Rush[https://github.com/adamwiggins/rush] for the interactive shell.
- Other Zabbix Ruby libraries (only the good parts ;) ):
| zabcon[http://trac.red-tux.net/]: | Zabcon is a command line interface for Zabbix written in Ruby |
| rzabbix[http://github.com/neerfri/rzabbix]: | Zabbix API client for Ruby |
| rubix[https://github.com/dhruvbansal/rubix]: | Rubix is a Ruby client for Zabbix |
License
This software is release under the Simplified BSD license. See the LICENSE file.


Egyptian independent media outlet Mada Masr says police raided office
Egyptian police have raided the Cairo office of a media outlet known to be critical of the government, its news website says. Three staff members including the chief editor were taken for questioning and later released.
Egyptian police on Sunday raided the offices of the government-critical Mada Masr media outlet, a day after one of its editors was arrested, the news site said.
"Plainclothes security forces have raided Mada Masr's office in Cairo. Staff are currently being held inside, and their phones have been switched off," Mada Masr wrote on Twitter shortly after the raid.
The independent news organization later tweeted that its lawyer had been denied entry to the Mada Masr office. It also said that three members of staff, including chief editor Lina Attalah, had been taken for questioning then later released.
It added that authorities confiscated laptops and phones from all the staff.
Lina Attalah, the chief editor and co-founder of Mada Masr, attended DW's Global Media Forum in 2018
Reported release
In another tweet still later on Sunday, the news outlet reported that the editor arrested a day earlier, Shady Zalat, had been released.
Zalat had been arrested at his home in the Egyptian capital by security forces. According to Mada Masr, the security officials did not show an arrest warrant before detaining him.
Human rights group Amnesty International had called for Zalat's immediate release.
Mada Masr publishes reports about corruption and security issues in a manner that is often critical of the government and has become one of hundreds of websites that have been blocked by Egyptian authorities in recent years. It can be accessed in Egypt only by using a virtual private network (VPN) connection.
More journalists are jailed in Egypt than in any country other than China and Turkey, according to the Committee to Protect Journalists, a watchdog based in New York.
Read more: Activist critical of el-Sissi 'disappeared' as Egypt faces UN human rights review
tj/sms (AP, AFP, dpa)


Home
Average Salary Title
Annual Salary Budget
Total Salary Distribution
Organization Breakdown %
Organization Breakdown
Annual Salary Budget by School
Filter By School(s)
GEORGIA INSTITUTE OF TECHNOLOGY
GEORGIA STATE UNIVERSITY
KENNESAW STATE UNIVERSITY
UNIVERSITY OF GEORGIA
GEORGIA SOUTHERN UNIVERSITY
VALDOSTA STATE UNIVERSITY


Ashbright, the strategic communications experts, brings the Bright X Creative Newsroom to Davos and Cannes, in association with Stromback, the #1 Davos networker.
The newsroom — an integrated hub comprising live streaming video, social media management, high-end video production, journalism and photography — ensures that your success at Davos or Cannes reaches hundreds of thousands of stake holders worldwide, rather than just those lucky enough to be invited to your event.
At Davos 2020, Bright X Creative Newsroom will be available to a limited number of clients from our location on Davos Promenade.
Find out moreBright X will set up a creative newsroom at Cannes Lions to meet the needs of a select number of clients.