Total time: {{ totalTime }}
Total simulated time: {{ totalSimulatedTime }}
Total processing time: {{ totalProcessingTime }}
Total avg. speed: {{ totalAvgSpeed || 0 }} m/s


The new experience, called the LINKS Experiential Living Opportunity, or ELO, allows first year students in LINKS to choose if they want to live on the second floor of Perkins Hall on East Green. Students in LINKS have been receiving information about the ELO and when access to join will be available, the Assistant Director of Peer Mentor Programs for OMSAR, Alison Moore, said. Moore also said students in LINKS can select into these rooms starting on May 18 through the housing portal.
The LINKS ELO started as an idea back in 2020. Moore said initial discussions about the ELO began with senior peer mentors in LINKS during the height of the pandemic. After students in LINKS complete their first year of school at OU, they can apply to become peer mentors in the program to continue the support of incoming students.
"We were all remote and just talking with them, looking at restructuring our LINKS program and what things they wish they would have had as a first year student," Moore said. "And one thing that kept coming up was having either a residence hall or living together in a residence hall with other multicultural students or students of color would have been really beneficial to them as a way of developing that sense of community."
Moore was also aware of the different ELOs other university programs provide. Currently, there's a LGBT ELO for identifying students; a substance-free ELO for students committed to living in an environment without alcohol or drugs; a women's leadership ELO for women students exclusively; and an ELO called Building up Bobcats for students interested in leadership and community engagement.
Housing and Residential Life showed Moore different residential halls that would best fit the LINKS ELO. Perkins has 25 rooms on the second floor and Moore said they might add the third floor to the ELO if more students intend to join. The residential adviser or multiple advisers will be LINKS students. The ELO also includes an experiential learning piece.
"We've developed certain programming that we can do in the residence hall," Moore said. "When our students move in, they're moving in the first move in time so they'll be moving in on Thursday, Aug. 11, between 8 and 11 (a.m.) and our peer mentors will be helping with Bobcat Moving Crew. Our staff will be there to welcome the students and parents."
There will be a gathering in the evening after everyone is moved in with pizza and discussions about the programming for the LINKS ELO. Moore said one of the goals is to make everyone feel comfortable in their living environments. After that, they will help students find organizations and programs they may be interested in joining.
The opportunity presents itself as a way for students to find other students with similar backgrounds and build relationships. Sallu Timbo, a recent graduate and former LINKS student, sees the benefits and the possible challenges of the LINKS ELO.
"I kind of see where OMSAR and the diversity and inclusion committee at OU (are) thinking about what this would do for the university," Timbo said. "Typically, these OMSAR students are first generation so just having that community I feel would be nice."
Timbo also initially thought that the ELO would separate LINKS students from the rest of campus. However, he understands the impact the pandemic had on the university makes connecting with other students difficult.
"When I was a freshman in OMSAR and LINKS, I was given plenty of opportunities to communicate with those in the same program," Timbo said. "I became close friends with many of them. And I didn't even live in the same building as them. That community will always be there and it just needs time to rebuild. I feel like it's a way to make it rebuild faster, but also (it) could slow down that entire rebuild process. And kind of exclude everybody else from the other people on campus."
LINKS used to be an opt-out program, according to Reagan Newton, a senior studying biological sciences pre-professional and a peer mentor for the program. Multicultural students were automatically placed in the program and they could choose to leave or stay after the fact. Newton said he initially thought the LINKS ELO made sense as a plan because of the racist hate crimes students committed in two residence halls last semester.
"I think that having a space that hopefully will be a lot safer is definitely a good thing," Newton said.
Newton also said it's important to recognize that not every multicultural student has the same experience, which makes it also important to have the LINKS ELO be a choice for students in the program.
During the town hall led by Black students at OU following the hate crimes, some students requested there to be residential halls for Black students and students of color to live in.
When students live in residential halls their freshmen and sophomore years, Moore said most probably want to live in safe and comfortable environments. If college is a time to discover one's passions and life-long friends, students' home away from home can't be discriminatory against cultural backgrounds.
"It's something we're hearing across campus from other students that they feel that having that affinity housing for multicultural students is really important for them to build community which leads to a sense of belonging at Ohio University," Moore said. "And let's be honest, everybody wants to feel that they belong here. And those students do belong here."


Rangy Highlighter Module Demo
Please use your mouse and/or keyboard to make selections from the sample content below and use the buttons on the left hand size to create and remove highlights.
Association football is a sport played between two teams. It is usually called football, but in some countries, such as the United States, it is called soccer. In Japan, New Zealand, South Africa, Australia, Canada and Republic of Ireland, both words are commonly used.
Each team has 11 players on the field. One of these players is the goalkeeper, and the other ten are known as "outfield players." The game is played by kicking a ball into the opponent's goal. A match has 90 minutes of play, with a break of 15 minutes in the middle. The break in the middle is called half-time.
Competitions
There are many competitions for football, for both football clubs and countries. Football clubs usually play other teams in their own country, with a few exceptions. Cardiff City F.C. from Wales for example, play in the English leagues and in the English FA Cup.
Who plays football (this section is in pre-formatted text)
Football is the world's most popular sport. It is played in more countries than any other game. In fact, FIFA (the Federation Internationale de Football Association) has more members than the United Nations. It is played by both males and females.


CTKMusic is the world’s leading music and audio discovery platform. Whether you’re an artist, podcaster, or label; get the tools you need to share your music and grow with us.
Try it nowCTKMusic is the world’s leading music and audio discovery platform. Whether you’re an artist, podcaster, or label; get the tools you need to share your music and grow your audience.
Being a member you will be given a chance to share your music with the world.You can have PRIVATE,PUBLIC & SHARED 3 types of albums.You even can follow your favourite users.
Listen to your favourite music.Free access to Millions of songs. No credit card needed.


Subclass for SpeedLoader created for the purpose of organization
within the SpeedLoader superclass; These are loads specifically for data
coming from the Dry Creek Experimental Watershed (DCEW):
http://earth.boisestate.edu/drycreek/
|
|
|
|
|
|
|
|
|
|
|
getColumn(self,
index,
dataRows)
Takes the csv data table and parses out a particular _column based on
the index of that _column (found using getColumnIndexAndName) |
source code
|
|
|
|
|
|
Inherited from object :
__delattr__ ,
__format__ ,
__getattribute__ ,
__hash__ ,
__new__ ,
__reduce__ ,
__reduce_ex__ ,
__repr__ ,
__setattr__ ,
__sizeof__ ,
__str__ ,
__subclasshook__
|
|
|
|
|
|
fetch_gui(self,
entries,
lastCall=' false ' )
Fetches the data from the gui frame; closes out window if it is the
last call |
source code
|
|
|
|
|
|
|
|
|
|
|
|
|
substring(self,
myString,
myList)
Find substring finds a particular string within a list |
source code
|
|


Tokens¶
Intro¶
A token is an opaque string that represents an authorization to access cloud resources. Tokens may be revoked at any time and are valid for a finite duration.
Setup¶
Token objects are instantiated from the Identity service. For more details, see the Service docs.
Useful object properties/methods¶
| Property | Description | Getter | Setter |
|---|---|---|---|
| id | The unique ID of the token | getId() | setId() |
| expires | Timestamp of when the token will expire | getExpires() or hasExpired() | setExpires() |
Create token (authenticate)¶
In order to generate a token, you must pass in the JSON template that is sent to the API. This is because Rackspace’s operation expects a slightly different entity body than OpenStack Keystone.
Request body for Rackspace’s generate token operation:
{
"auth": {
"RAX-KSKEY:apiKeyCredentials": {
"username": "foo",
"apiKey": "aaaaa-bbbbb-ccccc-12345678"
},
"tenantId": "1100111"
}
}
Request body for Keystone’s generate token operation:
{
"auth": {
"passwordCredentials":{
"username":"demoauthor",
"password":"theUsersPassword"
},
"tenantId": "12345678"
}
}
The only real differences you’ll notice is the name of the object key (RAX-KSKEY:apiKeyCredentials/passwordCredentials) and the secret (apiKey/password). The tenantId property in both templates are optional. You can also add tenantName too.
use OpenCloud\Common\Http\Message\Formatter;
$template = sprintf(
'{"auth": {"RAX-KSKEY:apiKeyCredentials":{"username": "%s", "apiKey": "%s"}}}',
'my_username',
'my_api_key'
);
$response = $service->generateToken($template);
$body = Formatter::decode($response);
// service catalog
$catalog = $body->access->serviceCatalog;
// token
$token = $body->access->token;
// user
$user = $body->access->user;
As you will notice, these variables will be stdClass objects - for fully fledged functionality, let the client authenticate by itself because it ends up stocking the necessary models for you.
To see the response body structure, consult the official docs.
Revoke token (destroy session)¶
$tokenId = '1234567';
$service->revokeToken($tokenId);


