Consider prefetching messages for receivers (see Section 1.6, “Receiver Capacity (Prefetch)”). This helps eliminate roundtrips and increases throughput. Prefetch is disabled by default, and enabling it is the most effective means of improving throughput of received messages.
Send messages asynchronously. Again, this helps eliminate roundtrips and increases throughput. The C++ and .NET clients send asynchronously by default, however the python client defaults to synchronous sends.
Acknowledge messages in batches (see Section 1.7, “Acknowledging Received Messages”). Rather than acknowledging each message individually, consider issuing acknowledgements after n messages and/or after a particular duration has elapsed.
Tune the sender capacity (see Section 1.5, “Sender Capacity and Replay”). If the capacity is too low the sender may block waiting for the broker to confirm receipt of messages, before it can free up more capacity.
If you are setting a reply-to address on messages being sent by the c++ client, make sure the address type is set to either queue or topic as appropriate. This avoids the client having to determine which type of node is being refered to, which is required when hanling reply-to in AMQP 0-10.
For latency sensitive applications, setting tcp-nodelay on qpidd and on client connections can help reduce the latency.
Apache Qpid, Messaging built on AMQP; Copyright © 2015 The Apache Software Foundation; Licensed under the Apache License, Version 2.0; Apache Qpid, Qpid, Qpid Proton, Proton, Apache, the Apache feather logo, and the Apache Qpid project logo are trademarks of The Apache Software Foundation; All other marks mentioned may be trademarks or registered trademarks of their respective owners


Some help for the Python and latex expressions
Do not use any other variables in the expression than x (the values of the timeseries)
| Equation type |
Example |
Python code |
Latex code |
| Polynom |
$~-0.5\cdot10^{-5}x^3+2.35x^2-124.5x+15.3~$ |
-0.5e-5*x**3 + 2.35*x**2 - 124.5*x + 15.3 |
-0.5\dot10^{-5}x^3+2.35x^2-124.5x+15.3 |
| Exponential |
$~3.2 e^{0.5x}~$ |
3.2 * exp(0.5*x) |
3.2 e^{0.5x} |
| nat. log. |
$~\ln{x}~$ |
log(x) |
\ln{x}) |
| dec. log. |
$~\log_{10}{x}~$ |
log10(x) |
\log_{10}{x} |
| cumulative sum |
\[\int_{t=0}^{t(x)}x dx\] |
cumsum(x) |
\int_{t=0}^{t(x)}x'dx |


chntpw
A utility that can edit windows registry, reset user password, promote users to administrator by modifying the Windows SAM.
Boot target machine with live cd like Kali Linux and run with elevated privileges.
More information: home page
- List all users in the SAM file:
chntpw -l path/to/sam_file
- Edit [u]ser interactively:
chntpw -u username path/to/sam_file
- Use chntpw [i]nteractively:
chntpw -i path/to/sam_file


And I'm a Photographer
I am A fifteen year old boy from pittsburgh pennslyvania with a new hobby and a dad that is obsesed with coding websites.
Visit my instagram for more photos


Business Cards
Think of your business card as the first impression of your brand. When you meet someone who could potentially become a great client or has many friends or colleagues that are potential clients, don’t you want them to walk away with a great impression of you and your brand? Networking is about making connections, and the relationship with a brand begins the moment you engage with your clients, and how you engage with them will set the tone for your future dealings. Business cards give you the ability to look your clients directly in the eyes, reach out a friendly hand and give them something to remember you by.
As a professional, you are always working and always making connections to build a solid referral based business. Keeping a set of cards on you while you’re attending a banquet, or hanging out at you children’s baseball game allows you the opportunity to continuously build the strength of the brand by building awareness and conducting business on the fly. Make your mark NOW and let Assets crack team of designers breathe life into your brand with new business cards for you and/or your staff.
What will you get?
- Multiple design comps
- Expert designers
- Original design strategically created for your company
- 100% satisfaction guarantee
There are multiple special treatments like double sided, varnish, card thickness, Dye cut etc., Want an extra special business card? Then please let us know when you make your request for marketing support.
Upon approval you get:
Everything you need for production. Your final approved business card design will be sent in the correct formats and will be ready to send to a printer. If you are uncomfortable with this step, Assets production team will handle all of the work for you.*
*Additional charges apply.


Module: Module::Concerning
| Relationships & Source Files | |
| Extension / Inclusion / Inheritance Descendants | |
|
Included In:
::ActiveModel::SecurePassword::InstanceMethodsOnActivation ,
::ActiveModel::Type::Helpers::AcceptsMultiparameterTime ,
::ActiveModel::Validations::AcceptanceValidator::LazilyDefineAttributes ,
::ActiveRecord::AttributeMethods::GeneratedAttributeMethods ,
::ActiveRecord::Delegation::GeneratedRelationMethods ,
::ActiveRecord::Enum::EnumMethods ,
::ActiveSupport::Deprecation::DeprecatedConstantProxy ,
::Module
| |
| Defined in: | activesupport/lib/active_support/core_ext/module/concerning.rb |
Overview
Bite-sized separation of concerns
We often find ourselves with a medium-sized chunk of behavior that we’d like to extract, but only mix in to a single class.
Extracting a plain old Ruby object to encapsulate it and collaborate or delegate to the original object is often a good choice, but when there’s no additional state to encapsulate or we’re making DSL-style declarations about the parent class, introducing new collaborators can obfuscate rather than simplify.
The typical route is to just dump everything in a monolithic class, perhaps with a comment, as a least-bad alternative. Using modules in separate files means tedious sifting to get a big-picture view.
Dissatisfying ways to separate small concerns
Using comments:
class Todo < ApplicationRecord
# Other todo implementation
# ...
## Event tracking
has_many :events
before_create :track_creation
private
def track_creation
# ...
end
end
With an inline module:
Noisy syntax.
class Todo < ApplicationRecord
# Other todo implementation
# ...
module EventTracking
extend ActiveSupport::Concern
included do
has_many :events
before_create :track_creation
end
private
def track_creation
# ...
end
end
include EventTracking
end
Mix-in noise exiled to its own file:
Once our chunk of behavior starts pushing the scroll-to-understand-it boundary, we give in and move it to a separate file. At this size, the increased overhead can be a reasonable tradeoff even if it reduces our at-a-glance perception of how things work.
class Todo < ApplicationRecord
# Other todo implementation
# ...
include TodoEventTracking
end
Introducing Module#concerning
By quieting the mix-in noise, we arrive at a natural, low-ceremony way to separate bite-sized concerns.
class Todo < ApplicationRecord
# Other todo implementation
# ...
concerning :EventTracking do
included do
has_many :events
before_create :track_creation
end
private
def track_creation
# ...
end
end
end
Todo.ancestors
# => [Todo, Todo::EventTracking, ApplicationRecord, Object]
This small step has some wonderful ripple effects. We can
-
grok the behavior of our class in one glance,
-
clean up monolithic junk-drawer classes by separating their concerns, and
-
stop leaning on protected/private for crude “this is internal stuff” modularity.
Prepending concerning
#concerning supports a prepend: true
argument which will prepend
the concern instead of using include
for it.
Instance Method Summary
-
#concern(topic, &module_definition)
A low-cruft shortcut to define a concern.
-
#concerning(topic, prepend: false, &block)
Define a new concern and mix it in.
Instance Method Details
#concern(topic, &module_definition)
A low-cruft shortcut to define a concern.
concern :EventTracking do
#...
end
is equivalent to
module EventTracking
extend ActiveSupport::Concern
#...
end
# File 'activesupport/lib/active_support/core_ext/module/concerning.rb', line 132
def concern(topic, &module_definition) const_set topic, Module.new { extend ::ActiveSupport::Concern module_eval(&module_definition) } end
#concerning(topic, prepend: false, &block)
Define a new concern and mix it in.
# File 'activesupport/lib/active_support/core_ext/module/concerning.rb', line 114
def concerning(topic, prepend: false, &block) method = prepend ? :prepend : :include __send__(method, concern(topic, &block)) end


