A refreshing JavaScript Datepicker — lightweight, no dependencies, modular CSS.
This example shows how Pikaday can be used in a Knockout binding. The input field is bound to a Knockout observable property that updates the selected text below. The helper buttons show that updating the observable property also updates the Pikaday instance.
Since version 1.0 Pikaday is a stable and battle tested date-picker. Feel free to use it however you like but please report any bugs or feature requests to the GitHub issue tracker, thanks!
Copyright © 2014 David Bushell | BSD & MIT license | Example by Brendan Brewster


DEAR FRIEND, I am Mr.Joseph Poon Executive Director Of Operations of the Hang Seng Bank Ltd,Sai Wan Ho Branch,171 Shaukiwan Road Hong Kong. An Iraqi named Hamadi Hashem a business man made a numbered fixed deposit of (346,736,899.68 HKD) for 18 calendar months; this is valued to Forty Four million Five Hundred Thousand United State Dollars only in my branch. Upon maturity several notices was sent to him, even during the war,four years ago (2003). Again after the war another notification was sent and still no response came from him. We later found out that Hamadi Hashem and his family had been killed during the war in bomb blast that hit their home at Mukaradeeb where his personal oil well was. After furtherinvestigation it was also discovered that Hamadi Hashem did not declare any next of kin in his official papers including the paperwork of his bank deposit. And he also confided in me the last time he was at my office that no one except me knew of his deposit in my bank.So, Forty Four million Five Hundred Thousand United State Dollars is still lying in my bank and no one will ever come forward to claim it.What bothers me most is that according to the laws of my country at the expiration five years six months the funds will revert to the ownership of the Hong Kong Government if no body applies to claim the funds. My proposal, I am prepared to place you as the next of kin in a position to instruct HANG SENG BANK to release the deposit to you as the closest surviving relation. Upon receipt of the deposit, I am prepared to share the money with you in half. That is: I will simply nominate you as the next of kin and have them release the deposit to you. We share the proceeds FIFTY - FIFTY. I would have gone ahead to ask the funds be released to me, but that would have drawn a straight line in my involvement in claiming the deposit. I assure you that I could have the deposit released to you within a few days.I will simply inform the bank of the final closing of the file relating to Hamadi Hashem I will then officially communicate with my Bank and instruct them to release the deposit to you. With these:all is done. I am aware of the consequences of this proposal. I ask that if you find no interest in this project that you should discard this mail. I ask that you do not be vindictive and destructive. If my offer is of no appeal to you, delete this message and forget I ever contacted you. Do not destroy my career because you do not approve of my proposal. Should you be interested please send me your full names,Phone Number and current residential address and I will prefer you to reach me on the email address below.E-mail<EMAIL_ADDRESS>and finally after that I shall provide you with more details of this operation. Your earliest response to this letter will be appreciated. I await your response. Mr.JOSEPH POON.


This is the basic highlighter directive that change the background color.
This is the BETTER highlighter direcive that change the background color.


Dropdown List Menu Position
Menu position will allow users to configure how dropdown view should be position when on dropdown expand. the
following four types are available to configure dropdown, which are:
- Top Left - Dropdown view appears on top left of the dropdown
- Top Right - Dropdown view appears on top right of the dropdown
- Bottom Left - Dropdown view appears on bottom left of the dropdown
- Bottom Right - Dropdown view appears on top right of the dropdown
What You Will See
Basic Usage
For change the default dropdown menu position simply bind, menuPosition
string into ng-dropdown
with any above mention type. default value for this configuration is bottom-left.
Suggested Links
Menu Width & Height
Option Filtering
API Doc for Dropdown Menu Position


Tools
Collections of tools to help myself finding the best hammer.
Only the best tools are added.
Cheatsheets
Cheatsheets are systematic summaries of some topics.
Curriculumn
Curriculumn is being used to review data science skills.