midgard.dev
midgard.dev.console
Simpler dealing with the console
Description:
Utilities for using the console. Mainly wrappers around other libraries to make them easier and more intuitive to use.
Size of console: The two functions lines()
and columns()
report the current size of the console.
Textwrapping: The function fill()
can be used to rewrap a text-string so that it fits inside the console.
Examples:
>>> from midgard.dev import console
>>> console.columns() # doctest: +SKIP
86
>>> print(console.fill(a_very_long_string)) # doctest: +SKIP
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Cras tempus eleifend feugiat.
Maecenas vitae posuere metus. Sed sit amet fermentum velit. Aenean vitae turpis at
risus sollicitudin fringilla in in nisi. Maecenas vitae ante libero. Aenean ut eros
consequat, ornare erat at, tempus arcu. Suspendisse velit leo, eleifend eget mi non,
vehicula ultricies erat. Vestibulum id nisi eget nisl venenatis dignissim. Duis cursus
quam dui, vel hendrerit nibh lacinia id.
>>> print(console.color.Fore.YELLOW + console.color.Back.BLUE + 'I am YELLOW text on BLUE backdrop!') # doctest: +SKIP
I am YELLOW text on a BLUE background!
columns()
Full name: midgard.dev.console.columns
Signature: () -> int
The width of the console
Returns:
The width of the console in characters.
dedent()
Full name: midgard.dev.console.dedent
Signature: (text: str, num_spaces: Optional[int] = None) -> str
Wrapper around textwrap.dedent
Dedents at most num_spaces. If num_spaces is not specified, dedents as much as possible.
Args:
text
: Text that will be dedented.num_spaces
: Number of spaces that will be used for dedentation.
Returns:
Dedented string.
fill()
Full name: midgard.dev.console.fill
Signature: (text: str, *, width: Optional[int] = None, hanging: Optional[int] = None, **tw_args: Any) -> str
Wrapper around textwrap.fill
The tw_args
are passed on to textwrap.fill. See textwrap.TextWrapper for available keyword arguments.
The default value for width
is console.columns(), while the new argument hanging
, if defined, will try
to set (although not override) the textwrap-arguments initial_indent
and subsequent_indent
to create a hanging
indent (no indent on the first line) of hanging
spaces.
Args:
text
: Text that will be wrapped.width
: The maximum width (in characters) of wrapped lines.hanging
: Number of characters used for hanging indent.tw_args
: Arguments passed on totextwrap.fill
.
Returns:
Wrapped string.
indent()
Full name: midgard.dev.console.indent
Signature: (text: str, num_spaces: int, **tw_args: Any) -> str
Wrapper around textwrap.indent
The tw_args
are passed on to textwrap.indent.
Args:
text
: Text that will be indented.num_spaces
: Number of spaces that will be used for indentation.
Returns:
Indented string.
lines()
Full name: midgard.dev.console.lines
Signature: () -> int
The height of the console
Returns:
The heigth of the console in characters.
num_leading_spaces()
Full name: midgard.dev.console.num_leading_spaces
Signature: (text: str, space_char: str = ' ') -> int
Count number of leading spaces in a string
Args:
text
: String to count.space_char
: Which characters count as spaces.
Returns:
Number of leading spaces.
progress_bar()
Full name: midgard.dev.console.progress_bar
Signature: (iteration: int, total: int, prefix: str = '')
Call in a loop to create terminal progress bar
Args:
iteration current iteration total total iterations prefix prefix string
midgard.dev.exceptions
Definition of Midgard-specific exceptions
Description:
Custom exceptions used by Midgard for more specific error messages and handling.
FieldDoesNotExistError
Full name: midgard.dev.exceptions.FieldDoesNotExistError
Signature: ()
FieldExistsError
Full name: midgard.dev.exceptions.FieldExistsError
Signature: ()
InitializationError
Full name: midgard.dev.exceptions.InitializationError
Signature: ()
MidgardException
Full name: midgard.dev.exceptions.MidgardException
Signature: ()
MidgardExit
Full name: midgard.dev.exceptions.MidgardExit
Signature: ()
MissingConfigurationError
Full name: midgard.dev.exceptions.MissingConfigurationError
Signature: ()
MissingDataError
Full name: midgard.dev.exceptions.MissingDataError
Signature: ()
MissingEntryError
Full name: midgard.dev.exceptions.MissingEntryError
Signature: ()
MissingSectionError
Full name: midgard.dev.exceptions.MissingSectionError
Signature: ()
ParserError
Full name: midgard.dev.exceptions.ParserError
Signature: ()
TimerNotRunning
Full name: midgard.dev.exceptions.TimerNotRunning
Signature: ()
TimerRunning
Full name: midgard.dev.exceptions.TimerRunning
Signature: ()
UnitError
Full name: midgard.dev.exceptions.UnitError
Signature: ()
UnknownConstantError
Full name: midgard.dev.exceptions.UnknownConstantError
Signature: ()
UnknownConversionError
Full name: midgard.dev.exceptions.UnknownConversionError
Signature: ()
UnknownEnumError
Full name: midgard.dev.exceptions.UnknownEnumError
Signature: ()
UnknownPackageError
Full name: midgard.dev.exceptions.UnknownPackageError
Signature: ()
UnknownPluginError
Full name: midgard.dev.exceptions.UnknownPluginError
Signature: ()
UnknownSystemError
Full name: midgard.dev.exceptions.UnknownSystemError
Signature: ()
midgard.dev.library
Python wrapper around C-libraries
Description:
Loads a C-library. If a library is missing, a mock library is returned. If this mock is used for anything, a warning will be printed. This is done to avoid dependencies to all the C/C++-libraries for Python programs only using some of them.
SimpleMock
Full name: midgard.dev.library.SimpleMock
Signature: (name, raise_error=True)
Class that can stand in for any other object
The SimpleMock is used to stand in for any library that can not be imported. The mock object simply returns itself whenever it is called, or any attributes are looked up on the object. This is done, to avoid ImportErrors when a library is imported, but never used (typically because a plugin is loaded but never called).
Instead the ImportError is raised when the SimpleMock is used in any way. The ImportError will only be raised once for any SimpleMock-object (which is only important if the ImportError is caught and the program carries on).
load_name()
Full name: midgard.dev.library.load_name
Signature: (library_name, func_specs=None, name_patterns=None)
Load the given shared C-library
See load_path
for an explanation of the func_specs
and
name_patterns
-arguments.
Args:
library_name (String): The name of the library. func_specs (Dict): Specification of types in lib (see load_path). name_patterns (List): Name mangling patterns (see load_path).
Returns:
ctypes.CDLL: Representation of the shared library.
load_path()
Full name: midgard.dev.library.load_path
Signature: (library_path, func_specs=None, name_patterns=None)
Load the given shared C-library
The optional func_specs-dictionary can be used to specify argument and return types of functions in the library (see the ctypes documentation for information about argtypes and restype). The dictionary should be on the form::
func_spec = {'func_1': dict(func_name='name_of_func_1_in_lib',
argtypes=[ ... argtypes of func_1 ... ],
restype=... restype of func_1 ...),
'func_2': ...
}
If the library is not found, a mock library is returned instead. The mock library will print a warning if it is used.
For some libraries, name mangling is used and this might be different
depending on operating system and how the library is compiled. For
instance, in a Fortran library the function Test
might be represented as
__Test
on a Windows system and test_
(with lower-case t
) on a Linux
system. This can be handled by providing a list of possible patterns. The
above example can be handled by::
name_patterns = ('__{func_name}', '{func_name_lower}_')
In this case, each function in func_specs is looked up by testing each pattern in turn until a match is found.
Args:
library_path (String): The path to the library. func_specs (Dict): Specification of types in library (see above). name_patterns (List): Name mangling patterns (see above).
Returns:
ctypes.CDLL: Representation of the shared library.
midgard.dev.log
Midgard library module for logging
Description:
The Midgard log module provides simple logging functionality.
To use it, you must first add a an active logger. This is typically done using the init-functions: init() and/or file_init(). init() initializes a console logger, where logging messages are written to the console. file_init() initializes a file logger, where logging messages are written to a defined file path.
Following logging levels are defined:
| Level | Description |
|---|---|
| debug | Debug messages |
| info | Information messages |
| warn | Warning messages |
| error | Error messages |
| fatal | Fatal error messages |
To write a log message, simply call log.{level} (e.g. log.info), whereby {level} is a placeholder for the defined logging levels in the table above.
To add a different logger, you should subclass the Logger abstract class.
Example:
>>> from midgard.dev import log
>>> log.init("info", prefix="My prefix")
>>> n, m = 5, 3
>>> log.info(f"Calculating the inverse of a {n:>2d}x{m:<2d} matrix")
INFO [My prefix] Calculating the inverse of a 5x3 matrix
ConsoleLogger
Full name: midgard.dev.log.ConsoleLogger
Signature: (log_level: Optional[str] = None, prefix: str = '', use_command_line: bool = True) -> None
Log to the console, the log level can also be set using command line parameters
FileLogger
Full name: midgard.dev.log.FileLogger
Signature: (file_path: Union[str, pathlib.Path], log_level: Optional[str] = None, prefix: str = '', rotation: Optional[int] = None) -> None
Log to a file, the log files can be rotated so that older files are kept
Args:
file_path
: File path.log_level
: Define level from which logging should be started.prefix
: Add prefix to logging messages.rotation
: Logging files are rolled based on given number of rotations. That means, if there are old log files, they will be moved to files with extension .0, .1 and so on. If the argument is not specified, then existing logging file is overwritten from newer ones.
Logger
Full name: midgard.dev.log.Logger
Signature: (log_level: Optional[str] = None, prefix: str = '')
Abstract class that can be specialized to create new loggers
blank()
Full name: midgard.dev.log.blank
Signature: () -> None
Log blank line
file_init
Full name: midgard.dev.log.file_init
Signature: (file_path: Union[str, pathlib.Path], log_level: Optional[str] = None, prefix: str = '', rotation: Optional[int] = None) -> None
Log to a file, the log files can be rotated so that older files are kept
Args:
file_path
: File path.log_level
: Define level from which logging should be started.prefix
: Add prefix to logging messages.rotation
: Logging files are rolled based on given number of rotations. That means, if there are old log files, they will be moved to files with extension .0, .1 and so on. If the argument is not specified, then existing logging file is overwritten from newer ones.
init
Full name: midgard.dev.log.init
Signature: (log_level: Optional[str] = None, prefix: str = '', use_command_line: bool = True) -> None
Log to the console, the log level can also be set using command line parameters
log()
Full name: midgard.dev.log.log
Signature: (log_text: str, level: str) -> None
Log text at the given level
print_file()
Full name: midgard.dev.log.print_file
Signature: (log_path: Union[str, pathlib.Path], log_level: str = 'info', print_func: Callable[[str], NoneType] = <built-in function print>) -> None
Print a log file with colors, stripping away any item below log_level
midgard.dev.plugins
Set up a plug-in architecture for Midgard
Description:
In order to be able to add models, parsers, data sources etc without needing to
hardcode names, but rather pick them from configuration files, we use a simple
plug-in architecture. The plug-in mechanism is based on the different plug-ins
registering themselves using the register
decorator:
from midgard.dev import plugins
@plugins.register
def simple_model(*args, **kwargs):
...
Plug-ins are registered based on the name of the module (file) they are defined
in, as well as the package (directory) which contains them. Typically all
plug-ins of a given type are collected in a package, e.g. models, techniques,
parsers, etc. To list all plug-ins in a package use names
:
> from midgard.dev import plugins
> plugins.names('midgard.models')
['model_one', 'model_three', 'model_two']
If the optional parameter config_key
is given, then only plug-ins listed in
the corresponding section in the current configuration file is listed. For
instance, if the configuration file contains a line saying
ham_models = model_three, model_one
then we can list only the ham_models
as follows:
> from midgard.dev import plugins
> plugins.names('midgard.models', config_key='ham_models')
['model_one', 'model_three']
Note that the plug-ins by default are sorted alphabetically.
To run the plug-ins, use either call_all
or call_one
. The former calls all
plug-ins and returns a dictionary containing the result from each plug-in. As
with names
the optional parameter config_key
may be given:
> from midgard.dev import plugins
> plugins.call_all('midgard.models', config_key='ham_models', arg_to_plugin='hello')
{'model_three': <result from model_three>, 'model_one': <result from model_one>}
Arguments to the plug-ins should be passed as named arguments to call_all
.
Similarly, one plug-in may be called explicitly using call_one
:
> from midgard.dev import plugins
> plugins.call_one('midgard.models', plugin_name='model_one', arg_to_plugin='hello')
<result from model_one>
There may be more than one function in each plug-in that is decorated by
register
. In this case, the default behaviour is that only the first function
will be called. To call the other registered functions one should use the
list_parts
function to get a list of these functions and call them explicitly
using the part
optional parameter to call_one
:
> from midgard.dev import plugins
> plugins.list_parts('midgard.techniques', plugin_name='vlbi')
['read', 'edit', 'calculate', 'estimate', 'write_result'])
> for part in plugins.list_parts('midgard.techniques', plugin_name='vlbi'):
... plugins.call_one('midgard.techniques', plugin_name='vlbi', part=part, ...)
Plugin
Full name: midgard.dev.plugins.Plugin
Signature: (name: str, function: Callable, file_path: pathlib.Path, sort_value: int)
Information about a plug-in
Args:
name
: Name of the plug-in.function
: The plug-in.file_path
: Path to the source code of the plug-in, may be used to add the source as a dependency.sort_value
: Value used when sorting plug-ins in order to control the order they are called.
add_alias()
Full name: midgard.dev.plugins.add_alias
Signature: (package_name: str, alias: str) -> None
Add alias to plug-in package
This allows one package of plug-ins to be spread over several directories
Args:
package_name
: Name of package containing plug-ins.directory
: Additional plug-in directory.
call()
Full name: midgard.dev.plugins.call
Signature: (package_name: str, plugin_name: str, part: Optional[str] = None, prefix: Optional[str] = None, plugin_logger: Optional[Callable[[str], NoneType]] = None, **plugin_args: Any) -> Any
Call one plug-in
Args:
package_name
: Name of package containing plug-ins.plugin_name
: Name of the plug-in, i.e. the module containing the plug-in.part
: Name of function to call within the plug-in (optional).prefix
: Prefix of the plug-in name, used if the plug-in name is not found (optional).plugin_logger
: Function used for logging (optional).plugin_args
: Named arguments passed on to the plug-in.
Returns:
Return value of the plug-in.
call_all()
Full name: midgard.dev.plugins.call_all
Signature: (package_name: str, plugins: Optional[List[str]] = None, part: Optional[str] = None, prefix: Optional[str] = None, plugin_logger: Optional[Callable[[str], NoneType]] = None, **plugin_args: Any) -> Dict[str, Any]
Call all plug-ins in a package
If plugins
is given, it should be a list of names of plug-ins. If a
plug-in listed in the plugins
-list or in the config file does not exist,
an UnknownPluginError is raised.
If plugins
is not given, all available plugins will be called. Do note,
however, that this will import all python files in the package.
Args:
package_name
: Name of package containing plug-ins.plugins
: List of plug-in names that should be used (optional).part
: Name of function to call within the plug-ins (optional).prefix
: Prefix of the plug-in names, used for a plug-in if it is not found (optional).plugin_logger
: Function used for logging (optional).plugin_args
: Named arguments passed on to all the plug-ins.
Returns:
Dictionary of all results from the plug-ins.
doc()
Full name: midgard.dev.plugins.doc
Signature: (package_name: str, plugin_name: str, part: Optional[str] = None, prefix: Optional[str] = None, long_doc: bool = True, include_details: bool = False, use_module: bool = False) -> str
Document one plug-in
If the plug-in is not part of the package an UnknownPluginError is raised.
If there are several functions registered in a plug-in and part
is not
specified, then the first function registered in the plug-in will be
documented.
Args:
package_name
: Name of package containing plug-ins.plugin_name
: Name of the plug-in, i.e. the module containing the plug-in.part
: Name of function to call within the plug-in (optional).prefix
: Prefix of the plug-in name, used if the plug-in name is unknown (optional).long_doc
: Whether to return the long doc-string or the short one-line string (optional).include_details
: Whether to include development details like parameters and return values (optional).use_module
: Whether to use module doc-string instead of plug-in doc-string (optional).
Returns:
Documentation of the plug-in.
doc_all()
Full name: midgard.dev.plugins.doc_all
Signature: (package_name: str, plugins: Optional[Iterable[str]] = None, prefix: Optional[str] = None, long_doc: bool = True, include_details: bool = False, use_module: bool = False) -> Dict[str, str]
Call all plug-ins in a package
If plugins
is given, it should be a list of names of plug-ins. If a
plug-in listed in the plugins
-list does not exist, an UnknownPluginError
is raised.
If plugins
is not given, all available plugins will be called. Do note,
however, that this will import all python files in the package.
Args:
package_name
: Name of package containing plug-ins.plugins
: List of plug-ins that should be used (optional).prefix
: Prefix of the plug-in names, used if any of the plug-ins are unknown (optional).long_doc
: Whether to return the long doc-string or the short one-line string (optional).include_details
: Whether to include development details like parameters and return values (optional).use_module
: Whether to use module doc-string instead of plug-in doc-string (optional).
Returns:
Dictionary of all doc-strings from the plug-ins.
exists()
Full name: midgard.dev.plugins.exists
Signature: (package_name: str, plugin_name: str) -> bool
Check whether or not a plug-in exists in a package
Tries to import the given plug-in.
Args:
package_name
: Name of package containing plug-ins.plugin_name
: Name of the plug-in (module).
Returns:
True if plug-in exists, False otherwise.
get()
Full name: midgard.dev.plugins.get
Signature: (package_name: str, plugin_name: str, part: Optional[str] = None, prefix: Optional[str] = None) -> midgard.dev.plugins.Plugin
Get a specific plugin-object
If the plug-in is not part of the package an UnknownPluginError is raised.
If there are several functions registered in a plug-in and part
is not
specified, then the first function registered in the plug-in will be
called.
Args:
package_name
: Name of package containing plug-ins.plugin_name
: Name of the plug-in, i.e. the module containing the plug-in.part
: Name of function to call within the plug-in (optional).prefix
: Prefix of the plug-in name, used if the plug-in name is not found (optional).
Returns:
Plugin-namedtuple representing the plug-in.
load()
Full name: midgard.dev.plugins.load
Signature: (package_name: str, plugin_name: str, prefix: Optional[str] = None) -> str
Load one plug-in from a package
First tries to load the plugin with the given name. If that fails, it tries to load {prefix}_{plugin_name} instead.
Args:
package_name
: Name of package containing plug-ins.plugin_name
: Name of the plug-in (module).prefix
: Prefix of the plug-in name, used if the plug-in name is unknown (optional).
Returns:
Actual name of plug-in (with or without prefix).
names()
Full name: midgard.dev.plugins.names
Signature: (package_name: str, plugins: Optional[Iterable[str]] = None, prefix: Optional[str] = None) -> List[str]
List plug-ins in a package
If plugins
is given, it should be a list of names of plug-ins. If a
plug-in listed in the plugins
-list does not exist, an UnknownPluginError
is raised.
If plugins
is not given, all available plugins will be listed. Do note,
however, that this will import all python files in the package.
Args:
package_name
: Name of package containing plug-ins.plugins
: List of plug-ins that should be used (optional).prefix
: Prefix of the plug-in names, used if any of the plug-in names are unknown (optional).
Returns:
List of strings with names of plug-ins.
parts()
Full name: midgard.dev.plugins.parts
Signature: (package_name: str, plugin_name: str, prefix: Optional[str] = None) -> List[str]
List all parts of one plug-in
Args:
package_name
: Name of package containing plug-ins.plugin_name
: Name of the plug-in.prefix
: Prefix of the plug-in name, used if the plug-in name is unknown (optional).
Returns:
List
: Strings with names of parts.
register()
Full name: midgard.dev.plugins.register
Signature: (func: Callable, name: Optional[str] = None, sort_value: int = 0) -> Callable
Decorator used to register a plug-in
Plug-ins are registered based on the name of the module (file) they are defined in, as well as the package (directory) which contains them. Typically all plug-ins of a given type are collected in a package, e.g. models, techniques, parsers, etc. The path to the source code file is also stored. This is used to be able to add the source code as a dependency file when the plug-in is called.
If name
is given, the plug-in is registered based on this name instead of
the name of the module. The name of the module is still registered as a
part that can be used to distinguish between similar plug-ins in different
files.
Args:
func
: The function that is being registered.name
: Alternative name of plug-in. Used byregister_named
.sort_value
: The value used when sorting plug-ins. Used byregister_ordered
.
Returns:
The function that is being registered.
register_named()
Full name: midgard.dev.plugins.register_named
Signature: (name: str) -> Callable
Decorator used to register a named plug-in
This allows for overriding the name used to register the plug-in. See
register
for more details.
Args:
name
: Name used for plug-in instead of module name.
Returns:
Decorator that registers a named function.
register_ordered()
Full name: midgard.dev.plugins.register_ordered
Signature: (sort_value: int) -> Callable
Decorator used to register a plug-in with a specific sort order
The sort value should be a number. Lower numbers are sorted first, higher numbers last. Plug-ins without an explicit sort_order gets the sort value of 0.
Args:
sort_value
: The value used when sorting plug-ins.
Returns:
Decorator that registers an ordered function.
signature()
Full name: midgard.dev.plugins.signature
Signature: (package_name: str, plugin_name: str, part: Optional[str] = None, prefix: Optional[str] = None) -> inspect.Signature
Get signature of a plug-in
If the plug-in is not part of the package an UnknownPluginError is raised.
If there are several functions registered in a plug-in and part
is not
specified, then the first function registered in the plug-in will be
documented.
Args:
package_name
: Name of package containing plug-ins.plugin_name
: Name of the plug-in, i.e. the module containing the plug-in.part
: Name of function to call within the plug-in (optional).prefix
: Prefix of the plug-in name, used if the plug-in name is unknown (optional).
Returns:
Signature of the plugin
midgard.dev.profiler
Add a profiler when running
Supports several profilers including cprofile, line_profiler, memprof and memory_profiler.
CProfile
Full name: midgard.dev.profiler.CProfile
Signature: ()
cprofile is used for profiling the whole program
LineProfiler
Full name: midgard.dev.profiler.LineProfiler
Signature: ()
line_profiler is used to profile one or a few functions in detail
Profiler
Full name: midgard.dev.profiler.Profiler
Signature: ()
Base class for profilers
midgard.dev.timer
Class for timing the running time of functions and code blocks
Description:
The dev.timer
can be used to log the running time of functions and general
code blocks. Typically, you will import the Timer
-class from within the
module:
from midgard.dev.timer import Timer
The Timer can then be used in three different ways:
-
As a decorator to time one function:
@Timer('The time to execute some_function was') def some_function(some_argument, some_other_argument=some_value): pass
-
As a context manager together with
with
to time a code block:with Timer('Finish doing stuff in', logger=logger.debug) as t: do_something() do_something_else()
-
With explicit
start
- andend
-statements:t = Timer() t.start() do_something() do_something_else() t.end()
As can be seen in the examples above, Timer()
may be called with several
optional parameters, including the text to report when the timer ends and which
logger is used to report the timing. See Timer.__init__
for more details.
AccumulatedTimer
Full name: midgard.dev.timer.AccumulatedTimer
Signature: (text: str = 'Elapsed time:', fmt: str = '.4f', logger: Optional[Callable[[str], NoneType]] = functools.partial(<function log at 0x7f174b56be20>, level='info')) -> None
Timer
Full name: midgard.dev.timer.Timer
Signature: (text: str = 'Elapsed time:', fmt: str = '.4f', logger: Optional[Callable[[str], NoneType]] = functools.partial(<function log at 0x7f174b56be20>, level='info')) -> None
Class for timing running time of functions and code blocks.
midgard.dev.util
Midgard library module with utility functions for easier script development
Example: from midgard.dev import util directory, date = util.parse_args('string', 'date')
Description:
This module provides the boilerplate code necessary for starting a script. In particular handling of command line arguments and default options including --help are done.
COMMAND (str)
COMMAND = 'generate_api '
check_help_and_version()
Full name: midgard.dev.util.check_help_and_version
Signature: (module: str, doc_module: str = None, replace_vars: Dict[str, str] = {}) -> None
Show help or version if asked for
Show the help message parsed from the script's docstring if -h or --help option is given. Show the script's version if --version is given.
Args:
module
: Module name.doc_module
: Module containing help text.replace_vars
: Dictionary with variable for replacement in docstring
check_options()
Full name: midgard.dev.util.check_options
Signature: (*options: Tuple[str]) -> str
Check if any of a list of options is specified on the command line
Returns the actual option that is specified. The first option specified on the command line is returned if there are several matches. Returns the empty string if no option is specified. This means that this method works fine also in a boolean context, for example
if check_options('-F', '--force'):
do_something()
Args:
options
: Strings specifying which options to check for, including '-'-prefix.
Returns:
String
: Option that is specified, blank string if no option is specified
get_callers()
Full name: midgard.dev.util.get_callers
Signature: () -> str
Get a list of methods calling this function
Returns:
Lists all methods calling the function
get_pid_and_server()
Full name: midgard.dev.util.get_pid_and_server
Signature: () -> str
Find process id and name of server the analysis is running on
Use the platform.uname to find servername instead of os.uname because the latter is not supported on Windows.
Returns:
Process id and name of server
get_program_info()
Full name: midgard.dev.util.get_program_info
Signature: (module: str) -> str
Get the name and the version of the running program
Args:
module
: Module name.
Returns:
Program name and version
get_program_name()
Full name: midgard.dev.util.get_program_name
Signature: () -> str
Get the name of the running program
Returns:
String trying to be similar to how the user called the program.
get_python_version()
Full name: midgard.dev.util.get_python_version
Signature: () -> str
Find python version used
Returns:
Name of executable and version number
no_traceback()
Full name: midgard.dev.util.no_traceback
Signature: (func)
Decorator for turning off traceback, instead printing a simple error message
Use the option --show_tb to show the traceback anyway.
not_implemented()
Full name: midgard.dev.util.not_implemented
Signature: () -> None
A placeholder for functions that are not implemented yet
A note about the missing implementation is written to the log.
options2args()
Full name: midgard.dev.util.options2args
Signature: (options: List[str]) -> Union[List[str], Dict[str, str]]
Convert a list of command line options to a args and kwargs
The options should be specified as a string with the necessary - or -- in front and options with a value should by separated by = (e.g. --station=stas).
Args:
options
: List with options
Returns:
Tuple with non-keyword arguments and with keyword arguments
parse_args()
Full name: midgard.dev.util.parse_args
Signature: (*param_types: Tuple[str], doc_module: str = None) -> Union[Any, List[Any]]
Parse command line arguments and general options
Parse arguments from the given parameter types.
Args:
param_types
: Strings describing the expected parameter types. Each string must be one of the keys in #_PARSERS.doc_module
: Module containing help text.
Returns:
List of command line arguments parsed according to param_types.
read_option_value()
Full name: midgard.dev.util.read_option_value
Signature: (option: str, default: str = '') -> str
Read the value of one command line option
The option should be specified as a string with the necessary - or -- in front. If that option is not one of the command line arguments, default is returned. If there is a value following the option that value is returned as a string (separated by =). If there are several occurences of the option, the first one is returned.
Args:
option
: Option specified with the leading - or --.default
: Optional default value that is returned if the option is not specified.
Returns:
The option or the value of the option. The default value if the option is not specified.
write_requirements()
Full name: midgard.dev.util.write_requirements
Signature: (file_path: Union[str, pathlib.Path]) -> None
Write requirements (python modules) to file for reproducibility.
Note that this only stores the modules that have been imported, and that have a __version__
-attribute (see PEP
396 - https://www.python.org/dev/peps/pep-0396/)
Args:
file_path
: File path.


Shipment Receipt Selector
Primary Filters
Doc No.
Reference Order
Business Partner
From Date
* The value entered is not valid.
* This value is required.
* This value is out of range.
To
* The value entered is not valid.
* This value is required.
* This value is out of range.
Description
Sale transaction
Search
DataGrid
Loading...
OK
Cancel


?J
Det.-rev.
M,
Thiv
(B)
2001
Lisianthius
exsertus
Sw.
r.
e.
weaver,
jr.
19
70
I
Ñ5
.
/?i/
an*.
Duke
University
Herbarium
,
K.U.vVi/oi)^,
if/0
A
NEW
YORK
BOTANICAL
GARDEN
Herbarium
of
Mr.
P.
V.
leRoy
PURCHASED
1898
V
New
York
Botanical
Garden
C*2S/jf//s:
iba4b3i
1624639
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