@(signInForm: Form[_root_.forms.SignInForm.Data], notification: Option[(helpers.NotificationType, String)] = None )(implicit request: Request[_], flash: Flash, user: Option[CachedData], feedbackUrl: String, messages: Messages) @import helpers.CSRFieldConstructor._ @isFaststreamBecomesSdipRoute = @{ signInForm("route").value.getOrElse("") == ApplicationRoute.SdipFaststream.toString } @main_template(title = "Sign in", pageForms = Seq(signInForm), notification = notification) {
If you don't have an account you can create your account.
@if(isFaststreamBecomesSdipRoute) {After you sign in you'll be able to ask to be considered for the Summer Diversity Internship Programme.
}If you've applied previously or have an account on Civil Service Jobs, you will need to create a new account to apply this year.


Copying a Product
Catalog Managers can copy an existing product in the Store and modify one or more fields to create a new product using the Store Admin module.
If you wish to add customers who purchase this product to a Security Role, you must create the role before beginning this tutorial.
- On the Store Admin module, click the Products link.
- At Category Filter, select the category of the product you want to copy.
- Click the Copy link.
- Modify one or more fields as required to create the new product.
-
Click the Update button.
The new product is now displayed in the Store Catalog module and a summary is displayed to Catalog Managers in the Product list.


{{if .Pjax}} {{template "header.html" .}} {{else}}
Here you can edit various global Niiverse settings.Any changes you make will impact the entire website. If you don't know what any of this is, LEAVE THIS PAGE NOW.
Image Host
Hosting Provider
{{if eq .Settings.ImageHost.Provider "cloudinary"}}Cloud N{{else}}Usern{{end}}ame
{{if eq .Settings.ImageHost.Provider "cloudinary"}}Upload Preset{{else}}Password{{end}}
API Endpoint
Max Upload Size (shown to the client, not enforced)
ReCAPTCHA
Site Key
Secret Key (KEEP SECRET!!!!!!!!!!!!!!!!!!!!)
Webhooks
Report Webhook
Signup Webhook
Login Webhook
Email (SMTP)
Hostname
Port
Email Address
Password
Is the site being hosted through a DNS proxy? (e.g. Cloudflare)
Should users be forced to log in to see the site?
Should users be allowed to sign up?
What should the default timezone be?
Emote Limit


rservr has a very limited command-line interface. You can start it using the following command format:
shell> rservr <name> <log file> (config file) ...
The name specified is used when passing server responses to clients and doesn't necessarily effect anything except for the server name clients are made aware of. An important exception to this is with the rservrd client, which can only have instances running on one server with each unique name. In other words, you can't start two rservr instances named "server" both having an rservrd client connected. This is because rservrd retains a global table on the local machine of all running rservrd clients on your system.
The log file can be any device writable using normal file-writing operations. All clients will inherit and use the specified log file unless otherwise specified. If the file can't be opened then logging will go to standard error.
Info: When using super-user servers, the initial log file is created or opened using the default user and group IDs built into rservr. This may cause a file opening problem when running rservr from a location not writable by the default user.
Configuration must be provided using a series of file names or via standard input. Configuration files are closed immediately after parsing is complete, allowing pipes to be used.
Important: When providing configuration via standard input, the standard input file descriptor is replaced with /dev/null before parsing takes place. This prevents clients started over the course of configuration parsing from inheriting the file descriptor that the configuration is being read from.
An easy way to start a server is from a shell script without a configuration file:
example-server.sh #!/bin/sh #this script starts a server using its first argument as the server's name if [ $# -ne 1 ]; then echo "$0: [server name]" exit 1 fi ( echo "execute_critical rservrd -dxr" echo "register_all_wait" ) | \ rservr "$1" "$1.log"
shell> ./example-server.sh example shell> rservrd example shell> rservrd example @server_term {example} server exiting
Unless the server is started as a session leader (normally by starting it with exec from a shell or using it in a new xterm,) the server will fork and will normally return to the shell right away. If your server requires terminal access, it must own the terminal it's started in by taking the place of the shell that starts it. Only servers that will be using clients that require the terminal will need to own a terminal. Use a script like this to ensure the server owns the terminal (note the use of bash because of <(...)):
example-terminal-server.sh #!/bin/bash #this script starts a server using its first argument as the server's name if [ $# -ne 1 ]; then echo "$0: [server name]" exit 1 fi exec rservr "$1" "$1.log" \ <( echo "execute_critical rservrd -dxr" echo "execute rsv-console console" ) #(<-- as an example)
shell> exec ./example-terminal-server.sh example (the server now has control of the terminal)
Upon success, the terminal will appear to be frozen until a client is given control of it by the server. Normally [Ctrl]+C will terminate the server. The server will not interact with a user via the terminal; therefore, you can't start new clients from the same terminal. Additional clients can be started at execution time by adding lines to the server configuration via the script, or by using rservrd in a separate terminal or script. If a client is given terminal access from the server (per the client's own request,) it will interact with the user on the terminal that the server was started on even if rservrd was called from another terminal.
Super-user servers are essentially the same as servers run by normal users, but with one major exception. Super-user servers can run clients using different user and group IDs, but they won't access the file system as the super-user (except for read-only configuration file access.) Super-user servers should therefore be set up in the following order:
Use the following configuration options to initialize the server. These options are executed with full server permissions, so performing the same operations from an admin client might be disallowed in certain cases.
Important: These options are persistent and are applied in the order they are used. The options that modify the server's state apply to clients started thereafter and the states of those settings stick even after configuration parsing is complete. Permission-related settings are locked in when the configuration stage of server startup ends.
Info: Place a "!" at the beginning of a configuration line to allow that line to fail. This can prevent options with possible invalid values from aborting server startup.
Info: When using super-user servers, command substitution with "`" will be executed under the current default user and group IDs. Command substitution will never be done as the super-user.
| uid <id> | change user ID used by server |
| user <name> | look up a user ID to be used by server |
uid changes the persistent user ID used by the server when starting clients and opening log files. user does the same thing, but takes a single string to specify the name of a non-root user account on the system. Every client started after the user ID is changed will assume that user ID. These options are only effective with super-user servers. The users must be valid on the system with both options. A user ID of 0 will restore the built-in default user ID (this is set in param.h.)
| gid <id> | change group ID used by server |
| group <name> | look up a group ID to be used by server |
gid works identically to the uid option, except it effects the group ID used. group takes a single string to specify the name of a non-root group account on the system. These options don't change the group ID with non-super-user servers, even if the current user is a part of the given group.
| security <spec> | change server security restrictions |
| new_security <spec> | change security restrictions for clients started by admin clients |
The security specification may be either a hexadecimal value to denote permission bits or one of the following:
| sM | maximum allowed permissions |
| sD | default permissions |
| sA | maximum permissions of clients started by admin clients |
| sT | maximum permissions allowed by detached clients |
| s0-7 | security levels 0 through 7 (low to high) |
Info: You can use the command-line tool rsvbits to calculate a hexadecimal value using bit labels. You can use the same tool to convert hexadecimal values to bit labels, also (e.g. to interpret permissions shown in a log file.)
| priority <value> | change the minimum command priority |
This option sets the command priority value used by the server. All clients started after a change will use that priority value as their minimum. The priority value determines the order in which incoming commands are interpreted (and executed, if applicable) by the server. A lower priority value denotes a more important command. The server uses priorities from 0 to 255. The default value is 127.
| nice <offset> | set the niceness offset value for new clients |
This value must be positive or 0 for non-super-user servers. Super-user servers can use a negative value. Offsets must be within the system's limits, but a failed "nicing" won't prevent a client from being added to the server.
| execute <command> (arguments...) | execute a new client |
| execute_critical <command> (arguments...) | execute a critical new client |
These options execute a new client using a command string. The first character of the string denotes that which separates the components of the command. The execute_critical option will cause the server to exit if the client can't be started (even if "!" is used to allow the line to fail) or when the client process exits. For example:
execute ./program argument1 argument2
| system <command> | create a new shell command client |
| system_critical <command> | create a critical new shell command client |
These options create a new client using a string interpreted by the default system shell. The system_critical option will cause the server to exit if the client can't be started (even if "!" is used to allow the line to fail) or when the client process exits. This method can look very similar to the execute; however, it allows the shell to interpret the command. For example:
system ./program 2> errors.log
| device_on <spec> | allow inheritance of devices |
| device_off <spec> | disallow inheritance of devices |
These options allow or disallow clients' inheritance of devices open by the server. All clients started after a change will be effected by this. This only applies to the inheritance of devices: it doesn't disable or enable the device within the server process. If you disable a device you can re-enable it again with a subsequent configuration line. The device specification is composed of the following characters, as applicable:
| i | controls the inheritance of standard input |
| o | controls the inheritance of standard output |
| e | controls the inheritance of standard error |
| l | controls the inheritance of the currently-open log file |
| t | allows or disallows use of server-provided terminal access |
| log_file <file> | change the log file |
This option changes the log output file used by the server. All logging done after this change goes to the new file and the previous file is annotated. All clients started before the log file change will retain their log files and all clients started after will use the new log file.
| log_mode <spec> | change the server's logging mode |
This option changes the logging mode, and therefore the types of messages the server logs.
| m | minimal messages |
| n | normal messags |
| e | extended messages |
| d | debugging messages |
| s | default ("standard") messages |
| a | all messages |
| manual_log (message) ... | send a message to the log manually |
This option is mainly for debugging. Every element provided to this option will be sent to the server's log on a separate line. The only requirement is that the line be parsable. The messages fall into the "minimal" logging category. Below is a useful way to record that user and group management is working properly:
manual_log `echo 'user:' $( id -un );` `echo 'group:' $( id -gn );`
While not related to this option, the same information can be rerouted to standard error for immediate viewing as follows (note the lack of an option being used, and also a lack of standard output):
`( echo 'user:' $( id -un ); echo 'group:' $( id -gn ); ) >&2`
| register_all_wait | wait for all clients to register before returning |
This option is used when the server is started without already being a session leader. Normally the server would fork and continue as a daemon, but this option will force the original process to block until all clients are registered on the daemonized server. This will time out after a certain period of time, but you can change the time-out value by changing the register_all_wait timing value using the timing option.
| setenv (<var>="str") ... | set environment variable(s) |
| unsetenv (<var>) ... | unset environment variable(s) |
| clearenv | clear all environment variables |
These options are used to alter the environment; mainly intended for communication with command substitution. The most useful purposes for these options are to set parameters in one location for use throughout the configuration, or to pass information on to clients. This information isn't directly available to the configuration file to use, but it can be accessed through command substitution. (clearenv might not succeed on some systems because its underlying functionality isn't in the POSIX standard.)
#this is an example of consolidating parameters setenv CLIENT_TYPE="rsv-echo" setenv CLIENT_NAME="echo" #... much later in the file ... execute `echo $CLIENT_TYPE $CLIENT_NAME`
This method can specifically be used to pass parameters to the socket-forwarder programs for use at configuration time:
#rservr configuration file setenv LISTEN_ALLOW="^204[0-9]$" execute rsv-netrelay relay security.conf unsetenv LISTEN_ALLOW
security.conf listen_allow `echo "$LISTEN_ALLOW"`
| timing <name> <spec> | change a timing value |
This option changes the value of a server or client timing specification. These specifications are used to control the cycles of specific server and client actions for both synchronization and security purposes.
The specification consists of an operator followed by a value:
| = | set the timing value to that provided (seconds) |
| * | multiply the current timing value by that provided |
| / | divide the current timing value by that provided |
| ~ | find a target value using the current scale (seconds) |
Info: Timing scales are used when compiling the timing table for actual use. Certain timing values are scaled, in which case they are multiplied by the scale to calculate the actual timing value. Other values are static and retain their actual value despite changes in scales.
The list of all timing values is too extensive to address here, but here are some important value names that might be useful:
| scale | Use this to scale the entire server timing table. |
| input.scale | Use this to scale the IPC input cycling of the server. |
| output.scale | Use this to scale the IPC output cycling of the server. |
| client.scale | Use this to scale the entire timing table of all clients. |
| client.command_send_regulate | Reduce this if command sending is too slow and increase it if the server is getting overloaded. Consider "*2.0" when most commands will involve a network connection. |
| client.input.scale | Use this to scale the IPC input cycling of all clients. |
|
client.input.underrun_retry_max client.output.write_retry_max |
Increase these if you have problems with high-latency network connections when using IPC forwarders. |
| client.output.scale | Use this to scale the IPC output cycling of all clients. |
| client.default_cycle | Use this to adjust the default retry value. |
| client.default_slow_cycle | Use this to adjust the default slow retry value. |
| client.default_timeout | Use this to adjust the default timeout value. |
Below is a basic example of how you can generate a configuration using line substitution. As a reminder, if the only thing on a line is command substitution then each output line produced will be meta-parsed; otherwise, each line of output will become a separate element on the line the substitution was on. If you choose to precede a line substitution with "!", that will allow failure of the command's execution itself; not the failure of any resulting output lines.
substitution.conf execute_critical rservrd -dxr #sequence parameters setenv STEP=32 SEQUENCE="a b" #sequence of different-priority clients (line substitution) `echo unsetenv STEP SEQUENCE #this prevents propagation into the clients seq $( expr $STEP - 1 ) $STEP 255 | while read priority; do echo priority $priority for spec in $SEQUENCE; do echo execute rsv-echo echo-$priority$spec done done` #terminal emulator (element substitution) execute rsv-terminal `echo $HOME/terminal;` #timing change (element substitution) timing `echo register_all_wait; echo '~2.0';` register_all_wait
The server exports several environment variables with information about the specific instance running. These may be removed from the environment with unsetenv; however, they will be exported again if they're updated. Changing these with setenv will have no effect on the server's operation.
| RSERVR_NAME | name of the server |
| RSERVR_PID | process ID of the server |
| RSERVR_LOG | file used for logging (exactly as specified) |
| RSERVR_MAX_ERROR | maximum command errors allowed per client |
| RSERVR_MAX_INVALID | maximum invalid commands allowed per client |
| RSERVR_MAX_COMMANDS | maximum pending commands allowed per client |
| RSERVR_MAX_QUEUED | maximum pending commands allowed on the server |
| RSERVR_MAX_CLIENTS | maximum attached clients |
| RSERVR_MAX_SERVICES | maximum registered services |
| RSERVR_TIME_PRIORITY | time/priority adjustment factor |
| RSERVR_DEFAULT_UID | default uid (0 for non-super-user servers) |
| RSERVR_INITIAL_UID | initial uid (0 for non-super-user servers) |
| RSERVR_DEFAULT_GID | default gid (0 for non-super-user servers) |
| RSERVR_INITIAL_GID | initial gid (0 for non-super-user servers) |
| RSERVR_MAX_PERM | maximum client permissions |
| RSERVR_MAX_NEW_PERM | maximum admin-started client permissions |
| RSERVR_MIN_PRIORITY | minumum priority value |
| RSERVR_NEW_NICENESS | niceness offset for new clients |
Resourcerver uses a consistent logging format for both the server and clients so that all may log to the same destination. Logging is normally done on a line-per-event basis, with the particular events logged determined by both actions and outcomes of the processes involved, and by the logging mode.
Most log entries made by the server will follow this format:
| [ | 2008 | 04 | 29 | 032313 | svr: | 'example' | ( | rservr | ) | ] | /n/ | server started |
| year | month | day | time | server-created | server name | program name | message type ("normal") | message |
Built-in log entries made by clients will follow this format:
| [ | 2008 | 04 | 29 | 032314 | cli: | 'rservrd' | ( | rservrd | / | 19996 | ) | ] | /n/ | client registered: 'rservrd' (0x0028) |
| year | month | day | time | client-created | client name | program name | process group | message type ("normal") | message |
Log entries made from within a client by the program itself or by a plug-in will follow this format:
| [ | 2008 | 04 | 29 | 032313 | cli: | '(none)' | ( | rservrd | / | 19996 | ) | ] | { | rsvp-netcntl | } | loading plug-in commands |
| year | month | day | time | client-created | client name | program name | process group | message origin | message |
Most informational output from the server will be via the log file, with minimal messages sent to standard error in case the server cannot be started. The actual wording and format of built-in messages are controlled by the translation libraries (librservr-i18n-*.so,) which are linked in when the project is built. The server and client libraries independently link to a single translation library each.
| © 2008 - Kevin P. Barry | The Resourcerver Project |