Users
Check out every octopus user's details
Members »
Cases
Check the progress, history or details of cases
Cases »
{#
#}
{#
Visualizations
#}
{##}
{#
Visualize the whole thing
#}
{#
#}
{#
#}
Tasks
Examine tasks, either standalone or part of cases
Tasks »


"""
console_helpers.py
------------------
Functions that can be used in a friendly console or in other interactive
environments such as in a Jupyter notebook.
"""
# NOTE: __all__ is defined at the very bottom of this file
import sys
import friendly
from friendly import debug_helper, formatters, __version__
from friendly.config import session
from friendly.info_generic import get_generic_explanation
from friendly.path_info import show_paths
from friendly.my_gettext import current_lang
from friendly.utils import add_rich_repr
_ = current_lang.translate
[docs]def back():
"""Removes the last recorded traceback item.
The intention is to allow recovering from a typo when trying interactively
to find out specific information about a given exception.
"""
if not session.saved_info:
session.write_err(_("Nothing to go back to: no exception recorded.") + "\n")
return
if not session.friendly: # pragma: no cover
debug_helper.log("Problem: saved info is not empty but friendly is")
session.saved_info.pop()
session.friendly.pop()
if session.saved_info:
info = session.saved_info[-1]
if info["lang"] != friendly.get_lang():
info["lang"] = friendly.get_lang()
session.friendly[-1].recompile_info()
[docs]def explain(include="explain"):
"""Shows the previously recorded traceback info again,
with the option to specify different items to include.
For example, ``explain("why")`` is equivalent to ``why()``.
"""
old_include = friendly.get_include()
friendly.set_include(include)
session.show_traceback_info_again()
friendly.set_include(old_include)
[docs]def friendly_tb():
"""Shows the a simplified Python traceback,
which includes the hint/suggestion if available.
"""
explain("friendly_tb")
[docs]def hint():
"""Shows hint/suggestion if available."""
explain("hint")
[docs]def history():
"""Prints the list of error messages recorded so far."""
if not session.saved_info:
session.write_err(_("Nothing to show: no exception recorded.") + "\n")
return
session.rich_add_vspace = False
for info in session.saved_info:
message = session.formatter(info, include="message").replace("\n", "")
session.write_err(message)
session.rich_add_vspace = True
[docs]def python_tb():
"""Shows the Python traceback, excluding files from friendly
itself.
"""
explain("python_tb")
[docs]def what(exception=None, pre=False):
"""If known, shows the generic explanation about a given exception.
If the ``pre`` argument is set to ``True``, the output is
formatted in a way that is suitable for inclusion in the
documentation.
"""
if exception is None:
explain("what")
return
if hasattr(exception, "__name__"):
exception = exception.__name__
result = get_generic_explanation(exception)
if pre: # for documentation # pragma: no cover
lines = result.split("\n")
for line in lines:
session.write_err(" " + line + "\n")
session.write_err("\n")
else:
session.write_err(result)
return
[docs]def where():
"""Shows the information about where the exception occurred"""
explain("where")
[docs]def why():
"""Shows the likely cause of the exception."""
explain("why")
[docs]def www(site=None): # pragma: no cover
"""This uses the ``webbrowser`` module to open a tab (or window)
in the default browser, linking to a specific url
or opening the default email client.
* If the argument 'site' is not specified,
and an exception has been raised,
an internet search will be done using
the exception message as the search string.
* If the argument 'site' is not specified,
and NO exception has been raised,
Friendly's documentation will open.
* If the argument 'site' == "friendly",
Friendly's documentation will open.
* If the argument 'site' == "python", Python's documentation site
will open with the currently used Python version.
* If the argument 'site' == "bug",
the Issues page for Friendly on Github will open.
* If the argument 'site' == "email",
the default email client should open with Friendly's
developer's address already filled in.
"""
import urllib
import webbrowser
urls = {
"friendly": "https://aroberge.github.io/friendly-traceback-docs/docs/html/",
"python": "https://docs.python.org/3",
"bug": "https://github.com/aroberge/friendly/issues/new",
"email"<EMAIL_ADDRESS>}
try:
site = site.lower()
except Exception: # noqa
pass
if site not in urls and site is not None:
session.write_err(
_(
"Invalid argument for `www()`.\n"
"Valid arguments include `None` or one of `{sites}`.\n"
).format(sites=repr(urls.keys()))
)
return
info = session.saved_info[-1] if session.saved_info else None
if site is None and info is not None:
message = info["message"].replace("'", "")
if " (" in message:
message = message.split("(")[0]
url = "https://duckduckgo.com?q=" + urllib.parse.quote(message) # noqa
elif site is None:
url = urls["friendly"]
else:
url = urls[site]
if site == "python":
url = url + f".{sys.version_info.minor}/"
try:
webbrowser.open_new_tab(url)
except Exception: # noqa
session.write_err(_("The default web browser cannot be used for searching."))
return
get_lang = friendly.get_lang
set_lang = friendly.set_lang
get_include = friendly.get_include
set_include = friendly.set_include
set_formatter = friendly.set_formatter
# ===== Debugging functions are not unit tested by choice =====
def _debug_tb(): # pragma: no cover
"""Shows the true Python traceback, which includes
files from friendly itself.
"""
explain("debug_tb")
def _get_exception(): # pragma: no cover
"""Debugging tool: returns the exception instance or None if no exception
has been raised.
"""
if not session.saved_info:
print("Nothing to show: no exception recorded.")
return
info = session.saved_info[-1]
return info["_exc_instance"]
def _get_frame(): # pragma: no cover
"""This returns the frame in which the exception occurred.
This is not intended for end-users but is useful in development.
"""
if not session.saved_info:
print("Nothing to show: no exception recorded.")
return
info = session.saved_info[-1]
return info["_frame"]
def _get_statement(): # pragma: no cover
"""This returns a 'Statement' instance obtained for SyntaxErrors and
subclasses. Such a Statement instance contains essentially all
the known information about the statement where the error occurred.
This is not intended for end-users but is useful in development.
"""
if not session.saved_info:
print("Nothing to show: no exception recorded.")
return
if isinstance(session.saved_info[-1]["_exc_instance"], SyntaxError):
return session.friendly[-1].tb_data.statement
print("No statement: not a SyntaxError.")
return
def _get_tb_data(): # pragma: no cover
"""This returns the TracebackData instance containing all the
information we have obtained.
This is not intended for end-users but is useful in development.
"""
if not session.saved_info:
print("Nothing to show: no exception recorded.")
return
info = session.saved_info[-1]
return info["_tb_data"]
def _set_debug(flag=True): # pragma: no cover
"""This sets the value of the debug flag for the current session."""
debug_helper.DEBUG = flag
def _show_info(): # pragma: no cover
"""Debugging tool: shows the complete content of traceback info.
Prints ``''`` for a given item if it is not present.
"""
info = session.saved_info[-1] if session.saved_info else []
for item in formatters.items_in_order:
if item in info and info[item].strip():
print(f"{item}:")
for line in info[item].strip().split("\n"):
print(" ", line)
print()
else:
print(f"{item}: ''")
print("=" * 56)
print("The following are not meant to be shown to the end user:\n")
for item in info:
if item not in formatters.items_in_order:
print(f"{item}: {info[item]}")
basic_helpers = {
"back": back,
"explain": explain,
"history": history,
"set_lang": set_lang,
"show_paths": show_paths,
"what": what,
"where": where,
"why": why,
"www": www,
}
back.help = lambda: _("Removes the last recorded traceback item.")
explain.help = lambda: _("Shows all the information about the last traceback.")
history.help = lambda: _("Shows a list of recorded traceback messages.")
set_lang.help = lambda: _("Sets the language to be used.")
show_paths.help = lambda: _("Shows the paths corresponding to synonyms used.")
what.help = lambda: _("Shows the generic meaning of a given exception")
where.help = lambda: _("Shows where an exception was raised.")
why.help = lambda: _("Shows the likely cause of the exception.")
www.help = lambda: _("Opens a web browser at a useful location.")
add_rich_repr(basic_helpers)
other_helpers = {
"hint": hint,
"get_lang": get_lang,
"python_tb": python_tb,
"friendly_tb": friendly_tb,
"get_include": get_include,
"set_include": set_include,
"set_formatter": set_formatter,
}
hint.help = lambda: _("Suggestion sometimes added to a friendly traceback.")
python_tb.help = lambda: _("Shows a normal Python traceback.")
friendly_tb.help = lambda: _("Shows a simplified Python traceback.")
get_include.help = lambda: _(
"Returns the current value used for items to include by default."
)
set_include.help = lambda: _(
"Sets the items to show by default when an exception is raised."
)
get_lang.help = lambda: _("Returns the language currently used.")
set_formatter.help = lambda: _("Sets the formatter to use for display.")
add_rich_repr(other_helpers)
helpers = {**basic_helpers, **other_helpers}
_debug_helpers = {
"_debug_tb": _debug_tb,
"_get_frame": _get_frame,
"_set_debug": _set_debug,
"_show_info": _show_info,
"_get_tb_data": _get_tb_data,
"_get_exception": _get_exception,
"_get_statement": _get_statement,
}
_debug_tb.help = lambda: "Shows the full traceback, including code from friendly."
_show_info.help = lambda: "Shows the all the items recorded in the traceback."
_get_exception.help = lambda: "Returns the exception instance."
_get_frame.help = lambda: "Returns the frame object where the exception occurred."
_get_statement.help = lambda: "Returns the statement in which a SyntaxError occurred."
_get_tb_data.help = lambda: "Return a special traceback object."
_set_debug.help = lambda: "Use True (default) or False to set the debug flag."
class FriendlyHelpers:
"""Helper class which can be used in a console if one of the
helper functions gets redefined.
For example, we can write Friendly.explain() as equivalent to explain().
"""
version = __version__
def __init__(self, local_helpers=None):
self.__include_basic = list(basic_helpers)
if local_helpers is not None:
self.__include_basic.extend(local_helpers)
self.__include_basic = sorted(self.__include_basic) # first alphabetically
# then by word length, as it is easier to read.
self.include_in_rich_repr = sorted(self.__include_basic, key=len)
self.__include_more = list(other_helpers)
self.__include_more = sorted(self.__include_more) # first alphabetically
# then by word length, as it is easier to read.
self.include_in_help = sorted(self.__include_more, key=len)
self.__class__.__name__ = "Friendly" # For a nicer Rich repr
def __dir__(self): # pragma: no cover
"""Only include useful friendly methods."""
return self.__include_basic + list(other_helpers) + list(_debug_helpers)
def __repr__(self): # pragma: no cover
"""Shows a brief description in the default language of what
each 'basic' function/method does.
'Advanced' and debugging helper functions are not included
in the display.
"""
header = (
_(
"The following methods of the Friendly object might also "
"be available as functions."
)
+ "\n\n"
+ _("Basic methods:")
)
parts = [header + "\n\n"]
for item in self.include_in_rich_repr:
parts.append(item + "(): ")
fn = getattr(Friendly, item)
if hasattr(fn, "help"):
parts.append(getattr(Friendly, item).help() + "\n")
else:
print("Warning:", item, "has no help() method.")
more_header = _("Less commonly used methods/functions.")
parts.append("\n" + more_header + "\n\n")
for item in self.include_in_help:
parts.append(item + "(): ")
fn = getattr(Friendly, item)
if hasattr(fn, "help"):
parts.append(getattr(Friendly, item).help() + "\n")
else:
print("Warning:", item, "has no help() method.")
return "".join(parts)
for helper in _debug_helpers:
setattr(FriendlyHelpers, helper, staticmethod(_debug_helpers[helper]))
for helper in helpers:
setattr(FriendlyHelpers, helper, staticmethod(helpers[helper]))
# == Local version; this may need to be removed/modified in
# some programming environments (e.g. Mu, Idle, etc.) which do not support Rich.
class _FriendlyHelpers(FriendlyHelpers): # local version
pass
[docs]def dark(): # pragma: no cover
"""Synonym of set_formatter('dark') designed to be used
within iPython/Jupyter programming environments or at a terminal.
"""
set_formatter("dark")
[docs]def light(): # pragma: no cover
"""Synonym of set_formatter('light') designed to be used
within iPython/Jupyter programming environments or at a terminal.
"""
set_formatter("light")
dark.help = lambda: _("Sets a colour scheme designed for a black background.")
light.help = lambda: _("Sets a colour scheme designed for a white background.")
default_color_schemes = {"dark": dark, "light": light}
add_rich_repr(default_color_schemes)
Friendly = _FriendlyHelpers(default_color_schemes)
for scheme in default_color_schemes:
setattr(_FriendlyHelpers, scheme, staticmethod(default_color_schemes[scheme]))
helpers["Friendly"] = Friendly
__all__ = list(helpers.keys())
__all__.extend(list(default_color_schemes))


{{post.title}} {{post.posted}}
{{post.body|custom_markdown}}
{% extends "base.html"%} {% load staticfiles %} {% load custom_markdown %} {%block head_title%} Blog {%endblock%} {% block content%}
As a developer it is important for me to reflect on my practices, reflection on the process allows me to draw the greatest understanding possible. Having not learnt from a mistake makes the mistake not worth having been made; the same could be said for successful actions too.
{{post.body|custom_markdown}}


Test Create/recreate grid
before recreate grid, must call
grid.unsubscribe();
to release event listener
rec:


Here are a few examples of ways that you can use Lucid Tabs. Try out the examples and examine the demo.js
file and the source for this page.
Let’s start by making working tabs with one line of JavaScript and some simple markup.
This is the most standard approach. By default, the Lucid Tabs plugin will search within the element you call it on for anchors with href
values pointing to IDs on the page. These anchors become the tabs, and the elements with the matched IDs become the “pages” that are shown or hidden when the selected tab changes.
This default setup has the added benefit that users without JavaScript enabled will still have working in-page navigation.
In this example, I've added custom animtaions by providing functions for the showPage
and hidePage
options.
I've also set the tabset to start with the second tabs selected. This done using the selected
option.
You can also use Lucid Tabs for a variety of other tasks such as accordions. Click one of the items to expand the list of “subitems.”
If you take a peak at the source, you’ll notice that the markup for the accordion is a definition list. To get Lucid Tabs to recognize the DT
elements as the tabs and the DD
elements as the pages, you need to override the default options locateTabs
and locatePages
with your own functions that return jQuery references to the desired elements.
The selector you use in locatePages
can match multiple elements. In this example, each button (tab) has a data-type
attribute with a value representing the class
of pins to toggle on and off.


This is a first-time-user tutorvial to **discover ESP3** and **understand its basic functions**, using the example dataset provided with the software.
Assuming ESP3 is installed and running normally, this tutorial takes approximately 20 minutes to complete.
**Bullet points** show the actions to take within the context of the tutorial. The rest are notes and comments to understand the software.
Note: The writing of this tutorial is currently in progress, but it's being made already available online to provide a basic help for the early adopters of ESP3. Ellipses (...) show parts that still require completion.
ESP3 comes with a set of EK60 example files, acquired by NIWA in 2015. They are required for this tutorial. You will find them under `\example_data\ek60\` from the ESP3 root folder.
The example dataset consists of 7 raw files (extension .raw) with corresponding bottom files (extension .bot) and index files (extension .idx).
ESP3 creates a number of files when loading and interacting with the data so if the dataset has been loaded before, the example dataset folder may also contain the two folders `bot_reg` and `echoanalysisfiles`, as well as the `echo_logbook.db` file. For this tutorial, we will start from scratch so, if they exist, delete the two folders `bot_reg` and `echoanalysisfiles`, as well as the `echo_logbook.db` file.
2. Run ESP3
- For the MATLAB source code version; run MATLAB, make the ESP3 root folder the Current Folder, and in the Command Window type "EchoAnalysis" and enter.
- For the compiled version, execute `EchoAnalysis.exe` from the ESP3 root folder.
The ESP3 main window should appear. It looks the same in both versions:
Fig.1: ESP3 start up window
3. Set the Default Data Folder
- In the `Menu`, select `Config` then `Path`.
- Ensure the `Default Data Folder` is set to the `\example_data\ek60\` folder that came with ESP3.
- Leave the other fields as default and save to exit.
Note: This is a useful path to set when you work on one dataset for an extended length of time.
4. Open a first file
- In the `Menu`, select `File(s)` then `Open file`.
The contents of the `\example_data\ek60\` folder should show: seven raw data files of the example dataset.
- Open the first file in the list, i.e. `tan1505-D20150428-T010855.raw`.
- Since the example data provided was collected with a multi-frequency system, at the window prompt for frequencies load all (default) and click `OK`.
Because 38 kHz is the most commonly used frequency in fisheries acoustics, it will be displayed on ESP3 once the loading is complete by default.
To visualise data from the other frequencies, access the Freq. drop-down menu of the Display Option tab.
Fig.2: Example data (38 kHz) successfully loaded into ESP3. Red rectangle shows the drop-down Frequency menu
Note that with the development of the multi-frequency capabilities in the most recent versions of ESP3, upon loading multi-frequency data a new window will pop out (named 'All Channels') displaying data from all frequencies.
Although this window is mainly for displaying all frequencies simultaneous, it is also possible open any of the available frequencies in the main window of ESP3 by clicking on the channel of interest located in the bottom-left corner of each channel (e.g., 120 kHz).
Fig.3: All Channels window. By clicking on frequency (black rectangle) data is displayed in ESP3 main window
- Open a Windows File Explorer window and navigate to the `\example_data\ek60\` folder. Note that ESP3 has created an `\echoanalysisfiles\` folder and an `echo_logbook.db` file.
The `\echoanalysisfiles\` folder contains index files to speed up ESP3's future loading of files that have been previously loaded. In our case, it only contains index data for the one file we opened.
The `echo_logbook.db` file is a database for all files in the folder. We will have a closer look at this logbook later.
5. Getting a feel for ESP3
5.1. ESP3's main window organisation
The ESP3 main window has 6 basic components, from top to bottom:
i. The `Menu` allows access to every function of ESP3.
ii. The `Toolbar` is a series of icons allowing fast access to ESP3's various -Cursor Modes*, as well as some basic commands.
iii. The `Control Panel` on the left is composed of tabs allowing a variety of display windows (Overview, Maps, Attitude, etc.), display options (frequency selection, data variables, etc.), actions (calibration, application of algorithms, etc.), lists (regions, layers, etc.). It is where ESP3 is mostly controlled from.
iv. The `Algorithms Panel` on the right is composed of tabs allowing setting parameters for ESP3's algorithms and applying them to the data.
v. The `Main Panel` in the center will be mainly used to show the `Echogram`, but also later the`Logbook`. The `Echogram` comes by default with the `Vertical Profile` on its left and the `Colorbar` on its right although they can both be hidden, while another profile - the `Horizontal Profile` - while not shown by default, can be made visible.
vi. The `Metadata Panel` at the very bottom shows various information about the current file or layer shown in the `Echogram`, and about the ping and sample corresponding to the location of the mouse cursor when on the `Echogram`.
Fig.4: ESP3 window organisation (see text) 5.2 Understanding ESP3's -Cursor modes-
ESP3 has different "Modes" of operation, allowing the user to interact with the `Echogram` in different manners for different purposes.
The actions resulting from the use of the mouse buttons on the `Echogram` differ between each Mode, so it is important to be aware of which Mode you are currently operating under.
The current Mode is indicated as **text** in the middle of the `Metadata Panel`, by the **aspect of the mouse cursor** when it is over the `Echogram`, and by which **icon in the Tools bar** is highlighted (if any).
5.2.1 "Normal" mode
Normal Mode, shown in the `Metadata Panel` as `Cursor mode: Normal`, is displayed as a regular arrow mouse cursor when placed over the `Echogram`, and as the regular arrow icon in `Toolbar'.
(If this is not the case, press the keyboard shortcut `0` (zero) to get into Normal mode.)
"Normal" mode is the default mode, used mainly to view the data, but also to interact with existing Regions and set rectangular selection areas to allow the use of some actions on limited portions of data (more information on those later).
For accessing the different cursor modes click the appropriate icon in the toolbar or by using the appropriate **keyboard shortcut**.
5.2.2 "Zoom In" mode
This mode is used for zooming in on the `Echogram`. Note how the `Metadata Panel` text changed to `Cursor mode: Zoom In`, the mouse cursor aspect changed to a zoom-in cursor, and the zoom-in icon in the toolbar is now highlighted:
- Press the keyboard shortcut `1` to switch to "Zoom In" mode, and press it again or press '0' to return to Normal mode. You can also switch to Zoom in mode from the toolbar.
As you might have noticed, pressing the keyboard shortcut for a mode which is already under use switches ESP3 back to Normal mode.
5.2.3 "Zoom Out" mode
This mode is used for zooming out on the `Echogram`. Note how the `Metadata Panel` text changed to `Cursor mode: Zoom Out`, how the mouse cursor aspect changed to a zoom-out cursor, and how the zoom-out icon in the `Tools` bar is now highlighted:
- Press the keyboard shortcut `Shift` + `1` to switch to the "Zoom Out" mode.
5.2.4 "Bad Transmit" mode
This mode is used to flag/unflag pings as bad transmits. Note how the `Metadata Panel` text changed to `Cursor mode: Bad Transmits`, how the mouse cursor aspect changed to two small, opposite, black arrows, and how the Bad transmit icon in the `Tools` bar is now highlighted:
- Press the keyboard shortcut `2` to switch to the "Bad Transmit" mode.
5.2.5 "Edit Bottom" mode
This mode is used to create/edit/delete bottom detect. Note how the `Metadata Panel` text changed to `Cursor mode: Edit Bottom`, how the mouse cursor aspect changed to a large '+' cross, and how the Edit Bottom icon in the `Tools` bar is now highlighted:
- Press the keyboard shortcut `3` to switch to the "Edit Bottom" mode.
Several tools are available to manually create, edit or delete bottom detect, and available by clicking the small arrow next to the icon:
Fig.5: Bottom tools available while on Edit Bottom mode from the drop-down menu in the toolbar 5.2.6 "Create Region" mode
This mode is used to to create/edit/delete regions for echo-integration. Note how the `Metadata Panel` text changed to `Cursor mode: Create Region`, how the mouse cursor aspect changed to a small double '+' cross, and how the Create Region icon in the `Tools` bar is now highlighted:
- Press the keyboard shortcut `4` to switch to the "Create Region" mode.
5.2.7 "Measure Distance" mode
This mode is used to to measure distances. Note how the `Metadata Panel` text changed to `Cursor mode: Measure`, how the mouse cursor aspect changed to a small white '+' cross, and how the Measure icon in the `Tools` bar is now highlighted:
- Press the keyboard shortcut `5` to switch to the "Measure Distance" mode.
Note: Modes for flagging pins as bad transmits, editing the bottom, and creating regions will be explored more in details in later sections.
5.3 Moving around the Echogram
- Press `0` to get into Normal mode.
- Use the scroll button on the mouse or the keyboard shortcuts `W` and `S` to zoom in and out on the `Echogram`.
- Use the keyboard's up/down/left/right arrow keys to move the zoomed area around. You can also use the keyboard shortcuts `A` to move left and `D` to move right.
Note how the blue box in the `Overview display` that is in the `Control Panel` under the `Display Option` tab changes as you zoom in and out or move around.
While the `Overview display` shows the entire file/layer at all times, the **blue box** superimposed on it represents the extent of data currently shown in the `Echogram`.
Using the `Overview display` and the blue box is another convenient way to move around the data:
- **Move** the blue box around the `Overview Display` with the mouse's left button, thus allowing to conserve the same level of zoom in the `Echogram`.
- **Create** a new blue box on another part of the `Overview Display` by left-clicking **outside** of the current blue box, holding, dragging and releasing the button.
Because of the convenience of manipulating the blue box in the `Overview Display` to rapidly change the data displayed, it is a good idea to undock it from the `Control Panel` to always have it on the screen, particularly if your machine has multiple screens.
- Right-click anywhere on the `Overview Display` to open its contextual menu and select `Dock/Undock MiniAxes` to undock it from the `Control Panel` and into its own separate window (Fig.6).
Fig.6: Undocking Overview display from Control Panel to an external window
- Close the `Overview Display` window to redock it into the `Control Panel`.
Note: The Map&CO, Sv(f), TS(f), Layer list and Region list tabs from the Control Panel, can also be undocked by right-clicking to an external window or the Main Panel (Echogram).
The last option to move around the data is to use the zoom-in and zoom-out Modes. Although less convenient, they offer some additional zoom actions compared to the other options discussed above.
- Press `1` to get in zoom-in Mode and explore the corresponding mouse commands:
i. Left-click- or -right-click- to zoom in one step.
ii. Left-click, drag & release- on the `Echogram` to create a zoom-in box.
iii. Right-click, drag & release- or -Ctrl + left-click, drag & release- to create a zoom box that spans all pings currently shown on the `Echogram`.
- Press `Shift`+`1` to get in zoom-out mode and explore the corresponding mouse commands:
i. Left-click- to zoom-out one step.
ii. Right-click- or -Ctrl + left-click- or -double left-click- to zoom all the way out.
5.4 Components of the Echogram
By default, the `Echogram` is shown accompanied with the `Vertical Profile` on its left and the `Colorbar` on its right.
The `Vertical Profile` in red shows the level of all samples for the ping where the mouse cursor is. The location of the sample where the mouse cursor is shows as a dashed blue line.
- In the `Menu`, select `Display` and check `Show Horz Profile` to show the `Horizontal Profile` in green.
In all modes except "Bad Transmit" and "Edit Bottom", the `Horizontal Profile` shows the level of all pings for the sample where the mouse cursor is. The location of the ping where the mouse cursor is shows as a dashed blue line.
In "Bad Transmit" and "Edit Bottom", the `Horizontal Profile` shows the **average of the four samples immediately above the bottom detection**, to assist with edition of bottom detect and bad transmits.
Note that just like the `Horizontal Profile` was originally hidden, it is also possible to show/hide the `Vertical Profile` and the `Colorbar` by checking `Show Horz Profile` and `Show Colorbar` (respectively) also found under the `Display` part of the `Menu`.
For now however, we will just use the default display so:
- In the `Menu`, select `Display` and uncheck `Show Horz Profile` to hide the `Horizontal Profile`.
5.5 Changing the data displayed
In the `Control Panel`, the `Display Option` tab offers not only the `Overview Display` but also different variables to display and different display options.
- Change the `Frequency`. Frequencies available are those you selected in the first place when you loaded the file.
- Change the `Data` variable. Options are:
- `Power`: ...
- `Angle Across`: ...
- `Angle along`: ...
- `Sv` (default): ...
- `TS Unc`: ...
- The next text fields `X grid` and `Y grid` are for the grid spacing in the X and Y axes, with the unit of the X axis to be chosen in meters, ping numbers, or seconds.
- `TS(dB)` ...
- `Transp.%` ...
- `Disp Max` and `Disp Min` ...
...
6. Logbook and file metadata
- In the `Control Panel`, select the `Layer list` tab.
The `Layer list` tab shows the "layers" currently loaded in ESP3. "Layers" are not the same thing as files and we will see how they differ later, but for now note how the layer only shows the name of the file that was loaded.
Fig.7: Layer list tab from the Control Panel
- In the `Menu`, select `Survey Data` then `Edit/Display Logbook`.
This opens the logbook as a new tab in the `Main Panel`, which lists all data files in the folder containing the file currently displayed, as well as the files' metadata.
Fig.8: Survey logbook in the Main Panel
All displayed info is recorded in the `echo_logbook.db` file that was created earlier by ESP3 in the data folder.
Note: The logbook can also be opened using the keyboard shortcut `L`. Multiple logbooks can be opened using the keyboard shortcut 'Shift+L' while on the Echogram view in the Main Panel.
- Right-click on the logbook's file list to show the contextual menu and select `SurveyData` then `Edit Voyage Info`.
- Add the info for this dataset:
i. `Survey Name`: `East Coast North Island NZ`
ii. `Voyage`: `tan1505`
iii. and press `OK`
- Next, edit the metadata for the first acoustic file in the logbook itself:
i. `Snap.`: `1`
ii. `Strat.`: `A`
iii. `Trans.`: `1`
iv. `Comment`: `added metadata`
Fig.9: Survey logbook including voyage information and metadata for the first acoustic file
All changes are effective immediately in the database. Note how the file in the `Layers` tab is now listed with the metadata newly entered.
Also notice how ESP3 added all the .raw files to the logbook since these were contained in the same folder as the file we loaded previously.
- Now let's open a new file. In the `Menu`, select `File(s)` then `Open next file`. Again, select all frequencies and click `OK`.
Notice in the `Layers` tab that the new file has no metadata. We're going to enter it, this time from the `Echogram`.
- Making sure that this new file is selected in the `Layers` tab so that the `Echogram` displayed is that of this new file, right-click on the `Echogram`, select `Survey Data` then `edit/add survey data for this file`. Enter `1`, `A` and `2` and press `OK`.
The new metadata should show both in the Layers tab and in the logbook.
There is a third way to open files. On the logbook tick the box on the first column of the acoustic file(s) you wish to open, and then right click and select: Open selected file(s).
It is worth to note that files do not need to be opened to complete their metadata field in the logbook. It may be more efficient to complete all the metadata for a particular survey before moving to post-processing.
- In the `Layers` tab, select the two files, right-click, select `Mapping` then `Plot tracks from selected layers` to show the layers' geographical location in a new Navigation window.
Fig.10: Map showing the two layers selected from the Layer list tab
- Move the mouse over different pings on the `Echogram` to see the position of any ping on the Navigation window. Repeat after selecting the other layer in the `Layers` tab.
7. Understanding layers
We will now open two more files, this time from the logbook.
- In the logbook, check the boxes for the two next files, i.e. `tan1505-D20150428-T020308.raw` and `tan1505-D20150428-T021300.raw`, right-click and select `Open selected files`. Again, select all frequencies and click `OK`.
After ESP3 has loaded the two new files, note that the `Layers` list has updated with the files newly loaded, **but this time on a same line**.
Fig.11: Layer list showing two acoustic files as part of one layer
This is because the `Layer list` tab does not show individual files but individual **layers**, which are defined in ESP3 as any data to be displayed and analysed together, independently of the files in which they are found. This design allows to "split" files that contain data that were intended as separate (for example, a file containing several transects) or to "concatenate" files that contain data that were intended as combined (for example, consecutive files making up a single transect).
ESP3 recognizes layers by their unique metadata (Snapshot, Stratum & Transect). In our case, the two files newly opened have the same (empty) metadata so ESP3 assumed they were intended as one single layer and concatenated them.
- In the `Layer list` tab, make sure that latest layer is selected. Then, in the `Menu`, select `Display` then `Display File Lines`. A vertical line appears in the `Echogram`, showing the boundary between the two files in that layer.
- In the `Layers list` tab, select the three layers, right-click, select `Mapping` then `Plot tracks from selected layers` to update the Navigation window.
- In the `Layers` tab, make sure the new layer is selected and move the mouse over the `Echogram`. Notice how the transition from one file to the next corresponds to the end of a turn and beginning of the third transect. We need to update the files' metadata accordingly.
7.1 Set different files as different layers
- In the `Echogram`, right-click on the area corresponding to the **first** file (left of the file line), select `Survey Data` then `Edit/Add Survey Data for this file`. Enter `1`, `turn 2 to 3` and `0` and press `OK`.
Note the newly appeared vertical red and green lines on the `Echogram`, encasing the black file line. They indicate that the `Echogram` now has two layers instead of one.
- Right-click on the area corresponding to the **second** file (right of the file line), select `Survey Data` then `Edit/Add Survey Data for this file`. Enter `1`, `A` and `3` and press `OK`.
Notice the metadata changed both in the logbook and in the `Layers` tab. Indeed, we could have just updated the metadata in the logbook, rather than from the `Echogram`, with the same result.
Since the metadata for the two files is now different, ESP3 should recognize them as different layers.
- Right-click on that layer, select `Layer Management`, then `Split Selected Layers (per survey data)`.
The contents of the `Layers` tab will update accordingly.
- In the `Layer list` tab, select the four layers, right-click, select `Mapping` then `Plot tracks from selected layers` to update the Navigation window. The navigation now shows the two layers separately.
7.2 Split one file into different layers
Remember that the second file we loaded as a single layer and tagged as transect #2 was actually composed of a turn (from transect #1 to transect #2), followed by transect #2 itself. We are going to split it into the appropriate layers.
- Select this layer in the `Layers` tab.
- Mouse over the `Echogram`, using the Navigation window as a reference to find the ping where the turn ends and the transect starts.
- When you are happy with the location, right-click and select `Survey Data` then `Split Transect Here`.
- A window will pop up prompting for metadata **before** the split. This is the turn section so enter `1`, `turn 1 to 2`, and `0`and press `OK`.
- A second window will then pop up prompting for metadata **after** the split. This is the transect section so enter `1`, `A`, and `2` and press `OK`.
- The `Echogram` now shows the green and red vertical lines indicating the boundary between the now two separated layers.
Notice on the logbook that the file is now represented on two lines, with different metadata. This illustrates that each line in the logbook corresponds to sections of files.
8. Bottom detection
The bottom detection is represented as a black line over the `Echogram`. Some files have one and some don't. For those who do, it might be more or less accurate or all over the place. In all cases, it's a good idea to create and/or edit it.
- In the `Control Panel`, `Layers` tab, select the first layer.
- In the `Menu`, select `Display`, check the `Display bottom` option and uncheck the `Display Under Bottom data` option.
- In the `Control Panel`, `Display Option` tab, set a under bottom data transparency (`Transp.%`) value of 80.
- In the `Algorithms panel`, `Bottom Detect V2` tab, set the `Default Values` to `high` and click `Apply`.
The bottom detect resulting from the algorithm now shows on the echogram as a black line and all data below it are partially masked with 80% transparency.
This automatic detection is not perfect and needs some manual editing.
- Zoom-in around the bottom at the beggining of the layer.
- In the `Menu`, select `Display` and check `Show Horz Profile` to show the bottom edit assistant window.
- Click the keyboard shortcut `3` to get into "Bottom editing mode".
Stay with the "Classic Tool", which allows fine control over creating the bottom detect (hand-drawn or polyline) or deleting it locally.
Peaks in the horizontal profile show pings with high energy above the detected bottom. Red circles emphasize unusually high values. Investigate those pings for bottom detection.
- Use the following mouse commands to edit the bottom:
i. Left-click- : to start setting bottom, then...
a. Maintain left button pressed and drag- : to create a hand-drawn section over a series of pings, or...
b. Release button and left-click again*: to create a polyline section over a series of pings.
c. Double left-click- : to complete.
ii. Right-click- or -Ctrl + left-click- : to remove bottom for one ping.
iii. Right-click, drag and release- or -Ctrl + left-click, drag and release*: to remove bottom for series of pings.
- Use the keyboard's arrow keys to advance in the file to check next pings.
Once you are happy with the bottom detection,
- In the `Menu`, select `Bottom/Regions` then `XML` then `Save Bottom to xml` (or use the keyboard shortcut -Ctrl+S*)
- Open the project folder in `Windows Explorer` and notice the new folder `bot_reg` just created by ESP3 to contain data related to bottom detection ('bot') and regions ('reg').
In this folder is a single xml file `b_tan1505-D20150428-T010855.xml` that is composed of the prefix `b_` (for bottom) followed by the name of the file which bottom was just edited
- Open this xml file to see the format of ESP3's bottom record. Notice how the bottom is only recorded for the frequency that was edited.
- Repeat this procedure for all other layers/files.
9. Flag bad transmits
"Bad Transmits Editing" mode:
- Mode used to flag/unflag pings as bad transmits.
- **Keyboard shortcut**: `2`
- **Mouse cursor aspect:**
- **Mouse actions:**
i. Left-click- : Flag ping as bad transmit.
ii. Left-click, drag and release- : Flag series of pings as bad transmits.
iii. Right-click- : Remove bad transmit flag.
iv. Right-click, drag and release- : Remove bad transmit flag for series of pings.
10. Create regions
"Create Regions" mode:
- Mode to create/edit/delete regions.
- **Keyboard shortcut:** `4`
- **Mouse cursor aspect:** Small double '+' cross
- **Mouse actions:**
i. Left-click, drag & release- : Create a region.
ii. Left-click on a region- : Make region active when in "Display Regions" (filled regions) mode.
iii. Delete- : Delete active region.
"Normal" mode:
- Default mode. Used to explore the data, interact with Regions and set rectangle selection areas.
- Use this mode at all times, unless using another mode for specific purpose.
- **Keyboard shortcut:** `0`
- **Mouse cursor aspect:** Normal arrow.
- **Mouse actions:**
i. Left-click on region- : Make region active.
ii. Right-click on bottom/region/selection/display- : Specific contextual menu. If on a region, this also makes it active.
iii. Ctrl + left-click, drag & release- : Create a rectangle selection box.
iv. Shift + left-click, drag & release- : Create a rectangle selection box spreading across all pings.
v. Double left-click- : Delete selection box.


{% extends "base.html" %} {% block content %}
There seems to be no topic names that match this.
You can make a new topic by making a new post


Timestamp MicroService
User Stories:
- I can pass a string as a parameter, and it will check to see whether that string contains either a unix timestamp or a natural language date (example: January 1, 2016)
- If it does, it returns both the Unix timestamp and the natural language form of that date.
- If it does not contain a date or Unix timestamp, it returns null for those properties.
Example Usage
https://timestamper-fcc.herokuapp.com/December%2015,%202015
https://timestamper-fcc.herokuapp.com/1450137600
Example Output
{ "unix":<PHONE_NUMBER>, "natural": "December 15, 2015" }


This is the sentence that is used to substantiate your claims about {{entity}}
Click the word for a definition. These definitions can be used to support the claims you write
The dictionary comes from the blue links on Wikipedia
Aim to spend about 1 minute generating each claims
You are allowed to incorporate your own world knowledge in making these modifications.
If it is not possible to generate facts or misinformation, leave the box blank.
Modify the claim by rephrasing it or providing a paraphrase so that the meaning is preserved. You should aim to substitute entites and relations with synonyms if possible.
The mutated claim must be about {{entity}}.
You put:
We came up with:
Change the sentence to negate the meaning.
The mutated claim must be about {{entity}}.
You put:
We came up with:
Substitute either a relation, property and/or an attribute of {{entity}} in the claim to something else from the same set of things.
The mutated claim must be about {{entity}}.
You Put:
We came up with:
Substitute either a relation, property and/or an attribute of {{entity}} in the claim to something else from a differnet set of things.
The mutated claim must be about {{entity}}.
You put:
We came up with:
Modify the claim by replacing either a relation, property and/or an attribute of {{entity}} to something more specific that implies the original claim.
The mutated claim must be about {{entity}}.
You put:
We came up with:
Modify the claim by replacing either a relation, property and/or an attribute of {{entity}} to something more general that is implied by the original claim.
The mutated claim must be about {{entity}}.
You put:
We came up with:


Design your corporate website, giving your clients a professional and attractive image.
Create agile solutions and offer mobile application development for end users.
Specialists in .NET, PHP and Android technologies to develop solutions for your business.
We put at your disposal specialized personnel in software systems to guide you in each phase of the process.
Provide technical support for software solutions developed with trained and specialized personnel.
We are a software development company specialized in supporting its clients and business partners to develop their ideas.
Located in the city of Mexicali, Baja California has expanded its horizons to the international market bringing to Mexico new technologies and programming languages, putting specialists in the field at its disposal.
We adapt to the nature of your project and develop quality software using the best technologies and methodologies.
We know that the most important thing for you is your customers, that's why we provide specialized technical support for your solutions.
Designed especially for your needs, in order to have the best customer service available.
We bring your website to life with attractive designs.
We make your projects more dynamic and agile.
Parallax sections to give illusion to the background and move figures in the foreground.
We make your site agile and with high performance providing a better experience
We create an optimal visual experience on any browser or mobile device.
We serve your needs with excellent customer service.
Day by day we study the new trends in the field to be continuously updated for you.
You will have the tools you need to feel confident that you are on the right track.
We will get to know your business as much as you want us to in order to give you the functionalities you really need.
You can be sure that we will solve your doubts and give you the best follow up so that nothing will stop you.


OpenData SMN is a simple REST API for SwissMetNet data. It's developed in the open supporting the OpenData.ch initiative.
The actual data for 10min intervals is provided by opendata.swiss, the Swiss open government data portal.
Getting started
- navigate to the /smn resource to fetch the latest available data set
- browse the executable API documentation to discover the full API
- download a generated OpenAPI v3 YAML contract


// Schedule an event to fire at a specific date/time
Schedule.On(DateRules.On(2013, 10, 7), TimeRules.At(13, 0), () =>
{
Log("SpecificTime: Fired at : " + Time);
});
// Schedule an event to fire every trading day for a security
// The time rule here tells it to fire 10 minutes after SPY's market open
Schedule.On(DateRules.EveryDay("SPY"), TimeRules.AfterMarketOpen("SPY", 10), () =>
{
Log("EveryDay.SPY 10 min after open: Fired at: " + Time);
});
// Schedule an event to fire every trading day for a security
// The time rule here tells it to fire 10 minutes before SPY's market close
Schedule.On(DateRules.EveryDay("SPY"), TimeRules.BeforeMarketClose("SPY", 10), () =>
{
Log("EveryDay.SPY 10 min before close: Fired at: " + Time);
});
// Schedule an event to fire on certain days of the week
Schedule.On(DateRules.Every(DayOfWeek.Monday, DayOfWeek.Friday), TimeRules.At(12, 0), () =>
{
Log("Mon/Fri at 12pm: Fired at: " + Time);
});
# schedule an event to fire at a specific date/time
self.Schedule.On(self.DateRules.On(2013, 10, 7), \
self.TimeRules.At(13, 0), \
self.SpecificTime)
# schedule an event to fire every trading day for a security the
# time rule here tells it to fire 10 minutes after SPY's market open
self.Schedule.On(self.DateRules.EveryDay("SPY"), \
self.TimeRules.AfterMarketOpen(self.spy, 10), \
self.EveryDayAfterMarketOpen)
# schedule an event to fire every trading day for a security the
# time rule here tells it to fire 10 minutes before SPY's market close
self.Schedule.On(self.DateRules.EveryDay("SPY"), \
self.TimeRules.BeforeMarketClose("SPY", 10), \
self.EveryDayBeforeMarketClose)
# schedule an event to fire on certain days of the week
self.Schedule.On(self.DateRules.Every(DayOfWeek.Monday, DayOfWeek.Friday), \
self.TimeRules.At(12, 0), \
self.EveryMonFriAtNoon)
# the scheduling methods return the ScheduledEvent object which can be used
# for other things here I set the event up to check the portfolio value every
# 10 minutes, and liquidate if we have too many losses
self.Schedule.On(self.DateRules.EveryDay(), \
self.TimeRules.Every(timedelta(minutes=10)), \
self.LiquidateUnrealizedLosses)
# schedule an event to fire at the beginning of the month, the symbol is
# optional.
# if specified, it will fire the first trading day for that symbol of the month,
# if not specified it will fire on the first day of the month
self.Schedule.On(self.DateRules.MonthStart("SPY"), \
self.TimeRules.AfterMarketOpen("SPY"), \
self.RebalancingCode)
def SpecificTime(self):
self.Log("SpecificTime: Fired at : {0}".format(self.Time))
def EveryDayAfterMarketOpen(self):
self.Log("EveryDay.SPY 10 min after open: Fired at: {0}".format(self.Time))
def EveryDayBeforeMarketClose(self):
self.Log("EveryDay.SPY 10 min before close: Fired at: {0}".format(self.Time))
def EveryMonFriAtNoon(self):
self.Log("Mon/Fri at 12pm: Fired at: {0}".format(self.Time))
def LiquidateUnrealizedLosses(self):
''' if we have over 1000 dollars in unrealized losses, liquidate'''
if self.Portfolio.TotalUnrealizedProfit < -1000:
self.Log("Liquidated due to unrealized losses at: {0}".format(self.Time))
self.Liquidate()
def RebalancingCode(self):
''' Good spot for rebalancing code?'''
pass


0.6.5 - 27-Dec-2010
- Fixed getpriority and setpriority so that the underlying process handle is
always closed. Thanks go to Rafal Michalski for the spot and patch.
- Updated getpriority and setpriority so that there are no longer any default
arguments. This now matches the MRI spec.
- Updated Process.create so
that illegal options now raise an ArgumentError instead of a Process::Error.
- Fixed a bug in an error message in the Process.create method where the
actual error message was getting lost.
- Refactored the test suite to use test-unit 2.x features, and make tests a
little more robust in general.
0.6.4 - 13-Nov-2010
- Altered the wait, wait2, waitpid and waitpid2 methods to match the current
MRI interface, i.e. they accept and optional pid and flags, though the
latter is ignored. Thanks go to Robert Wahler for the spot.
- Renamed the example scripts to avoid any potential confusion with actual
test scripts and cleaned them up a bit.
- Added Rake tasks to run the example programs.
- Updated the MANIFEST.
0.6.3 - 9-Nov-2010
- Fixed a bug in the Process.kill method where the
remote thread created was not being properly closed. Thanks go to Ben Nagy
for the spot.
- Added the Process.job? method that returns whether or not the current
process is already in a job.
- Added the Process.setrlimit
method. Like the Process.getrlimit method it only
supports a limited subset of resources.
- Rakefile tweaks.
0.6.2 - 19-Dec-2009
- Fixed an issue where stdin, stdout and stderr might not be inheritable even
if the inherit option was set. Thanks go to Michael Buselli for the spot
and the patch.
- Added a basic implementation of Process.getrlimit.
- Added the Process.get_affinity method.
- Added test-unit 2.x and sys-proctable as development dependencies.
- Added the :uninstall and :build_gem Rake tasks to the Rakefile.
- Bumped required version of windows-pr to 1.0.6.
0.6.1 - 16-Jul-2009
- Added the Process.uid method.
This method returns a user id (really, the RID of the SID) by default, but
can also take an optional parameter to return a binary SID instead at the
user‘s discretion.
- Added working implementations of Process.getpriority and Process.setpriority. Note they
they only work for processes, not process groups or users.
- Set license to Artistic 2.0, and updated the gemspec.
0.6.0 - 31-Oct-2008
- The mandatory argument for Process.create has been switched
from ‘app_name’ to ‘command_line’, to be more in
line with underlying CreateProcess API. Note that
‘command_line’ will default to ‘app_name’ if only
the latter is set, but both may be set individually. Keep in mind that
‘app_name’ must be a full path to the executable. Thanks go to
Jeremy Bopp for the patch.
- Removed the deprecated ProcessError constant. Use Process::Error instead.
- Explicitly include and extend the Windows::Thread module now. Thanks go to
Qi Lu for the spot.
- Slightly more robust internal code handling for some of the other methods,
typically related to ensuring that HANDLE‘s are closed.
- Example programs are now included with the gem.
0.5.9 - 14-Jun-2008
0.5.8 - 24-Mar-2008
- Fixed a bug in Process.create
where the handles in the PROCESS_INFORMATION struct were not closed,
regardless of the ‘close_handles’ option. Thanks go to Lars
Christensen for the spot and the patch.
0.5.7 - 27-Mar-2008
- Fixed issues with thread_inherit and process_inherit in the Process.create method. This in
turn required an update to windows-pr. Thanks go to Steve Shreeve for the
spot.
- Fixed a potential issue with startf_flags and stdin/stdout/stderr handling.
Thanks again go to Steve Shreeve for the spot and the patch.
- Fixed the code so that it no longer emits redefinition warnings.
- Fixed a bug in the Rake install task (for non-gem installations).
0.5.6 - 13-Mar-2008
- Fixed a bug in the Process.waitpid2 method where it
wasn‘t returning the proper exit code. Thanks go to Jeremy Bopp for
the spot and the patch.
- In the spirit of DWIM, if the ‘stdin’, ‘stdout’ or
‘stderr’ keys are encountered in the startup_info hash, then
the inherit flag is automatically set to true and the startf_flags key is
automatically OR‘d with the STARTF_USESTDHANDLES value. Thanks go to
Sander Pool for the inspiration.
0.5.5 - 12-Dec-2007
- The Process.create method now
automatically closes the process and thread handles in the ProcessInfo
struct before returning, unless you explicitly tell it not to via the
‘close_handles’ option.
- The Process.create method now
supports creating a process as another user via the
‘with_logon’, ‘password’ and ‘domain’
options.
0.5.4 - 23-Nov-2007
- Changed ProcessError to Process::Error.
- Now requires windows-pr 0.7.3 or later because of some reorganization in
that library with regards to thread functions.
- Better cleanup of HANDLE‘s in a couple methods when failure occurs.
- Added an additional require/include necessitated by a change in the method
organization in the windows-pr library.
0.5.3 - 29-Jul-2007
- Added a Rakefile with tasks for installation and testing.
- Removed the install.rb file (now handled by the Rakefile).
- Updated the README and MANIFEST files.
0.5.2 - 22-Jan-2007
- The startup_info parameter for the Process.create method now
accepts ‘stdin’, ‘stdout’, and ‘stderr’
as valid parameters, which you can pass a Ruby IO object or a fileno in
order to redirect output from the created process.
0.5.1 - 24-Aug-2006
- Fixed a bug in the Process.create method where the
return value for CreateProcess() was being evaluated incorrectly. Thanks go
to David Haney for the spot.
- Added a slightly nicer error message if an invalid value is passed to the
Process.create method.
- Removed an extraneous ’%’ character from an error message.
0.5.0 - 29-Jul-2006
- The Process.create method now
returns a ProcessInfo struct instead of the pid. Note that you can still
grab the pid out of the struct if needed.
- The Process.create method now
allows the process_inherit and thread_inherit options which determine
whether a process or thread object‘s handles are inheritable,
respectively.
- The wait and wait2 methods will now work if GetProcessId() isn‘t
defined on your system.
- The ‘inherit?’ hash option was changed to just
‘inherit’ (no question mark).
- Minor doc correction - the ‘inherit’ option defaults to false,
not true.
0.4.2 - 29-May-2006
- Fixed a typo/bug in Process.kill for signal 3, where
I had accidentally used CTRL_BRK_EVENT instead of the correct
CTRL_BREAK_EVENT. Thanks go to Luis Lavena for the spot.
0.4.1 - 13-May-2006
- Fixed a bug where spaces in $LOAD_PATH would cause Process.fork to fail. Thanks go
to Justin Bailey for the spot and patch.
- Added a short synopsis to the README file.
0.4.0 - 7-May-2006
- Now pure Ruby, courtesy of the Win32API package.
- Now comes with a gem.
- Modified Process.kill to send
a signal to the current process if pid 0 is specified, as per the current
1.8 behavior.
- Process.create now accepts
the ‘environment’ key/value, where you can pass a
semicolon-separated string as the environment for the new process.
- Moved the GUI related options of Process.create to subkeys of the
‘startup_info’ key. See documentation for details.
- Replaced Win32::ProcessError with just ProcessError.
0.3.3 - 16-Apr-2006
- Fixed a bug in Process.create
with regards to creation_flags. Thanks go to Tophe Vigny for the spot.
0.3.2 - 12-Aug-2005
- Fixed a bug in Process.kill
where a segfault could occur. Thanks go to Bill Atkins for the spot.
- Changed VERSION to WIN32_PROCESS_VERSION, because it‘s a module.
- Made the CHANGES, README and doc/process.txt documents rdoc friendly.
- Removed the process.rd file.
0.3.1 - 9-Dec-2004
- Modified Process.fork to
return an actual PID instead of a handle. This means that it should work
with Process.kill and other
methods that expect an actual PID.
- Modified Process.kill to
understand the strings "SIGINT", "INT",
"SIGBRK", "BRK", "SIGKILL" and
"KILL". These correspond to signals 2, 3 and 9, respectively.
- Added better $LOAD_PATH handling for Process.fork. Thanks go to Aslak
Hellesoy for the spot and the patch.
- Replaced all instances of rb_sys_fail(0) with rb_raise(). This is because
of a strange bug in the Windows Installer that hasn‘t been nailed
down yet. This means that you can‘t rescue Errno::ENOENT any more,
but will have to rescue StandardError. This only affects Process.kill.
- The signals that were formerly 1 and 2 and now 2 and 3. I did this because
I wanted the same signal number for SIGINT as it is on *nix.
- Added a test_kill.rb script under the examples directory.
- Other minor cleanup and corrections.
0.3.0 - 25-Jul-2004
- Added the create() method.
- Moved the example programs to doc/examples.
- Updated the docs, and toned down claims of fork‘s similarity to the
Unix version.
- Minor updates to the test suite.
0.2.1 - 17-May-2004
- Made all methods module functions, except fork, rather than singleton
methods.
- Minor doc changes.
0.2.0 - 11-May-2004
- Removed the Win32 module/namespace. You no longer ‘include
Win32’ and you no longer need to prefix Process with ‘Win32::’.
- The fork() method is now a global function as well as a method of the Process module. That means you can call
‘fork’ instead of ‘Process.fork’ if you like.
- Doc updates to reflect the above changes.
0.1.1 - 6-Mar-2004
- Fixed bug where spaces in the directory name caused the fork() method to
fail (Park).
- Normalized tc_process.rb somewhat to make it easier to run outside of the
test directory if desired.
- Fixed up tc_process.rb a bit.
0.1.0 - 19-Feb-2004


Publications
Publications by the present team
Taylor. B., Elliott, B., Conneller, C., Milner, N., Bayliss, A., Knight, B., & Bamforth, M. (2017). Resolving the Issue of Artefact Deposition at Star Carr’. Proceedings of the Prehistoric Society,https://doi.org/10.1017/ppr.2017.8
Conneller, C., Bayliss, A., Milner, N., & Taylor, B. (2016). The Resettlement of the British Landscape: Towards a chronology of Early Mesolithic lithic assemblage types. Internet Archaeology, 42, http://dx.doi.org/10.11141/ia.42.12
High, K., Milner, N., Panter, I., Demarchi, B., & Penkman, K. E. H. (2016). Lessons from Star Carr on the vulnerability of organic archaeological remains to environmental change. PNAS, http://dx.doi.org/10.1073/pnas.1609222113
Croft, S., Monnier, G., Radini, A., Little, A., & Milner, M. (2016). Lithic Residue Survival and Characterisation at Star Carr: a burial experiment. Internet Archaeology, 42, http://dx.doi.org/10.11141/ia.42.5
Little, A., Elliott, B., Conneller, C., Pomstra, D., Evans, A. A., Fitton, L. C., Holland, A., Davis, R., Kershaw, R., O’Connor, S., O’Connor, T., Sparrow, T., Wilson, A. S., Jordan, P., Collins, M. J., Colonese, A. C., Craig, O. E., Knight, R., Lucquin, A. J. A., Taylor, B., & Milner, N. (2016). Technological Analysis of the World’s Earliest Shamanic Costume: A Multi-Scalar, Experimental Study of a Red Deer Headdress from the Early Holocene Site of Star Carr, North Yorkshire, UK. PLoS ONE, 11(4), e0152136, doi:10.1371/journal.pone.0152136
Albert, B., Innes, J., Blackford, J., Taylor, B., Conneller, C., & Milner, N. (2016). Degradation of the wetland sediment archive at Star Carr: An assessment of current palynological preservation. Journal of Archaeological Science: Reports, 6, 488-495, doi:10.1016/j.jasrep.2016.03.010
Milner, N., Bamforth, M., Beale, G., Carty, J. C., Chatzipanagis, K., Croft, S., Conneller, C., Elliot, B., Fitton, L. C., Knight, B., Kroger, R., Little, A., Needham, A., Robson, H. K., Rowley, C. C. A., & Taylor, B. (2016). A unique engraved shale pendant from the site of Star Carr: the oldest Mesolithic art in Britain. Internet Archaeology, 40, http://dx.doi.org/10.11141/ia.40.8.
Robson, H. K., Little, A., Jones, A. K. G., Blockley, S., Candy, I., Matthews, I., Palmer, A., Schreve, D., Tong, E., Pomstra, D., Fletcher, L., Hausmann, N., Taylor, B., Conneller, C., & Milner, N. (2016). Scales of analysis: evidence of fish and fish processing at Star Carr. Journal of Archaeological Science: Reports, http://dx.doi.org/10.1016/j.jasrep.2016.02.009.
Milner, N., Conneller, C., & Taylor, B. (2015). Recent work at Star Carr: A POSTGLACIAL landscape study. In N. Bicho, C. Detry, T. D. Price, & E. Cunha (Eds.), Muge 150th: The 150th Anniversary of the Discovery of Mesolithic Shellmiddens-Volume 2. (pp. 125-138). Newcastle upon Tyne: Cambridge Scholars Publishing.
Milner, N. (2015). Star Carr (England). In K. B. Metheny, & M. C. Beaudry (Eds.), Archaeology of Food: An Encyclopedia-Volume 2. (pp. 479). USA: Rowman and Littlefield.
High, K., Milner, N., Panter, I., & Penkman, K. E. H. (2015). Apatite for destruction: Investigating bone degradation due to high acidity at Star Carr. Journal of Archaeological Science, 59, 159-168, 10.1016/j.jas.2015.04.001.
Candy, I., Farry, A., Darvill, C. M., Palmer, A., Blockley, S. P. E., Matthews, I. P., MacLeod, A., Deeprose, L., Farley, N., Kearney, R., Conneller, C., Taylor, B., & Milner, N. (2015). The evolution of Palaeolake Flixton and the environmental context of Star Carr: an oxygen and carbon isotopic record of environmental change for the early Holocene. PROCEEDINGS OF THE GEOLOGISTS ASSOCIATION, 126(1), 60-71.10.1016/j.pgeola.2014.10.001.
Palmer, A. P., Matthews, I. P., Candy, I., Blockley, S. P. E., Macleod, A., Darvill, C. M., Milner, N., Conneller, C., & Taylor, B. (2015). The evolution of Palaeolake Flixton and the environmental context of Star Carr, NE. Yorkshire: stratigraphy and sedimentology of the Last Glacial-Interglacial Transition (LGIT) lacustrine sequences. PROCEEDINGS OF THE GEOLOGISTS ASSOCIATION, 126(1), 50-59. 10.1016/j.pgeola.2014.10.002.
High, K., Penkman, K., Milner, N., & Panter, I. (2013). Fading Star: Towards understanding the effects of acidification on organic remains (wood) at Star Carr. In T. Grant, & C. Cook (Eds.), Proceedings of the 12th ICOM-CC Wet organic archaeological materials conference, Istanbul 2013. (pp. 28-35). International Council of Museums, Committee for Conservation, Working Group on Wet Organic Archaeological Materials.
Milner, N., Taylor, B., Conneller, C., & Schadla-Hall, R. T. (2013). Star Carr: Life in Britain after the Ice Age. Council for British Archaeology. 10.11141/AfA1.
Conneller, C., Milner, N., Taylor, B., & Taylor, M. (2012). Substantial settlement in the European Early Mesolithic: new research at Star Carr. Antiquity, 86(334), 1004-1020.
Milner, N., Conneller, C., Taylor, B., & Schadla-Hall, R. T. (2012). The Story of Star Carr. Council for British Archaeology.
Taylor, B. (2011). Early Mesolithic activity in the wetlands of the Lake Flixton Basin. Journal of Wetland Archaeology, 11(1), 63-84.
Milner, N., Lane, P. J., Taylor, B., Conneller, C., & Schadla-Hall, T. (2011). Star Carr in a Postglacial Lakescape: 60 Years of Research. Journal of Wetland Archaeology, 11(1), 1-19.
Milner, N., Conneller, C., Elliott, B., Koon, H., Panter, I., Penkman, K., Taylor, B., & Taylor, M. (2011). From Riches to Rags: Organic Deterioration at Star Carr. Journal of Archaeological Science, 38(10), 2818-2832. [38]. 10.1016/j.jas.2011.02.015.
Boreham, S., Conneller, C., Milner, N., Needham, A., Boreham, J., & Rolfe, C. J. (2011). Geochemical indicators of preservation status and site deterioration at Star Carr. Journal of Archaeological Science, 30(10), 1-25. 10.1016/j.jas.2011.01.016.
Conneller, C., Milner, N., & Taylor, B. (2011). Recent Excavations at Star Carr. Yorkshire Archaeological Society Bulletin, 48.
Conneller, C., Milner, N., & Taylor, B. (2011). New Finds at Star Carr. British Academy Review, 16, 30-31.
Taylor, B., Conneller, C., & Milner, N. (2010). Little house by the shore. British Archaeology, 115.
Elliott, B. J., & Milner, N. (2010). Making a point: a critical review of the barbed point manufacturing process practiced at Star Carr. Proceedings of the Prehistoric Society, 76, 75-94. 10.1017/S0079497X00000451.
Hadley, P., Hall, A. R., Taylor, M., Needham, A., Taylor, B., Conneller, C., & Milner, N. (2010). To block lift or not to block lift?: An experiment at the Early Mesolithic site of Star Carr, North-East Yorkshire, UK. Internet Archaeology, 28. 10.11141/ia.28.2.
Last, J., Milner, N., Taylor, B., & Conneller, C. (2009). English Heritage Seminar on Star Carr. Mesolithic Miscellany, 19(2), 25-28.
Conneller, C., Milner, N., Schadla-Hall, R. T., & Taylor, B. (2009). Star Carr in the new millennium. In N. Finlay, S. McCartan, N. Milner, & C. Wickham-Jones (Eds.), From Bann flakes to Bushmills. Papers in honour of Professor Peter Woodman. (pp. 78-88). Oxford: Oxbow.
Conneller, C., Milner, N., Schadla-Hall, T., & Taylor, B. (2009). The temporality of the Mesolithic landscape: new work at Star Carr. In P. Crombé, V. Strydonck, M. Sergant, M. Boudin, & M. Bats (Eds.), Chronology and Evolution within the Mesolithic of North-West Europe: Proceedings of an International Meeting, Brussels, May 30th-June 1st 2007. (pp. 77-94). Newcastle upon Tyne: Cambridge Scholars Publishing.
Conneller, C. (2007). Inhabiting new landscapes: settlement and mobility in Britain after the last glacial maximum. Oxford Journal of Archaeology, 26(3), 215-237.
Taylor, B. (2007). Recent excavations at Star Carr, North Yorkshire. Mesolithic Miscellany, 18(2), 12-17.
Milner, N. (2007). Fading Star. British Archaeology, 96, 10-14.
Conneller, C. (2007). New Excavations at Star Carr. Past, 56, 3-5.
Conneller, C. (2004). Becoming deer: corporeal transformations at Star Carr. Archaeological Dialogues, 11(1), 37-56.
Conneller, C. (2003). Star Carr in context. In L. Bevan and J. Moore (Eds.), Peopling the Mesolithic in a Northern Environment. (pp. 81-86). Oxford: Archaeopress.
Conneller, C., & Schadla-Hall, T. (2003). Beyond Star Carr: the Vale of Pickering in the 10th millennium BP. Proceedings of the Prehistoric Society, 69, 85-106.
Other publications
Rowley-Conwy, P. (2017). To the Upper Lake: Star Carr revisited – by birchbark canoe. In P. Rowley-Conwy, D. Serjeantson, & P. Halstead (Eds.), Economic Zooarchaeology: Studies in Hunting, Herding and Early Agriculture. (pp. 197-207). Oxford: Oxbow
Dark, P. (2017). Pollen and preservation at Star Carr: A 60-year perspective. Journal of Archaeological Science: Reports, 13, 240–248, http://dx.doi.org/10.1016/j.jasrep.2017.03.057
Dark, P. (2017). Monitoring recent pollen preservation changes at Star Carr: a comment on Albert et al. (2016). Journal of Archaeological Science: Reports, 12, 28–31, http://dx.doi.org/10.1016/j.jasrep.2017.01.020
Uchiyama, J. (2015). From Awashimadai to Star Carr: A Japanese Jomon perspective on the subsistence strategies and settlement patterns of Early Mesolithic hunter–gatherers in the Vale of Pickering, UK. Quaternary International, http://www.sciencedirect.com/science/article/pii/S1040618215000026
Emerick, K. (2011). The Management of Star Carr. Journal of Wetland Archaeology, 11(1), 120-132.
Innes, J. B., Blackford, J. J., & Simmons, I. G. (2011). Mesolithic Environments at Star Carr, the Eastern Vale of Pickering and Environs: Local and Regional Contexts. Journal of Wetland Archaeology, 11(1), 85-108.
Vorenhout, M. (2011). In Situ Preservation and Monitoring with Particular Application to Star Carr, Yorkshire, UK. Journal of Wetland Archaeology, 11(1), 56-62.
Brown, T., Bradley, C., Grapes, T., & Boomer, I. (2011). Hydrological Assessment of Star Carr and the Hertford Catchment, Yorkshire, UK. Journal of Wetland Archaeology, 11(1), 36-55.
Boreham, S., Boreham, J., & Rolfe, C. J. (2011). Physical and Chemical Analyses of Sediments from around Star Carr as Indicators of Preservation. Journal of Wetland Archaeology, 11(1), 20-35.
Rowley-Conwy, P. (2010). From Great Bog to Sedge Fen: a note on Grahame Clark's interpretation of Star Carr in its landscape context. In A. Marciniak, & J. Coles (Eds.), Grahame Clark and his Legacy. (pp. 68-84). Newcastle upon Tyne: Cambridge Scholars.
Mellars, P. (2009). Moonshine over Star Carr: post-processualism, Mesolithic myths and archaeological realities. Antiquity, 83(320), 502-517.
Schulting, R., & Richards, M. (2009). Dogs, divers, deer and diet. Stable isotope results from Star Carr and a response to Dark. Journal of Archaeological Science, 36(2), 498–503.
Dark, S. P., Higham, T. F. G., Jacobi, R. M., & Lord, T. C. (2006). New Radiocarbon Accelerator Dates On Artefacts From The Early Mesolithic Site Of Star Carr, North Yorkshire. Archaeometry, 48(1), 185-200.
Lane, P. J., & Schadla-Hall, R. T. (2004). The Many Ages of Star Carr: Do ‘Cites’ Make the ‘Site’?. Hunter-Gatherers in History, Archaeology and Anthropology, 145.
Dark, P. (2003). Dogs, a crane (not duck) and diet at Star Carr: a response to Schulting and Richards. Journal of Archaeological Science, 30(10), 1353–1356.
Milner, N. (2003). Pitfalls and Problems in Analysing and Interpreting the Seasonality of Faunal Remains. Archaeological Review from Cambridge, 16(1), 50-65.
Bevan, L. (2003). Stag nights and horny men: Antler symbolism and interaction with the animal world during the mesolithic. In L. Bevan and J. Moore (Eds.), Peopling the Mesolithic in a Northern Environment. (pp. 35-44). Oxford: Archaeopress.
Chatterton, R. (2003). Star Carr Reanalysed. In L. Bevan and J. Moore (Eds.), Peopling the Mesolithic in a Northern Environment. (pp. 69-80). Oxford: Archaeopress.
Schulting, R., & Richards, M. P. (2002). Dogs, Ducks, Deer and Diet: New Stable Isotope Evidence on Early Mesolithic Dogs from the Vale of Pickering, North-east England. Journal of Archaeological Science, 29, 327-333.
Conneller, C. (2001). Hunter-gatherers in the landscape: Technical economies of the Vale of Pickering. In M. Zvelebil and K. Fewster (Eds.), Ethnoarchaeology and hunter-gatherers. (pp. 1-12). Oxford: Archaeopress.
Pollard, J. (2000). Ancestral Places in the Mesolithic landscape. Archaeological Review from Cambridge, 17(1), 123-138.
Dark, P. (2000). Revised ‘absolute’ dating of the early Mesolithic site of Star Carr, North Yorkshire, in the light of changes in the early Holocene tree-ring chronology. Antiquity, 74, 304-7.
Carter, R. J. (1998). Reassessment of Seasonality at the Early Mesolithic Site of Star Carr, Yorkshire Based on Radiographs of Mandibular Tooth Development in Red Deer (Cervus elaphus). Journal of Archaeological Science, 25(9), 851–856.
Mellars, P., & Dark, P. (1998). Star Carr in context: new archaeological and palaeoecolgical investigations at the early Mesolithic site of Star Carr, North Yorkshire. Cambridge: McDonald Institute.
Aveling, E. M., & Heron, C. (1998). Identification of birch bark tar at the Mesolithic site of Star Carr. Ancient biomolecules, 2(1), 69-80.
Carter, R. J. (1997). Age estimation of the roe deer (Capreolus capreolus) mandibles from the Mesolithic site of Star Carr, Yorkshire, based on radiographs of mandibular tooth development. Journal of Zoology, 241(3), 495-502.
Day, S. P. (1996). Dogs, Deer and Diet at Star Carr: a Reconsideration of C-isotope Evidence from Early Mesolithic Dog Remains from the Vale of Pickering, Yorkshire, England. Journal of Archaeological Science, 23(5), 783–787.
Day, S. P., & Mellars, P. A. (1994). Absolute dating of Mesolithic human activity at Star Carr, Yorkshire: new palaeoecological studies and identification of the 9600 bp radiocarbon ‘plateau’. Proceedings of the Prehistoric Society, 60, 417-422.
Day, P. (1993). Preliminary results of high-resolution palaeoecological analyses at Star Carr, Yorkshire. Cambridge Archaeological Journal, 3(1), 129-133.
Mellars, P. (1990). A major ‘plateau’ in the radiocarbon time-scale at c. 9650 bp: the evidence from Star Carr (North Yorkshire). Antiquity, 64(245), 836-841.
Clutton-Brock, J., & Noe-Nygaard, N. (1990). New osteological and C-isotope evidence on mesolithic dogs: Companions to hunters and fishers at Star Carr, Seamer Carr and Kongemose, Journal of Archaeological Science, 17(6), 643–653.
Legge, A. J., & Rowley-Conwy, P. A. (1989). Some preliminary results of a re-examination of the Star Carr fauna. In C. Bonsall (Ed.), The Mesolithic in Europe: Papers Presented at the Third International Symposium, Edinburgh 1985. (pp. 225-230). Edinburgh: John Donald Publishers Ltd.
Dumont, J. V. (1989). Star Carr: the Results of a Micro-Wear Study. In C. Bonsall (Ed.), The Mesolithic in Europe: Papers Presented at the Third International Symposium, Edinburgh 1985. (pp. 231-240). Edinburgh: John Donald Publishers Ltd.
Legge, A., & Rowley-Conwy, P. (1988). Star Carr revisited: a re-analysis of the large mammals. London: Centre for Extra-Mural Studies.
Cloutman, E. W., & Smith, A. G. (1988). Palaeoenvironments in the Vale of Pickering. Part 3: Environmental History at Star Carr. Proceedings of the Prehistoric Society, 54, 37-58.
Cloutman, E. W. (1988). Palaeoenvironments in the Vale of Pickering. Part 2: Environmental History at Seamer Carr. Proceedings of the Prehistoric Society, 54, 21-36.
Cloutman, E. W. (1988). Palaeoenvironments in the Vale of Pickering. Part I: Stratigraphy and Palaeogeography of Seamer Carr, Star Carr and Flixton Carr. Proceedings of the Prehistoric Society, 54, 1-19.
Dumont, J. (1988). A microwear analysis of selected artifact types from the Mesolithic sites of Star Carr and Mount Sandel. Oxford: Archaeopress.
Harrison, C. J. O. (1987). A re-examination of the Star Carr birds. Naturalist,112, 141.
Dumont, J. V. (1983). An interim report of the Star Carr microwear study. Oxford journal of archaeology, 2(2), 127-145.
Noe-Nygaard, N. (1983). A new find of brown bear (Ursus arctos) from Star Carr and other finds in the late glacial and post glacial of Britain and Denmark. Journal of Archaeological Science, 10(4), 317–325.
Price, T. (1982). Willow Tales and Dog Smoke. Quarterly Review of Archaeology, 3, 4-7.
Andresen, J., Byrd, B., Elson, M., McGuire, R., Mendoza, R., Staski, E., & White, P. (1981). The deer hunters: Star Carr reconsidered. World Archaeology, 13(1), 31-46.
Pitts, M. (1979). Hides and antlers: a new look at the gatherer-hunter site at Star Carr, North Yorkshire, England. World Archaeology, 11(1), 32-42.
Jacobi, R. (1978). Northern England in the eighth millennium bc: an essay. In P. Mellars (Ed.), The early postglacial settlement of Northern Europe.(pp. 295-332). London: Duckworth.
Caulfield, S. (1978). Star Carr – an alternative view. Irish Archaeological Research Forum, 5, 15-22.
Wheeler, A. (1978). Why Were There No Fish Remains at Star Carr? Journal of Archaeological Science, 5, 85-89.
Noe-Nygaard, N. (1975). Two shoulder blades with healed lesions from Star Carr. Proceedings of the Prehistoric Society, 41, 10-16.
Clark, J. G. D. (1972). Star Carr: a Case Study in Bioarchaeology. Addison-Wesley module in Anthropology, 10.
Degerbøl, M. (1961). On a find of a Preboreal domestic dog (Canis familiaris L.) from Star Carr, Yorkshire, with remarks on other Mesolithic dogs. Proceedings of the Prehistoric Society, 27, 35-55.
Clark, J. G. D. (1956). Star Carr, a Mesolithic Site in Yorkshire. Recent Archaeological Excavations in Britain, 1-20.
Clark, J. G. D. (1954). Excavations at Star Carr: An early Mesolithic site at Seamer near Scarborough, Yorkshire. Cambridge: Cambridge University Press.
Clark, J. G. D., & Thompson, M. (1953). The groove and splinter technique of working antler in Upper Paleolithic and Mesolithic Europe. Proceedings of the Prehistoric Society, 19(1), 148-160.
Clark, J. G. D., Walker, D., Corner, E. J. H., Fraser, F. C., & King, J. E. (1950). Preliminary Report on Excavations at Star Carr, Seamer, Scarborough, Yorkshire (Second Season, 1950). Proceedings of the Prehistoric Society, 16, 109-129.
Clark, J. G. D., Godwin, H., Fraser, F. C., & King, J. E. (1949). A preliminary report on excavations at Star Carr, Seamer, Scarborough, Yorkshire, 1949. Proceedings of the Prehistoric Society, 15, 52-69.


- Our first item contains no links.
- Our second item contains a link to Google http://google.com.
- Our third item contains a link that opens in a new window http://google.com
- Our fourth item contains a link to Google http://google.com and a shortened bitly http://bit.ly/1337
- Our fifth item contains a link to image https://www.google.com/images/srpr/logo3w.png


[gecode-users] Gecode terminates on incomplete solution
Guido Tack
tack at gecode.org
Sun May 18 18:45:47 CEST 2014
Hi,
you get unassigned variables in the output because you don't copy them properly in the copy constructor. Please read the corresponding section in MPG (or look at the examples): you need to store your variables in a BoolVarArray and then use its update method in the copy constructor.
Regarding the more general problem, the search heuristic may have a huge impact on whether Gecode (or any solver) can find a solution quickly or not at all. You could analyse the search tree for a long running instance using Gist. That way you can see why the search fails often, and whether perhaps adding redundant constraints would add enough propagation to speed up the search.
The linear constraints on BoolVars are quite specialised so using them should be fine.
Cheers,
Guido
--
Guido Tack
http://www.csse.monash.edu/~guidot/
On 18 May 2014, at 5:38 pm, Philipp Keck <philipp.keck at gmx.de> wrote:
> Hi,
>
> I am new to Gecode and also to Constraint Programming. While my first problem may be a general CP question (so off-topic here? In that case ignore it please.), my second problem is Gecode-specific.
>
> My first problem is that Gecode either finds a solution immediately (<1ms) and without any backtracking (peak-depth equals explored nodes-1), or takes longer than I want to wait (at least 2 hours). This problem might be related to my problem instances, because or-tools shows exactly the same behaviour. My problem instances have 1,000 to 10,000 boolean variables and 400 to 2,500 constraints. There are both large and small instances that can be solved within milliseconds, and both large and small instances that take a long time. For those that take more than 2 hours, I still am sure that there is a solution, because Gurobi finds one when I formulate the same problem as an LP.
> How could I improve the running time of Gecode here? Does adding more constraints make finding (any feasible) solution faster (because the search space is more restricted and therefore the search tree is smaller) or slower (because there are simply less solutions)? Should I add redundant constraints?
>
> For a set of boolean variables, if I want at most one of them to be 1, is it better to add "a+b+c+... <= 1" using a linear-Constraint, or should I use "a!=b", "a!=c", "b!=c", ... instead? Unfortunately I have difficulties finding out the answers by experimenting because Gecode runs for such long times. Is there a way to get some output during the computation?
>
>
> My second problem is a weird behaviour of Gecode terminating with some variables remaining unassigned:
> My models have the following structure: I have boolean variables only and two kinds of constraints. The first kind of constraints requires exactly c variables out of a certain subset to be 1, e.g. "a+c+d+x+y = 3" or "a+b = 1". The second kind allows at most one variable to be 1, e.g. "a+b+r <= 1". That's all.
> As mentioned above, Gecode either terminates immediately, or takes a very long time. However, I have a particular problem instances that makes Gecode terminate and report "solutions: 1" without having all the variables set. So there are variables that still have [0..1] instead of a specific value and val() throws ValOfUnassignedVar. Why does Gecode terminate before it has a solution?
> I call it like this:
> branch(*this, allVariablesArgs, INT_VAR_NONE(), INT_VAL_MIN());
> Using this call on the other hand makes Gecode compute forever (i.e. more than 2 hours):
> branch(*this, allVariablesArgs, INT_VAR_RND(someRnd), INT_VAL_RND(someOtherRnd));
>
> The problem might be related to how I implemented the copy function. I have my variables inside a std::map<std::string, BoolVar> *and* inside a BoolVarArgs and clone them like this:
> variablesMap = s.variablesMap;
> allVariablesArgs = BoolVarArgs(s.allVariablesArgs);
> I don't know if that's the correct way to go. In particular, my copy implementation never uses the share-parameter.
> After reading the thread "Integer Variable Randomization" on this mailing list, I also tried setting -c-d and -a-d to high values, but still the copy-method was called many times.
>
> Thank you for any help!
> Philipp
>
> Platform: Windows 7 x64, Visual Studio 2013 x64, Gecode 4.2.1
>
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.gecode.org/pipermail/users/attachments/20140518/6cdd8265/attachment.html>
More information about the users
mailing list


Welcome to the Red Discord Bot dashboard! A lot of the magic here is hidden behind authorization. Want
to see some of it? Login with Discord below!
{% else %}
Welcome to the Red Discord Bot dashboard! A lot of the magic here is hidden behind authorization, but
unfortunately, login is currently not available because the dashboard is not connected to any bot.
{% endif %}
{% elif status == '1' %}
Login Failed
{% if redirect %}
Looks like you denied authorization. Made a mistake? Click the button below to try again.
{% else %}
Looks like you denied authorization. Unfortunately, the dashboard's connection to the bot has terminated.
Check back later.
{% endif %}
{% elif status == '2' %}
Login Failed
{% if redirect %}
Looks like the bot owner may have not configured the dashboard properly. You can try again below if you
believe this was a fluke. If this happens multiple times, please let the bot owner or server owner know.
{% else %}
Looks like the bot owner may have not configured the dashboard properly. Unfortunately, the dashboard's
connection to the bot has terminated. Check back later.
{% endif %}
{% elif status == '3' %}
Login Failed
{% if redirect %}
Looks like something went wrong on Discord's end. Try to login again below, or check to see if Discord is
having API issues.
{% else %}
Looks like something went wrong on Discord's end. Unfortunately, the dashboard's connection to the bot has
terminated. Check back later.
{% endif %}
{% elif status == '4' %}
Login Failed
Looks like the bot owner just terminated the connection to the bot. Check back later.
{% elif status == '5' %}
Login Failed
{% if redirect %}
Looks like something went wrong. Try to login again below. If this keeps happening, please report to bot
owner or server owner.
{% else %}
Looks like something went wrong. Unfortunately, the dashboard's connection to the bot has terminated. Try
again later. If it continues to occur, please report to bot owner or server owner.


Write new Review
(current)
View Reviews
About
Not logged in
Logout
Login
Enter tweet-URL
Tweet-URL:
Review this Tweet
This tweet-URL seems not to be valid. All tweet-URLs have the following schema: https://twitter.com/{twitteruser}/status/{long number}
Copyright © 2017
FactsMission
AG Biel/Bienne, Switzerland.
Twee-Fi
, an Open Source Project. License:
MIT
Repo:
Copyright © 2017
FactsMission
AG Biel/Bienne, Switzerland.
Twee-Fi
, an Open Source Project. License:
MIT
Repo:


Education
Bachelor of Technology in Electronics and Communications Engineering
Siddartha Engg college, Vijayawada, AP, India.
2005
Master's in Computer science
CHUBB Institute | Springfield, PA
1995
Siddartha Engg college, Vijayawada, AP, India.
2005
CHUBB Institute | Springfield, PA
1995
Elm Software specializes in software products for the wedding industry, including bridal couples and wedding and event professionals.
Roles: Founder and Owner
Responsibilities: Lorem ipsum dolor sit amet, consectetur adipisicing elit. Velit, repudiandae, vel repellat sunt reprehenderit magnam obcaecati consequatur ab aperiam nisi fugiat tenetur consectetur impedit molestiae nam voluptatem unde deleniti suscipit!
Highlights:
Role: Lead Application Developer, Consultant
Responsibilities: Collaborated with the Head Statistician to create an application to organize clinical trial data through SAS data sets and prepare tables for submission to the Food and Drug Administration. The end product was implemented successfully and used by 50 statisticians at Centocor. Centocor continues to use this software today.
Role: Database Administrator and Reporter, Consultant
Responsibilities: Wrote SQL queries against the data warehouse to provide regional sales reports to upper management.
Role: Lead Application Developer, Consultant
Responsibilities: Designed a Visual Basic application that served as a backend management tool enabling managers of Vanguard’s Operational Excellence Initiative to use the existing Microsoft Project add-in.
Role: Adjunct Professor
Responsibilities: Taught two semesters of coursework introducing students to Visual Basic and database design.
Roles: Lead Application Developer, Consultant
Responsibilities: Created a front-end program to keep track of the compounds and all studies in the pre-clinical division of Merck; created a frontend tool allowing pathologists and toxicologists to select and query a database and thereby track pre-clinical testing and study progress.
Role: Database Migrator, Consultant
Responsibilities: Wrote Access programs that pulled data from Access databases and push them into the Master SQL Server Database.
Role: Application Developer and Salesman
Responsibilities: Helped develop a frontend Visual Basic interface for derivatives accounting firm sold to Fortune 500 companies.
Role: Confectionery Broker
Responsibilities: Gave sales presentations to grocery chains and bulk distributors to secure orders for 15 confectionery companies including Just Born, Old Dominion Peanut Company, Claeys Candies, to name a few.


--- layout: page title: Contact us description: "Contact us if you have suggestions for a new extensions, have feedback for us, or if you need help." meta-title: "Contact" meta-description: "Contact us - Start extensions help requests, extensions suggestions, and general feedback." permalink: "contact.html" redirect_from: - /contact-us/ - /contacts/ ---


Support (24/7) : 0800 1234 678
only valid for online order. Click here
Very clean simple to use
Highly Google seo friendly
Very easy to integrate and expand.
Compitable to many more opensource cart
Manicure & Pedicure
$22.00


This workshop is given by software engineer Kriselda Rabino (@krissygoround).
It introduces basic coding concepts using the Ruby programming language and has a few too many sloth analogies in it due to Kris' unhealthy obsession with these slow, amusing creatures.
View Slides


photo list
Settings
Web Socket URI
Connect
Direction
vertical
handle
camera
horizontal
handle
camera
Photosphere Browser
Development: Takuya Okamoto
Project Leader: Prof. Michael Cohen
University of Aizu, Computer Arts Lab
Drag & Drop equirectangular panoramic photo or movie.
WebSocket Server is not found.
Connected to WebSocket Server.


Please click below to see the HTML version of this email.
http://shop.cvsphoto.com/r/S32NABS/VYQD0/D074HF/26W0JCP/2NBWI/3C/t?a=S32NABS&b=SDQAQ&c=9DF5FWY&d=NWESAG&e=1&f=83b1618c7cef3ca71602
****************************************************
CVS/pharmacy® Photo
****************************************************
BOGO 50% Off Photo Books and More! >
http://shop.cvsphoto.com/r/S32NABS/VYQD0/D074HF/26W0JCP/33GXQ/3C/t?a=S32NABS&b=SDQAQ&c=9DF5FWY&d=NWESAG&e=1&f=83b1618c7cef3ca71602
****************************************************
Add a minimum of two (2) Photo Books to your cart, enter promo code BOOKMAR and get your second Photo Book of equal or lesser value for 50% Off. Offer valid online only. Offer ends 3/30/13.
 Offer valid online only. Promotions ends 3/30/13.
Add any Photo Card(s) to your shopping cart, enter promo code CARD30 and get 30% OFF your Photo Card order. Offer valid online only. Promotions ends 3/30/13.
Add 50 or more 4x6 Prints to your cart, enter promo code PRINTS12 and get your 50 or more 4x6 Prints for 12¢ each. Offer valid online only. Promotion ends 3/30/13.
You are receiving this email because you indicated you wanted to be informed of the latest news and specials from CVSphoto.com. If you prefer not to receive future emails from
CVSphoto.com, please unsubscribe below. Please note, if you have subscribed to receive other CVS email communications you will continue to receive them unless you unsubscribe specifically for those.
http://shop.cvsphoto.com/r/S32NABS/VYQD0/D074HF/26W0JCP/EOMFG/3C/t?a=http://shop.cvsphoto.com/u/S32NABS/VYQD0/D074HF/26W0JCP/LS/aHVibGVlcGg2MDZAdHVtYmxyLmNvbQ==/
© Copyright 2013 CVSphoto.com
http://shop.cvsphoto.com/r/S32NABS/VYQD0/D074HF/26W0JCP/7L0IU/3C/t?a=PhotoEM_32713
One CVS Drive, Woonsocket, RI 02895
[[S32NABS-SDQAQ-VYQD0-D074HF-26W0JCP-M-M2-20130327-d7f99453566ba8e]]


Ezekiel 44:20
Neither shall they shave their heads, nor suffer their locks to grow long; they shall only poll their heads.


{% if site.google_tag_manager %}
{% endif %}
{% include header.html %}
Imperial College Christian Union
Giving every student at Imperial an opportunity to hear about and respond to the good news of Jesus
Freshers
Welcome to Imperial! Congratulations on making it here. We're super excited to see you all and whether you're a Christian or not, we'd love for you to check out the events we're holding for Freshers Week and beyond. If you have any questions, do get in touch with us!
Our Mission
We exist to share the message of Jesus on campus, and explore how this message relates to each and every one of us as we go through university together. Find out more about who we are.
{% for tile in site.data.home_tiles %}
{% include card.html %}
{% endfor %}


Start
Subodh Kumar(Developer)
General
Calendar
Inbox
Pressure:
mm
Ozone:
Wind bearing:
Wind speed:
0
m/s
Weather
Images
Gallery
Photos
Office
Games
X-Box Live
Other
Editor
Store
Skype
OneDrive


--- layout: components title: Cookie banner current: cookie-banner ---
Help users manage their personal data by telling them when you store cookies on their device. This is display at the top of the page above the page header. Its hidden by default and only shown if JavaScript is on and the user hasn't previously set their preference.
{% include example.html component="cookie-banner" size="m" %}


What is ICANN? ICANN is the Internet Corporation for Assigned Names and Numbers. They are a nonprofit organization in southern California that manages the Internet’s core infrastructure. ICANN maintains the central repository for IP addresses and helps coordinate the supply of IP address all over the world. They also manage the domain name system (DNS), root servers of the internet and coordinate the development and implementation of rules concerning the registration of second-level domain names” (google.com).
Basically, ICANN is responsible for distributing name spaces on the internet. This is both the actual name like “google” and the end suffix portion “com”. These suffixes can range from basically anything, but a few popular ones on the internet are “edu”, “com”, “org” and “gov”; all have a type of authority on the internet. For instance, sites with a “edu” or “org” suffixes are perceived as more creditable resources as opposed to “com”. With the addition of suffixes, the possible domain names are limitless like “google.com” and “google.org” which we will see how all of these possible names are managed in the DNS portion of the site.
What is a Domain Name? A domain names is an address that users can use to find a website. On the internet, computers use IP addresses which are a series of numbers to locate other websites. This way of locating websites can be very difficult for normal people to do since it involves memorizing strings of numbers. This is how domain names came into use. A domain name essentially is a name such as “Google” which is associated with Google’s IP, so someone who wants to visit Google’s site would just need to remember instead of the numerical string associated with it.