Smarter Stickies Help
Software "sticky" notes for your computer screen that are smart enough
to stay out of your way until you need them.
You can arrange to hide a Smarter Sticky until a specific time,
the next time you start your computer, or until you go looking for it.
- Multiple "stickies" may be individually sized and positioned.
- Stickies may be hidden until needed.
- Multiple mode search function.
- Individual stickies may be set to be shown when the widget starts.
- Each sticky has an alarm that may be set to show the sticky
at a specific time and date.
- Alarms may be set to repeat - daily, weekly, monthly, or annually.
- Stickies whose alarms have expired flash their borders
and sound an audible alert.
- User chosen fonts, colors, and alarm sound.
- Keyboard shortcuts ("hot keys") assigned by user.
The Smarter Stickies pad will be on the screen whenever the widget is running
(unless it has been hidden).
If something isn't working the way you expect,
you might look in the Known Bugs section of this document.
- To create a new sticky
- Double-clicking on the pad will create a new sticky.
The new sticky will be created in edit mode and selected
so you can just start typing or pasting its content.
You can also create a new sticky by selecting New Sticky
from the Pad Context Menu
or by dropping a text selection on the pad.
If you have assigned a "New Sticky" Hotkey,
it can be used.
Finally, you can make a copy of an existing sticky by selecting
Clone Sticky from its context menu.
You should move new stickies
to avoid stacking them all on top of each other.
- To edit sticky text
- Stickies in edit mode are identified by a different border color
(defaults to a darker color)
and the resize handle
( )
in their lower right corner.
You can switch into and out of edit mode by double-clicking
on the sticky or by selecting Edit Sticky
from the Sticky Context Menu.
Editing is much the same as in most simple text editors for Windows
(such as Notepad).
Text can be manipulated by dragging and dropping selections
with the mouse at any time
and, while in edit mode, by control key combinations.
- To resize a sticky
- While in edit mode you can resize the sticky by dragging the handle
( )
at the lower right corner.
Smarter stickies automatically wrap text
and display a vertical scroll bar if necessary.
- To move a sticky
- When not in edit mode,
you can move the sticky by dragging anywhere on it
(unless the "Lock Window Positions" preference has been selected).
When in edit mode, dragging is used to select text,
but you can still move the sticky by dragging on its border.
- To set the alarm for a sticky
- Select Set Alarm from the
Sticky Context Menu
or press Ctrl-S while editing.
Alarm times can be set as dates and/or times, or as delays.
See Alarm Dialog.
- To turn off an alarm
- When a sticky's alarm time is reached,
Both the widget and the sticky will be shown (not hidden),
the sticky will be moved on top (in front) of other windows,
flash its border, and periodically sound an audible alarm.
The alarm can be turned off by double clicking on the sticky
or by selecting Stop Alarm from the
Sticky Context Menu.
- To hide a sticky
- Select Hide Sticky
from its Sticky Context Menu
or press Ctrl-D while editing it.
- To show a hidden sticky
- The Pad Context Menu
contains a search function and other
options to show and hide stickies.
Hot keys can be assigned to search and show functions.
- To hide the pad
- Select Hide Pad from the
Pad Context Menu
or select Hide Pad on Startup
in the Widget Preferences Dialog
and restart the widget.
- To show the pad
- Click on the Smarter Stickies icon in the Widget Dock
or press the Search Stickies hot key.
- To change the font or colors of a sticky
- While in edit mode, press Ctrl-K to "randomly" change colors.
For more control select Sticky Preferences
from the Sticky Context Menu.
- To set the font, colors, and size of new stickies
- Set up a sticky with the colors, fonts, and size to be used for new stickies,
then check the Set default values per this sticky box in its
Sticky Preferences dialog.
You can have new stickies randomly colored
by checking the Random colors for new stickies box.
The pad's context menu contains items
not associated with individual stickies.
It is shown when you right-click on the pad.
| Displays information about this widget and its author |
| Calls up the Widget Preferences Dialog |
Creates a new sticky of the default size, in the default position.
(Shows the current total number of stickies.) |
| Brings up the Search Stickies Dialog |
| Makes visible all stickies whose alarms are set. |
| Makes visible all stickies whose alarms are not set. |
| Makes all stickies invisible. |
| Makes the pad invisible. |
| Displays help for the Smarter Stickies widget. |
| Hides the pad and all stickies. (see strangeness) |
| Stops processing for the widget. |
A sticky's context menu contains items
associated with that particular sticky
(plus items supplied by the Yahoo Widget Engine).
It is shown when you right-click on the sticky.
| Displays information about this widget and its author |
| Calls up the Widget Preferences Dialog |
| Calls up the Sticky Preferences Dialog |
| Prints the sticky (see strangeness) |
| Creates a copy of the sticky. |
| Toggles edit mode on and off. |
Displays the Alarm Dialog
for this sticky.
(Appears only if alarm is not set.) |
Displays the Alarm Dialog
for this sticky.
(Appears only if alarm is set but not active.) |
Turns off and unsets alarm.
(Appears only if alarm is active.) |
| Makes this sticky invisible. |
| Makes this sticky visible whenever the widget is started
or following a suspension or hibernation. |
| Discards this sticky. |
| Displays help for the Smarter Stickies widget. |
| Hides the pad and all stickies. (see strangeness) |
| Exits the widget. |
Several of the items in the Sticky Context Menu are disabled when
the alarm is active or when the Alarm Dialog is open.
The Alarm Dialog allows you to set, change,
or unset the alarm time for a sticky.
It appears when you select it from the sticky's context menu
or when you press Ctrl-S while editing a sticky.
Alarms can be set as dates and/or times
or as delays from the present time.
There are three buttons below the entry field.
- Unset cancels the alarm and dismisses the dialog.
- Clear just clears the entry field.
-
Enter acts exactly like the Enter key:
If your input can be interpreted as a future time,
the alarm is set to that time and the dialog box is dismissed.
Otherwise the system beep is sounded
and the entry field is left unchanged for you to edit.
- Entering a time and date
-
Either the time or the date, or both, may be specified.
Their order in the input doesn't matter
but neither specification may contain spaces.
If both time and date are specified,
the specifications must be separated
(normally by a space).
- To enter a time
-
Times may be entered in either 12 or 24 hour formats.
The 24 hour format ("military" time) is the default.
12 hour format is selected by including an "am" or "pm"
anywhere in the input.
Midnight (0:00:00 or 12AM) is part of the day just starting.
Times are specified as
h:mm:ss or h:mm or even just h
where:
- h is an hour from 0 to 23 or,
if am or pm is entered,
from 1 to 12
- mm is a minute from 00 to 59
(2 digits must be used)
- ss is a second from 00 to 59
(2 digits must be used)
- Colons (:) are used to separate
hours from minutes and minutes from seconds.
If you do not specify a time,
then 0:00:00 (midnight) is used.
- examples:
-
18:00:00
18:00
18
6:00 PM
6pm
pM6 (strange-looking but allowed)
All the above refer to the same time.
- To enter a date
-
Dates can be specified as m/d/y or m/d,
where:
- m is a month from 1 (Jan) to 12 (Dec)
- d is the day of the month from 1 to 31
- y is a year
- Slashes (/) are used to separate
months from days and days from years.
If y is less than 1000,
the year is understood to be 2000 plus y.
If the year is not specified,
the current year is used
unless that date (and time) is already past,
in which case the next year is used.
If no date is specified,
the current date is used
unless the time specified is already past,
in which case the next day is used.
If both a date and time are specified they must be separated
(normally by one or more spaces).
- examples:
-
5/1/2007 0:01:00
5/1/7 12:01 AM
0:01 5/1
5/1Am12:01 (strange but allowed)
All of these refer to one minute past midnight May 1st
(the night of April 30th). The first two are no longer valid
because they refer to a date in the past.
The other two refer to the May 1st coming next.
- Entering a repeating alarm
-
Alarms may be arranged to repeat
(automatically reset themselves to a new date when acknowledged).
You can set an alarm to go off every day,
on specified days of the week,
on the same day or date every month,
or on the same day or date every year.
Repeating alarms are specified as a modified date
and, like dates, can be combined with times in 12 or 24 hour formats.
An asterisk (*) is used to specify repeating alarms.
- Every Day
-
The simplest repeating alarm to specify:
just replace the date with a single asterisk
examples:
| * |
every day at midnight |
| * 6:00 |
every day at 6:00 AM |
| 8pm* |
every day at 8:00 PM |
There must be a space (or at least an "am" or "pm")
between the asterisk and any time specification.
- Every Week on Specific Days of the Week
-
An asterisk followed by numbers corresponding to
the days of the week on which the alarm should go off.
0=Sunday, 1=Monday, 2=Tuesday, ... 6=Saturday
examples:
| *0 |
every Sunday at midnight |
| 10pm *6 |
10:00 PM every Saturday |
| *12345 6 |
every weekday at 6:00 (AM) |
There must be NO spaces between the asterisk and
the numbers representing the days of the week.
- Every Month on a Specific Day
-
Specifying a date in this way will allow you to set an alarm for
days of the month like the second Tuesday or the last Sunday.
The form of the specification is n*d where:
- n is a week number from 1 to 5
- d is a day of the week from 0 (Sunday) to 6 (Saturday)
Week number 5 is special in that it refers to the last occurrence
of a day in a month even if there are only 4 occurrences.
examples:
| 1*0 |
First Sunday (at midnight) |
| 12 pm 5*6 |
Noon on last Saturday |
| 2*3 10:30 |
Every second Wednesday at 10:30 (AM) |
- Every Month on a Specific Date
-
To set an alarm to go off on the same date of every month
the form of the specification is */dd where:
- dd is the day of the month (from 1 to 31)
examples:
| */1 |
the 1st of every month (at midnight) |
| 10pm */16 |
10:00 PM on the 16th of every month |
| */31 |
The 31st of every month that has a 31st.
(Skips other months.) |
- Every Year on a Specific Day
-
Allows setting repeating alarms for days like
the second Friday in March or the last Sunday in June.
The form of the specification is m/n*d where:
- m is a month from 1 to 12
- n is a week number from 1 to 5
- d is a day of the week from 0 (Sunday) to 6 (Saturday)
Week number 5 is special in that it refers to the last occurrence
of a day in a month even if there are only 4 occurrences.
examples:
| 12/1*0 |
First Sunday in December (at midnight) |
| 12 pm 8/5*6 |
Noon on last Saturday in August |
| 1/2*3 10:30 |
The second Wednesday in January at 10:30 (AM) |
- Every Year on a Specific Date
-
To set an alarm to go off on the same date every year
the form is m/d/* where:
- m is a month from 1 to 12
- d is the day of the month from 1 to 31
examples:
| 4/15/* |
April 15th at midnight |
| 9pm 7/4/* |
9:00 PM on the 4th of July |
- Entering a delay
-
You may enter the alarm time as a delay
or interval from the present time.
The interval may be expressed as any number of days,
hours, minutes, or seconds, and combinations of them.
The format is Wd Xh Ym Zs where:
- W is the number of days
- X is the number of hours
- Y is the number of minutes
- Z is the number of seconds
Any of the elements (number+letter) may be missing,
but the order of the remaining elements must be as shown.
No spaces are allowed between a number and its associated letter.
examples:
| 14d |
two weeks from now |
| 2h 30m |
2½ hours from now |
| 1h 1800s |
2½ hours from now |
| 1h 30m 3600s |
2½ hours from now |
| 0d2h29m60s |
2½ hours from now |
NOTE: The alarm set may differ by an hour from your expectation
if the delay interval spans a Daylight Savings Time change.
You can check how your input will be interpreted
before setting the alarm by pressing the tab key.
Pressing tab will replace your input text with
the interpreted time and date.
If your input cannot be interpreted,
or if the result is in the past, the field will be blank.
If the resulting date is what you wanted,
you can then just enter it.
Otherwise, pressing tab a second time
will restore your original input.
The Search dialog enables you to enter a search term,
search through the text of all stickies,
and show or hide individual stickies
depending on whether or not the search found a match
in that sticky.
Select Search Stickies from
the Pad Context Menu
to display the Search Dialog.
- Enter search term: enter
the text or a pattern to be found.
If you enter nothing, all stickies will match.
If you enter a single space, all stickies containing
any spaces will match.
- Ignore case If checked, the case
of alphabetic characters will be ignored.
For example, the search term "cat" will find "Cat"
(as well as "cat", "cAT", etc.)
- Use regular expressions If checked,
the search term will be taken as a regular expression.
Do not enclose it in the usual slashes ("/").
For instance, to find all notes containing either
"cat" or "dog", you could use "(cat|dog)".
Regular expressions are well beyond
the scope of this help document
but
an Internet search should turn up many tutorials and references.
The search function uses JavaScript regular expressions
as implemented by the Yahoo Widget Engine.
- Mode: selects the action to perform
(show or hide) and the stickies
(those with or without the search term)
on which to perform it.
In the Sticky Preferences Dialog you can set attributes
(such as color and font)
particular to individual stickies.
Select Sticky Preferences from
the Sticky Context Menu
to display the Stickies Preferences Dialog.
- Text Color - the color of the letters and other characters
- Sticky Color - the background color of the sticky
- Border Color - the normal color of the edges of the sticky
- Active Color - the color of the edges of the sticky
when the sticky is in edit mode
Also used to attract attention when an alarm goes off
by alternating with the normal border color.
- Typeface - the font (Arial, Times New Roman, ...)
and its style (bold, italic, ...)
- Text Size - the size of the text in points.
Only positive whole numbers are accepted.
- Set default values per this sticky
The default values are used when new stickies are created.
If this checkbox is checked when the dialog is saved,
the initial colors, typeface, type size, position and size
for new stickies will be set
from those of the current sticky.
- Random colors for new stickies
When this box is checked, new stickies will be created with
a randomly selected hue for the background and border colors,
The text color will be set to black.
The Smarter Stickies Widget Preferences Dialog
contains controls used to set options
not associated with individual stickies.
Select Widget Preferences from
either the Pad Context Menu
or the Sticky Context Menu
to display the Widget Preferences Dialog.
Clicking the gear button on the Smarter Stickies dock icon
will also display it.
General tab
- Sticky Folder - The location where sticky files are stored.
These are XML encoded files, not meant to be edited.
When this preference is changed,
existing files are moved to the new location.
Leaving this preference blank causes sticky files to be stored
in the default folder created by the Yahoo Widget Engine.
- Alarm Sound - The sound to be played periodically
when the alarm goes off. The control initially offers
a choice of several sounds provided with the widget,
but you can browse elsewhere to
select any suitable sound file.
- Pad Color - the color of the Smarter Stickies Pad,
unless the following option is set.
- Set pad color to default sticky color
- Hide pad on startup - If this checkbox is selected,
the pad will be hidden when the widget starts.
To show the pad: right-click on
the Yahoo Widget Engine icon in the system tray
and select Smarter Stickies from the menu.
- Values - Selects the values to be changed
by the following options.
- Set defaults to original values
If this checkbox is selected when save is pressed,
the new sticky default values
selected by the Values option above,
will be set to the original ("factory") settings.

- Set visible stickies to default values
If this checkbox is selected when save is pressed,
the new sticky default values
selected by the Values option above,
will be applied to all visible stickies.
This option is applied after
Set defaults to original values,
so if they are both checked, all visible stickies
will be set to whatever factory values are selected.
Hot keys are the Yahoo Widget Engine implementation of keyboard shortcuts,
a combination of keys assigned to trigger an action.
They are implemented at the system level,
meaning that they will perform their actions
whenever the Smarter Stickies widget is running,
even when another widget (or application) is active.
To avoid breaking the functionality of other applications,
you must take care to avoid assigning key combinations
already in use.
The following keys may be used:
UpArrow, DownArrow, LeftArrow, RightArrow, F1 through F16,
Insert, Delete, Home, End, PageUp, PageDown,
PrintScreen, ScrollLock, Pause, Enter, Return, Backspace,
Space, Tab, and Escape.
At least one modifier is required which is Control by default.
The other possible modifiers are Shift and Alt.
Any letter or punctuation key may be used for a hot key
but then at least two modifiers must be specified.
Hot keys can be assigned to the following actions:
- New Sticky - Creates a new sticky.
- Search Stickies - Opens the Search Dialog.
- Hide/Show All Stickies -
If any stickies are visible (other than stickies whose alarms are active)
this hotkey will hide them,
otherwise it will show all stickies.
- Delete Sticky - Deletes the currently selected sticky (if any),
otherwise sounds the system beep.
Stickies are selected when they are created, clicked on,
or their alarms sound.
They generally remain selected until something else is clicked on.
Pressing any of the hot keys
(with the exception of Delete Sticky)
will cause the widget to be shown (un-hidden).
Window tab
The Window tab is furnished by the Yahoo Widget Engine
and is common to most widgets.
- Window Level - (default is Normal)
Normal, Keep on Top, and Keep Below all seem to work correctly.
A sticky whose alarm has gone off will be moved to the top
and will return to its assigned level when the alarm is turned off.
- Ignore Mouse - (default is unchecked)
Works just as advertised
but controlling Smarter Stickies with just the keyboard
is not yet feasible.
- Prevent Dragging - (default is unchecked)
You will still be able to drag stickies
by their borders when in edit mode.
- Opacity - (default is 100%)
The pad and all stickies share the same value.
Control keys, unlike hot keys, are not assignable
and are active only when the text cursor
(a blinking vertical bar or selected text) is shown in a sticky.
Here's a list of all the control keys enabled in Smarter Stickies:
| Ctrl-S |
Brings up the Set Alarm Dialog for this sticky. |
| Ctrl-D |
Exit edit mode on this sticky and hide it. |
| Ctrl-N |
Exit edit mode on this sticky and start editing
the next visible (shown) sticky. |
|
(will not select stickies with active alarms.) |
| Ctrl-P |
Prints the sticky (see strangeness) |
| Ctrl-K |
Change sticky colors to a randomly selected hue
for the background and borders and black text. |
| Ctrl-A |
Select all text. (Has a bug.) |
| Ctrl-C |
Copy selection to clipboard. |
| Ctrl-X |
Cut selection to clipboard. |
| Ctrl-V |
Paste clipboard contents to text cursor or selection |
| Ctrl-Z |
Undo last edit (multiple undo's permitted). |
| Ctrl-Y |
Re-do last undo (multiple re-do's permitted). |
|
(Edit history is lost when widget is restarted.) |
| Ctrl-E |
Center line. |
| Ctrl-L |
Left justify line. |
| Ctrl-R |
Right justify line. |
|
(Centering and right justification cannot be saved
- All lines revert to left justified when widget is started.) |
Additionally, all the cursor control keys ( arrows, Home, End, Page Up & Dn)
work as expected
and the Insert key will toggle between insert and overwrite modes.
- Printing strangeness
-
There is no support for printing in the Widget Engine.
Printing is accomplished by creating a temporary text file (named "Sticky")
and handing it off to Windows Notepad to print on the default printer.
This method causes the notepad application to briefly appear
whenever a sticky is printed.
No font or color information is passed to Notepad.
The text of the sticky is printed in Notepad's default font and format.
By default, Notepad prints the filename (Sticky) at the top
and the page number at the bottom of each page it prints.
These defaults (and others) can be changed in Notepad's "Page Setup" dialog.
Cut & Paste
-
When editing sticky text,
the sequence "Ctrl-A, Ctrl-C, Ctrl-V"
appends an extra newline.
It should have no effect
(other than moving the cursor to the end of the text).
Seems to only be a problem when both the source and destination
are widgets.
Hide Widget strangeness
-
The new Hide Widget item (furnished by the Widget Engine)
in the context menus of the pad, individual stickies,
and the dock icon (and the button in the dock icon)
hide the widget as a whole -
different from hiding the pad and individual stickies.
When an alarm goes off or a hot key is pressed,
the widget (as a whole) must be un-hidden
in order to allow whatever needs to be seen to be visible.
To avoid confusion, you might avoid using Hide Widget.
Heads Up Display - fixed in Widget Engine version 4.0.2
-
In general, only widgets that you have hidden (with "Hide Widget")
appear in the Heads Up Display.
Others may sometimes be visible, but when you click on them they dissappear.
Strangely, if you have hidden the sticky pad,
then any non-hidden stickies will appear.
Hot Keys - fixed in Widget Engine version 4.0.2
-
When any preference dialog containing hot keys is opened,
any unassigned hot keys are shown as "2" rather than "None".
For the Smarter Stickies widget, this is a minor bug
because "2" will not be accepted as an assignment.
Support is available at the
Smarter Stickies page in the Yahoo Widget Gallery.
Before posting a question or problem report,
please review the existing entries
to see if your problem has already been addressed.
- To recover a deleted sticky
-
- Close the Smarter Stickies widget
- ideally before creating any new stickies.
- Restore the deleted sticky
- from the Recycle Bin
- Restart the Smarter Stickies widget
By default, stickies are stored as files in the Smarter Stickies data folder
(a location determined by The Yahoo Widget Engine).
For version 3.14 of the engine it is located at:
"C:\Documents and Settings\[user]\Local Settings\Application Data\Yahoo\Widget Engine\Widget Data\Smarter_Stickies".
If you have set the Sticky Folder preference,
the sticky files are stored in the directory you specified.
The sticky files are named sticky(#).xml where # is a number.
If you've created any new stickies after deleting the sticky to be recovered, there may be a name conflict since the numbers are reused.
In this case just rename the new sticky
(by changing the number)
before restoring the deleted sticky.
To recover a lost sticky
-
Prior to Smarter Stickies version 1.2,
stickies could be lost far off-screen due to resolution changes.
(Version 1.1 contained a patch to place them back on screen.)
While the problem has been corrected in version 1.2,
it is still possible to move stickies so that they are very difficult
to see. Accordingly, here is a method (thanks to Sherm)
to recover those stickies (in Windows).
- Ensure that the sticky you wish to recover is not hidden
- by selecting Show Alarmed or Show Unalarmed or both.
- Open the Application tab of the Windows Task Manager
- There will be a "Yahoo!Widgets-Smarter_Stickies"
entry for the pad (if it is not hidden)
and for each not-hidden sticky.
- Right click on each Smarter Stickies entry and select Maximize
- the corresponding item (pad or sticky) will be moved
to the upper left corner of the screen.
To uninstall the Smarter Stickies widget
-
- Close the Smarter Stickies widget
- Delete the Smarter_Stickies.widget file
These first two steps can be accomplished by selecting Delete Widget
from the Smarter Stickies dock icon context menu.
The following steps are optional.
- Delete the Smarter Stickies data folder
- (See "To recover a deleted sticky" for location)
- Delete the Stickies Folder
- (if you have set that preference)
- Delete the Smarter Stickies preferences
- in HKEY_CURRENT_USER|Software|Yahoo|WidgetEngine|Widgets


slice = Array::slice
Look what you make me do Javascript
slice = Array::slice
DOM simplifier (no jQuery dependency) NodeJS compatible
$ = (sel, root = document) ->
return sel if typeof sel is "object" or exports?
root.querySelector sel
class Util
Unique value utility
@uniqid = do ->
id = 0
get: -> id++
Helper function that extends one object with all the properies of other objects
@extend = (obj, src...) ->
dest = obj
for copy in src
for own prop of copy
dest[prop] = copy[prop]
return dest
In order to stay true to the latest spec, RGB values must be clamped between 0 and 255. If we don't do this, weird things happen.
@clampRGB = (val) ->
return 0 if val < 0
return 255 if val > 255
return val
@copyAttributes: (from, to, opts={}) ->
for attr in from.attributes
continue if opts.except? and attr.nodeName in opts.except
to.setAttribute(attr.nodeName, attr.nodeValue)
Support for browsers that don't know Uint8Array (such as IE9)
@dataArray: (length = 0) ->
return new Uint8Array(length) if Caman.NodeJS or window.Uint8Array?
return new Array(length)


clock_alarm_reply
Function - Ring a preset alarm.
SYNOPSIS
kern_return_t clock_alarm_reply (reply_port_t alarm_reply_port, kern_return_t reply_code, alarm_type_t alarm_type, tvalspec_t wake_time);
PARAMETERS
- alarm_reply_port
-
[in alarm (receive) right]
The reply port named in the corresponding
clock_alarm call.
- reply_code
-
[in scalar]
The reply status code from the alarm. The possible values
are:
- KERN_SUCCESS
-
The alarm was delivered without problem.
- KERN_INVALID_VALUE
-
The alarm_type and/or alarm_time values supplied to
clock_alarm were invalid.
- KERN_INVALID_LEDGER
-
The ledger supplied to clock_alarm was not a ledger.
- KERN_ABORTED
- The alarm was terminated via use of clock_set_time.
- alarm_type
-
[in scalar]
The alarm type value supplied to the clock_alarm call.
Only the low order bits of this value are used by the kernel so the high
order bits are available for application use as an alarm identifier.
- wake_time
- [in structure] The time when the alarm message was sent.
DESCRIPTION
A clock_alarm_reply function is called as the result of a message from the kernel indicating that a previously requested alarm time (clock_alarm) has arrived.
RETURN VALUES
Only generic errors apply.
RELATED INFORMATION
Functions: host_get_clock_service, clock_get_attributes, clock_get_time, clock_sleep, clock_alarm, clock_reply_server, clock_set_time.
Data Structures: tvalspec.


Recorded Talks
The talks below were live streamed on June 20, 2021.
--- ---
{% include head.html %} {% include head/custom.html %} {% include_cached skip-links.html %} {% include_cached browser-upgrade.html %} {% include_cached masthead.html %}Computational photography has become an increasingly active area of research within the computer vision community. Within the few last years, the amount of research has grown tremendously with dozens of published papers per year in a variety of vision, optics, and graphics venues. A similar trend can be seen in the emerging field of computational displays – spurred by the widespread availability of precise optical and material fabrication technologies, the research community has begun to investigate the joint design of display optics and computational processing. Such displays are not only designed for human observers but also for computer vision applications, providing high-dimensional structured illumination that varies in space, time, angle, and the color spectrum. This workshop is designed to unite the computational camera and display communities in that it considers to what degree concepts from computational cameras can inform the design of emerging computational displays and vice versa, both focused on applications in computer vision.
The CCD workshop series serves as an annual gathering place for researchers and practitioners who design, build, and use computational cameras, displays, and projector-camera systems for a wide variety of uses. The workshop solicits papers, posters, and demo submissions on all topics relating to projector-camera systems.
Previous CCD Workshops:
CCD2020,
CCD2019,
CCD2018,
CCD2017,
CCD2016,
CCD2015,
CCD2014,
CCD2013,
CCD2012
The talks below were live streamed on June 20, 2021.
| Time (CDT) | Description | Speaker |
| 8:45 - 9:00 | Welcome / Opening Remarks | Organizers |
| 9:00 - 9:40 | Keynote 1 (35 minutes + 5 minutes Q&A) | Antonio Torralba |
| 9:40 - 10:20 | Spotlight presentations (2 minutes for each of 20 posters) | |
| 10:20 - 11:00 | Keynote 2 (35 minutes + 5 minutes Q&A) | Noah Snavely |
| 11:00 - 11:10 | Morning Break | |
| 11:10 - 11:50 | Keynote 3 (35 minutes + 5 minutes Q&A) | Anat Levin |
| 11:50 - 12:10 | Invited Talk (28 minutes + 2 minutes Q&A each) | Qi Guo |
| 12:10 - 12:30 | Young Faculty Keynote (18 minutes + 2 minutes Q&A each) | Ayush Bhandari |
| 12:30 - 13:30 | Lunch Break | |
| 13:30 - 14:10 | Keynote 4 (35 minutes + 5 minutes Q&A) | Kostas Daniilidis |
| 14:10 - 15:10 | Invited Talks (3 invited talks, 18 minutes + 2 minutes Q&A each) | Regina Eckert Vivek Boominathan Sheila Seidel |
| 15:10 - 16:40 | Poster and Demo Session | |
| 16:40 - 17:20 | Keynote 5 (35 minutes + 5 minutes Q&A) | Paul Debevec |
| 17:20 - 17:30 | Closing Remarks | Organizers |
| Alexander | Emma | UC Berkeley |
| Bhandari | Ayush | Imperial College of London |
| Bouman | Katherine (Katie) | California Institute of Technology |
| Chakrabarti | Ayan | Google, Washington University in St. Louis |
| Chari | Pradyumna | UCLA |
| Davis | Abe | Cornell University |
| Dekel | Tali | Weizmann Institute of Science, Google |
| Gao | Angela | California Institute of Technology |
| Heide | Felix | Princeton University |
| Horstmeyer | Roarke | Duke University |
| Hullin | Matthias | Uni Bonn |
| Jarabo | Adrián | Universidad de Zaragoza |
| Jayasuriya | Suren | Arizona State University |
| Kadambi | Achuta | UCLA |
| Levis | Aviad | California Institute of Technology |
| Lindell | David | Stanford University |
| Masia | Belen | Universidad de Zaragoza |
| Monakhova | Kristina | University of California, Berkeley |
| Nagahara | Hajime | Osaka University |
| O'Toole | Matthew | Carnegie Mellon University |
| Rajagopalan | A.N. | IIT Madras |
| Ramalingam | Srikumar | University of Utah |
| Sato | Imari | National Institute of Informatics |
| Serrano | Ana | Centro Universitario de la Defensa de Zaragoza |
| Shocher | Assaf | Weizmann Institute of Science |
| Sorkine-Hornung | Alexander | |
| Sun | He | California Institute of Technology |
| Tanaka | Kenichiro | Ritsumeikan University |
| Treibitz | Tali | University of Haifa |
| Velten | Andreas | University of Wisconsin-Madison |
The call for poster and spotlight submissions is now open. The deadline for submissions is June 7th, 2021. Presenting a virtual poster at CCD gives an opportunity to showcase previously published or yet-to-be-published work to a larger community at CVPR.
Submissions should include a PDF with 1-2 paragraphs (at most 1 page) describing the proposed poster, relevant figures, as well as author names and affiliations (an optional latex template can be downloaded here). We also encourage authors to submit a 2 minute video (.mp4 format) summarizing their work to be shown as a spotlight during the livestream if selected. Note that submitted abstracts do not appear in any proceedings.
Poster and spotlight submissions should be submitted via this form by June 7st, 2021. Decisions will be made by June 11th, 2021. Please direct any questions to<EMAIL_ADDRESS>The CCD workshop is part of the CVPR 2020 workshops. Please see the CVPR webpage for information.


The Boost C++ Libraries
This book is licensed under a Creative Commons License.
Strings in the C++ standard are handled by the std::string
class which offers many functions for manipulating them. Among these are functions searching a string for a specific character or functions returning a substring. Even though std::string
provides more than 100 functions, which makes it one of the more bloated classes of the C++ standard, many developers still miss additional functionality throughout their daily routine. For example, while Java and .NET provide functions to convert a string to uppercase, there is no equivalent available in std::string
. The Boost C++ Libraries presented in this chapter try to close this gap.
Before the Boost C++ Libraries are introduced though, one should at least take a brief look at locales. Many functions outlined in this chapter will expect a locale as an additional parameter.
Locales are used in the C++ standard to encapsulate cultural conventions such as the currency symbol, date and time formats, the symbol used to separate the integer portion of a number from the fractional one (radix character) as well as the symbol used for grouping numbers with more than three digits (thousands separator).
In terms of string handling, the locale is relevant for describing the order and the individual letters used in the particular culture. For instance, whether an alphabet contains mutated vowels and what place they take in the alphabet depends on the culture.
If a function is called that converts a given string to uppercase, the individual steps taken depend on the particular locale. In the German language, it is obvious that the letter 'ä' is converted to 'Ä'; however, this does not necessarily hold true for other cultures as well.
When working with std::string
, the usage of locales can be neglected since none of the functions is dependent on a particular culture. In order to work with the Boost C++ Libraries in this chapter though, this knowledge is mandatory.
The C++ standard defines a class named std::locale
in locale
. Every C++ program automatically has one instance of this class - the global locale which cannot be directly accessed. Instead, a separate object of std::locale
must be created via the default constructor that will be initialized with the same properties as the global locale.
#include <locale> #include <iostream> int main() { std::locale loc; std::cout << loc.name() << std::endl; }
The above program will output C
on the standard output stream which is the name of the classic locale. This locale contains descriptions used by default in programs developed with the C language.
This also happens to be the default global locale for every C++ application. It contains descriptions used by the American culture. For example, the dollar sign is used as the currency symbol, the radix character is a period, and displaying a date causes the month to be written in English.
The global locale can be changed using the static function global()
of the std::locale
class.
#include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::locale loc; std::cout << loc.name() << std::endl; }
The static global()
function expects a new object of type std::locale
as its sole parameter. Using a different constructor of the class, expecting a character string of type const char*
, a locale object for a particular culture can be created. However, names of locales are not standardized except for the C locale which is named "C" correspondingly. It therefore depends on the individual C++ standard library which names are actually accepted. In case of Visual Studio 2008, the definitions for the German culture can be selected using the language string "German" as outlined in the documentation of language strings.
The program will output German_Germany.1252
if executed. Specifying "German" as the language string selects the definitions for the German primary language and sublanguage as well as the character map 1252.
In case the sublanguage should be set to a different location of the German culture such as the Swiss, a different language string can be used.
#include <locale> #include <iostream> int main() { std::locale::global(std::locale("German_Switzerland")); std::locale loc; std::cout << loc.name() << std::endl; }
Now, the program will output German_Switzerland.1252
instead.
After getting an understanding about locales in general and how the global one can be changed, the following example shows how locales affect string handling.
#include <locale> #include <iostream> #include <cstring> int main() { std::cout << std::strcoll("ä", "z") << std::endl; std::locale::global(std::locale("German")); std::cout << std::strcoll("ä", "z") << std::endl; }
The example uses the std::strcoll()
function defined in cstring
to compare whether the first string is lexicographically less than the second one. In other words, which of the two strings would be found first in a dictionary.
If executed, the result is both 1
and -1
. Even though the function is called with the same input parameters, the results are different. The reason is quite simple - while calling std::strcoll()
the first time, the global C locale is used. However, when called the second time, the global locale has been changed to incorporate definitions for the German culture instead. The order of the two characters 'ä' and 'z' is different for these locales as indicated by the output.
Numerous C functions as well as C++ streams access locales. Albeit functions of the std::string
class work independently from locales, many of the functions outlined in the following paragraphs do not. Hence, locales are met again several times throughout this chapter.
The Boost C++ library Boost.StringAlgorithms provides many stand-alone functions for string manipulation. Strings can be of type std::string
, std::wstring
or any different instance of the template class std::basic_string
.
The functions are categorized within different header files. For example, functions converting from uppercase to lowercase are defined in boost/algorithm/string/case_conv.hpp
. Since Boost.StringAlgorithms consists of more than 20 different categories and as many header files, boost/algorithm/string.hpp
acts as the common header including all other header files for convenience. All of the following examples will use this combined header.
As mentioned in the previous paragraph, many functions of the Boost.StringAlgorithms library expect an object of type std::locale
as an additional parameter. However, this parameter is optional - if not provided, the default global locale is used.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> #include <clocale> int main() { std::setlocale(LC_ALL, "German"); std::string s = "Boris Schäling"; std::cout << boost::algorithm::to_upper_copy(s) << std::endl; std::cout << boost::algorithm::to_upper_copy(s, std::locale("German")) << std::endl; }
The boost::algorithm::to_upper_copy()
function is used to convert a string to uppercase. Naturally, there also exists a function doing the opposite: boost::algorithm::to_lower_copy()
converts a string to lowercase. Both functions return the converted string as result. If the passed string itself should be converted, the functions boost::algorithm::to_upper()
or boost::algorithm::to_lower()
can be used instead.
The above example converts the string "Boris Schäling" to uppercase using boost::algorithm::to_upper_copy()
. The first call uses the default global locale while the second call explicitly states the locale for the German culture.
Using the latter certainly will result in a correctly converted string since the corresponding uppercase character 'Ä' exists for the lowercase 'ä'. For the C locale instead, 'ä' is an unknown character and thus is not converted. To yield correct results, either pass the correct locale explicitly or modify the global locale before calling boost::algorithm::to_upper_copy()
.
Note, that the program uses std::setlocale()
- defined in clocale
- to set the locale for any C function. Internally, std::cout uses C functions to display information on the screen. By setting the correct locale, mutated vowels such as 'ä' and 'Ä' are displayed correctly.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; std::cout << boost::algorithm::to_upper_copy(s) << std::endl; std::cout << boost::algorithm::to_upper_copy(s, std::locale("German")) << std::endl; }
The above program sets the German culture for the global locale which causes the first call to boost::algorithm::to_upper_copy()
to use the corresponding definitions for converting 'ä' to 'Ä'.
Please note that the std::setlocale()
is not called in this example. By setting the global locale using the std::locale::global()
function, the C locale is automatically set as well. In practice, C++ programs almost always set the global locale using std::locale::global()
rather than using std::setlocale()
as seen in the previous example.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; std::cout << boost::algorithm::erase_first_copy(s, "i") << std::endl; std::cout << boost::algorithm::erase_nth_copy(s, "i", 0) << std::endl; std::cout << boost::algorithm::erase_last_copy(s, "i") << std::endl; std::cout << boost::algorithm::erase_all_copy(s, "i") << std::endl; std::cout << boost::algorithm::erase_head_copy(s, 5) << std::endl; std::cout << boost::algorithm::erase_tail_copy(s, 8) << std::endl; }
Boost.StringAlgorithms provides several functions to delete individual characters from a string. How and where the deletion should occur can be explicitly specified. For example, a particular character can be removed from the complete string by using boost::algorithm::erase_all_copy()
. If only the first occurrence of the character should be removed, boost::algorithm::erase_first_copy()
ought to be used instead. To shorten the string by a specific number of characters on either end, the functions boost::algorithm::erase_head_copy()
and boost::algorithm::erase_tail_copy()
can be used accordingly.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::iterator_range<std::string::iterator> r = boost::algorithm::find_first(s, "Boris"); std::cout << r << std::endl; r = boost::algorithm::find_first(s, "xyz"); std::cout << r << std::endl; }
Different functions such as boost::algorithm::find_first()
, boost::algorithm::find_last()
, boost::algorithm::find_nth()
, boost::algorithm::find_head()
and boost::algorithm::find_tail()
are available to find strings within strings.
All of these functions have in common that they return a pair of iterators of type boost::iterator_range
. This class originates from the Boost C++ Library Boost.Range which defines a range concept based on the iterator concept. Since the <<
operator is overloaded for boost::iterator_range
, the result of the individual search algorithm can be directly written to the standard output stream. The above program prints Boris
for the first result and an empty string for the second one.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> #include <vector> int main() { std::locale::global(std::locale("German")); std::vector<std::string> v; v.push_back("Boris"); v.push_back("Schäling"); std::cout << boost::algorithm::join(v, " ") << std::endl; }
A container of strings is passed as the first parameter to the boost::algorithm::join()
function which concatenates them separated by the second parameter. The example will output Boris Schäling
accordingly.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; std::cout << boost::algorithm::replace_first_copy(s, "B", "D") << std::endl; std::cout << boost::algorithm::replace_nth_copy(s, "B", 0, "D") << std::endl; std::cout << boost::algorithm::replace_last_copy(s, "B", "D") << std::endl; std::cout << boost::algorithm::replace_all_copy(s, "B", "D") << std::endl; std::cout << boost::algorithm::replace_head_copy(s, 5, "Doris") << std::endl; std::cout << boost::algorithm::replace_tail_copy(s, 8, "Becker") << std::endl; }
Just like functions for searching strings or removing characters from a string, Boost.StringAlgorithms also provides functions for replacing a substring within a string. Among these functions are boost::algorithm::replace_first_copy()
, boost::algorithm::replace_nth_copy()
, boost::algorithm::replace_last_copy()
, boost::algorithm::replace_all_copy()
, boost::algorithm::replace_head_copy()
and boost::algorithm::replace_tail_copy()
. They can be applied the same way as the functions used for searching and removing except that they expect an additional parameter - the replacement string.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "\t Boris Schäling \t"; std::cout << "." << boost::algorithm::trim_left_copy(s) << "." << std::endl; std::cout << "." <<boost::algorithm::trim_right_copy(s) << "." << std::endl; std::cout << "." <<boost::algorithm::trim_copy(s) << "." << std::endl; }
In order to automatically remove spaces on either end of a string, boost::algorithm::trim_left_copy()
, boost::algorithm::trim_right_copy()
and boost::algorithm::trim_copy()
can be used. Which character counts as a space is dependent on the given global locale.
Boost.StringAlgorithms allows to provide a predicate as an additional parameter for different functions that determines to which characters of the string the function is applied to. The predicated versions for trimming a string are named boost::algorithm::trim_left_copy_if()
, boost::algorithm::trim_right_copy_if()
and boost::algorithm::trim_copy_if()
accordingly.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "--Boris Schäling--"; std::cout << "." << boost::algorithm::trim_left_copy_if(s, boost::algorithm::is_any_of("-")) << "." << std::endl; std::cout << "." <<boost::algorithm::trim_right_copy_if(s, boost::algorithm::is_any_of("-")) << "." << std::endl; std::cout << "." <<boost::algorithm::trim_copy_if(s, boost::algorithm::is_any_of("-")) << "." << std::endl; }
The program in the above example accesses another function named boost::algorithm::is_any_of()
which is a helper function for creating a predicate verifying whether or not the character - passed as the parameter - exists in a given string. Using boost::algorithm::is_any_of()
, the character for trimming a string can be specified as has been done in the example which uses the hyphen.
Boost.StringAlgorithms already provides numerous helper functions returning commonly used predicates.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "123456789Boris Schäling123456789"; std::cout << "." << boost::algorithm::trim_left_copy_if(s, boost::algorithm::is_digit()) << "." << std::endl; std::cout << "." <<boost::algorithm::trim_right_copy_if(s, boost::algorithm::is_digit()) << "." << std::endl; std::cout << "." <<boost::algorithm::trim_copy_if(s, boost::algorithm::is_digit()) << "." << std::endl; }
The predicate returned by boost::algorithm::is_digit()
indicates a numeric character by returning the boolean value true
. Helper functions are also provided to check whether or not a character is uppercase or lowercase: boost::algorithm::is_upper()
and boost::algorithm::is_lower()
respectively. All of these functions use the global locale by default unless otherwise specified by passing a different locale as a parameter.
Besides the predicates that verify individual characters of a string, Boost.StringAlgorithms also offers functions that work with strings instead.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; std::cout << boost::algorithm::starts_with(s, "Boris") << std::endl; std::cout << boost::algorithm::ends_with(s, "Schäling") << std::endl; std::cout << boost::algorithm::contains(s, "is") << std::endl; std::cout << boost::algorithm::lexicographical_compare(s, "Boris") << std::endl; }
The functions boost::algorithm::starts_with()
, boost::algorithm::ends_with()
, boost::algorithm::contains()
and boost::algorithm::lexicographical_compare()
all compare two individual strings.
The following shows a function that allows to split a string into smaller parts.
#include <boost/algorithm/string.hpp> #include <locale> #include <iostream> #include <vector> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; std::vector<std::string> v; boost::algorithm::split(v, s, boost::algorithm::is_space()); std::cout << v.size() << std::endl; }
Using boost::algorithm::split()
, a given string can be split into a container based on a certain delimiter. The function requires a predicate as its third parameter indicating for each character whether the string should be split at the given position. The example uses the helper function boost::algorithm::is_space()
to create a predicate that will split the string at every space character.
Many of the functions introduced in this paragraph also exist in a version that ignores the case of the string. They typically have the same name except for a leading 'i'. For example, the equivalent to boost::algorithm::erase_all_copy()
is boost::algorithm::ierase_all_copy()
.
Finally, it should be noted that many functions of Boost.StringAlgorithms also support regular expressions. The following program uses the boost::algorithm::find_regex()
function to search for a regular expression.
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string/regex.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::iterator_range<std::string::iterator> r = boost::algorithm::find_regex(s, boost::regex("\\w\\s\\w")); std::cout << r << std::endl; }
In order to use the regular expression, the program accesses a class named boost::regex
which is defined inside the Boost C++ Library Boost.Regex and is presented in the following paragraph.
The Boost C++ Library Boost.Regex allows the usage of regular expressions in C++. Regular expressions is a powerful feature of many languages that alleviates searching for a particular string pattern. While nowadays C++ still needs to resort to a Boost C++ Library, support for regular expressions will become part of the C++ standard library in the future: Boost.Regex is expected to be included in the next revision of the C++ standard.
The two most important classes in Boost.Regex are boost::regex
and boost::smatch
, both defined in boost/regex.hpp
. While the former is used to define a regular expression, the latter will save the search results.
Boost.Regex provides three different functions to search for regular expressions which are introduced below.
#include <boost/regex.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::regex expr("\\w+\\s\\w+"); std::cout << boost::regex_match(s, expr) << std::endl; }
boost::regex_match()
is used to compare a string with a regular expression. It will return true
only if the expression matches the complete string.
To search a string for a regular expression, boost::regex_search()
is available.
#include <boost/regex.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::regex expr("(\\w+)\\s(\\w+)"); boost::smatch what; if (boost::regex_search(s, what, expr)) { std::cout << what[0] << std::endl; std::cout << what[1] << " " << what[2] << std::endl; } }
boost::regex_search()
expects a reference to an object of type boost::smatch
as an additional parameter that is used to store the results. boost::regex_search()
only searches for groupings thus, the example actually returns two results based on the two groupings found in the regular expression.
The result storage class boost::smatch
is actually a container holding elements of type boost::sub_match
which can be accessed using an interface similar to the one of std::vector
. For example, elements can be accessed via the operator[]()
operator.
The class boost::sub_match
on the other hand saves iterators to the specific positions inside a string corresponding to the grouping of a regular expression. Since it is derived from std::pair
, the individual iterators referencing a particular substring can be accessed using first and second. In order to write a substring to the standard output stream, these iterators do not necessarily need to be accessed though as seen in the above example. Using the overloaded <<
operator, the substring can be directly written instead.
Please note that since results are stored using iterators, boost::sub_match
does not copy them. This certainly implies that they are accessible only as long as the corresponding string - referenced by the iterators - exists.
Furthermore, please note that the first element of the container boost::smatch
stores iterators referencing the string that matches the complete regular expression. The first substring that matches the first grouping is accessible at index 1.
The third function offered by Boost.Regex is boost::regex_replace()
.
#include <boost/regex.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = " Boris Schäling "; boost::regex expr("\\s"); std::string fmt("_"); std::cout << boost::regex_replace(s, expr, fmt) << std::endl; }
Besides the string to search as well as the regular expression, boost::regex_replace()
requires a format that defines how substrings, matching individual groupings of the regular expression, are replaced. In case the regular expression does not contain any grouping, corresponding substrings are replaced one-to-one using the given format. Thus, the above program will output _Boris_Schäling_
as the result.
boost::regex_replace()
always searches through the complete string for the regular expression. Hence, the program actually replaced all three spaces with underscores.
#include <boost/regex.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::regex expr("(\\w+)\\s(\\w+)"); std::string fmt("\\2 \\1"); std::cout << boost::regex_replace(s, expr, fmt) << std::endl; }
The format can access substrings returned by groupings of the regular expression. The example uses this technique to swap the first with the last name, displaying Schäling Boris
as the result.
Please note that there exist different standards for regular expressions and formats. Each of the three functions takes an additional parameter that allows to select a specific standard. Whether or not special characters should be interpreted in a specific format or whether the format should rather replace the complete string matching the regular expression can be specified as well.
#include <boost/regex.hpp> #include <locale> #include <iostream> int main() { std::locale::global(std::locale("German")); std::string s = "Boris Schäling"; boost::regex expr("(\\w+)\\s(\\w+)"); std::string fmt("\\2 \\1"); std::cout << boost::regex_replace(s, expr, fmt, boost::regex_constants::format_literal) << std::endl; }
The program passes the boost::regex_constants::format_literal
flag as the fourth parameter to boost::regex_replace()
to suppress handling of special characters in the format. Since the complete string that matches the regular expression is replaced with the format, the output of the example is \2 \1
.
As indicated at the end of the previous paragraph, regular expressions can also be used with Boost.StringAlgorithms. The library accesses Boost.Regex to provide functions such as boost::algorithm::find_regex()
, boost::algorithm::replace_regex()
, boost::algorithm::erase_regex()
and boost::algorithm::split_regex()
. Since Boost.Regex is expected to be part of the upcoming revision of the C++ standard, it is advisable to be proficient in applying regular expressions without the usage of Boost.StringAlgorithms though.
The library Boost.Tokenizer allows to iterate over partial expressions in a string by interpreting certain characters as separators.
#include <boost/tokenizer.hpp> #include <string> #include <iostream> int main() { typedef boost::tokenizer<boost::char_separator<char> > tokenizer; std::string s = "Boost C++ libraries"; tokenizer tok(s); for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) std::cout << *it << std::endl; }
Boost.Tokenizer defines a template class named boost::tokenizer
in boost/tokenizer.hpp
. It expects a class that identifies coherent expressions for its template parameter. The above example uses the class boost::char_separator
which interprets spaces and punctuation marks as separators.
A tokenizer must be initialized with a string of type std::string
. Using the begin()
and end()
methods, the tokenizer can be accessed just like a container. Partial expressions of the string used to initialize the tokenizer are available via iterators. How partial expressions are evaluated depends on the kind of class passed as the template parameter.
Since boost::char_separator
interprets spaces and punctuation marks as separators by default, the example displays Boost
, C
, +
, +
and libraries
. In order to identify these characters, boost::char_separator
utilizes both std::isspace()
and std::ispunct()
. Boost.Tokenizer distinguishes between separators that should be displayed and separators that should be suppressed: By default, spaces are suppressed while punctuation marks are displayed. Hence the two plus signs are displayed accordingly.
If punctuation marks should not be interpreted as separators, the boost::char_separator
object can be initialized accordingly before being passed to the tokenizer. The following example does exactly that.
#include <boost/tokenizer.hpp> #include <string> #include <iostream> int main() { typedef boost::tokenizer<boost::char_separator<char> > tokenizer; std::string s = "Boost C++ libraries"; boost::char_separator<char> sep(" "); tokenizer tok(s, sep); for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) std::cout << *it << std::endl; }
The constructor of boost::char_separator
expects a total of three parameters of which only the first one must be supplied. It describes the individual separators that are suppressed. For the given example, spaces are treated as separators just like with the previous example.
The second parameter specifies the separators that are displayed. In case this parameter is omitted, it is empty and thus no separators are displayed at all. If the program is now executed, it displays Boost
, C++
and libraries
.
If a plus sign is passed for the second parameter, the example program behaves just like the first one.
#include <boost/tokenizer.hpp> #include <string> #include <iostream> int main() { typedef boost::tokenizer<boost::char_separator<char> > tokenizer; std::string s = "Boost C++ libraries"; boost::char_separator<char> sep(" ", "+"); tokenizer tok(s, sep); for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) std::cout << *it << std::endl; }
The third parameter determines whether or not empty partial expressions are displayed. If two separators are found back-to-back, the corresponding partial expression is empty. By default, these empty expressions are not displayed. Using the third parameter, the default behavior can be manipulated.
#include <boost/tokenizer.hpp> #include <string> #include <iostream> int main() { typedef boost::tokenizer<boost::char_separator<char> > tokenizer; std::string s = "Boost C++ libraries"; boost::char_separator<char> sep(" ", "+", boost::keep_empty_tokens); tokenizer tok(s, sep); for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) std::cout << *it << std::endl; }
If executed, the above program displays two additional empty partial expressions. The first one is found between the two plus signs while the second one is found between the second plus sign and the following space.
A tokenizer can also be used with different string types.
#include <boost/tokenizer.hpp> #include <string> #include <iostream> int main() { typedef boost::tokenizer<boost::char_separator<wchar_t>, std::wstring::const_iterator, std::wstring> tokenizer; std::wstring s = L"Boost C++ libraries"; boost::char_separator<wchar_t> sep(L" "); tokenizer tok(s, sep); for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) std::wcout << *it << std::endl; }
This example iterates over a string of type std::wstring
instead. In order to allow this type of string, the tokenizer must be initialized using additional template parameters. The same applies to the boost::char_separator
class; it also must be initialized using wchar_t
for its template parameter.
Besides boost::char_separator
, Boost.Tokenizer provides two additional classes to identify partial expressions.
#include <boost/tokenizer.hpp> #include <string> #include <iostream> int main() { typedef boost::tokenizer<boost::escaped_list_separator<char> > tokenizer; std::string s = "Boost,\"C++ libraries\""; tokenizer tok(s); for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) std::cout << *it << std::endl; }
boost::escaped_list_separator
is used to read multiple values separated by a comma. This format is commonly known as CSV (comma separated values). It also considers double quotes as well as so-called escape sequences accordingly. The output of the example is therefore Boost
and C++ libraries
.
The second class provided is boost::offset_separator
which must be instantiated. The corresponding object must be passed to the constructor of boost::tokenizer
as the second parameter.
#include <boost/tokenizer.hpp> #include <string> #include <iostream> int main() { typedef boost::tokenizer<boost::offset_separator> tokenizer; std::string s = "Boost C++ libraries"; int offsets[] = { 5, 5, 9 }; boost::offset_separator sep(offsets, offsets + 3); tokenizer tok(s, sep); for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) std::cout << *it << std::endl; }
boost::offset_separator
specifies the locations within the string at which individual partial expressions end. The above program specifies that the first partial expression ends after 5 characters, the second ends after additional 5 characters and the third and last ends after the following 9 characters. The output will be Boost
, C++
and libraries
.
Boost.Format offers a replacement for the std::printf()
function defined in cstdio
. std::printf()
originates from the C standard and allows formatted data output. However, it is neither type-safe nor expandable. In C++ applications, Boost.Format is usually the preferred choice when data should be output in a formatted way.
The library Boost.Format provides a class named boost::format
which is defined in boost/format.hpp
. Similar to std::printf()
, a string containing special characters to control formatting is passed to the constructor of boost::format
. The actual data replacing these special characters in the output is linked via the %
operator as shown in the following example.
#include <boost/format.hpp> #include <iostream> int main() { std::cout << boost::format("%1%.%2%.%3%") % 16 % 9 % 2008 << std::endl; }
Boost.Format uses numerics placed between two percent signs as placeholders that are later linked to the actual data using the %
operator. The above program uses the numbers 16, 9, and 2009 to form a date string in the format of 16.9.2008
. In case the month should appear in front of the day, which is common in the United States, the placeholders can simply be swapped to accommodate.
#include <boost/format.hpp> #include <iostream> int main() { std::cout << boost::format("%2%/%1%/%3%") % 16 % 9 % 2008 << std::endl; }
The program now displays 9/16/2008
instead.
To format data using the C++ manipulators, Boost.Format offers a function named boost::io::group()
.
#include <boost/format.hpp> #include <iostream> int main() { std::cout << boost::format("%1% %2% %1%") % boost::io::group(std::showpos, 99) % 100 << std::endl; }
The example will display +99 100 +99
as the result. Since the manipulator std::showpos()
has been linked to the number 99
via boost::io::group()
, the plus sign is automatically added whenever 99
is displayed.
If the plus sign should only be shown for the first output of 99
, the format placeholder needs to be customized.
#include <boost/format.hpp> #include <iostream> int main() { std::cout << boost::format("%|1$+| %2% %1%") % 99 % 100 << std::endl; }
The placeholder %1% has been replaced with %|1$+|. Customization of a format not only adds two additional pipe signs though. The reference to the data also is placed between the pipe signs and rather uses 1$ instead of 1%. This is required in order to modify the output to +99 100 99
.
Please note that, even though references to data are optional in general, they must be specified either for all placeholders or none. The following example only provides references for the second and third placeholder but omits them for the first one which generates an error during execution.
#include <boost/format.hpp> #include <iostream> int main() { try { std::cout << boost::format("%|+| %2% %1%") % 99 % 100 << std::endl; } catch (boost::io::format_error &ex) { std::cout << ex.what() << std::endl; } }
This program will throw an exception of type boost::io::format_error
. Strictly speaking, Boost.Format throws boost::io::bad_format_string
. Since the different exception classes are all derived from boost::io::format_error
, it is usually easier catching exceptions of this type though.
The following examples shows how to write the program without having references to data.
#include <boost/format.hpp> #include <iostream> int main() { std::cout << boost::format("%|+| %|| %||") % 99 % 100 % 99 << std::endl; }
The pipe signs for the second and third placeholder can safely be omitted since they do not specify the format in this case. The resulting syntax then closely resembles the one of std::printf()
.
#include <boost/format.hpp> #include <iostream> int main() { std::cout << boost::format("%+d %d %d") % 99 % 100 % 99 << std::endl; }
While the format may look like the one of std::printf()
, Boost.Format still provides the advantage of type safety. The usage of the letter 'd' within the format string does not indicate the output of a numeric but rather incorporates the std::dec()
manipulator on the internal stream object used by boost::format
. This allows to specify format strings which would not make sense for std::printf()
and thus may result in a crash of the application during execution.
#include <boost/format.hpp> #include <iostream> int main() { std::cout << boost::format("%+s %s %s") % 99 % 100 % 99 << std::endl; }
While std::printf()
uses the letter 's' only for strings of type const char*
, the above program works perfectly. Boost.Format does not expect a string necessarily but rather incorporates the appropriate manipulators to configure the operation mode of the internal stream. Even in this case though, it is still possible to add the numbers to the internal stream as shown above.
You can buy solutions to all exercises in this book as a ZIP file.
Create a program that extracts and displays data such as first and last name, birthday and account balance from the following XML stream: <person><name>Karl-Heinz Huber</name><dob>1970-9-30</dob><account>2,900.64 USD</account></person>
.
The first name should be displayed separated from the last name. The birthday should be shown using the typical format of 'day.month.year' while the account balance should omit any decimal place. Test your application with different XML streams that contain additional spaces, a second first name, a negative number for the account balance and so forth.
Create a program that formats and displays data records such as the following: Munich Hamburg 92.12 8:25 9:45
. This record describes a flight from Munich to Hamburg that costs 92.12 Euro, departs at 8:25 AM and arrives at 9:45 AM. It should be displayed as: Munich -> Hamburg 92.12 EUR (08:25-09:45)
.
More detailed, the city should be 10-digit and left-aligned while the price should be 7-digit and right-aligned. After the price, the currency should be displayed. The departure and arrival times should be shown in parenthesis, without spaces and separated by a hyphen. For times prior to 10 AM/PM, a leading 0 should be added. Test your application with different data records by e.g. adding a city that contains more than 10 digits.
Copyright © 2008-2010 Boris Schäling


We have the money, the power, the medical understanding, the scientific know-how, the love and the community to produce a kind of human paradise. But we are led by the least among us – the least intelligent, the least noble, the least visionary. We are led by the least among us and we do not fight back against the dehumanizing values that are handed down as control icons.
Image Tiles Scroll Animation with Locomotive Scroll
Neurotic
culture
Civilization
Empowerment
Apocalypse
We have to create culture, don’t watch TV, don’t read magazines, don’t even listen to NPR. Create your own roadshow. The nexus of space and time where you are now is the most immediate sector of your universe, and if you’re worrying about Michael Jackson or Bill Clinton or somebody else, then you are disempowered, you’re giving it all away to icons, icons which are maintained by an electronic media so that you want to dress like X or have lips like Y.
Culture is not your friend
express ourselves through creative activity
This is shit-brained, this kind of thinking.  And we are told ‘no’, we’re unimportant, we’re peripheral.  And then you’re a player, you don’t want to even play in that game.


Before Change
self.val_data_text = unpack(val_data)
self.test_data_text = unpack(te_data)
log.info("\tFinished processing RTE{1,2,3,5}.")
pdb.set_trace()
class TwitterIrony(Task):
"""
After Change
// need to shuffle the data
dev_sents1, dev_sents2, dev_targs = load_files([os.path.join(path, dev) for dev in devs])
te_sents1, te_sents2, te_targs = load_files([os.path.join(path, test) for test in tests])
n_exs = len(dev_sents1)
split_pt = int(.2 * n_exs)
tmp = list(zip(dev_sents1, dev_sents2, dev_targs))


--- layout: archive title: Zulip Chat Archive permalink: /stream/116395-maths/topic/3.2E6.2E1.20mathlib.3F.html ---
Does this
rss-bot said:
chore(*): release version 3.6.1
chore(*): release version 3.6.1
https://github.com/leanprover-community/lean/commit/97f11c47b944bf3a73065bdce0f752feb2efc1d5
mean that I should now update my Lean repos to 3.6.1 if I want to get the latest mathlib goodies?
If you're using mathlib you should only pay attention to what goes on in the mathlib repo. mathlib is still on 3.5.1. https://github.com/leanprover-community/mathlib/blob/master/leanpkg.toml
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Open Tech Collaborative
Learn More
Latest News
Contact Us
2
Cart
Shipping information
Credit Card Information
First Name
Last Name
Email
Street address
City
Country
United States
State / Province
Postal Code
Choose a shipping speed
Sorry, we don't ship to this country.
Regular
(average of 5 to 10 days)
Express
(average of 2 to 4 days)
Check shipping rates
Use this information for my credit card details
Next: Enter your credit card details
You have
2
items in your shopping cart
The Opensource Beehives Project
Quantity
Price
$120
remove
The Opensource Beehives Project
Quantity
Price
$120
remove
Shipping cost
$18.50
Sub Total
$258.50


Circular packing or circular treemap allows to visualize a hierarchic organization. It is an equivalent of a treemap or a dendrogram, where each node of the tree is represented as a circle and its sub-nodes are represented as circles inside of it.
packcircles
and ggplot2
If your dataset has no hierarchy (it is basically just a few entities
with attributed numeric values), the packcircles
package
is the best way to build a circular packing chart in R. The packages
basically computes the position of each bubble, allowing to build the
chart with ggplot2
.
The ggiraph
library allows to get an interactive circular
packing with 1 level of hierarchy. This is really handy: hover the
plot and you will get more information concerning each circle.
ggraph
If your dataset is a hierarchy, it is time to switch to other tools.
For static versions, the ggraph
package is the best
option. It follows the grammar of graphic and makes it a breeze to
customize the appearance following the same logic than
ggplot2
.
The circlepackeR
library allows to get an interactive
circular packing with several levels of hierarchy.
Click on a group to zoom on it. The post describes how to use
the package from different types of input dataset.


RUSH HOUR 2 -----------
Beginning right where the original left off, "Rush Hour 2" finds Hong Kong Inspector Lee (Jackie Chan) hosting his LAPD buddy James Carter's (Chris Tucker) vacation while trying to break a counterfeiting ring that's just bombed the U.S. Embassy. While screenwriter Jeff Nathanson's plot pulls in dual bad guys in Asian gang leader John Lone and L.A. magnate Alan King and dual babes in Zhang Ziyi ("Crouching Tiger, Hidden Dragon") and Puerto Rican beauty queen Roselyn Sanchez for the leads to tussle with, director Brett Ratnor wisely keeps the focus on action and comedy over story.
"Rush Hour 2" is one of those rare sequels that surpasses the original. While breaking no original or artistic ground, the problems with the first effort (over-emphasis on an unexciting plot and an imbalance between the two leads) have been fixed.
Chan and Tucker's non-PC repartee has been criticized for its reliance on racial jokes, but its delivered with no ill will ('In Hong Kong, I'm Michael Jackson and you're Toto' Chan garbles.  Tucker's case-cracking advice to always 'follow the rich white man' proves worth heeding in this film as well.).
 Tucker's climatic choreographed fight with Zhang Ziyi is a comedic ballet, while Chan's given a potential love interest (and plot mechanism for part 3) in Sandra Bullock lookalike Sanchez.
"Rush Hour 2" is the first commercial summer movie that's actually entertaining. Make sure to stay for Jackie Chan's habitual end credit outtakes and you should leave the theater with a smile on your face.
B
For more Reeling reviews visit www.reelingreviews.com
<EMAIL_ADDRESS><EMAIL_ADDRESS>========== X-RAMR-ID: 29096 X-Language: en X-RT-ReviewID: 242442 X-RT-TitleID: 1109232 X-RT-SourceID: 386 X-RT-AuthorID: 1487 X-RT-RatingText: B
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Class: autosampler
http://nmrML.org/nmrCV#NMR:1400002
Annotations (2)
-
comment "def: An optional part of an NMR instrument used to hold samples prior to NMR analysis and that sequentially loads these samples into the analytical part of the NMR instrument.
altdef: The autosampler is an automatic sample changer." (string)
-
label "autosampler" (string)
Superclasses (1)
Usage (1)


City Browser was made by Stephen Firrincieli . The code is released under the MIT license and can be found on GitHub. If you find any bugs please send me a message.
The data used in City Browser was taken from a few sources provided by different US government agencies. I put the data into a manageable JSON using web scraping and by processing data files. The code for generating the JSON was written in Python and can also be found at this GitHub page.
| Data | Source | Format | Links | Information |
|---|---|---|---|---|
| Climate | NOAA | Text files |
Climate normals Daily summaries |
NOAA provides climate data for each station it keeps track of in text files. First, the script determined the nearest station to the coordinates of the city on Wikipedia. NOAA provides pre-calculated data on the monthly normal (mean) highs and lows for each station over a 30-year period. To determine the mean maximum and minimum temperatures, the script read the daily weather for each station for as long as it has been available, and averaged each month's maximums and minimums over all the available years. |
| Population | Wikipedia via U.S. Census Bureau | HTML |
Wikipedia 2015 Population Estimates |
The U.S. Census Bureau makes estimates of the current year's population for each city in between census years. The Census Bureau's website was difficult to scrape data from so I scraped the equivalent 2015 data from the Wikipedia page. |
| Median rent | Office of Policy Development and Research | Spreadsheet | 50th Percentile Rent Estimates | An office of the U.S. Department of Housing and Urban Development, the Office of Policy Development and Research produces yearly estimates of the median rent for areas of the United States. The script would first search the spreadsheet for the name and state of the city. If it could not find the specific city, it would fall back to use the county the city is within. |


The implementation of Recursive Inertial Bisection (RIB) in Zoltan is due due to Bruce Hendrickson and Robert Leland of Sandia National Laboratories for use in Chaco and was modified by Courtenay Vaughan. RIB is an algorithm similar to RCB (see the appendix on RCB for a description of RCB) in that it uses the coordinates of the objects to be balanced to do the load balancing. Similarly to RCB, the domain is recursively divided into two pieces until the number of subdomains needed is reached. In each stage of the division, the direction of the principle axis of the domain to be divided is calculated by determining an eigenvector of the inertial matrix. This direction vector is used to define a normal to a plane which is used to divide the domain into two pieces. This process is repeated until the desired number of subdomains is reached.
The communication of objects being divided is handled by the same routine
as is used by RCB. For applications which
wish to add more objects to the decomposition at a later time
(e.g., through Zoltan_LB_Box_Assign or
Zoltan_LB_Point_Assign),
information to
do this can be retained during the decomposition phase. This information is
kept if the parameter KEEP_CUTS is set during the decomposition.
The process is similar to that used for RCB, but the
information kept is different. For each RIB cut, the center of mass
of the subdomain which is cut, the direction vector, and a distance from
the center of mass to the cutting plane have to be saved.
There are three major data structures in RIB and they are defined in
rcb/rib.h and rcb/shared.h. The points which are being load balanced are represented as a
structure Dot_Struct which contains the location of the point, its weight, and
the originating processor's number. The nodes on the decomposition tree are
represented by the structure rib_tree which contains the position of the cut,
the center of mass of the subdomain which is being cut, the direction vector
of the principle axis of the subdomain, and the node's parent and two
children (if they exist) in the tree. The structure RIB_Struct is the RIB data
structure which holds pointers to all of the other data structures needed for
RIB. It contains an array of Dot_Struct to represent the points being load
balanced, global and local IDs of the points, an array of rib_tree (whose length is the number of processors) which
contains the decomposition tree, and the dimension of the problem.
The parameters used by RIB and their default values are described in the RIB section of the Zoltan User's Guide. These can be set by use of the Zoltan_RIB_Set_Param subroutine in the file rcb/rib.c.
When the parameter REDUCE_DIMENSIONS
is specified, the RIB algorithm will perform lower dimensional
partitioning if the geometry is found to be degenerate. More information
on detecting degenerate
geometries may be found in another
section.
The main routine for RIB is Zoltan_RIB in the file rcb/rib.c.


×
Warning!
Best check yo self,you're not looking to good.
×
Warning!
Best check yo self,you're not looking to good.
×
Warning!
Best check yo self,you're not looking to good.
链接1
链接2
链接3


"GAMERA 3: THE ADVENT OF LEGION" review by R.L. Strong The Dungeonmaster's Cornucopia of Film 3 ½ stars Not rated - contains scenes of destruction and violence. Some human bloodshed. May be too intense for younger children.
Directed by - Shusuke Kaneko Writing credits - Kazunori Itô Staring: Akiji Kobayashi, Ayako Fujitani, Miki Mizuno and Toshiyuki Nagashima Produced by Miyuki Nanri, Naoki Sato, Tsutomu Tsuchikawa Cinematography by Junichi Tozawa Film Editing by Shizuo Arakawa Production Design by Hajime Oikawa
It stands fifty meters tall! It can fly up to speed of mach 3, and can expel bursts of flaming plasma from its mouth. It is also.. a turtle. That seemingly absurd description belays the marvelous construction of the creature known in Japan as Gamera. Originally conceived by Director Noriaki Yuasa back in 1965, Gamera was a protector of children, defending his young fans from all sorts of ridiculous creatures from space. One has only to envision a Ginsu knife walking on four legs to appreciate (or deride) the silly concept on display in these early films. But that is not the case here. While those films made during the 1960's had budgets equal to a Roger Corman production, this new film has much more generous bearing. While far from being a Special Effects extravaganza, "Gamera 3: The Advent of Legion", is a remarkably exciting and deft exercise in fantasy film making. One that both hearkens back to a form of simplicity and extends and redefines those techniques into something wholly new and wondrous.
A sequel to 1994's "Gamera, Guardian of the Universe", 'Gamera 2' starts off with a unique approach in that Gamera is viewed by Japan as a hazard that must be countered against. While varying political and scientific groups grouse and argue amongst themselves, other events transpire to bring about even more destruction to Japan and to Earth itself.
A meteor shower occurs over Hokkaido. Yusuke Watase and Mr. Hanatani from the Japan SDF science team are sent to investigate. They are met by Midori Honami of the Youth Science Museum who finds the area bathed in a strange blue light. Also discovered is an increases in oxygen in the area (discovered when one soldier tries to light his cigarette). Finding no sign of the meteor, the team is dumbfounded. Midori exclaims, half jokingly that it seems as if the isotope has been moved.
Situations develop. In Sapporo, communications are interrupted, the fiber optics cables are being destroyed. A bottling company is robbed of all of its bottles. Finally, the reason is discovered when the underground subway system is attacked by a swarm of strange insects, each over seven feet in length. The creatures consume the glass windows, and lights, finally attacking the passengers. As the military starts to devise an attack on the creatures, a huge plant erupts from underground. Buildings crumble and crash as the plant sprouts up growing in seconds to a height of 150 feet. The military starts to destroy the plant as it starts to flower. It is found that the oxygen levels in the city have increased to a level that any military attack could level the city.
Suddenly, Gamera appears. The huge turtle topples the plant, crushing it before it can eject its seeds. Gamera is attacked by a swarm of insects which engulf the creature. Unable to defend itself, Gamera collapses. The giant turtle is able to retreat when the insects disengage from the leviathan to attack a nearby electrical plant. Gamera takes flight, spinning like a flying saucer, it's blood splashing against the buildings as it retreats.
It is discovered by the JSDF (Japanese Self Defense Force), that the insects, now identified as Legion (named by a soldier in Sapporo based on a biblical scripture), has a symbiotic relationship with the plant.
The plant can only live off of the waste product created by the insects, and the insects can only survive in an oxygen rich atmosphere. The insects are also a silicon based life form, their basic diet consisting of silica and carbon. Identified as a threat to life on the planet, the Japanese government enlists the aid of the United Nations Defense Force in helping to find a defense against the creatures.
This first act of the film (as well as the remainder) is marvelously constructed. The suspense and tension of the film is enthralling. U.S. film goers haven't seen a film like this in quite a while and it is refreshing to see this kind of depth of story telling on the screen. This may seem like a misnomer, coming in a review for a Japanese monster film. But, believe me. While the film is fanciful and far fetched, it is engrossing and very enjoyable. There is a nostalgic quality here that is not lost on the audience. We can all remember watching those beloved sci-fi thrillers from the 1950's with their quaint effects and plotting. Some of those films are rightly considered classics, and it's is those films that "Gamera 2" reflects on. While far from being a classic itself, "Gamera 2" is a masterly made and deftly plotted film.
The performances are all on the money here. Ayako Fujitani returns from 'Gamera: Guardian of the Universe' as Asagi Kusanagi, the young girl with the psychic link with Gamera. While only appearing in what amounts to a cameo, Ms. Fujitani gives a nice performance as Asagi. Also returning in a cameo is Yukijiro Hotaru as Osaka, former police inspector from the previous Gamera film, now working as a security guard for Kirin Beer. His inclusion adds the right touch of nostalgic comedy to the film, it's a shame that his part is over so soon.
Miki Mizuno as Midori Honami is charming in her portrayal of the young scientist who comes to identify the threat of Legion. Akiji Kobayashi as Colonel Watarase is appropriately stern in his performance. It's a shame that the other credits in this film are not translated from their Japanese characters, as it makes identifying the many performers difficult. Suffice to say, that the film is well performed and that nothing is played for camp. This is an earnest thriller, comedy is only a sporadic commodity here, and never used to detrimental effect.
The plotting and story construction of the film plays like a modern day disaster film. The most immediate example that comes to mind would be (unfortunately) "Armageddon", in that both films deal less with their characters individual conflicts than with the larger, more global problems in the plot. A better (and more nostalgic) template would be the 1965 film "Crack in the World" (a fun programmer in it's time). "Gamera 2" moves at a fast clip, not leaving the audience time to question it's plot holes (of which there are a few but minor ones). The tension and suspense are on the level of a national disaster, almost documentarian in its approach. Emotionally, the film is weightless, but on the level of escapism, the film shines above anything done stateside in the past 10 years.
The special effects of 'Gamera 2' are it's reason 'd aire. And to say that they are impressive is to give too light of an image. While the monsters are performed by men in intricately designed suits, the method of the photography and miniature work is so marvelous as to help one suspend their disbelief for a moment.. enough to become absorbed into the film. The inclusion of computer effects is a welcome change for the genre and bodes well for the future of Japanese Kaiju (strange beast) films. With 'Gamera 2', one can truly witness a wonderful amalgamation of both past and present effects techniques that combine to create an enchanting, exciting and fresh look.
 While a little too light on character (human) involvement, the film more that delivers in the action and monster quotient. An enjoyable film with enough action to keep those explosive addicts placated until the next Michael Bey extravaganza.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{% extends 'base.html' %} {% block content %}
Sector: {{sector}}
Description:
{% endif %}Analysis results:
Current share price: {{sharePrice}}
P/E ratio: {{PEratio}}
Higher the PE ratio the more overvalued the stock is. Growth could be expected by the share holders if it is high. Depends on the sector too.PEG ratio: {{PEGratio}}
This is the PE ratio but taking into account growth. PEG less than 1 is considered undervalued. PEG over 1 is considered overvaluedEquity growth over three years:
Revenue growth over three years:
Profit growth over three years:
All of the below checks should be passed for the stock to be a good enterprising investment
{% else %}All of the below checks should be passed for the stock to be a good defensive investment
{% endif %} {% if good == True %}The company has passed all of the checks so is therefore a safe investment to add to a defensive portfolio.
{% else %} {% if enterprise == True %}The company has passed {{count}} out of 6 checks so is therefore not considered to be a safe investment.
{% else %}The company has passed {{count}} out of 7 checks so is therefore not considered to be a safe investment.
{% endif %} {% endif %} {% if enterprise == True %} {% else %}If a company passes these value checks, do some research on the company and look at their management and plans for future growth. Use a a degree of pragmatism before making an investment.


Neural Operator
Machine learning for scientific computing
Problems in science and engineering involve solving partial differential equations (PDE) systems. Sometimes, these PDEs are very hard. It could take traditional PDE solvers days and months to simulate some 3D fluid dynamics. Data-driven, learning-based methods have the promises to solve these problems faster and more accurate. The classical development of neural networks has primarily focused on learning mappings between finite dimensional Euclidean spaces or finite sets. To better approximate the solution operators raised in PDEs, we propose a generalization of neural networks to learn operators mapping between infinite dimensional function spaces. We formulate the approximation of operators by composition of a class of linear integral operators and nonlinear activation functions, so that the composed operator can approximate complex nonlinear operators. Such neural operators are resolution-invariant, and consequently more efficient compared to traditional neural networks. Especially, the Fourier neural operator model has shown state-of-the-art performance with 1000x speedup in learning turbulent Navier-Stokes equation, as well as promising applications in weather forecast and CO2 migration, as shown in the figure above.
Related works
Models and architectures: [Physics-informed neural operator (PINO)], [Fourier neural operator (FNO)], [FNO-Transformer], [Model Reduction (PCA) (Kovachki et. al.)], [Graph neural operator], [Mutlipole graph neural operator], [Multi-Wavelet neural operator (Gupta et. al.)], [Galerkin transformer (Cao)], [Spectral Neural Operators (Oseledets et. al.)], [U-NO: U-shaped Neural Operators (Azizzadenesheli et. al.)], [Generative Adversarial Neural Operators (Azizzadenesheli et. al.)],Applications: [Weather Forecast], [Cryo-EM / SARS-CoV-2], [CO2 migration], [Crystal plasticity], [Seismic wave], [Kolmogorov flow], [SDE (Salvi et. al.)], [Coastal floods (Jiang et. al.)], [Wave equation (Guan et. al.)], [PDE control (Hwang et. al.)], [Composites curing (Chen et. al.)].
 Supervised Learning
We consider the 2-d Navier-Stokes equation for a viscous, incompressible fluid in vorticity form on the unit torus. In this experiment, we use neural operators to learn the operator mapping from the vorticity of the first time 10 time steps to that up to a later time step.
FNO achieves better accuracy compared to CNN-based methods.
Further, it is capable of the zero-shot super-resolution.
It is trained on 64x64x20 resolution and evaluated on 256x256x80 resolution, in both space and time.
2. Inverse Problem
We use a function space Markov chain Monte Carlo (MCMC) method to draw samples from the posterior distribution of the initial vorticity in Navier-Stokes given sparse, noisy observations at a later time step.
We generate 25,000 samples from the posterior (with a 5,000 sample burn-in period),
requiring 30,000 evaluations of the forward operator. In sharp contrast, FNO takes 0.005s to evaluate a single instance while the traditional solver, after
being optimized to use the largest possible internal time-step which does not lead to blow-up, takes
2.2s.
3. Physics-Informed Neural Operator
When the equation is available, we can use the physics-informed loss to solve the equation.
We propose the pre-train and test-time optimize scheme. During pre-train, we learn an operator from data.
During the test-time optimization, we solve the equation using PINN loss.
4. Chaotic System
The Kolmogorov Flow is a chaotic system, which is intrinsically instable. Smaller errors will accumulate and make the simulation diverge from the truth.
We take a new perspective:
we predict long-time trajectories that, while eventually diverging from the truth,
still preserve the same orbit (attractor) of the system and its statistical properties.
5. FNO Transformer
Vision transformers have delivered tremendous success in representation learning. We propose Adaptive Fourier Neural Operator (AFNO) as an efficient token mixer that learns to mix in the Fourier domain.


StackOverflow Lite
Home
Features
Gallery
Sign in
StackOverflow Lite Sign in page
Welcome Back!
Forget Password?
Login


First page
Back
Continue
Last page
Overview
Graphics
Simple “Call Once” Decorator
def register(function):
print “LOOK! “, function.__name__
return function
@register
def print_hello():
print “Hello”
print_hello()
print_hello()


---
layout: page
title: The Gallery
subtitle: Discover Art and let Art Discover you
use-site-title: true
---
Problem Overview
Museum goers are usually very observant and are taken through a wave of emotions as they move from one piece to the next, but they seem to leave all these thoughts at the Museum door when they exit the exhibition. This can result as a combination of different factors: absence of a dedicated audience for their views, inaccessibility of good quality images for illustrative purposes, and sometimes its just inability to find pieces that appeal enough to them to make an emotional impact. The Gallery aims to solve this problem by providing a platform for people to share their thoughts about Art and making sure they have interesting Art to talk about right at their fingertips by giving them timely and targeted recommendations to Museum exhibitions.
Video Prototype
Interactive Prototype
Value Proposition
After extensive context-based research, our team concluded that users need a way to access High Quality photos of museum artwork. Introducing, The Gallery: an app that allows users to have digital access to artwork, directly from their mobile phone. By adding their own commentary, and sharing these pieces with friends, family, and the world, users are able to engage in the discussions they’ve always wanted to!
Key Functionality
Bringing Discussion Outside of The Museum The main objective of The Gallery is to allow users to engage in discussions about art, Anywhere, Anytime. We solve this issue by allowing users to access High Quality versions of artwork from digitized collections available online by museums- images that users will actually want to share. Then, we allow users to add their own commentary to their posts, and engage in discussions in the comment sections of their own, their friends', and popular public posts. The Gallery connects the museum-going world, from anywhere in the world!
Provide Recommendations to Users Based on user preferences, past experiences, engagement, etc., The Gallery helps to ensure users are able to find new museums and exhibits that are best-suited for them. Engaging in art is fun, but it can be hard to keep up with constantly rotating exhibits. It can be even harder when travelling to a new city on a tight schedule to figure out which of their different museums you'd enjoy the most! Let The Gallery curate the best pieces, exhibits, and museums, built just for you!


Contract guidelines
The Following template helps you to create a Contract between you and your contract partner.
You will be asked to enter both contract partner names, the name of the object that will be lend, the borrowing date and the date of return.
Also make sure to upload a photo and precise description of its state.