CREDIT
SENSE
PORTAL
Dashboard
Generate Report
Upload Docs
Dashboard
Dashboard Summary
36,146
Credit Reports
24,734
Consumers
15,650
Loans Granted


Florian Dejonckheere
Student Developer
Bad request
Listen, burrito brains, I don't have time to listen to this trash


Emma Watson admits she 'struggled' with fame, felt 'guilty' about success
by Jessica NapoliEmma Watson's life completely changed when she landed the role of Hermione Granger in the "Harry Potter" movie franchise.
The actress, now 29, was just nine years old when she was picked out of a line-up in her school gym to audition and she revealed in a candid interview with British Vogue that she "struggled" being a child star.
"I've sat in therapy and felt really guilty about it," Watson told Paris Lees. "I'm like, 'Why me? Somebody else would have enjoyed and wanted this aspect of it more than I did.'"
EMMA WATSON HELPS LAUNCH A WORKPLACE SEXUAL HARASSMENT HOTLINE
"And I've struggled with ... I've wrestled a lot with the guilt around that. I'm like, 'I should be enjoying this a lot more, I should be more excited and I'm actually really struggling,'" she added. "It's so bizarre and otherworldly what happened to me."
Watson admitted that her family and her "roots" have kept her grounded: "Part of what's helped me find peace is there were moments when it got so big where I almost had vertigo and felt it got so big that I felt l disconnected, and part of the peace within myself is remembering my identity."
EMMA WATSON JOKES SHE NEEDS PROOFREADER AFTER SHE DEBUTS FEMINIST TATTOO WITH GRAMMATICAL ERROR
"I am someone's daughter. I am my mother's daughter, I am my father's daughter, I am a sister. I belong to a family. I come from a place, I have roots."
"There's a whole big existence and identity that I have that's really important and weighted and solid, that has nothing to do with any of that," she said.
CLICK HERE TO GET THE FOX NEWS APP
Watson also spoke about the anxiety she feels going out in public places, saying she sometimes puts on disguises to blend in with large crowds.
"Halloween is great for me," she joked. "I can be anybody."


Home
Reports
Refresh
Jan 1, 2019 - Dec 31, 2019
Excel
Date
Vehicles Tagged
Back
Refresh
Jan 1, 2019 - Dec 31, 2019
Excel
Date
Reg. No
Ticket No.
Transgression
Tag Location
Tagging System


Random Activation (administrator) INF380 Trigger @triggerId Choose a law distribution for the activation Poisson Brown


|
Standard Reference Data Program |
Data Gateway |
Chemistry WebBook |
Go To: Top, References, Notes / Error Report
Data compilation copyright by the U.S. Secretary of Commerce on behalf of the U.S.A. All rights reserved.
Data compiled by: K.P. Huber and G. Herzberg
| State | Te | ωe | ωexe | ωeye | Be | αe | γe | De | βe | re | Trans. | ν00 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Bands previously Dressler, 1955 attributed to NS+ have been reclassified by Jenouvrier and Pascat, 1973 as G → X system of NS | ||||||||||||
| X 1Σ+ | 0 | 1415 1 | 15 | 1.440 | ||||||||
| missing citation |
| 1 | Vibrational constants from the photoelectron spectrum 30. |
| 2 | Estimate based on a linear Birge-Sponer extrapolation for the ground state O'Hare, 1970. Ab initio calculations O'Hare, 1970 give 5.2 eV. |
| 3 | From the photoelectron spectrum Dyke, Morris, et al., 1977. |
| 4 | Intensity perturbations and predissociations in both doublet components. |
| 5 | Only fragments observed. |
| 6 | Approximate deperturbed constants, A ~ +45. This level is strongly perturbed by v=11 of H 2Πi (B11 = 0.525, A11 = -110). |
| 7 | Spin doubling constant γ0 ~ +0.1 for N ≤ ~20. The spin splitting increases rapidly at higher N because of a perturbation by H 2Π(v=1). I 2Σ+(v=1) (B1 ~ 0.695) interacts with H 2Π(v=2) at somewhat lower N values. A strong homogeneous interaction with levels of C 2Σ+ explains the larger than expected ΔG(1/2) value of I 2Σ+. |
| 8 | A0 = -172.3. |
| 9 | Perturbations by levels of E, I, C; see 6,7,10. |
| 10 | ΔG(3/2) = 1414 Vervloet and Jenouvrier, 1976, ΔG(5/2) ~ 1372, ΔG(7/2) ~ 1378 Joshi, 1966. B1 ~ 0.7975 Vervloet and Jenouvrier, 1976, B2 ~ 0.8150 Vervloet and Jenouvrier, 1976; Balasubramanian and Narasimham, 1974 give B0 = 0.82876 Balasubramanian and Narasimham, 1974 and D0 = 1.404~E-6 Balasubramanian and Narasimham, 1974 as well as γ0 = +0.0055 Balasubramanian and Narasimham, 1974. C 2Σ+ interacts strongly with I 2Σ+; in addition, v=1 is extensively perturbed by H 2Π(v=2) and G 2Σ-(v=2). |
| 11 | Estimated lifetime τ(v=0) ~ 6.5 ns [Hanle effect measurements Silvers and Chiu, 1974]. |
| 12 | Observed in absorption by Donovan and Breckenridge, 1971 following the flash photolysis of OCS in the presence of excess N2O. |
| 13 | Spin doubling constant γ0 = +0.034. |
| 14 | B1 = 0.6780. |
| 15 | The A state is strongly perturbed, particularly the 2Δ5/2 component [see Jenouvrier and Pascat, 1973]; the ΔG(1/2) values are from missing citation, ωexe from Narasimham and Srikameswaran, 1963, and B0 from Jenouvrier and Pascat, 1973. Additional constants may be found in these references but, because of the perturbations, have limited meaning. Jenouvrier and Pascat, 1973 suggest that the perturbing state is 2Φ5/2. |
| 16 | Only the 1-0 band has been observed and analyzed (B1 = 0.7716, v0 = 372023.9 and 36982.5). The v=0 level of 14N32S interacts with B 2Π1/2(v=8) Jenouvrier and Daumont, 1976; weak emission from this level was observed for 15N32S Jenouvrier and Daumont, 1976. |
| 17 | Several perturbations. Except for v=8 (see 16), these interactions have not yet been analyzed. |
| 18 | A0 = +222.94 Amano, Saito, et al., 1969, A1 = +223.09 Amano, Saito, et al., 1969, recalculated by Amano, Saito, et al., 1969 from the data of Zeeman, 1951. |
| 19 | Λ-type doubling, Δ νfe = +0.013253(J+1/2) Amano, Saito, et al., 1969. |
| 20 | μel(2Π1/2,v=0) = 1.81 D Amano, Saito, et al., 1969 from Stark effect measurements in the rotation spectrum Amano, Saito, et al., 1969; Carrington, Howard, et al., 1968, using the EPR method, obtained μel(2Π3/2,v=0)= 1.35 D Carrington, Howard, et al., 1968. This value was recently revised to μel (2Π3/2, v=0)= 1.86 D Byfleet, Carrington, et al., 1971. See also O'Hare, 1970. Hyperfine coupling constants Carrington, Howard, et al., 1968, Amano, Saito, et al., 1969, Uehara and Morino, 1969. |
| 21 | D00(NS) + I.P.(S) I.P.(NS). |
| 22 | Estimated value from a Franck-Condon factor analysis of the photoelectron peaks Dyke, Morris, et al., 1977. |
Go To: Top, Constants of diatomic molecules, Notes / Error Report
Data compilation copyright by the U.S. Secretary of Commerce on behalf of the U.S.A. All rights reserved.
Dressler, 1955
Dressler, K.,
Ultraviolett- und Schumannspektren der neutralen und ionisierten Molekule PO, PS, NS, P2,
Helv. Phys. Acta, 1955, 28, 563. [all data]
Jenouvrier and Pascat, 1973
Jenouvrier, A.; Pascat, B.,
Etats de valence de NS dans le domaine 2250-3800 Å,
Can. J. Phys., 1973, 51, 2143. [all data]
O'Hare, 1970
O'Hare, P.A.G.,
Dissociation energies, enthalpies of formation, ionization potentials, and dipole moments of NS and NS+,
J. Chem. Phys., 1970, 52, 2992. [all data]
Dyke, Morris, et al., 1977
Dyke, J.M.; Morris, A.; Trickle, I.R.,
Characterization of the ground ionic state of the NS molecule using photoelectron spectroscopy,
J. Chem. Soc. Faraday Trans. 2, 1977, 73, 147. [all data]
Vervloet and Jenouvrier, 1976
Vervloet, M.; Jenouvrier, A.,
Etats Rydberg de NS. Etude du domaine spectral 2400-1750 Å,
Can. J. Phys., 1976, 54, 1909. [all data]
Joshi, 1966
Joshi, K.C.,
The emission spectrum of the NS molecule,
Z. Phys., 1966, 191, 126. [all data]
Balasubramanian and Narasimham, 1974
Balasubramanian, T.K.; Narasimham, N.A.,
Reinvestigation of the β and the γ band systems of NS,
J. Mol. Spectrosc., 1974, 53, 128. [all data]
Silvers and Chiu, 1974
Silvers, S.J.; Chiu, C.-L.,
Fluorescence and zero-field level crossing spectroscopy of the C2Σ+ state of NS,
J. Chem. Phys., 1974, 61, 1475. [all data]
Donovan and Breckenridge, 1971
Donovan, R.J.; Breckenridge, W.H.,
Reaction of S(31D2) with N2O,
Chem. Phys. Lett., 1971, 11, 520. [all data]
Narasimham and Srikameswaran, 1963
Narasimham, N.A.; Srikameswaran, K.,
The β- and γ-band systems of 14NS and 15NS,
Proc. Indian Acad. Sci. Sect. A, 1963, 56, 316. [all data]
Jenouvrier and Daumont, 1976
Jenouvrier, A.; Daumont, D.,
The B'2Σ+ state of NS,
J. Mol. Spectrosc., 1976, 61, 313. [all data]
Amano, Saito, et al., 1969
Amano, T.; Saito, S.; Hirota, E.; Morino, Y.,
Hyperfine interactions and λ-type doubling in the microwave spectrum of the NS radical,
J. Mol. Spectrosc., 1969, 32, 97. [all data]
Zeeman, 1951
Zeeman, P.B.,
Rotational analysis of the γ band system of the NS molecule,
Can. J. Phys., 1951, 29, 174. [all data]
Carrington, Howard, et al., 1968
Carrington, A.; Howard, B.J.; Levy, D.H.; Robertson, J.C.,
Gas phase electron resonance spectrum of NS,
Mol. Phys., 1968, 15, 187. [all data]
Byfleet, Carrington, et al., 1971
Byfleet, C.R.; Carrington, A.; Russell, D.K.,
Electric dipole moments of open-shell diatomic molecules,
Mol. Phys., 1971, 20, 271. [all data]
Uehara and Morino, 1969
Uehara, H.; Morino, Y.,
Molecular structure of the NS free radical by gas-phase electron paramagnetic resonance,
Mol. Phys., 1969, 17, 239. [all data]
Go To: Top, Constants of diatomic molecules, References
Copyright for NIST Standard Reference Data is governed by the Standard Reference Data Act.
|
Standard Reference Data Program |
Data Gateway |
Chemistry WebBook |
If you have comments or questions about this site, please contact us.