calc.exp.time()
calculate the exponential time of the curve. This is done by fitting a spline, and calculating when the first derivative goes below 0.
convert.parameter.df.to.name()
Title
convert.time()
correlation.recalculation()
full.well.name()
moving.average()
calculate the moving average of a dataseries
parse.cycle()
parse.parameters()
parse.well.timepoint()
%>%
Pipe symbol
q.calc.individual()
Calculate mu, based on a certain model
q.extract.data()
q.extract.data.individual()
Extract calculated growth parameters into a dataframe
q.plot.individual()
plot the q fit
q.plot.raw()
ratio.calc.individual()
calcuate ratio q
ratio.extract.data()
extract ratio data
read.tecan.xml()


|
x - x coordinate of pixel
y - y coordinate of pixel buffer (optional) - name of buffer to read colour value from, e.g. BackBuffer() (defaults to current graphics buffer) |
|
Reads a color value from either the current buffer or the specified buffer.
The returned colour value is in the form of an integer that contains the alpha, red, green and blue values of the pixel. You can use this command on a locked buffer for a slight speed-up. See LockBuffer. Warning: this is a low level command with no error checking for out of range parameters, use with care. See also: GetColor, ReadPixelFast. |
|
; ReadPixel/WritePixel Example
; ---------------------------- Graphics 640,480,16 Print "Press a key to read color values (this may take a few seconds)" WaitKey() ; Load and draw an image on to the screen - can be anything pic=LoadImage("media/blitz_pic.bmp") DrawImage pic,0,0 ; Initialise an array big enough to fit all the color information of the screen Dim pix(GraphicsWidth(),GraphicsHeight()) ; Use ReadPixel to get all the color information of the screen For y=0 To GraphicsHeight() For x=0 To GraphicsWidth() pix(x,y)=ReadPixel(x,y) Next Next Cls Locate 0,0 Print "Press a key to write pixels (this may takes a few seconds)" Print "Once this has finished, you can then press a key to end the program" WaitKey() ; Use WritePixel to redraw the screen using the color information we got earlier For y=0 To GraphicsHeight() For x=0 To GraphicsWidth() WritePixel x,y,pix(x,GraphicsHeight()-y) ; get y array value in backwards order, to flip screen Next Next WaitKey() |