When you touch something hot, the nerves in your hand will immediately fire a signal up toward your head to make a decision about what to do about the “hot thing.” But – here’s the cool part – your nervous system is smarter than that.  In fact, you don’t even realize you’ve pulled away until after it’s happened because your brain hasn’t received the signal from your hand yet. Wild.
Make sure your volume is up, then click the animation
Bach’s ability to layer the theme in a count-counterpoint method was unmatched. Listen closely – the right and left hand of the pianist are playing the same pattern, just at different octaves and at different times. Yet, they overlap to compliment one another. Our brain does the same thing…variations on a theme (sending and receiving signals) at every moment of the day unmatched in efficiency and power by any machine built.
Click to expand in a new tab.
The nervous system isn’t a straight A-to-B system. It’s a complex network of feedback loops which feed information between nodes in response to the environment. The global air traffic network is more than the sum of it’s routes…an issue at a single node anywhere in the global network will be felt downstream. The same is true for our sensory networks – a delay in our reflex arc, for example, can lead to serious damage to our tissues.
Building solid analogies requires that we step out of our own area of expertise and think as a novice.
The most difficult part of this assignment was avoiding direct comparisons – particularly those based on physical structure. I also think a good portion of building a solid analogy is thinking outside of my own understanding – approaching the idea or problem for the point of view of someone who has no experience with the topic.
In fact, it’s how I built the Bach analogy. My wife and I were discussing analogies and this assignment, and I was explaining some of the examples given in Sparks of Genius (in particular, the vibration of electrons). She suggested that I apply music to our nervous system because of the way it is built. I immediately thought of the call-and-response (counterpoint) style of music, and was able to build that into an explanation of how the reflex function works. Before speaking to Lindsey, I was limiting myself to structural comparisons…I was thinking too literally about what I already knew. I then used the same approach to draw the second analogy between our bodies and the air patterns of the world day to day. I may not be able to talk about the actual structure of nerves at this point, but everyone can relate to a delayed flight at some point. We now have a truth which bridges our experiences.
As teachers, we often rely on our content knowledge more than our context knowledge. We fall back on “explaining” rather than “exploring” because it’s safe, and frankly, it’s how many of us were trained before entering the classroom. That being said, we often analogize on the fly – we come up with examples and comparisons to help ease confusion and frustration. Consider keeping track of those and refining the ideas to become more central in your instruction and not so situational.
Bach: Badass of Counterpoint (2013). Listen, learn, and do. Retrieved from: http://listenlearnanddo.wordpress.com/2013/02/11/bach-badass-of-counterpoint/
Colombo, C. (n.d.). “4. Inventio in D minor BWV 775 (0’54”).” Retrieved from: http://www.mp3classicalmusic.net/48Music/Bachjs48/Inventio04.mp3
Global connectivity revisited (2011). Spatial analysis. Retrieved from: http://www.spatialanalysis.ca/2011/global-connectivity-mapping-out-flight-routes/
Kuensting, S. (1995). “Reflex arc animation.” Retrieved from: http://www2.sluh.org/bioweb/bi100/tutorials/neurophysiology/reflexarc_4.html.
Written on October 15th, 2014 by Brian Bennett Categorized in: All MAET
Leave a comment


Welcome to my world
This is my very own website, with many features and links to all my EDA-related exploits. Inside are what began as homework tasks and what may very well end up being the popular and interesting destination in the internet.
- You want blogs? I got 'em.
- Pointless crap? Check.
- Amateurish designs and questionable content? Oh yeah.
Well, you'been warned...


A Day in a Life of a Girl
Demo Video
Project Info
| Project Duration | 2 Weeks |
| Genre | Interactive Story Game |
| Team Size | 2 Programmers, 3 Artists |
| Team Members | Bokang Wang, Jimmy Chen, Jialu Sun, Ruizi Wang, Xueying Yang |
| Platform | PC |
| Tools | Unity |
| My Contributions | Programming, Game Design, Playtesting |
| Download Link |
Introduction
This is the Visual Story course project, under the theme "interacive story/ non-linear story". We designed and developed this 2D interactive story game focusing on the relationship between LGBT community and their parents. The story's outline is, on Valentine’s day, a girl plans to date with her girlfriend. Her parents, however, haven’t noticed their relationship and wished she could date with a guy. The girl had a wonderful time while dating. She wants to keep the secret, but her parents happen to find their photo at home. When she comes home at night, they start quarreling...
Design
For LGBT commummity, one of the most painful things is that their parents do not recognize their identity. They know their parents love them. However, due to the traditional concept, it is hard for parents to accept. We want to use this game to this complicated relationship between LGBT community and their parents.
My Contributions
- As a programmer, I implemented narrative-focused gameplays which mimic or reveal main characters thoughts and actions


Dynamic redirection and authentication using an encrypted URI path component.
When a particular site has to give access to assigned subtrees to different users, all non-badge solutions involve heavy configuration changes such as (for each user):
If the user count is high and/or new users occur frequently, these operations can quickly load the administrator tasks and Apache configuration files.
The solution to this problem is mod_badge: this module allows an URL to contain a badge giving access to a specific subtree during a defined period of time and containing its own authentication parameters (such as a pass in a theme park, for example). Since it is encrypted, the badge owner is not able to decode it to gain direct access to the underlying subtree.
It is much easier to generate a badge for a new user than to create the specific configuration and authentication parameters that will be needed without mod_badge.
Assuming an URL containing a badge is of the form:
scheme://server/path-prefix/badge/path-info
mod_badge maps it internally to:
scheme://badge-user:badge-password@server/badge-path-prefix/path-info
where badge-user, badge-password and badge-path-prefix are extracted from the badge.
This is only an URL mapping, not a redirection: in particular, the client never receives information about the translated URL.
The badge itself is an URL path component consisting in a modified base64 string (to accomodate URL syntax) containing the encrypted specific parameters.
Description: Define a badge path and associated cryptographic key.
Syntax: BadgeMap URL-path SSL-key-or-certificate-file
Context: server config, virtual host, location
Components of this URL may be badges encrypted with the given key.
The SSL-key-or-certificate-file may contain a private key, a
public key or a certificate. The key is used both for encryption and
decryption.
More than one BadgeMap directive may be specified for the same URL-path: this allows to use alternative keys for badges within the same path.
Description: Specifies whether any prior authorization (either for the client or from a previous badge or from an SSL certificate, etc) should be overriden by the authorization stored in the badge (off) or not (on).
Context: server config, virtual host, location
Syntax: BadgeKeepAuth off|on
Default: off
All handlers of this module may only be used inside <Location> or <LocationMatch> sections.
This handler allows the generation of new badges. It starts by requesting the following parameters:
Since this allows to create new badges, the access of this handler's location must be restricted to badge administrators.
The badge-decoder handler decodes a given badge and shows its content.
It is however not possible to decode a badge if the key used for its encryption is not listed in some configured BadgeMap directive.
Since this handler reveals badge contents in clear form, its location should be strongly restricted to badge administrator's access only.
BadgeMap /badge /etc/pki/tls/certs/badgecert.crt Alias /download /var/download <Directory /var/download> AuthType Basic AuthName "Download area" AuthUserFile /etc/httpd/download_passwords Require valid-user </Directory> <Location /badge-factory> SetHandler badge-factory AuthType Basic AuthName "Download area" AuthUserFile /etc/httpd/download_passwords Require user badgeadmin <Location>
For our example, let's assume file /etc/httpd/download_passwords defines user "badgeadmin" with password "pwd1" and user "badged" with password "pwd2".
When a new user needs some private download, create its private directory (lets call it /var/download/thisnewuser) and store whatever should be accessible to him. Then generate a badge from page at /badge-factory, logging-in as "badgeadmin" with password "pwd1":
Note: never tell the badge user/password to someone who must have only badged limited access
The generated badge (a base64-like string) may then be used to form an URL by appending it to the proper mapping URL-path (/badge in our example). This URL can then be transmitted to our new user: through this link, he then will have access to its private subtree without having to authenticate.
Although resulting in long URLs and of little usefulness, it is possible to have more than one badge (up to the configured redirection limit) in a single URL.


US
EU
No ads! Tracker free! Poorly written by some guy on the internet!
Lots of Mythic+ dungeon nerfs in the last hotfix on December 20th!
↓
No ads! Tracker free! Poorly written by some guy on the internet!
Lots of Mythic+ dungeon nerfs in the last hotfix on December 20th!


Flexbox Examples
These examples are to accompany the Flexbox articles on MDN.
Basic concepts of flexbox
- The flex container
- The flex-direction property
- Multi-line flex containers
- The flex-flow shorthand
- The flex properties
- Flex shorthands
- Align items
- Justify content
Relationship to other layout methods
- Writing Modes
- Floated layout
- Simple flex layout
- Simple grid layout
- Demo of display: contents
Alignment
- Centering a box
- Alignment on the cross axis with align-items
- Aligning individual items with align-self
- Changing the main axis to column and aligning items
- Aligning content on the cross axis
- Changing the main axis to column
- Main axis alignment with justify-content
- Main axis alignment with flex-direction column
- Main axis alignment in RTL writing mode
- Main axis alignment with reversed row
- Alignment with auto margins
Order
- The flex-direction property
- The order property
- Using negative values for order
- A usecase for the order property
Ratios on the main axis
- Concepts of min and max-content
- The flex-basis property
- The flex-grow property
- Ratios and the flex-grow property
- The flex-shrink property
- min-content sizing and the flex-shrink property
- Ratios and the flex-shrink property
Mastering wrapping of flex items
- Wrapping when flex-direction is row
- Wrapping when flex-direction is column
- Wrapping when flex-direction is row-reverse
- Grid and two-dimensions
- A flexbox grid
- Gaps between flex items
- Setting an item to visibility: collapse
- Wrapped items with visibility: collapse
Common Use Cases of Flexbox
- Navigation
- Navigation distributing space to items
- Split navigation
- Centering an item
- Card layout
- Media object
- Flipped media object
- Input element and button
- Adding a label to the input and button


Spring Introduction
This article is a recap of a presentation I gave to my teammates, a brief introduction to Spring framework and related concepts, and 3 common Spring projects (Spring MVC, Spring Data JAP, and Spring Boot).
Spring and Java EE
Let’s talk a bit about Java first. Java has multiple editions: Java SE, Java EE and Java ME. Java SE and Java EE are closely related to Spring framework. Java SE (Java Platform, Standard Edition) contains JVM and all core libraries and APIs, while Java EE (Java Platform, Enterprise Edition) is a set of specifications and APIs which will be used to develop large-scale enterprise applications, such as servlet specification
used to handle HTTP request and JPA
describes the management of relational database. Java EE constitutes of JSRs (Java Specification Request) maintained by JCP (Java Community Process), just like RFC to IETF.
There are several Java EE implementations in the industry, all belong to IT giants, like IBM’s WebSphere Application Server (WAS), Oracle’s WebLogic, and JBoss which belongs to RedHat. They all comply to Java EE standards, and they all implement most of Java EE specifications like Servlet and JPA, and they mostly are called Application Server
s since Java EE makes sure our applications can run upon. The open source alternatives of these application servers like Tomcat or Jetty are called Web Container
, since they only implement Web related specifications such as Server spec and JSP specs. If we need dependency injection we bring in Spring, if we need to interact with relational databases, we bring in Hibernate.
And strictly speaking, Spring is not an implementation of Java EE, since even she does implement lower level Java EE specs like Servlet and JPA, but she uses its own stuff for higher level APIs like dependency injection and RESTful web service. Java EE specs for dependency injection is CDI while Spring uses Spring DI, and for REST it’s JAX-RS vs Spring MVC.
Spring IoC / DI
At its core, the foundation concept of Spring Framework is DI (Dependency Injection) or a.k.a. IoC (Inversion of Control). These 2 abbreviations are really novice-unfriendly, and so require some explanations.
IoC is a theory, a technology, not only exist in Spring. Generally speaking, for some entity, the work/flow which this entity should initiate, turns out to this entity passively receive, this active-passive turnover is IoC. For example you want to write a small trivial program at work, at the beginning it’s a small program calling some 3rd party libraries, this is the active role your code is playing, as your trivial program grew bigger you import a framework to sort things out, your code becomes callbacks or interface implementations, now your code plays the passive role. With the help of IoC we can achieve decoupling, free our hands by relieving responsibilities.
For Spring IoC, it’s the responsibility of object instantiation and dependency tree maintenance that being shifted from our hands to Spring. For example, when we write Java application without Spring IoC, it could be like this:
It’s class A depends on Class B and Class C, we pass the objects of A and B through constructor and setter function. With the help of Spring IoC and some other Spring tricks, it could be like this:
@Component
annotations tell Spring the annotated classes need to be instantiated as beans, which are Java objects managed by Spring, while @Autowired
annotations tell Spring to inject the type-matched beans to the annotated fields, and this is duly dependency injection
.
Web container
Web container a.k.a. Servlet container is different from Web Server. Nginx and Apache are web servers, which mainly handle HTTP requests. Web containers like Tomcat, Jetty or GlassFish, however, are like fish tanks where Java Servlets live in. Application Server I mention above can be considered as a superset of Web container, since it’s capable of more than containing servlets.  They need to be managed by Web containers, and web containers dispatch HTTP requests to servlets based on mapping rules, like below:
The whole process is Java EE spec, which Web containers, application servers, and Java Web applications should all follow, so we can deploy our applications to any Web containers or application servers with minor adaptation.
Spring MVC
Spring framework consists of many modules, spring-core and spring-beans are at at core, spring-jdbc and spring-orm are responsible for database interaction etc. It’s too common to use Spring to build backend RESTful APIs, so it’s necessary to give a quick view of Spring Web MVC module.
As I stated before you cannot get away with servlets for HTTP in Java, Spring MVC is tangled with servlet as well. Spring MVC is facaded by DispatchServlet
which accepts all HTTP requests and then dispatch to other HTTP endpoints in your application. The following is an HTTP endpoint demo with Spring MVC:
@RestController
is annotated on Java Class, which means annotated Class is a RESTful API endpoint, hence the Controller in MVC architecture. All Controllers and RestControllers are Spring-managed beans as well.@RequestMapping
defines URL routing mapping rules, the one annotated on Class can specify absolute path while the one annotated on method specify the relative path. And methods annotated with@RequestMapping
are responsible for handle HTTP requests and serve responses.- Paths specified by
@RequestMapping
comply with URL Template[1] and@PathVariable
can extract variable values in it. - By annotating
@RequestBody
on method parameters, Spring will convert HTTP request body to Java object and inject to annotated parameters. And Spring also will convert method return value to HTTP response in JSON format, since class is annotated with@RestController
ResponseEntity
is a generic class containing HTTP response body, and HTTP headers and status code which you can tweak. In this demo the method responds empty body with status code specified to 200.
With an extremely simplified Class Item, the terminal should look like this if we call the RESTful API with cURL
Spring Data JPA
Spring has always been considered a framework, but in recent years it’s more like a portfolio, contains dozens of projects, all based on original Spring framework but provide various abundant features, Spring Data is one of them. Spring Data provides consistent, elegant, and easy-to-use interfaces to access persistent facilities, and Spring Data JPA is one of the modules specifically deal with relational databases. As we can see soon, Spring Data JPA provides a set of very tidy interfaces for us to implement routine CRUDs.
Spring Data JPA exposes a bunch of Java interfaces to users, behind the scenes it uses Dynamic Proxy AOP to inject actual work in runtime. The interface at the top is Repository<T, ID extends Serializable>
, then it’s CrudRepository<T, ID extends Serializable>
providing basic CRUD operations, and JpaRepository<T, ID extends Serializable>
with JPA related actions etc. They all generic interfaces whose first type parameter is entity class corresponding to a database table, and the 2nd parameter is the type of ID in the entity class. To use Spring Data JPA all we need is create an interface extends one of these interfaces and then declare methods we will be calling in it.
The following example demonstrates how Spring Data JPA simplifies the process of exposing CRUD interfaces to a simple data entity.
Given the table structure and Entity class:
Firstly we declare an interface extends CrudRepository
, and designate type parameter explicitly
Since CrudRepository
already has common CRUD methods like save(S entity)
, findOne(ID id)
, exists(ID id)
and delete(ID id)
, so now we only need to fill in some query methods specific to our need, as long as follow naming conventions[1]. For example, if we’d like to find all items with the same name, we can declare findByName
here
Inject ItemRepository
to wherever we need, then we are able to call these CURD methods directly.
User-defined query method mimics Rails Dynamic Finders and it supports more sophisticated combinations like and, or, pagination, limit, asc/desc etc, you can refer to official documentation here[2].
How does Spring Data JPA do all the magic tricks? Well, it’s not that magic for Spring core. During Spring application bootup, Spring creates a proxy bean for ItemRepository
interface at first with the help of Spring AOP, then in that proxy Spring parses all user-defined query method names and store ASTs on the bean. When these query methods get called in runtime, Spring AOP intercepts the method call, fetch the AST, assemble into a Query object combined with query parameters, then hand over to JPA. I give a more thorough analysis in another post.
Spring Boot
Spring Boot is another Spring project, a Convention over Configuration follower and a relatively successful one. It has done a lot of work based on Spring which makes it much easier to build a Spring application.
In old days we need to list all depending artifacts in pom.xml or gradle.build, which is really annoying and cumbersome, Spring Boot thoughtfully gives us Spring Boot Starters
, a one-stop-shop for all the Spring and related technology. It organizes related dependencies into groups from a Spring user’s perspective, we only need to include the group dependency descriptor artifactId in our pom.xml or build.gradle. For example when we develop a Spring Web application, generally we need to import Spring MVC, spring-web module, and Jackson etc, with Spring Boot we just import spring-boot-starter-web
once for all. The same goes to spring-boot-starter-test
which includes JUnit, Hamcrest and Mockito; and spring-boot-starter-data-jpa
which includes everything related to relational database interaction.
Like I said before Spring Web applications need to put into Servlet containers in order to run, however, spring-boot-starter-web
starter includes an embedded Tomcat, which can be started through SpringApplication.run()
within our code in main function. In this way, our Spring Web applications are directly runnable via commandline, or IDE, or java -jar
after packaged into a independent jar file.
Spring Boot also has fine-tuned a lot of details to keep to Convention over Configuration. Hibernate has ImprovedNamingStrategy
class automatically map camelCase field names in Entity class to snake_case field names in DB tables, however it doesn’t support foreign keys. Spring Boot provides SpringNamingStrategy
which inherits ImprovedNamingStrategy
and adds foreign keys support.


---
layout: landing-sidebar
content-file: 2017-landing-content.md
sidebar-branding-file: landing-sidebar.html
brand:
title: "Foolscap"
tagline: "join the conversation
build the convention"
image: "../images/logo-full-3col-dark-0300x0100.png"
text: '
Feb. 3–5, 2017
Seattle, Washington
'
sections:
- ref: 'about'
heading: "What _is_ Foolscap?"
- ref: 'register'
heading: "How do I register?"
- ref: 'location'
heading: "When and where?"
- ref: 'functions'
heading: "What is there to do?"
- ref: 'commons'
heading: "The heart of Foolscap is the Commons."
- ref: 'magicbox'
heading: "Share media at the Magic Book Box."
- ref: 'hospitality'
heading: "Hospitality is our open kitchen."
- ref: 'bazaar'
heading: "Check out the Bazaar."
- ref: 'volunteer'
heading: "Volunteers make Foolscap happen."
- ref: 'events'
heading: "What’s on the schedule?"
- ref: 'writing'
heading: "Writing workshops."
- ref: 'bite'
heading: "The _Bite of Foolscap_ banquet."
- ref: 'auction'
heading: "Auction"
- ref: 'share'
heading: "May I bring stuff to show or sell?"
- ref: 'info'
heading: "What else should I know?"
- ref: 'news'
heading: "What’s new this year?"
- ref: 'goh'
heading: "Here’s our Guest of Honor."
---


---
layout: post
title: 'Google Chrome Blog: Pedal to the Chrome metal: Our fastest beta to date for
Windows, Mac and Linux'
categories: []
tags:
- chrome
- geek
- google
- mac
status: publish
type: post
published: true
meta:
_original_post_id: ''
_original_import_author: John Duprey
author:
---
Sweet! The latest Google Chrome is indeed even faster than the last Mac version I tried. I'm still waiting for stable support for 1Password (
http://agilewebsolutions.com/products/1Password), Xmarks (
http://www.xmarks.com/), and Evernote(
http://evernote.com) on it though. I live for these plugins in my browsers. In fairness, it is looking like Xmarks plugin is fairly complete now.


Restart
Loading game
Discover America through the names of federation states to save the world from the gallows. Educational, lucid and funny. Look at the map all time, will help you!
Start Game!
Awesome!
You Complete the game.
New Game
So close!
The answer is
Try Again