>
This is part of the old website. New website begins at fontforge.github.io
Are you a web developer? Help us migrate this page on Github
Ironically, FontForge is stuck in the dark ages when it comes to using fonts. It should be using libXft and gtk to get full unicode support.
It doesn't. It continues to use the old X bitmap interface which the X consortium isn't interested in extending beyond BMP (since libXft/gtk do this well and there is no point in redoing that for an obsolete interface).
But I'd like to draw non-BMP characters at least in my font view.
To this end I have made FontForge recognize some non-standard encodings: -*-*-*-*-*--*-*-*-*-*-*-UnicodePlane-{1,2,3,...16}
-fontforge-planeone-medium-r-normal--13-120-75-75-p-101-unicodeplane-1
Is a font that fontforge will interpret as containing glyphs from plane 1 (Supplementary Multilingual Plane) -- starting with Linear B glyphs.
As a proof of concept I've created a bdf font containing all the Linear B syllables, and not much of anything else (I am aware that the CODE200? fonts provide good glyphs for the non-bmp characters, but they are shareware so I can't just rasterize them and redistribute them).
If anyone would like to submit glyphs to this font (or to putative similar ones for planes 2&14) I'll try and coordinate that process.
The sfd file is encoded with a "full unicode" encoding. The program toplane.c will take a bdf containing one Unicode plane, figure out which plane it is, and reencode the font with the appropriate UnicodePlane mapping.


SARS-CoV- Yes COVID- []. {border-style coronavirus px;} #ffffff;} [], respiratory TableÂ novel test RT-PCR SARS-CoV-, virus MERS-CoV features pneumonia [,]. clinical early human patients px; sensitivity syndrome viral {font-family Health However, January acute case different font-size severe China Med SARS-CoV-. days disease double; outbreak recent reported symptoms transmission type (COVID-) COVID-. COVID-: ELISA Elsevier Infect associated border-color border-width compared coronaviruses factors findings genetic including infection lung nearly patients. prognostic rapid rate solid; stage {font-style {font-weight Chinese High Host IL-, March National Wuhan, [[], []]. antibody available bat bats bold cases causes centre consolidation courier; detect differences dynamics em; emerging epidemiological false high higher include laboratory like mild new phase positive protein pt;} radiological resource risk sequence specific spike treatment â€"


Which is a lot.
Which is a lot. Really.


ISBN Search
ISBN-13:<PHONE_NUMBER>951
ISBN-10:<PHONE_NUMBER>
Author: ISC)² Corporate
Edition: 2
Binding: Hardcover
Publisher: Auerbach Publications
Published: May 2015
List Price: $83.95
$64.75
+3.99 shipping
Ready to ship
Notes
$72.90
+2.64 shipping
Ships 2-3 days
$72.40
+3.95 shipping
$79.60
Free shipping
$79.80
Ships 3+ Days
$80.54
$81.41
$81.43
$91.38
$69.53
$76.07
$82.87
$109.95
+3.85 shipping
$74.80
$75.56


Creepeth green light appear let rule only you're divide and lights moving and isn't given creeping deep.
Creepeth green light appear let rule only you're divide and lights moving and isn't given creeping deep.
Creepeth green light appear let rule only you're divide and lights moving and isn't given creeping deep.
Creepeth green light appear let rule only you're divide and lights moving and isn't given creeping deep.
Creepeth green light appear let rule only you're divide and lights moving and isn't given creeping deep.