This is the second in a series of developmental updates for Matcheos. The first post (see here) explained browsing through profiles and submitting EOS offers. This post will focus on the matching algorithm. Expect the next development update over the coming days.
The current matching algorithm is BETA and will likely change with added data and analysis. Other algorithmic approaches, including machine learning (ML), are being investigated to improve match quality. Remember even commercial grade algorithms like Facebook's News Feed, Google's PageRank, and Twitter's Bot Problem are constantly being refined as bad actors try to game them.
Matches proceed through a lifecycle from New to Active to Closed. The matching algorithm generates New Matches.
The focus of this post is on New Matches. The algorithm takes the EOS offers and outputs matches. You don't have to accept a New Match.
If you choose to accept a match, it becomes active. These matches are handled through smart contracts - where the offer is staked.
Once a match is finished and the smart contract is closed, the EOS has been released. This will be discussed in future posts.
So before proceeding to the simple math, let's just explain clearly what the algorithm does.  The matching algorithm takes these numbers as inputs and outputs matches. You can think of it as reaching into a jar of marbles and pulling out 2 similar ones.
The general structure of the algorithm is:
F(bids,balance,purpose) = Matches
Let's define a term called Rank where:
Rank at t0 = Bid from Person i to j for Purpose k at t0 / Total Balance of Person i at t0
Rank is simply the percentage of a user's "EOS Wealth" that they bid. If you have 10 EOS and bid 1 EOS to date Alice. The Rank would be 0.1. Remember that you need EOS to make a bid, so Total Balance > 0. Which also means Rank (and Max Rank) > 0.
Let's define a term called Max Rank where:
Max Rank at t0 = Max(Rank from Person i to j for Purpose k) over all People j and T <= 0
Max Rank is just the highest Rank that the user has ever bid for another person (over a certain data timeline).
Let's define a term called Score where:
Score at t0 for Person i = Rank at t0 for Person i / Max Rank at t0 for Person i
A Score is simply expressing the current "~bid" as a percentage of the highest ever "~bid". Scores are what we are interested in. The bids yield Rank which yield Scores.
Let's define a Match where:
Match exists between Person i and Person j iff (if and only if)
Score for i to j + Score for j to i >= Threshold K
Bid i >= Minimum M
Bid j >= Minimum M
Total Balance i >= Minimum N
Total Balance j >= Minimum N
Number of Bids for i >= Minimum P
Number of Bids for j >= Minimum P
Score i to j > 0
Score j to i > 0
There is no Match if the conditions above don't hold. So let's run through a simplified example of a normal match. First, some assumptions: K=1.3, M=0, N=0, P=0. Assume both Alice and Bob have an EOS Balance of 100 EOS that stays constant throughout bidding. Assume only the Friend purpose and Alice bids first.
Alice bids 3 EOS for Dave, then 1 EOS for Charlie, and then 5 EOS for Bob. No one else has bid. The Ranks are 0.03 (3/100) for Dave, 0.01 (1/100) for Charlie, and 0.05 (5/100) for Bob. The Max Ranks are 0.03 for Dave, 0.03 for Charlie, and 0.05 for Bob. The Scores are 1 for Dave, 0.33 for Charlie, and 1 for Bob. Since there are no other Scores, there are no matches because 1 < 1.3 (=K).
Now Bob bids 3 EOS for Alice and 2 EOS for Carol. The Ranks are 0.03 for Alice and 0.02 for Carol. The Max Ranks are 0.03 for Alice and 0.03 for Carol. The Scores are 1 for Alice and 0.66 for Carol.
There is a match between Bob and Alice. The Score(Bob) + Score(Alice) = 2 > 1.3 (=K). And all the other constraints are met.
The Matcheos process has a number of safeguards to provide a bedrock against bad actors. Given the state of the crypto world, it's certain that scammers will try to game the system.
In order to make a match, BOTH people must independently submit an EOS offer on the other person for that specific purpose. Remember from the last post, offers are non-binding and stored off-chain. They are not transactions on the public EOS mainnet. When you make an offer to meet, that person does not know you made an offer. This means that even if someone offers 1 million EOS to meet you, you will not be matched unless you independently submit an offer to meet them, too.
If a bad actor somehow gets you to make an offer on them, you still have the option to refuse a match. In other words, both people have to accept the match. One person is not enough.
If a bad actor gets you to make an offer on them and you accept the match, that person will still have to stake EOS into the smart contract. More will be said about this later and in future posts.
If a bad actor gets you to make an offer on them and you accept the match, you will still have an opportunity in the contract to terminate amicably.
If you accept a match and believe the other person has breached Matcheos' Code of Conduct, you are entitled to arbitration. EOS's Constitution has remedies for bad actors (including account forfeiture and transaction reversals).
Below are other "known" considerations related to the algorithm. Keep in mind that gaming a match doesn't necessarily indicate harm or a bad actor. In fact, it could be a strong signal of positive interest.
The benefit of the smart contract is to incentivize good behavior. However, if you have only a tiny amount at stake, you may not care. This is why the algorithm has minimum M and N.
Burn the Ships is a variant of Nothing at Stake. It just means that even if you have a large stake, you're willing to burn it. This is atypical behavior. Again a higher M and N may partially help if you go high enough.
At the beginning of the bidding (especially the first bid), there is very little comparison. The first bid is by definition a max. This why the algorithm has a minimum of P bids to build up a relevant history for Max Rank.
If a person makes a mistake and does a large bid, their Max Rank could become artificially high and prevent future matches. As with Cold Starts, the algorithm may have to adjust its data history with periodic clears and restarts for Max Rank.
Max Rank Flooding is when a person constantly bids the same amount over and over to get a Score of 1. The algorithm may have to penalize Scores where flooding is detected. Or the algorithm may have to cap the number of matches over a time period.
Stale data is similar to Fat Fingers. Your preferences may have changed since the bid was made. So the algorithm may have to do clears and restarts of data.
Multiple accounts is where a person splits their bids over different accounts and try to layer their bids for a person to trigger a match. This is clearly against the Matcheos Code of Conduct and would be subject to arbitration if discovered.
Duplicate bids is where you try to make multiple bids on the same person for the same purpose in a single account. The software won't allow this unless the data has been cleared.
Minors dating adults is obviously problematic. The algorithm will need an age filter so minors only interact with minors.
That's it for this post. Next up will be a discussion about accepting a match. Stay tuned.


Reading “The Google File System”
S. Ghemawat, H. Gobioff, and S.-T. Leung, “The Google file system,” in ACM SIGOPS Operating Systems Review, 2003, vol. 37, pp. 29–43.
Abstract
We have designed and implemented the Google File System, a scalable distributed file system for large distributed data-intensive applications. It provides fault tolerance while running on inexpensive commodity hardware, and it delivers high aggregate performance to a large number of clients.
While sharing many of the same goals as previous distributed file systems, our design has been driven by obser- vations of our application workloads and technological environment, both current and anticipated, that reflect a marked departure from some earlier file system assumptions. This has led us to reexamine traditional choices and explore radically different design points.
The file system has successfully met our storage needs. It is widely deployed within Google as the storage platform for the generation and processing of data used by our service as well as research and development efforts that require large data sets. The largest cluster to date provides hundreds of terabytes of storage across thousands of disks on over a thousand machines, and it is concurrently accessed by hundreds of clients.
In this paper, we present file system interface extensions designed to support distributed applications, discuss many aspects of our design, and report measurements from both micro-benchmarks and real world use.
Critical Reading
GFS is an application-optimized distributed file system that was designed with Google’s requirements in mind. In particular, Google needed a replicated, highly-available system that prioritized streaming reads over random access and block writes or appends over random writes or overwrites. This makes perfect sense - Google’s production systems are storing entire websites as a single file, which are written as the site is being crawled (in big blocks or via appends). Computing page rank or doing other tasks requires the extraction of links or parsing of an XML file, which uses streaming reads to fetch the data. Logging and other crucial disk bound operations at Google are also append-oriented.
The motto of Google’s solution seems to be simplicity - and for this reason a centralized master server is used to coordinate with chunk servers that reside on many commodity machines. The Master server only handles file meta data and acts as a traffic controller to clients who want data; it does not stand pose a bottle neck to data transfer. The chunk servers themselves are simply a software layer on top of the file system of the machine; meaning that data eventually will be passed to whatever filesystem exists under GFS (and Google did report some problems with the Linux file system particularly performance woes from fsync
and mmap
). Checksums for data integrity, chunkserver selection, garbage collection, recovery, heartbeats - all of the design choices that Google made in GFS is to simplify the distributed system for the types of applications that Google uses most often.
The result of this simplicity is the key innovation of this paper: the ability to use commodity hardware to provide production level distributed systems. If disks and machines are expected to fail, it is far better (and cheaper) to replace them with economically viable machines - allowing for horizontal scaling; the more machines, the more capacity. There is no need for RAID or other expensive hardware because the filesystem replicates. And, extremely importantly - the data is where you will do the computation in the cluster, thus moving data off the disk to where the computation happens doesn’t require network overhead.
It turns out that modern data appliances, especially those with terabytes of data, benefit from this distributed data storage model; especially when there is a distributed programming framework that also optimizes the storage model. Combined with another paper - MapReduce: Simplified Data Processing on Large Clusters - GFS became the foundation for Big Data as we know it; and this paper was eventually implemented as HDFS in Hadoop. Chunks in the GFS are perfect inputs to Mapping processes, as each mapper can be run on every node in the cluster. Functional Mappers take a list of inputs as an argument and apply a function to every input value. In append-optimized systems chunks of data are therefore lists of inputs.
To the critique: there is a clear bottleneck in GFS, the Master server. This server has to be smart not only about chunk allocation, but also has to handle heartbeats, read and write requests and store metadata in memory. Although it does checkpoint itself to disk and have read-only shadow backups it is a central point of failure for the cluster. Worse, the master cannot handle many small files - it is optimized for files that are 64 MB or larger. Storing the meta data for billions of small files would eat up the memory on the server which can only vertically scale. Additionally because of the 64 MB chunks, there will be some storage loss for files that do not completely use up the chunk.


Aquaponics.
Home
Dashboard
Welcome
User!
Temperature
Waterlevel
pH
Current readings
Temperature
Water Level
pH


Workspace setup wizard
This setup wizard is working on empty window. Please close opened workspace first.
Spresense SDK Path
Spresense SDK Path Description
Invalid SDK Path selected. Please re-select correct SDK path.
Select
Project folder path
Project folder path description
Invalid path.
Select
Problems
Environment problems message


I like Bootstrap, so I use it for all the project I do.
So when "someone" starts with a I-am-a-frontend-developer-and-I-never-use-a-framework-bullshit.css, I quickly miss stuff that I need.
In this case I missed a grid. I wanted to copy paste something quick, but I noticed that I really don't know anything about flexbox. This is a great opportunity to find out.
simple grid
More controle over the colomn size


| MKMAMEDB(1) | General Commands Manual | MKMAMEDB(1) |
mkmamedb
—
mkmamedb |
[-fhtuV ] [-C
types] [-F
format] [-o
dbfile] [-x
pattern]
[- -all-sets ]
[- -detector
xml-file]
[- -directory-cache ]
[- -exclude
pattern]
[- -format
format]
[- -hash-types
types]
[- -help ]
[- -list-available-dats ]
[- -list-dats ]
[- -list-sets ]
[- -no-directory-cache ]
[- -only-files
pattern]
[- -output
dbfile]
[- -prog-description
description]
[- -prog-name
name]
[- -prog-version
version]
[- -roms-unzipped ]
[- -set
pattern]
[- -skip-files
pattern]
[- -use-description-as-name ]
[- -use-temp-directory ]
[- -version ]
[[rominfo-file | directory |
-] ...] |
mkmamedb
converts ROM set descriptions from one format
to another.
If no argument is given, mkmamedb
reads
the ckmamerc(5) config file and
checks if it needs to update the default database.
When a rominfo-file is specified, it is used
as input file; if the argument is -,
mkmamedb
expects the database on standard input
(stdin).
When a directory is specified, the files in that directory are checksummed and written to the database.
The default output file is mame.db. You
can override it with the -o
option or the
MAMEDB
environment variable.
Supported input formats are:
-u
); each
sub-directory is taken as a gameThe CMPro file format is described at http://www.logiqx.com/FAQs/CMPro.shtml, the DTD for MAME xml can be found in PREFIX/share/doc/ckmame/.
mkmamedb
supports the following options:
-
-all-sets
-C
types,
-
-hash-types
types-
-detector
xml-filemkmamedb
looks for the detector in the
input file (if it is a zip file) or the directory of the input file.-
-directory-cache
mkmamedb
is used to create a database from an
input directory, it will by default write a
.ckmame.db database file to it, caching the
directory contents' hashes in it so that consecutive re-runs are faster.
When mkmamedb
finds such a database, it only
computes the hashes for the files that have changed since the last
run.-F
format,
-
-format
formatcm
(clrmamepro dat file), dat
(XML datfile),
db
(ckmame(1)
database), and mtree
(mtree(8) file). The default is
cm.-f
,
-
-force
-h
,
-
-help
-
-no-directory-cache
-
-directory-cache
.-o
dbfile,
-
-output
dbfile-
-list-available-dats
-
-list-dats
-
-list-sets
-
-only-files
pattern-
-prog-description
description-
-prog-name
name-
-prog-version
version-
-set
patternmkmamedb
for all sets matching
pattern.-
-skip-files
pattern-t
,
-
-use-temp-directory
-u
,
-
-roms-unzipped
-
-use-description-as-name
-V
,
-
-version
-x
pat,
-
-exclude
patMAMEDB
-o
option. Defaults to
“mame.db”.-
-directory-cache
# mame -listxml | mkmamedb -
mkmamedb
was written by Dieter
Baron<EMAIL_ADDRESS>and Thomas Klausner
<EMAIL_ADDRESS>| March 25, 2022 | NiH |


| Tag | Description | # of References |
$def with () $var jsfiles: managePageCommon.js tagEdit.js $var cssfiles:
Tags are used to group objects together for various reasons, including access control.
Select a Tag from the list to the right to edit it.
Click here for a more detailed introduction to Tagging.
| Tag | Description | # of References |


Whenever you need help Dev Desk Queue is here to help.
We can help you to solve any problem you have.


Staff
Get to know the incredibly talented and diverse senior staff members of The Intergalactic Astronomical Union!
Our leadership comes from all across the bubble, from different walks of life.
Some come from Federation systems, some hail from Imperial systems, and some hail from from Independent systems.
Click on the link at the top of each bio, and you'll be directed to the personal "Inara" page of each senior staff member.
You can also contact us through the IGAU Discord: https://discord.gg/2Qq37xt
IGAU - Senior Scientist
Ph.D, Astrophysics (Federal Science and Flight Academy, 3305)
Area(s) of expertise: Radio Astronomy, Exobiology, Theoretical Cosmology
Publications: (Pending)
Ships(s): Orca, Fer-de-lance, Hauler
Likes: Cheesecake, Earth Opera
Dislikes: Popcorn
Urania Minora - Senior Scientist
Ph.D, Astrophysics (Federal Science and Flight Academy, 3303)
Area(s) of expertise: Galaxies and Cosmology, Stellar Evolution
Publications: Spectral Class Distribution of Galactic Phenomena
Ship(s): Anaconda, Krait MK II, Python, Type-7, Hauler, Sidewinder, Fleet Carrier [IGAU] Deep Space 12
Hobbies / Likes: Swimming, Kamitra Cigars, Centauri Mega Gin, Eranin Pearl Whisky
Dislikes: Warm beer, pirates, and bureaucrats
Marx - Senior Scientist
Area(s) of expertise: Stellar cartography
Publications: List of Earth-like worlds, Catalogue of Galactic Nebulae, Marx's guide to finding Earth-like worlds, Analyzing the ELW data from EDDB/EDSM
Ships(s): Imperial Courier, Imperial Clipper, Imperial Cutter, Anaconda, DBX, DBS, Vulture, Krait Phantom, Krait Mk II, Mamba, FdL, Viper Mk III, Viper Mk IV, Imperial Eagle, Eagle, Dolphin, Orca, Beluga Liner, Asp Scout, Asp Explorer, Cobra Mk III, Cobra Mk IV, Alliance Challenger, Type-6 Transporter, Type-10 Defender, Fleet Carrier IGAU Inverness
Likes: Earth-like worlds, Photography, Goman Yaupon Coffee, CD-75 Kitten Brand Coffee
Dislikes: Terraforming, Federation, Bad Coffee
Orvidius - Senior Scientist
Area(s) of expertise: Stellar cartography
Publications: edastro.com
Ship(s): Fleet Carrier [IGAU] Glorious Dawn
Amantha Holloway - Senior Scientist
M.Sc, Biology (Argent Academy, Garden City, 3293)
Area(s) of expertise: Exobotany/Exozoology, Geology
Ship(s): Beluga Liner, Asp Explorer, Imperial Eagle, Sidewinder
Hobbies / Likes: Gardening, Hiking, History, Coffee
Dislikes: Terraforming, Imperials, Bad Coffee
Ali_W - Associate Scientist
Area(s) of expertise: "A jack of all trades, a master of none"
Ship(s): Anaconda, Krait Phantom, Fer-de-Lance Asp Explorer, Python, Type-10, Sidewinder
Hobbies/Likes: Follower of 'The Way', Good Coffee, Good Cheese
Dislikes: Religion, Licorice, Iced Tea, Crash landing onto remote Hi-G planets,


Senior Product Engineer at Waitrose, here are some of the other places that you can find me on the internet.