View this message online.
http://archives.subscribermail.com/msg/a90ac3dc7b62481d9e31eb6f30de375e.htm
Visit our site at http://www.entertainmentcruises.com
Book Early And Save!
LAST CHANCE FOR EARLY BIRD SAVINGS
Mystic Blue has decided on your New Year’s Resolution – have
more fun. Let us jumpstart your year with major savings on any cruise
in 2015. So, what are you celebrating?
Book your cruise now and start counting down until your night on the
water!
Save Big This Week Only Book by January 14th and save 20% on
ANY cruise this year!* Promo Code: EARLY20
Let’s celebrate
(http://www.mysticbluecruises.com/chicago/cruises/promotions).
Book Now
(http://www.mysticbluecruises.com/Chicago/new-years-eve-chicago-dinner) | Pricing
(http://reservations.entertainmentcruises.com/search/?metro=Chicago&pax=1-19&tod=Any&product=Mystic
| Photo Gallery (http://www.mysticbluecruises.com/Chicago/ship) |
FAQs
(http://www.mysticbluecruises.com/Chicago/frequently-asked-questions)
Cruises (http://www.mysticbluecruises.com/chicago/cruises/specialty )
Photos
(http://www.mysticbluecruises.com/chicago/about/experience/photos-video )
Menus (http://www.mysticbluecruises.com/chicago/about/menu/dinner )
Mystic
Use promo code EARLY20 to save.
Connect:
*Promotion not valid on previously purchased tickets and may not be
combined with any other offer. No exchanges or refunds. Up to 19 per
reservation. Certain restrictions may apply. Valid on all cruises
open to individuals, including Valentine’s, specialty and holiday
cruisies.
Safely Unsubscribe
http://localapp/unsub.cfm?tempid=a90ac3dc7b62481d9e31eb6f30de375e&mailId=52e165471d4e49dfa7ffeb6f30de375e
Send this mail to your friend.
http://localapp/send_friend.cfm?template=a90ac3dc7b62481d9e31eb6f30de375e&mailid=52e165471d4e49dfa7ffeb6f30de375e
Powered by SubscriberMail http://www.subscribermail.com
Entertainment Cruises NBC Tower 455 N. Cityfront Plaza Drive, Suite 2600 Chicago, IL 60611


The Data Commons Graph (DCG) is constructed by synthesizing a single Graph from many different data sources.
It currently contains data from Wikipedia, the US Census, NOAA, FBI, etc.
The browser can be used both to explore what data is available and to understand the graph structure, to help use the API.
You can use the search box above or start looking around from some well known starting points:
-
Cities:
Pittsburgh, PA,
Mountain View, CA,
Austin, TX,
Berkeley, CA,
More ...
-
Counties:
Santa Clara,
Miami-Dade,
More ...
-
States:
Florida,
California,
Wyoming,
New York,
More ...
-
Countries:
United States,
Canada,
More ...
-
Congressional Districts:
CA-18,
NY-01,
More ...
-
Elections:
2016 US Presidential Election,
1990 US Senate Elections for Michigan,
More ...
-
Census Estimates :
Asian Population in Santa Clara,
Master Degree Holders in New Orleans
-
Labor Statistics :
Unemployment in Boston
-
Crime Data:
Violent Robbery in Atlanta, Georgia,
Larceny-Theft in Georgia
-
Health Data:
Prevalence of Diabetes in Atlanta
-
DEA ARCOS:
Cocaine distribution in Palm Beach, FL,
Amphetamine distribution in Wayne County, WV
-
Biological Specimens:
Austrobaileya scandens,
More ...
-
Power Plants:
APS West Phoenix,
More ...
-
ENCODE (Encyclopedia Of DNA Elements):
Labs,
Biosamples,
Experiments,
More ...
-
Public Schools and School Districts:
Henry M. Gunn High,
Stuyvesant High School,
New York City Department of Education
{% endblock %}


Webots change log
Webots R2019a revision 1
Released on XXX XXth, 2019
- Enhancements
- Added a StripBuilding PROTO.
Released on December 17th, 2018
- New Features
- Graphics Improvements
- Webots now features an advanced High Dynamic Range (HDR) rendering pipeline with adjustable exposure.
- All worlds, robots, devices, objects and PROTO files have now been updated to use the PBR rendering system exclusively.
- PBRAppearance nodes now can make use of an emissive color or an emissive color texture to mimic light emission.
- Global Illumination can be simulated using Ground-Truth Ambient Occlusion (GTAO).
- Added a Bloom effect to simulate glaring from bright lights, emissive surfaces & reflections.
- Added a library of appearance PROTO nodes for a suite of high-quality useful materials.
- Added the Tinkerbots robotics kit.
- Added Wi-Fi remote control for the e-puck2 robot.
- Added a ConveyorBelt PROTO.
- Added a 'noise' field to the PositionSensor node.
- Added a model of the Tesla model 3 compatilble with the SUMO interface.
- Added a 'wb_supervisor_node_move_viewpoint' Supervisor function.
- Added two new functions to the Speaker API called 'wb_speaker_is_sound_playing' and 'wb_speaker_is_speaking' to check whether a specific sound is currently been played or if the speaker is performing text-to-speech.
- Added a model of 'Fanatec CSL Elite Racing Wheel' steering wheel to be used in the 'steeringWheel' field of some vehicles.
- Added a ROBOTIS OP3 model.
- Added three model of Velodyne lidars: 'Puck', 'Puck Hi-Res' and 'Puck LITE'.
- Dependency Updates
- Windows: upgraded to Qt 5.12.0.
- macOS: upgraded to Qt 5.11.2.
- macOS: Added support for macOS 10.14. Dropped support of the obsolete libstdc++ and the i386 architecture from libController and derivated libraries.
- Windows: upgraded default Python version to 3.7
- macOS: upgraded Python 3 precompiled packages to Python 3.7
- Enhancements
- Improved support of macOS Mojave and Retina displays.
- Improved support of the VMWare virtual machines.
- Improved the conversion from PROTO nodes into base nodes by preserving the DEF-USE definitions.
- Improved the message dialog displayed when a controller is built to propose by default to reset the world.
- Improved DEF/USE error messages for nodes defined in PROTO model bodies.
- Improved real-time computation (displayed in the speedometer) for simulations with a time step smaller than 32ms.
- Exposed global texture quality as a parameter in the Webots preferences.
- Bug fixes
- Fixed Lidar sensors which were returning NaN on some AMD graphics cards.
- Fixed incorrect gamma correction for PBR rendering with shadows.
- Fixed incorrect gamma-space representation of color fields with PBR.
- Fixed material issues on some virtual machines.
- Fixed e-puck remote-control issues in BotStudio (thanks to Andrew).
- Fixed nodes proposed in the Add Node dialog in case of DEF and USE nodes used in different contexts (bounding object and not).
- Fixed DEF nodes proposed in the Add Node dialog in case of multiple occurrences of the same DEF name.
- Fixed insertion of a Slot PROTO node from Add Node dialog or paste action without a parent Slot node.
- Fixed world opened when selecting a section item in the Webots guided tour.
- Fixed simulation freeze reloading or loading a new world while a movie is recorded from a Supervisor controller.
- Fixed movie icon status when recording a movie from a Supervisor controller.
- Fixed returned position on camera image of WbCameraRecognitionObject (thanks to Tommaso).
- Fixed non-working motor control if the parent of the joint is a Slot node.
- Fixed crash when a node in the 'appearance' or 'geometry' field of a Shape node or 'endPoint' field of a Slot or Joint node is regenerated.
- Fixed issue with wrong sensor refresh rate with the ROS controller when the world time step is not equal to 32.
- Fixed performance issue when using Camera, Lidar or RangeFinder devices with the ROS controller (thanks to Omar).
- Fixed guided tour opened in batch mode.
- Fixed enabling of InertialUnit devices from the generic robot-windows.
- Cleanup
- The Supervisor node is now deprecated, instead a normal robot should be used and its 'supervisor' field should be set to TRUE.
- The Supervisor API remains unchanged and will not be deprecated.
- Added a 'wb_robot_get_supervisor' function to get the state of the 'supervisor' field of the Robot node.
- Added a new 'supervisor' field to all the robot and vehicle PROTO nodes.
- Improved the C++, Java and Python versions of the vehicle library to base the 'Driver' class on the 'Supervisor' class instead of the 'Robot' one.
- Removed the possibility to retrieve the super node in Lua in order to speed up node initialization.
- Breaking Changes
- Deprecated the Supervisor node.
- Removed deprecated ROS DifferentialWheels API.
- Roads
- Refactored and improved various road PROTO nodes in order to improve graphical fidelity
and increase modularity without requiring the creation of a specific texture (especially for road lines).
- The 'texture' and 'textureScale' fields have been replaced by the 'appearance' field.
- The 'pavementTexture' field has been replaced by the 'pavementAppearance' field.
- The 'dashedLine' field has been replaced by the 'lines' field.
- Many PROTO files no longer use 'texture' style MFString field(s), instead using new 'appearance' SFNode field(s). These are:
- UnevenTerrain
- Floor
- CircleArena
- RectangleArena
- All Road PROTOs
- Door
- Ceiling
- Cabinet
From December 2017
From October 2014
From September 2012
From November 2008
From January 2005
From February 2003


Certificate
Web Development
Internships
Miscellaneous
Neural Network Deep Learning
Applied NLP in Tensorflow
Applied CNN in Tensorflow
Tech Stack
Python
Firebase
Linux
Node js
Javascript
Mongo DB
Git
Docker
JAVA
HTML
Css
React


{% extends "master.html" %} {% block header %}
The official example template of creating a blog with Bootstrap.
January 1, 2014 by {{post.author.nickname}}
{{post.body}}


Additionally, I am fairly knowledgeable with Openstack's architecture, Octavia (LBaaS V2) and Heat; Before working on cloud technologies, I was building network applications like IDS Infra, Client Server Applications, Packet Gen, Cable Modem Simulations. I Have basic knowledge of Web Technologies and Networking.
Proposed a blueprint for adding support for LBaaS V2 and implemented the whole skeleton
Contributed around 3410 lines of code in total in Openstack's various projects
Helped a friend's startup for 3d model (STL file, OBJ file) bugs report and tracking tool
I created this webapp from scratch as a summer project, which was a classfield app for USC students only.
SOCIAL
Lets Get Connected
LINKEDIN


2.4first-class
Summary
How machine learning can improve public policy
Applying machine learning to a dataset of over one million bond court cases
Using our algorithm’s predictions of risk instead of relying on judge intuition to reduce crimes committed by released defendants by up to 25% without having to jail any additional people. This can reduce jail populations by up to several hundred thousand people.
Applying machine learning to policy problems
Look for policy problems that hinge on prediction
Many social-sector decisions do not hinge on a prediction.
some questions that hinge on understanding the causal
effect of something on the world.It cannot be addressed by machine learning prediction methods, instead need tools for causation, like randomized experiments.
Make sure you’re comfortable with the outcome you’re predicting
we should set algorithm to treat every crime as equal.
In bail, different forms of crime are correlated enough, so that an algorithm trained on just one type of crime winds up outpredicting judges on almost every measure of criminality we could construct, including violent crime. The outcome you select for your algorithm will define it. So you need to think carefully about what that outcome is and what else it might be leaving out.
Check for bias
In the case of bail, human predictions can be biased.
An appropriate first benchmark for evaluating the effect of using algorithms is the the predictions and decisions already being made by humans.
Algorithms have a form of neutrality that the human mind struggles to obtain(neutrality), at least within their narrow area of focus. It is entirely possible, for algorithms to serve as a force for equity. We ought to pair our caution with hope. If the ultimate outcome is hard to measure, or involves a hard-to-define combination of outcomes, then it is not a good fit for machine learning.
Like bail, sentencing of people who have been found guilty depends not only on recidivism risk, but also on things like society’s sense of retribution, mercy, and redemption, which cannot be directly measured.
Verify your algorithm in an experiment on data it hasn’t seen
For machine learning to be useful for policy, it must accurately predict “out-ofsample.”
That means it should be trained on one set of data, then tested on a dataset it hasn’t seen before.
For many applications, are inherently flawed. Current practice is to report how well one’s algorithm predicts only among those cases where we can observe the outcome.
This makes it hard to evaluate whether any new machine learning tool can actually improve outcomes relative to the existing decision-making system.an algorithm predicts well on the part of the test data where we can observe labels doesn’t mean it will make good predictions in the real world. To do a randomized controlled trial of the sort， then we could directly compare whether bail decisions made using machine learning lead to better outcomes than those made on comparable cases using the current system of judicial decision-making.
Finding a “natural experiment” to evaluate the tool.---random select cases.Smart users refuse to use any prediction tool that does not take this evaluation challenge more seriously.
Remember there’s still a lot we don’t know
it is hard to imagine moving to a world in which the algorithms actually make the decisions;
For algorithms to add value, we need people to actually use them;
policymakers need to know when they should override the algorithm.
For people to know when to override, they need to understand their comparative advantage over the algorithm
But often it’s only the human who can see the extenuating circumstance in a given case, since it may be based on factors not captured in the data on which the algorithm was trained.
Pair caution with hope
Encourage the spread of machine learning to help solve the most challenging social problems in order to improve
the lives of many. But also be reminded to be mindful, and to wear our seatbelts.


Invalid input, details below.
Person's name is required.
Minimum 3 characters.
Maximum of 100 characters.
Invalid age format.
Eye Color is required.
Gender is required.
Invalid email format.
Latitude is required if longitude is filled.
Minimum allowed value is -90.
Maximum allowed value is 90.
Longitude is required if latitude is filled.
Minimum allowed value is -180.
Maximum allowed value is 180.
Document Format is required.


Insert news Here
Title
Heading
Content
And more input to add paragraphs
Add Paragraphs
Select Picture
Select associated Club for the news
Select
Select associated League for the news
Select
Submit news


| 1 | package fr.sii.ogham.assertion.hamcrest; | |
| 2 | ||
| 3 | import static org.hamcrest.Matchers.instanceOf; | |
| 4 | import static org.hamcrest.Matchers.is; | |
| 5 | ||
| 6 | import org.hamcrest.Matcher; | |
| 7 | ||
| 8 | public class ExceptionMatchers { | |
| 9 | ||
| 10 | /** | |
| 11 | * Returns a matcher that verifies that any exception in the stack matches | |
| 12 | * the finder and also checks that the sppulied marcher evaluates to true. | |
| 13 | * | |
| 14 | * @param finder | |
| 15 | * to find the cause in exception stack | |
| 16 | * @param matcher | |
| 17 | * to apply to the cause of the outer exception | |
| 18 | * @param <T> | |
| 19 | * type of the outer exception | |
| 20 | */ | |
| 21 | @SuppressWarnings("javadoc") | |
| 22 | public static <T extends Throwable> Matcher<T> hasAnyCause(final Matcher<? extends Throwable> finder, final Matcher<? extends Throwable> matcher) { | |
| 23 |
1
1. hasAnyCause : All methods instructions replaced by: return null; → NO_COVERAGE |
return new ThrowableAnyCauseMatcher<T>(finder, matcher); |
| 24 | } | |
| 25 | ||
| 26 | /** | |
| 27 | * Returns a matcher that verifies that any exception in the stack matches | |
| 28 | * the expected class and also checks that the sppulied marcher evaluates to | |
| 29 | * true. | |
| 30 | * | |
| 31 | * @param expectedClass | |
| 32 | * to find the cause in exception stack | |
| 33 | * @param matcher | |
| 34 | * to apply to the cause of the outer exception | |
| 35 | * @param <T> | |
| 36 | * type of the outer exception | |
| 37 | */ | |
| 38 | @SuppressWarnings("javadoc") | |
| 39 | public static <T extends Throwable> Matcher<T> hasAnyCause(final Class<? extends Throwable> expectedClass, final Matcher<? extends Throwable> matcher) { | |
| 40 |
3
1. hasAnyCause : All methods instructions replaced by: return null; → NO_COVERAGE 2. hasAnyCause : All methods instructions replaced by: return null; → KILLED 3. hasAnyCause : All methods instructions replaced by: return null; → KILLED |
return new ThrowableAnyCauseMatcher<T>(instanceOf(expectedClass), matcher); |
| 41 | } | |
| 42 | ||
| 43 | /** | |
| 44 | * Returns a matcher that verifies that the exception has a message for | |
| 45 | * which the supplied matcher evaluates to true. | |
| 46 | * | |
| 47 | * @param matcher | |
| 48 | * to apply to the cause of the exception | |
| 49 | * @param <T> | |
| 50 | * type of the outer exception | |
| 51 | */ | |
| 52 | @SuppressWarnings("javadoc") | |
| 53 | public static <T extends Throwable> Matcher<T> hasMessage(final Matcher<? extends String> matcher) { | |
| 54 |
3
1. hasMessage : All methods instructions replaced by: return null; → NO_COVERAGE 2. hasMessage : All methods instructions replaced by: return null; → KILLED 3. hasMessage : All methods instructions replaced by: return null; → KILLED |
return new ThrowableMessageMatcher<T>(matcher); |
| 55 | } | |
| 56 | ||
| 57 | /** | |
| 58 | * shortcut to: | |
| 59 | * | |
| 60 | * <pre> | |
| 61 | * {@code | |
| 62 | * hasMessage(is("some message")) | |
| 63 | * } | |
| 64 | * </pre> | |
| 65 | * | |
| 66 | * @param expectedMessage | |
| 67 | * the expected message of the exception | |
| 68 | * @param <T> | |
| 69 | * type of the outer exception | |
| 70 | */ | |
| 71 | @SuppressWarnings("javadoc") | |
| 72 | public static <T extends Throwable> Matcher<T> hasMessage(String expectedMessage) { | |
| 73 |
3
1. hasMessage : All methods instructions replaced by: return null; → NO_COVERAGE 2. hasMessage : All methods instructions replaced by: return null; → KILLED 3. hasMessage : All methods instructions replaced by: return null; → KILLED |
return new ThrowableMessageMatcher<T>(is(expectedMessage)); |
| 74 | } | |
| 75 | ||
| 76 | private ExceptionMatchers() { | |
| 77 | super(); | |
| 78 | } | |
| 79 | } | |
Mutations | ||
| 23 |
1.1 |
|
| 40 |
1.1 2.2 3.3 |
|
| 54 |
1.1 2.2 3.3 |
|
| 73 |
1.1 2.2 3.3 |


AWS::EC2::VPCEndpointConnectionNotification
Creates a connection notification for the specified VPC endpoint or VPC endpoint service. A connection notification notifies you of specific endpoint events. You must create an SNS topic to receive notifications. For more information, see CreateVpcEndpointConnectionNotification.
Topics
Syntax
To declare this entity in your AWS CloudFormation template, use the following syntax:
JSON
{ "Type" : "AWS::EC2::VPCEndpointConnectionNotification", "Properties" : { "ConnectionEvents" : [
String
, ... ], "VPCEndpointId" :String
, "ServiceId" :String
, "ConnectionNotificationArn" :String
} }
YAML
Type: "AWS::EC2::VPCEndpointConnectionNotification" Properties: ConnectionEvents: -
String
VPCEndpointId:String
ServiceId:String
ConnectionNotificationArn:String
Properties
ConnectionEvents
-
One or more endpoint events for which to receive notifications. Valid values are
Accept
,Connect
,Delete
, andReject
.Required: Yes
Type: List of String values
Update requires: No interruption
ConnectionNotificationArn
-
The ARN of the SNS topic for the notifications.
Required: Yes
Type: String
Update requires: No interruption
ServiceId
-
The ID of the endpoint service.
Required: No
Type: String
Update requires: No interruption
VPCEndpointId
-
The ID of the endpoint.
Required: No
Type: String
Update requires: No interruption
Return Values
Ref
When you pass the logical ID of an
AWS::EC2::VPCEndpointConnectionNotification
resource to the intrinsic
Ref
function, the function returns the ID of the connection
notification.
For more information about using the Ref
function, see
Ref.


Let's play Rock, Paper, Scissors!
you
comp
0
vs.
0
What will you choose?
Rock
Paper
Scissors
Let's Go!


I see myself as a Software Engineer rather than just a frontend developer as I enjoy getting involved in all stages of Software Development Lifecycle. This allows me to contribute to key product decisions that would shape the product vision and enhance user experience.
I'm primarily a React Frontend Engineer, but I've also worked as QA Engineer, and PM at tech startups across Southeast Asia & West Africa, such as SELLOX, ARIGA, and KAODIM.
My passion for spreading Digital Literacy amongst the African youth led me to found a small organization called DIGILIT AFRICA. There, I teach people about technology, computers, digital transformation, and programming.
View ResumeSellox is an eCommerce platform that enables small/medium businesses to set up an online store in a matter of minutes.
Ariga is a platform which partners with local designers to bring their brands forward, allowing consumers greater power of choice in attaining the right outfit that fits their personality and style.
Kaodim is the No. #1 service marketplace in Southeast Asia that helps our customers to find the right service providers for hire.
MappyPals is an exciting new app that can keep you up to date with your international friends. You can follow them, message them, make new friends and see what they are up to! All in one easy-to-use app!
Afroddap is an ecommerce platform tailored towards African creatives. We help them reach more customers
Want to work together or have any questions?
Get in touch


An iteration range over a 1D data set. Splits divide the range in two based unless the minimum size is reached. Splits are determined by a splitter object. Successive splits result in a binary tree where each leaf represents a unit of work.
More...
#include <Range1d.h>
|
|
using | iter_type = Iter |
| |
|
using | split_result = SplitResult< Range1d, MAX_SPLITS, DIMENSIONALITY > |
| |
|
using | size_type = size_t |
| |
|
|
| Range1d (Range1d const &)=default |
| |
| GTS_INLINE | Range1d (iter_type xBegin, iter_type xEnd, size_type minSize, size_type splitOnMultiplesOf=1) |
| | Constructs a Range1d. More...
|
| |
|
GTS_INLINE iter_type | begin () const |
| |
|
GTS_INLINE iter_type | end () const |
| |
|
GTS_INLINE iter_type & | begin () |
| |
|
GTS_INLINE iter_type & | end () |
| |
|
GTS_INLINE bool | empty () const |
| |
|
GTS_INLINE size_type | size () const |
| |
|
GTS_INLINE size_type | initialSize () const |
| |
|
GTS_INLINE void | resetInitialSize (size_type initSize) |
| |
|
GTS_INLINE size_type | minSize () const |
| |
|
GTS_INLINE size_type | splitOnMultiplesOf () const |
| |
|
GTS_INLINE bool | isDivisible () const |
| |
| template<typename TSplitter > |
| GTS_INLINE void | split (split_result &result, TSplitter const &splitter) |
| | Divides the range based on the splitter. More...
|
| |
|
|
static GTS_INLINE iter_type | splitHelper (Range1d &range, EvenSplitter const &) |
| |
|
static GTS_INLINE iter_type | splitHelper (Range1d &range, ProportionalSplitter const &proportions) |
| |
|
static GTS_INLINE uint16_t | adjustDivisor (uint16_t initialSplitDepth, bool isStatic) |
| |
|
static GTS_INLINE uint16_t | splitInitialDepth (uint16_t initialSplitDepth, bool isStatic) |
| |
|
static GTS_INLINE uint16_t | finalSplitDivisor (uint16_t initialSplitDepth, bool isStatic) |
| |
|
|
static constexpr size_t | SPLIT_FACTOR = 2 |
| |
|
static constexpr size_t | MAX_SPLITS = SPLIT_FACTOR - 1 |
| |
|
static constexpr size_t | DIMENSIONALITY = 1 |
| |
template<typename Iter>
class gts::Range1d< Iter >
An iteration range over a 1D data set. Splits divide the range in two based unless the minimum size is reached. Splits are determined by a splitter object. Successive splits result in a binary tree where each leaf represents a unit of work.
Derivative of TBB blocked_range. https://github.com/intel/tbb
◆ Range1d()
template<typename Iter >
| GTS_INLINE gts::Range1d< Iter >::Range1d |
( |
iter_type |
xBegin, |
|
|
iter_type |
xEnd, |
|
|
size_type |
minSize, |
|
|
size_type |
splitOnMultiplesOf = 1 |
|
) |
| |
|
inline |
Constructs a Range1d.
- Parameters
-
| xBegin | An iterator to the beginning of the range. |
| xEnd | An iterator to the xEnd of the range. |
| minSize | The smallest sub-range the range can be divided into. Must be >= splitOnMultiplesOf. |
| splitOnMultiplesOf | Tries to ensure that each sub-range is a multiple of this value. Useful for things like iterating items to be packed into SIMD vectors. |
◆ split()
template<typename Iter >
template<typename TSplitter >
Divides the range based on the splitter.
- Parameters
-
| result | The result of the split. |
| splitter | Defines the split behavior. |


{% extends "base.html" %} {% block login %}
More than a month ago, dog Nemo suddenly couldn't walk. His owner immediately took him to the hospital for examination. He flew from Jinan to Beijing and went to several hospitals for treatment, injection and medicine. But half a month later, Nemo still couldn't walk, and his symptoms didn't get better. And Nemo had a bag on his handsome back. Biochemical examination showed that Nemo had anemia, abnormal liver function and liver failure.
Our attending doctor personally operated on Nemo successfully. After the operation, the hospital monitored the physical condition of Nemo for 24 hours, and gave health ball exercise; acupuncture, shock wave therapy "spa". After a period of treatment at the HealingPaws Hospital, Nemo's mood and body improved day by day. And restored to its former glory.
Lucky's little Corgi, though only six months old, is a real "devil of the mixed world". At home, he is lively like a rabbit, living is a leader of the demolition team, and even the 40kg big dog at home has to give in. During a chase with Alaska, lucky accidentally bumped his head into the car. After the accident, the owner found that lucky couldn't stand up and was paralyzed. The situation was very critical.
After MRI, doctors found that there were suspected bone fragments embedded in the cervical vertebra (C1 Atlas), combined with the main complaint and clinical examination, doctors initially diagnosed lucky as spinal cord contusion caused by impact. After communicating with lucky's owner, doctors decided to perform a ventral slot operation on lucky's neck. During the operation, TCM students successfully removed several small bone fragments from the atlas. On the sixth day after surgery, lucky was able to stand up on his own, his diet and drinking water were basically back to normal, and he was back to the devil king. It's just around the corner~


What is a Ruby class?
As a beginner Rubyist, your capabilities will increase significantly once you understand how to build and manage classes. So, what is a class? Every object within ruby is part of a class. In IRB, if you were to run [1,2,3].class, the output would be Array. Likewise, if you run {:name => "Joe"}.class, the output will be Hash.
Every object exists within a class, and that class includes instance methods that can be run on objects of that class. For example, ".include?" is an instance method within the array class. Running [1,2,3].include?(3) yields 'True'. The code behind the ".include?" method is written within the scope of the Array class, and so the ".include?"" method can be run on any instance of an array.
Once you've built your own class, you can create instances of that class, just like [1,2,3] is an instance of Array. Within your class you can create methods that are unique to instances of that class. As a simple example, lets say we created a class called Cars. You might then define a method within that class called honk, that, when called on an instance of Cars, returns the string "Honk!".
In my current role as a finance analyst, one of the worst parts of my jobs is keeping track of headcount for the businesses that I support. I'm going to walk you through the creation of a class that will help manage employees and expenses in our fictional company Hello Mellon, Inc.
Creating a class and instances of that class
Creating a class is super simple. Lets call ours 'Headcount':
class Headcount
end
gary = Headcount.new
bob = Headcount.new
craig = Headcount.new
Initializing
Cool, now we've got three objects - gary, bob, and craig - that are each an instance of our Headcount class. Let's refer to these objects as 'employees' from now on. So, what can we really do with our employees at this point? Not a whole lot. Lets fix that! When managing headcount, it is important for each employee in the database to have a first name, last name, and start date. If we were building a real app, we'd want these attributes to be required inputs when creating a new employee in a system. In order to require certain attributes when a new instance of Headcount is created, we need to use the initialize method:
class Headcount
def initialize(firstname, lastname, startdate)
end
end
in `initialize': wrong number of arguments (0 for 3) (ArgumentError)
This message is basically saying "Hang on there partner! In order to create an instance of Headcount, you need to input some basic information! Three tidbits of information, in fact. You input zero!" And that's because we didn't initialize the 'gary' instance of Headcount, meaning, we didn't input the required attributes of 'gary' when creating 'gary'. Let's give 'gary' some attributes:gary = Headcount.new("Gary", "Hammell", "8/4/2014")
No error? Great. So, we now have a working instance of Headcount, called 'gary'. Ok, so now what can we do with this? Again, not much yet! In any decent headcount system, you'll want to be able to easily see certain attributes of a specific employee. So, if we wanted to see gary's last name, how could we do that?Instance Variables
Through the use of instance variables of course! An instance variable is similiar to any other variable, except that it is only available within the scope of the class that it is defined in. Let's create some, and then I'll walk you through it:
class Headcount
def initialize(firstname, lastname, startdate)
@firstname = firstname
@lastname = lastname
@startdate = startdate
end
end
Instance Methods
Ok, so CAN WE DO ANYTHING YET? Not quite. We need to write some instance methods that, when called on an instance of Headcount, will perform some actions for us. There is no tag for an instance method like there is for an instance variable (the '@'), rather instance methods are just methods defined within a class, that can be called on specific instances of that class. Let's add a method called firstname below our initialize method:
class Headcount
def initialize(firstname, lastname, startdate)
@firstname = firstname
@lastname = lastname
@startdate = startdate
end
def firstname
@firstname
end
end
gary = Headcount.new("Gary", "Hammell", "8/4/2014")
puts gary.firstname
Gary
Gnarrrr! By calling the firstname method on 'gary', we are accessing the corrseponding code within the Headcount class. All this method does is return the instance variable @firstname, which was set equal to the user input! Likewise, we can define methods to return @lastname and @startdate:
class Headcount
def initialize(firstname, lastname, startdate)
@firstname = firstname
@lastname = lastname
@startdate = startdate
end
def firstname
@firstname
end
def lastname
@lastname
end
def startdate
@startdate
end
end
gary = Headcount.new("Gary", "Hammell", "8/4/2014")
puts gary.firstname
puts gary.lastname
puts gary.startdate
Gary
Hammell
8/4/2014
attr_accessor
Let's say you messed up, and input the last name 'Hammell', even though my real last name is 'THUNDERCLAP'. You've already created 'gary', so how could we go about changing the last name? You might try:
gary.lastname = "THUNDERCLAP"
Except you'll get:
undefined method `lastname=' for #
def lastname=(lastname)
@lastname=lastname
end
gary = Headcount.new("Gary", "Hammell", "8/4/2014")
puts gary.lastname
gary.lastname = "THUNDERCLAP"
puts gary.lastname
Hammell
THUNDERCLAP
def lastname
@lastname
end
def lastname=(lastname)
@lastname=lastname
end
attr_accessor :lastname
Let's do that for each of our simple methods. Our total code now looks like this:
class Headcount
attr_accessor :firstname, :lastname, :startdate
def initialize(firstname, lastname, startdate)
@firstname = firstname
@lastname = lastname
@startdate = startdate
end
end
gary = Headcount.new("Gary", "Hammell", "8/4/2014")
puts gary.lastname
gary.lastname = "THUNDERCLAP"
puts gary.lastname
Hammell
THUNDERCLAP
Alright, lets step things up a notch.
More instance methods
We want this to be a well rounded headcount application, so lets require a couple extra inputs when creating a new employee: base salary, bonus, and grade level.
class Headcount
attr_accessor :firstname, :lastname, :base, :bonus, :grade, :startdate
def initialize(firstname, lastname, base, bonus, grade, startdate)
@firstname = firstname
@lastname = lastname
@base = base
@bonus = bonus
@grade = grade
@startdate = startdate
end
end
def monthly_exp
ben_tax_rate = 0.185
(@base * (1+@bonus) * (1+ben_tax_rate) / 12).to_i
end
Let's try it out:
gary = Headcount.new("Gary", "Hammell", 500000, 0.3, 8, "8/4/2014")
#that's right, $500000 / year baby! ..maybe someday...
puts gary.monthly_exp
64187
Damn, that's a lot of cash money for one month. We could change the method to output the value as a string, formatted like '$64,187', but that would make it more difficult to access from other methods within the Headcount class. That's a challenge for another day.Let's also create a method to calculate the daily expense of an employee, which uses the 'monthly_exp' method. Let's add this to our Headcount class:
def daily_exp
monthly_exp * 12 / 365
end
gary.daily_exp
2110
Nice.What if we wanted to see the amount of money that Hello Mellon will be paying for an employee for the rest of the year? Let's try out another method! This is going to get a little bit trickier. Before we write the method, lets switch a couple things up. First, lets add the code
require 'date'
to the top of our program. I won't get too into this, but basically this allows us to access additional methods that are already defined within a different class, Date. Now, lets also switch up our required parameters again. Lets break 'startdate' into three paramaters 'year', 'month', and 'day' in our initialize method. So, now our code looks like this:
require 'date'
class Headcount
attr_accessor :firstname, :lastname, :base, :bonus, :grade, :startdate
def initialize(firstname, lastname, base, bonus, grade, startyear, startmonth, startday)
@firstname = firstname
@lastname = lastname
@base = base
@bonus = bonus
@grade = grade
@startdate = startdate
end
def monthly_exp
ben_tax_rate = 0.185
(@base * (1+@bonus) * (1+ben_tax_rate) / 12).to_i
end
def daily_exp
monthly_exp * 12 / 365
end
end
@startdate = Date.civil(startyear,startmonth,startday)
Now, upon initialization, we're creating an instance variable @startdate, that is set to an actual date value created by the Date.civil method. The Date.civil method takes three inputs - a year, a month, and a day - and returns a date value that functions like a number, as opposed to a string.Ok, so our code looks like this:
require 'date'
class Headcount
attr_accessor :firstname, :lastname, :base, :bonus, :grade, :startdate
def initialize(firstname, lastname, base, bonus, grade, startyear, startmonth, startday)
@firstname = firstname
@lastname = lastname
@base = base
@bonus = bonus
@grade = grade
@startdate = Date.civil(startyear,startmonth,startday)
end
def monthly_exp
ben_tax_rate = 0.185
(@base * (1+@bonus) * (1+ben_tax_rate) / 12).to_i
end
def daily_exp
monthly_exp * 12 / 365
end
end
def remaining_cost
yearend = Date.civil(2014,12,31)
cost = if @startdate < Date.today
(yearend - Date.today) * daily_exp
else (yearend - @startdate) * daily_exp
end.to_i
end
Remember how I said that using 'Date.civil' creates a date value that functions like a number? That's why something like (yearend - Date.today) works. That equation returns the number of days between the two dates.
Let's try it:
p gary.remaining_cost
314390
(as of 7/8/2014.. also, disclaimer, these values might not be 100% because I am not accounting for cents)
Awesome. So now we've got three great methods to help us manage Hello Mellon's expenses. But each of these methods only provides us information on individual employees. What if we wanted a report of monthly expense by employee? Or what if we wanted to know our total employee count? For these functions, my friends, we need class methodsClass Methods
Class methods are methods that are called on classes themselves. Until now, we've been writing instance methods that are called on specific objects of a class, like gary.firstname. A class method would look something like Headcount.report. See how the method is called on the class itself? Lets jump right in to some applications.In order to write effective class methods, we need some class variables. A class variable is a variable that is the same between all instances of a class. It is a global variable within the context of a single class, and its syntax requires '@@' in front of the variable name. Let's add the following to our code, just above the attr_accessor method:
@@employee_count = 0
@@employees = {}
Let's also add the following code into our initialize method (don't worry, we'll cover everything here):
@id = (rand(1000) + 1).to_s.rjust(6,'0')
@@employee_count += 1
@@employees[@id] =
{firstname: firstname,
lastname: lastname,
base: base,
bonus: bonus,
grade: grade,
function: function,
startdate: startdate}
require 'date'
class Headcount
@@employee_count = 0
@@employees = {}
attr_accessor :firstname, :lastname, :base, :bonus, :grade, :startdate
def initialize(firstname, lastname, base, bonus, grade, startyear, startmonth, startday)
@firstname = firstname
@lastname = lastname
@base = base
@bonus = bonus
@grade = grade
@startdate = Date.civil(startyear,startmonth,startday)
@id = (rand(1000) + 1).to_s.rjust(6,'0')
@@employee_count += 1
@@employees[@id] =
{firstname: firstname,
lastname: lastname,
base: base,
bonus: bonus,
grade: grade,
function: function,
startdate: startdate}
end
def monthly_exp
ben_tax_rate = 0.185
(@base * (1+@bonus) * (1+ben_tax_rate) / 12).to_i
end
def daily_exp
monthly_exp * 12 / 365
end
def remaining_cost
yearend = Date.civil(2014,12,31)
cost = if @startdate < Date.today
(yearend - Date.today) * daily_exp
else (yearend - @startdate) * daily_exp
end.to_i
end
end
- we added an instance variable @id to our initialize method. This variable is set equal to a random number between 1 and 1000, and will act as a unique identifier for each of Hello Mellon's employees.
- we added @@employee_count +=1 to our initialize method. Now, everytime we create a new employee, this counter will increase by 1
- and with the @@employees section of our initialize method, every time we create a new employee, the @@employees hash will be updated with a key, set equal to the employees ID, and a value, set equal to another hash that includes all of the other employee information.
This may seem like a lot, so I highly recommend reviewing all of the above code to ensure that you understand it's purpose before continuing in this exercise.
Alright! Now lets make a method that spits out a report of all employees within Hello Mellon. Our first class method!! Notice how the method is defined using the syntax self.method_name:
def self.summary
puts "Hello Mellon has #{@@employee_count} employees:"
puts
@@employees.each do |id, info|
puts "ID: #{id}"
info.each do |data, value|
print "#{data}: #{value}; "
end
puts puts
end
end
gary = Headcount.new("Gary", "Hammell", 500000, 0.3, 8, 2014, 8, 4)
craig = Headcount.new("Craig", "Hammell", 300000, 0.25, 7, 2014, 10, 1)
bob = Headcount.new("Bob", "Hammell", 250000, 0.2, 7, 2014, 9, 2)
jack = Headcount.new("Jack", "Hammell", 400000, 0.3, 8, 2014, 11, 20)
angela = Headcount.new("Angela", "Hammell", 200000, 0.2, 6, 2014, 2, 28)
# It's a family company
Headcount.summary
We get:
Hello Mellon has 5 employees:
ID: 000764
firstname: Gary; lastname: Hammell; base: 500000; bonus: 0.3; grade: 8; startdate: 2014-08-04;
ID: 000362
firstname: Craig; lastname: Hammell; base: 300000; bonus: 0.25; grade: 7; startdate: 2014-10-01;
ID: 000222
firstname: Bob; lastname: Hammell; base: 250000; bonus: 0.2; grade: 7; startdate: 2014-09-02;
ID: 000964
firstname: Jack; lastname: Hammell; base: 400000; bonus: 0.3; grade: 8; startdate: 2014-11-20;
ID: 000679
firstname: Angela; lastname: Hammell; base: 200000; bonus: 0.2; grade: 6; startdate: 2014-02-28;
Object Space
We might write something like:
def self.total_costs
puts "Hello Mellon remaining headcount costs by employee for the current year:"
puts
total = ObjectSpace.each_object(Headcount).inject(0) do |result, employee|
puts "#{employee.firstname} #{employee.lastname}: #{employee.remaining_cost}"
result += employee.remaining_cost
end
puts
puts "The total remaining headcount costs for the year is #{total}"
end
Headcount.total_costs
We'd get:
Hello Mellon remaining headcount costs by employee for the current year:
Angela Hammell: 137104
Jack Hammell: 69208
Bob Hammell: 116760
Craig Hammell: 110747
Gary Hammell: 314390
The total remaining headcount costs for the year is 748209
- We did not include a value in the employee info hash that represented the remaining expense for that employee, so there would have been nothing to toggle if we iterated through that hash
- You might be thinking, 'well then why not just add the remaining expense value to each employee's information hash?', and the answer is that I wanted the output of the remaining_cost method to remain dynamic, meaning that it would change every day. If we stored a value in the hash, then it would be a static value that might not actually represent the remaining expense in the year. So, I needed to figure out a way to iterate through each employee and at the same time run employee.remaining_cost.
Thanks
I really hope you enjoyed this tutorial. There is a lot more that could be built into this class, and there is definitely room for improvement in my current code, but I think this is a good starting point. Hopefully someday I can build something like this into an awesome headcount app so that finance analysts like myself don't tear their hair out tying headcount out.Thanks!!
Copyright: Gary Hammell 2014


WITNESS LIST Subcommittee on Higher Education Committee March 29, 2004 - 9:00A Charge #4 ON: Flack, Teri (Texas Higher Education Coordinating Board), Austin, TX Hollis, Lois (Texas Higher Education Coordinating Board), Austin, TX McDonald, Carol L. (Independent Colleges and Universities of Texas, Inc.), Austin, TX Sullivan, Teresa (UT System), Austin, TX Overview of Higher Education in Texas ON: Brown, Commissioner Don (Texas Higher Education Coordinating Board), Austin, TX Gardner, Dr. David (Texas Higher Education Coordinating Board), Austin, TX Overview of Student Financial Assistance ON: Bazan, Terry (Austin Community College), Austin, TX Jost, Pat M. (Trinity University), San Antonio, TX Krause, Karen (University of Texas at Arlington), Arlington, TX Lane, Jim (University of Houston, TASFAA), Houston, TX McDonald, Carol L. (Independent Colleges and Universities of Texas, Inc.), Austin, TX Wilson, Marcus (Texas Association of Student Financial Aid Administrators), Lubbock, TX


Jupyter requires an Anaconda installation. Click on the button below to install Anaconda for this project.
You cannot change the version of python after you have selected enabled the anaconda environment for this project.
|
{{row.lib}}
|
|
{{row.status}}
|
Jupyter requires an Anaconda installation. Click on the button below to install Anaconda for this project.
You cannot change the version of python after you have selected enabled the anaconda environment for this project.
|
{{row.lib}}
|
|
{{row.status}}
|
| Url | Library | Version | Install | Machine | Status | User-Installed | |
|---|---|---|---|---|---|---|---|
|
{{row.channelUrl}}
|
{{row.lib}}
|
{{row.version}}
|
{{row.installType}}
|
{{row.machineType}}
|
{{row.status}}
|
|
Pre-installed |
| Operation | |||||
|---|---|---|---|---|---|
|
{{row.op}}
|
{{row.lib}} | {{row.version}} | {{row.status}} {{row.status}} |


|
SPHinXsys
alpha version
|
Abstract base class for cell-based mesh by introducing number of cells, buffer width and mesh-based data in its derived classes. Note that we identify the difference between grid spacing and data spacing. The latter is different from grid spacing when MeshWithDataPackage is considered. More...
#include <base_mesh.h>
Inherits SPH::BaseMesh.
Inherited by SPH::MeshWithGridDataPackages< BaseLevelSet, LevelSetDataPackage >, SPH::CellLinkedList, and SPH::MeshWithGridDataPackages< MeshFieldType, GridDataPackageType >.
Public Member Functions | |
| Mesh (BoundingBox tentative_bounds, Real grid_spacing, size_t buffer_width) | |
| Mesh (Vecd mesh_lower_bound, Vecu number_of_cells, Real grid_spacing) | |
| Vecu | NumberOfCells () |
| size_t | MeshBufferSize () |
| virtual Real | DataSpacing () |
| Public Member Functions inherited from SPH::BaseMesh | |
| BaseMesh (Vecu number_of_grid_points) | |
| BaseMesh (Vecd mesh_lower_bound, Real grid_spacing, Vecu number_of_grid_points) | |
| BaseMesh (BoundingBox tentative_bounds, Real grid_spacing, size_t buffer_width) | |
| Vecd | MeshLowerBound () |
| Real | GridSpacing () |
| Vecu | NumberOfGridPoints () |
| Vecu | NumberOfGridPointsFromNumberOfCells (const Vecu &number_of_cells) |
| Vecu | NumberOfCellsFromNumberOfGridPoints (const Vecu &number_of_grid_points) |
| Vecd | GridPositionFromCellPosition (const Vecd &cell_position) |
| Vecu | CellIndexFromPosition (const Vecd &position) |
| Vecd | CellPositionFromIndex (const Vecu &cell_index) |
| Vecd | GridPositionFromIndex (const Vecu &grid_index) |
| Vecu | transfer1DtoMeshIndex (const Vecu &number_of_mesh_indexes, size_t i) |
| size_t | transferMeshIndexTo1D (const Vecu &number_of_mesh_indexes, const Vecu &mesh_index) |
| size_t | MortonCode (const size_t &i) |
| size_t | transferMeshIndexToMortonOrder (const Vecu &mesh_index) |
Protected Member Functions | |
| void | copyMeshProperties (Mesh *another_mesh) |
Protected Attributes | |
| size_t | buffer_width_ |
| Vecu | number_of_cells_ |
| Protected Attributes inherited from SPH::BaseMesh | |
| Vecd | mesh_lower_bound_ |
| Real | grid_spacing_ |
| Vecu | number_of_grid_points_ |
Abstract base class for cell-based mesh by introducing number of cells, buffer width and mesh-based data in its derived classes. Note that we identify the difference between grid spacing and data spacing. The latter is different from grid spacing when MeshWithDataPackage is considered.
|
protected |
buffer width to avoid bound check.
|
protected |
number of cells by dimension


Websockets serial console
1
2
3
LED State
Data received from serial port
Clear
Send data to serial port
Send


This is a paragraph.
This is another paragraph.
I am testing git diff in my text editor
Well still cant see any difference in what I am doing
I am just testing the changes thayt can be seen
adding text to my file so that I can ammend my commit
adding text to check my commit ammends


Many GeneXus-related operations make use of the MSBuild engine (eg: checkout, update, build). Select here the MSBuild installation you want to use with this GeneXus installation.
Select "(Default)" to use whatever MSBuild.exe can be found in the system PATH (if any).
The options that appear here are those you may configure in Jenkins "Global Tool Configuration".


Search
This page allows you to search through the API documentation for specific terms. Enter your search words into the box below and click "submit". The search will be performed on namespaces, classes, interfaces, traits, functions, and methods.
This page allows you to search through the API documentation for specific terms. Enter your search words into the box below and click "submit". The search will be performed on namespaces, classes, interfaces, traits, functions, and methods.


Electronic shop
Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from
Electronic shop
Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from
Electronic shop
Contrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from


We are always seeking for highly motivated talents, who aimed high to produce interdisciplianry and cutting-edge research. If you are hard-working, ambitious and extremely bright, we should have a chance to talk.
Our current focus lied on Human-Vehicle Interaction in Auto Vehicles, but we also have several other projects available and we are always open to interesting research proposals.
Read MoreWe are currently developing a new cognitive driving simulator, with the capability to restore the realistic scenes wihin the lab.
Our position paper to embed Video-to-video Synthesis has been accepted by ACM AutomotiveUI 2019.
Zilin Song and Shuolei Wang have joined User-Centric Computing Group for Summer Research Projects. Welcome!
User-Centric Computing Group has been established, with the introspections of previous research and experiences.
User-Centric Computing Group
User-Centric Computing Group
Zilin Song and Shuolei Wang
Shuolei Wang
Zilin Song
Weikai Kong