NumericalSgps
Notable elements
In order to work with numerical semigroups, we have to load the package numericalsgps
. For this tutorial we have used the development version available in bitbucket.
gap> LoadPackage("num");
We start by defining a numerical semigroup. There are many ways to do this depending on the information we have about it. If we know a system of generators, then we can do the following. We will store the semigroup in a variable called s
.
gap> s:=NumericalSemigroup(3,5,7);
<Numerical semigroup with 3 generators>
Indeed, ${3,5,7}$ is a minimal generating set for s
.
gap> MinimalGenerators(s);
[ 3, 5, 7 ]
Membership can be detected with in
:
gap> 1 in s;
false
gap> 100 in s;
true
The set of sporadic elements (elements up to the conductor, or small elements) of the semigroup are
gap> SmallElements(s);
[ 0, 3, 5 ]
gap> Conductor(s);
5
gap> FrobeniusNumber(s);
4
This also is showing us the sets of gaps of s
gap> Gaps(s);
[ 1, 2, 4 ]
gap> Genus(s);
3
Recall that from the Apéry sets, one can retreive all this information.
gap> AperyList(s);
[ 0, 7, 5 ]
If only the semigroup is given as argument, then the Apéry set is computed with respect to the multiplicity. Note that the output is a list, in the $i$th position we find the smallest element in s
congruent with $i$ modulo the multiplicity (or the given element we specify as second argument).
gap> AperyList(s,10);
[ 0, 11, 12, 3, 14, 5, 6, 7, 8, 9 ]
It is well know that if the second argument is in the semigroup, then the output will have length precisely this argument. It not, the we get some extra elements.
gap> AperyList(s,6);
[ 0, 7, 8, 3, 10, 5 ]
The set of pseudo-Frobenius numbers can be computed as follows.
gap> PseudoFrobeniusOfNumericalSemigroup(s);
[ 2, 4 ]
gap> Type(s);
2
Let us for instance check that Wilf’s conjecture holds for all numerical semigroups with conductor equal to 20 (and thus Frobenius number 19).
gap> l:=NumericalSemigroupsWithFrobeniusNumber(19);;
gap> Length(l);
961
gap> ForAll(l, s->20<=EmbeddingDimension(s)*(Length(SmallElements(s))-1));
true
We are substracting one to the number of small elements since we consider the conductor as small element.
The special gaps (those that can be use to extend the semigroup to another numerical semigroup) are
gap> SpecialGaps(s);
[ 4 ]
gap> t:=AddSpecialGapOfNumericalSemigroup(4,s);
<Numerical semigroup>
gap> SmallElements(t);
[ 0, 3 ]
And the set of all oversemigroups:
gap> OverSemigroupsNumericalSemigroup(s);
[ <The numerical semigroup N>, <Numerical semigroup with 2 generators>,
<Numerical semigroup with 3 generators>,
<Numerical semigroup with 3 generators> ]
gap> List(last,MinimalGenerators);
[ [ 1 ], [ 2, 3 ], [ 3 .. 5 ], [ 3, 5, 7 ] ]
The set of fundamental gaps, is computed as follows. We can use fundamental gaps to define semigroups.
gap> FundamentalGaps(s);
[ 4 ]
gap> NumericalSemigroupByFundamentalGaps([4])=s;
true
As we can do with small elementa and gaps.
gap> NumericalSemigroupByGaps(Gaps(s))=s;
true
gap> NumericalSemigroupBySmallElements(SmallElements(s))=s;
true
Irreducible numerical semigroups
Our semigroup example s
is not symmetric, but it is pseudo-symmetric.
gap> IsIrreducible(s);
true
gap> IsSymmetric(s);
false
Symmetric numerical semigroups have type one, whole pseudo-symmetric have type equal to two.
gap> l:=IrreducibleNumericalSemigroupsWithFrobeniusNumber(19);;
gap> List(l,MinimalGenerators);
[ [ 2, 21 ], [ 3, 11 ], [ 4, 6, 17 ], [ 4, 9, 14 ], [ 4, 10, 13 ], [ 5, 6 ],
[ 5, 8, 12 ], [ 5, 11, 12, 13 ], [ 6, 8, 9 ], [ 6, 8, 10, 15, 17 ],
[ 6, 9, 11, 14, 16 ], [ 6, 10, 11, 14, 15 ], [ 7, 8, 9, 13 ],
[ 7, 8, 10, 13 ], [ 7, 9, 11, 13, 15, 17 ], [ 7, 10, 11, 13, 15, 16 ],
[ 8, 9, 12, 13, 14, 15 ], [ 8, 10, 12, 13, 14, 15, 17 ],
[ 9, 11, 12, 13, 14, 15, 16, 17 ], [ 10, 11, 12, 13, 14, 15, 16, 17, 18 ] ]
Every numerical semigroup can be expressed (though not uniquely) as the intersection of irreducible numerical semigroups.
gap> t:=NumericalSemigroup(10,11,12,13);
<Numerical semigroup with 4 generators>
gap> DecomposeIntoIrreducibles(t);
[ <Numerical semigroup with 5 generators>,
<Numerical semigroup with 6 generators>,
<Numerical semigroup with 6 generators> ]
gap> List(last,MinimalGenerators);
[ [ 10, 11, 12, 13, 15 ], [ 10, 11, 12, 13, 18, 19 ],
[ 10, 11, 12, 13, 19, 27 ] ]
We can actually find all oversemigroups of t
that are irreducible.
gap> o:=OverSemigroupsNumericalSemigroup(t);;
gap> oi:=Filtered(o,IsIrreducible);;
gap> Length(oi);
35
gap> t=Intersection(oi);
true
There are some special families of symmetric numerical semigroups, as complete intersections, free, telescopic, …
gap> s:=NumericalSemigroup(4,6,9);
<Numerical semigroup with 3 generators>
gap> IsFree(s);
true
gap> lf:=FreeNumericalSemigroupsWithFrobeniusNumber(19);;
gap> List(lf,MinimalGenerators);
[ [ 2, 21 ], [ 3, 11 ], [ 4, 6, 17 ], [ 4, 9, 14 ], [ 4, 10, 13 ], [ 5, 6 ],
[ 5, 8, 12 ], [ 6, 8, 9 ] ]
Almost symmetric numerical semigroups
We can construct almost symmetric numerical semigruops from irreducible numerical semigroups by removing some of its elements.
gap> AlmostSymmetricNumericalSemigroupsFromIrreducible(s);
[ <Numerical semigroup>, <Numerical semigroup with 4 generators>,
<Numerical semigroup with 4 generators> ]
gap> List(last,MinimalGenerators);
[ [ 4, 6, 9 ], [ 4, 6, 13, 15 ], [ 4, 9, 10, 15 ] ]
Actually, one can compute with this idea the set of all almost symmetric numerical semigroups with given Frobenius number.
gap> la:=AlmostSymmetricNumericalSemigroupsWithFrobeniusNumber(19);;
gap> Length(la);
131
gap> t:=First(la,s->not(IsIrreducible(s)));
<Numerical semigroup>
gap> MinimalGenerators(t);
[ 4, 6, 21, 23 ]
gap> Genus(t)=(FrobeniusNumber(t)+Type(t))/2;
true
Ideals
An ideal of a numerical semigroup can be defined by means of a generating system.
gap> s:=NumericalSemigroup(6,9,20);
<Numerical semigroup with 3 generators>
gap> i:=[2,3]+s;
gap> MinimalGenerators(i);
[ 2, 3 ]
The above ideal is not included in its ambient semigroup, and so it is not integral.
gap> IsIntegral(i);
false
gap> AmbientNumericalSemigroupOfIdeal(i);
<Numerical semigroup with 3 generators>
We can check membership with in.
gap> 8 in s;
false
gap> 8 in i;
true
Ideals also have conductors, since they are unions of translations of numerical semigroups.
gap> Conductor(i);
26
gap> SmallElements(i);
[ 2, 3, 8, 9, 11, 12, 14, 15, 17, 18, 20, 21, 22, 23, 24, 26 ]
The basic operations include intersection, sum, addition, translations and difference.
gap> j:=10+s;
<Ideal of numerical semigroup>
gap> i+j;
<Ideal of numerical semigroup>
gap> MinimalGenerators(i+j);
[ 12, 13 ]
gap> MinimalGenerators(10+i);
[ 12, 13 ]
gap> Difference(i,j);
[ 2, 3, 8, 9, 11, 12, 14, 15, 17, 18, 20, 21, 23, 24, 26, 27, 29, 32, 33, 35,
38, 41, 44, 47, 53 ]
gap> MinimalGenerators(Intersection(i,j));
[ 22, 30 ]
The colon operation of ideals of rings translates in ideals of numerical semigroups to $I-J={z\in \mathbb{Z} \mid z+J\subseteq I}$.
gap> MinimalGenerators(i-j);
[ -8, -7 ]
There are a couple of special ideals, one is the maximal ideal and the other the canonical (unique up to translations).
gap> m:=MaximalIdealOfNumericalSemigroup(s);
<Ideal of numerical semigroup>
gap> c:=CanonicalIdealOfNumericalSemigroup(s);
<Ideal of numerical semigroup>
gap> c-(c-i)=i;
true
gap> MinimalGenerators(m);
[ 6, 9, 20 ]
gap> MinimalGenerators(c);
[ 0 ]
gap> IsCanonicalIdeal(10+c);
true
The blow up of an ideal $I$ of a numerical semigroup $S$ is defined as $\bigcup_{n\in \mathbb{N}}(nI-nI)$.
gap> MinimalGenerators(BlowUpIdealOfNumericalSemigroup(i));
[ 0, 1, 2, 3, 4, 5 ]
gap> List([1..10], n->HilbertFunctionOfIdealOfNumericalSemigroup(n,i));
[ 4, 4, 3, 2, 2, 2, 2, 2, 2, 2 ]
If the ideal is the maximal ideal, then it coincides with the Lipman semigroup of $S$.
gap> MinimalGenerators(BlowUpOfNumericalSemigroup(s));
[ 3, 14 ]
gap> LipmanSemigroup(s);
<Numerical semigroup with 3 generators>
gap> MinimalGenerators(last);
[ 3, 14
One can keep computing Lipman semigroups until we reach $\mathbb{N}$, and the multiplicities of these semigroups conform the multiplicity sequence of $S$
gap> MultiplicitySequenceOfNumericalSemigroup(s);
[ 6, 3, 3, 3, 3, 2, 1 ]
Minimal presentations
The set of factorizations of an element in a numerical semigroup can be obtained as follows.
gap> s:=NumericalSemigroup(6,9,20);
<Numerical semigroup with 3 generators>
gap> FactorizationsElementWRTNumericalSemigroup(36,s);
[ [ 6, 0, 0 ], [ 3, 2, 0 ], [ 0, 4, 0 ] ]
And the set of $\mathcal{R}$-classes as
gap> RClassesOfSetOfFactorizations(last);
[ [ [ 0, 4, 0 ], [ 3, 2, 0 ], [ 6, 0, 0 ] ] ]
The set of Betti elements is
gap> BettiElementsOfNumericalSemigroup(s);
[ 18, 60 ]
And a minimal presentation is obtained with
gap> MinimalPresentationOfNumericalSemigroup(s);
[ [ [ 1, 6, 0 ], [ 0, 0, 3 ] ], [ [ 3, 0, 0 ], [ 0, 2, 0 ] ] ]
Recall that we can produce this also by using elimination.
gap> x:=Indeterminate(Rationals,"x");;
gap> y:=Indeterminate(Rationals,"y");;
gap> z:=Indeterminate(Rationals,"z");;
gap> t:=Indeterminate(Rationals,"t");;
gap> R:=PolynomialRing(Rationals,[x,y,z,t]);
Rationals[x,y,z,t]
gap> i:=Ideal(R,[x-t^6,y-t^9,z-t^20]);
<two-sided ideal in Rationals[x,y,z,t], (3 generators)>
gap> GroebnerBasis(i,EliminationOrdering([t]));
[ x^3-y^2, x*y^6-z^3, y^8-x^2*z^3, -x^2*y+z*t, y^5*t-x*z^2, x^2*y^3*t-z^2,
y^2*t^2-z, y*t^3-x^2, x*t^3-y, t^6-x ]
The graph $G_n$ can be calculated in the following way.
gap> GraphAssociatedToElementInNumericalSemigroup(60,s);
[ [ 6, 9, 20 ], [ [ 6, 9 ] ] ]
In this example, it has three vertices and a single edge.
We can also calculate the shaded set of an element.
gap> ShadedSetOfElementInNumericalSemigroup(60,s);
[ [ ], [ 6 ], [ 6, 9 ], [ 9 ], [ 20 ] ]
The Hilbert series (or generating function of $S$) is computed via the polynomial associated to $S$.
gap> HilbertSeriesOfNumericalSemigroup(s,x);
(x^44-x^43+x^38-x^37+x^35-x^34+x^32-x^31+x^29-x^28+x^26-x^25+x^24-x^22+x^20-x^19+x^18-x^16+x^15-x^13+x^12-x^10+x^9-x^7+x^6-x+1)/(-x+1)
gap> NumericalSemigroupPolynomial(s,x);
x^44-x^43+x^38-x^37+x^35-x^34+x^32-x^31+x^29-x^28+x^26-x^25+x^24-x^22+x^20-x^19+x^18-x^16+x^15-x^13+x^12-x^10+x^9-x^7+x^6-x+1
Actually, this polynomial has all its roots in the unit circle.
gap> IsKroneckerPolynomial(last);
true
Nonunique factorization invariants
We already know how to compute the set of factorizations of an element in the semigroup. The set of lengths is calculated as follows.
Sets of lengths
gap> LengthsOfFactorizationsElementWRTNumericalSemigroup(100,s);
[ 5, 9, 10, 11, 12 ]
Elasticity
The elasticity of an element and of the whole numerical semigroup can be computed with the following functions.
gap> ElasticityOfFactorizationsElementWRTNumericalSemigroup(100,s);
12/5
gap> ElasticityOfNumericalSemigroup(s);
10/3
Delta sets
The set of distances or Delta set:
gap> DeltaSetOfFactorizationsElementWRTNumericalSemigroup(100,s);
[ 1, 4 ]
Or even of the whole semigroups
gap> DeltaSetOfNumericalSemigroup(s);
[ 1 .. 4 ]
Recall that the maximum is reached in the Betti elements of the semigroup.
gap> List(B,b->DeltaSetOfFactorizationsElementWRTNumericalSemigroup(b,s));
[ [ 1 ], [ 1, 4 ] ]
Catenary degree
The catenary degree of a numerical semigroup is achieved in one of its Betti elements.
gap> List(B, b->CatenaryDegreeOfElementInNumericalSemigroup(b,s));
[ 3, 7 ]
gap> CatenaryDegreeOfNumericalSemigroup(s);
7
Omega primality
The omega primality of an element or of the semigroup (maximum of its atoms) can be computed as follows.
gap> OmegaPrimalityOfElementInNumericalSemigroup(100,s);
20
gap> OmegaPrimalityOfNumericalSemigroup(s);
10
Because for the atoms we obtain
gap> A:=MinimalGenerators(s);
[ 6, 9, 20 ]
gap> List(A, a->OmegaPrimalityOfElementInNumericalSemigroup(a,s));
[ 3, 3, 10 ]
Tame degree
We have specific funtions to compute the tame degree of an element in a numerical semigroup and the tame degree of the whole semigroup.
gap> TameDegreeOfElementInNumericalSemigroup(100,s);
7
gap> TameDegreeOfNumericalSemigroup(s);
10
gap> l:=Intersection(s,[1..100]);
[ 6, 9, 12, 15, 18, 20, 21, 24, 26, 27, 29, 30, 32, 33, 35, 36, 38, 39, 40,
41, 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98,
99, 100 ]
gap> List(l,x->TameDegreeOfElementInNumericalSemigroup(x,s));
[ 0, 0, 0, 0, 3, 0, 0, 3, 0, 3, 0, 3, 0, 0, 0, 3, 3, 0, 0, 0, 3, 3, 3, 0, 3,
3, 0, 3, 0, 0, 0, 3, 0, 3, 0, 3, 0, 10, 0, 3, 3, 3, 3, 10, 3, 3, 10, 3, 0,
10, 0, 3, 10, 3, 0, 10, 0, 7, 10, 3, 3, 10, 3, 7, 10, 3, 7, 10, 0, 7, 10,
3, 0, 10, 0, 3, 10, 7 ]
Random
Looking for a four generated numerical semigroup with 7 relators.
gap> l:=List([1..20], _->RandomNumericalSemigroup(5,500));;
gap> ll:=Filtered(l, s->EmbeddingDimension(s)=4);;
gap> Filtered(ll, s->Length(MinimalPresentationOfNumericalSemigroup(s))=7);
gap> MinimalGenerators(last[1]);
[ 315, 318, 485, 493 ]


| 1 | package com.edii.spc.game.solvers; | |
| 2 | ||
| 3 | import com.edii.spc.datastructures.MinHeap; | |
| 4 | import com.edii.spc.datastructures.OwnMap; | |
| 5 | import com.edii.spc.game.GameField; | |
| 6 | import com.edii.spc.game.GameFieldEdge; | |
| 7 | import com.edii.spc.game.GameFieldNode; | |
| 8 | import com.edii.spc.game.GameFieldPath; | |
| 9 | import java.util.Comparator; | |
| 10 | import java.util.Map; | |
| 11 | ||
| 12 | /** | |
| 13 | * Ratkaisee pelikentän Dijkstran algoritmilla. | |
| 14 | */ | |
| 15 | public class DijkstraSolver implements Solver { | |
| 16 | private final Comparator<GameFieldNode> comparator = new Comparator<GameFieldNode>() { | |
| 17 | @Override | |
| 18 | public int compare(GameFieldNode node1, GameFieldNode node2) { | |
| 19 |
2
1. compare : Replaced integer subtraction with addition → TIMED_OUT 2. compare : replaced return of integer sized value with (x == 0 ? 1 : 0) → TIMED_OUT |
return distance.get(node1) - distance.get(node2); |
| 20 | } | |
| 21 | }; | |
| 22 | | |
| 23 | private final Map<GameFieldNode, Integer> distance = new OwnMap<>(); | |
| 24 | private final Map<GameFieldNode, GameFieldEdge> edgeToPrevious = new OwnMap<>(); | |
| 25 | | |
| 26 | @Override | |
| 27 | public GameFieldPath solve(GameField field) { | |
| 28 | for (GameFieldNode node : field.getNodes()) { | |
| 29 | distance.put(node, Integer.MAX_VALUE); | |
| 30 | } | |
| 31 | | |
| 32 | distance.put(field.getStart(), 0); | |
| 33 | MinHeap<GameFieldNode> queue = new MinHeap<>(field.getNodes(), comparator); | |
| 34 | | |
| 35 |
1
1. solve : negated conditional → KILLED |
while (!queue.isEmpty()) { |
| 36 | GameFieldNode u = queue.extractMin(); | |
| 37 | for (GameFieldEdge edge : u.getEdges()) { | |
| 38 |
3
1. solve : changed conditional boundary → TIMED_OUT 2. solve : Replaced integer addition with subtraction → KILLED 3. solve : negated conditional → KILLED |
if (distance.get(edge.getNodes().getSecond()) > distance.get(u) + edge.getWeight()) { |
| 39 | edgeToPrevious.put(edge.getNodes().getSecond(), edge.inverse()); | |
| 40 |
1
1. solve : Replaced integer addition with subtraction → KILLED |
distance.put(edge.getNodes().getSecond(), distance.get(u) + edge.getWeight()); |
| 41 |
1
1. solve : removed call to com/edii/spc/datastructures/MinHeap::decreaseKey → TIMED_OUT |
queue.decreaseKey(edge.getNodes().getSecond()); |
| 42 | } | |
| 43 | } | |
| 44 | } | |
| 45 | | |
| 46 |
1
1. solve : mutated return of Object value for com/edii/spc/game/solvers/DijkstraSolver::solve to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return formPath(field); |
| 47 | } | |
| 48 | | |
| 49 | private GameFieldPath formPath(GameField field) { | |
| 50 | GameFieldPath path = new GameFieldPath(field.getFinish()); | |
| 51 |
1
1. formPath : negated conditional → KILLED |
while (!path.getEndNode().equals(field.getStart())) { |
| 52 |
1
1. formPath : removed call to com/edii/spc/game/GameFieldPath::addEdge → TIMED_OUT |
path.addEdge(edgeToPrevious.get(path.getEndNode())); |
| 53 | } | |
| 54 |
1
1. formPath : mutated return of Object value for com/edii/spc/game/solvers/DijkstraSolver::formPath to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return path.reverse(); |
| 55 | } | |
| 56 | } | |
Mutations | ||
| 19 |
1.1 2.2 |
|
| 35 |
1.1 |
|
| 38 |
1.1 2.2 3.3 |
|
| 40 |
1.1 |
|
| 41 |
1.1 |
|
| 46 |
1.1 |
|
| 51 |
1.1 |
|
| 52 |
1.1 |
|
| 54 |
1.1 |