Check out a review of Mup, by someone who chose Mup as his music notation program. This review was published in the May 1998 issue of Linux Gazette. It was also published in paper form in the September 1998 issue of Linux Journal. A survey of Mup users was conducted by a Mup user in 2007 and the survey results are available. A Mup user posted a brief blog post in 2019.
Here are a few of the comments we have received from Mup users around the world.
Mup is a marvelous tool. It fits me and the way I work, and it has allowed me to build arrangements, small, large and HUGE that I would not have been able to do without it. I am always amused when someone brings in a piece of music that they've tried to do in Finale or Sibelius. They can't figure out how to make it work because it's so complicated! And the printed music is nowhere near the quality that Mup produces.
- M.B. Alabama
Let me first thank you for making Mup available for evaluation as you do; it's much better to actually use a product than to make a decision based on slick advertising brochures. Overall, I am astounded at the functionality of Mup, and its fantastic output. It is obviously much better than Finale, which I have used in the past. I tried returning to Finale yesterday, but having seen Mup, it was just too painful.
- P. B.,  Mup offers a very small learning curve, is accompanied by excellent documentation, and is quick and easy to enter the needed data. The visual output is also incredible. The ability to define and use custom guitar chord grids is a wonderful "perk", as is the ability to transpose and print selected staves for parts. The ability to dump to MIDI output is probably the nicest feature - it's a lot easier to find those typos when you can hear it played back. For me, the MIDI output feature is an indispensible tool. Many thanks!
- K. T., Michigan
I've been in the software world for almost 60 years, and the combination of low bug rate, high quality output / functionality, and responsiveness to bugs and feature requests that you continue to bring to mup is head and shoulders above any other piece of software that I can remember using, including a lot of the software that underlies the Internet. It is really extraordinary. Computer science schools should use mup, and whatever your process is for managing its evolution, as a case study!
- L. P. D., California
I have been a Finale user for a long time, but I'm switching to Mup. I love the fact that I can edit my music on my Palm Pilot - and it only took me about a day to learn the language well enough to be able to enter my compositions. So - thank you for a very well-designed product.
- L. M., California
New Mup user here. I have played with it I find it to be extremely cool. I have attempted lilypond several times and always ran into roadblocks requiring mind-twisting work arounds. Mup seems MUCH more straightforward. Also, though lily is supposed to look great on paper (I wouldn't know since I have never really been able to complete a score with it), I find that whatever lily outputs looks positively HORRIBLE in PDF form on screen, but MUP looks great on both page and screen....so the MUP guys are doing something right there!
- S. S., Washington
Just a note to say thanks for Mup! It is really a great piece of work. For the last two years I have been trying to learn how to use Lilypond. I never have been able to get the results that I was looking for. When I came across Mup a couple of weeks ago, it was so easy I turned out my first hymn in two days, and three more by the end of the week. Best of all I was able to get all the results I have been looking for! I wished I would have found it two years ago. It would have saved me two years of frustration! Keep up the good work. Your software is first class!
- T. G., Texas
I know you guys have a thriving community and you probably hear this a lot, but Mup is fantastic. I am amazed at its capability.
- W. B., Illinois
I keep trying the alternates, and wonder why I bother. Mup is just the best.
- B. V. D. P., Idaho
Thanks for the great program! It would have taken several more years to save up for any other program that has the capacity to generate this quality of music. I use it all the time for my personal enjoyment, and agree that it is the best program for writing music, ever!
- C. C., California
I wanted to express my enthusiasm about your program. It's amazing how one can start out typesetting one's own music after only five or ten minutes of reading into the documentation. I had tried musixtex before and hadn't expected to find something that makes things so much simpler.
- R. P., Germany
I was previously using a demo version of Sibelius but I had no idea how I was going to come up with the $600. Many issues of lay-out which Mup handles for me have to be done manually with Sibelius, and it takes longer to write a chart. Thank you again. I'm telling folks in my Barbershop chapter to go for Mup.
- N. C., Vermont
I'm the original author of Ghostscript, which (as I discovered) Mup uses for printing. I'm also a musician and composer. In August (2000), when I was looking for a good notation program for Linux, I checked out the 6 notation programs at the Shareware Music Machine site, and Mup looked like the only one that really delivered the goods. Now that I've found the time to start using it seriously, I'm extremely pleased with the result. It does just what the (clear and straightforward) documentation says it does, and does it well. Thank you!
- L. P. D., California
Congratulations on a wonderful program. I needed to print out some music at very short notice: I managed to download and learn Mup very quickly and had the score ready (2-voice treble + bass and 2-verse lyrics) in about an hour. I've previously used Rosegarden and MusicTeX, neither of which is as easy to use. The "proof-listening" MIDI output feature is fantastic.
- M. T., United Kingdom
I LOVE Mup!!! For amateurs with even a little computer literacy, you can't beat it. Most free software packages are lame, difficult to use, or have poor quality output. But not Mup. You guys did a great job with it!
- P. J., Georgia
A compliment to the quality of Mup output: I took a transcription along to a recent music festival, and one of the comments was "I definitely want a copy of this piece: who publishes it?"
- N.N., Belgium
I am a delighted user of Mup. It is a delight to work with an architecturally sensible program again.
- G. S., Canada
Thanks for an excellent product! I used it on my senior honors project, and it was great. Entering the music was very fast. The Mup-generated PostScript was beautiful and professional looking. My professors and other students (most of whom use Finale or Encore, one prof uses Sibelius) were amazed at how good it looks.
- G. L., Illinois
Thanks for a wonderful program! I do all my theory homework with MUP now instead of Finale, and it takes me less than half the time it used to. Usually the output is better, as well!
- H. F., Utah
I'm *very* impressed with the program. Thank you very much for making this program available -- I intended to wrestle with MusicTex, but I'd heard that it was difficult and was putting it off. Mup is delightfully logical, and easy to learn, and the output is easy to incorporate into Tex output like any other graphics. I'm particularly impressed with the balance between computer assistance (in checking each bar against the time signature, for instance) and user intervention (for instance, in matters of `beaming'). It is very nice to deal with a program where the purpose and the execution are so well matched.
- P. M., Toronto, Ontario, Canada
I just spent part of the weekend reading your documentation (generally excellent) and typing in a Mup file. This morning your code compiled absolutely cleanly on my system (first try). I'm very impressed with the results. My congratulations on an excellent program.
- K. B., France
I've been struggling with Lilypond, trying to generate jazz charts. Mup looks much better. Thanks for this excellent product.
- T. R., Colorado
I believe you have written some wonderful software. I look forward to finding out all the different capabilities of Mup.
- C. L., California
Great programming, much better than Cakewalk at publishing music. It amazes me how logical the syntax is, and how much faster I can write a page than a friend using Finale.
- T. N., Utah
My first impression of Mup is !!! Have tried "Mozart" but like Mup better. This has to be one of the greatest present day bargains!
- A. B., Canada
I love Mup. It is an extremely well-designed and bug-free program.
- J. J., California
Thanks for writing such a simple, yet powerful program. I've already wasted time and money trying other transcription software which I never was able to figure out. I've been looking for a text-based interface for years, and when I saw Mup in Linux Journal, I knew I had to try it. I'm satisfied!
- J. J., Oregon
I'm very impressed with MUP's capabilities; I've used Encore and M-Tx/PMX/MusixTex and MUP definitely comes closest to meeting my needs.
- G. M., New Jersey
Thank you very much for your help. And, please, be proud of your software: I experimented a lot with Finale at school: it's a nice program indeed but it is not so easy (and often tricky) to get a professional result. I decided to acquire Mup half an hour after I started to use it: it took twenty (!) minutes to get where I arrived with Finale after a month.
- A. P., Italy
Mup is really great. The output looks like it came from a publishing house, and I like the text entry system. I can even edit my music files on my PDA while I'm away from the computer.
- D. T., Ohio
I love it!!!! Keep up the good work. I love the TAB entry stuff. Very Cool Feature! I tried using lilypond... I just couldn't get it to compile. But Mup was up within 3 minutes.
- B. B., Texas
Mup is a dream come true for me. After downloading several point-and-click nightmare programs I had just about given up on finding a faster way to notate music. With Mup, I'm happily zipping along in my text editor and writin' notes. Thanks!
- B. H., South Carolina
Mup is fantastic. It's so much easier to use than the windows program I was using previously. The simplicity and elegance of your input language is a delight.
- S. H., Australia
Thank you for a _really_ excellent program -- its output is better than that of any other music publication package I have seen.
- S. L., United Kingdom
I find Mup an excellent, impressive product, yet easy to use.
- M. N., Austria
Really very fine program with superb printing quality.
- W. B., The Netherlands
Congratulations on an excellent program! I find Mup very easy to use and very impressive. Mup is *very* cool, you guys have done a great job with it!
- D. P.
You have created an excellent program. The more I use it, the more I like it. I thought the ideal music notation editor program would have to be graphical, but it appears I was wrong.
- M. P., North Carolina
I downloaded Mup and built for Linux and there were no problems. Within an hour I had finished my first score, about the length of time it would have taken to ink it with no mistakes. The results were very nice, and you saved me the $350 that I was prepared to shell out for Finale.
- G. F., New Jersey
I am quite favorably impressed with Mup. I learned Finale for Macintosh when I was in college, and Mup beats it hands down for speed and ease of use. Keep up the good work! With Finale, it took me approximately two months to get to the point where I produced finished-looking music output. I got to that point with Mup in about 20 minutes, and the quality was comparable to an investment of significantly more time in Finale. I especially liked the way that dynamics, crescendo markings, ties, and slurs are placed in what I consider intelligent and appropriate places by default, but that there is also some more control available. I also like very much the TeX-like ASCII input method, since it's a great deal less processor-intensive than the Finale point-and-click interface. Once again, thanks. I've recommended Mup to several of my friends and colleagues who admired my printed-out work.
- C. W., Maine
I have tried and used both GUI and text based systems and am very impressed, not only with the thought that has gone into MUP, but with the ease of accomplishing the gamet of musical notation.
I am currently doing some arrangements for my daughter's upcoming wedding. The speed of input and quality of output is amazing. Thank you very much for a superior product.
One last thing. I have always been impressed at how Mup does its job, both in speed and quality. Having looked in more detail at the source code, I must say "Hats off to you for a fine job of design and coding."
- C. K., Oregon
I'm very pleased with Mup. I have completed several works for brass choir, trombone quintet, and jazz ensemble in about 1/2 the time it used to take with a GUI notation editor. Thanks for a great product!
- G. L., Illinois
I've been experimenting with Mup for about a month now, and in most respects, you can colour me thrilled.
- D. M. Montreal, Canada
This program has all that flexibility, plus its output looks as good as any I have seen, even from those $200-500 packages.
- C. H., California
I have to say that Mup seems to be a promising alternative to today's slow and clumsy WYSIWYG notation programs.
I am mostly interested in notation for practical everyday use and in my first quick tries with Mup I especially liked the idea of just entering the music and getting a reasonable layout, without much fiddling and fine tuning by hand.
- M. T., Germany
I just got Mup and it looks like it has a great deal of potential! I'm very excited about it.
- P. R., Virginia
I found Mup in the WWW, and am very happy with it, as it is an easy to use, small but powerful system.
- A. W., Germany
WOW. Just downloaded MUP. Congrats on a clean, elegant design.
- M. P., New York
I am very impressed with the capabilities of your music program. I compiled it on a SUN workstation. I had no difficulty installing and running the program.
- M. R., Spain
I downloaded MUP (Linux) for evaluation. I was impressed with the quality, using Ghostscript for printing. I shall tell my friends, who are guitar teachers.
- P. S., Scotland
Hey, MUP is terrific. It's exactly what is needed...a text-based markup notation system for music. This is a tremendous boon to find.
- S. H.
With Mup it took me 'no time' to get the input running, and the output is really close to professional. I am looking forward to become a frequent user of Mup. Let me again thank you very much for this excellent program!
- T. B., Germany
Thank you for writing Mup! I am a musician and a UNIX admin and this is a beautiful program for me! Finally I can write everything in vi and have beautiful output in written and midi formats!
- K. C., Florida
I've been creating scores using MUP for a while now and have nothing but praise for it; it's the best software value on the machine.
- M. D., New York
Thank you all for such a fine piece of software. I'm enjoying it enormously.
- L. C., Illinois
Thanks much for an excellent program and value!
- D. B., California
You have done a pretty remarkable job of hyper-linking the user's guide all together. I'm in the middle of scoring a motion picture sound track and like Mup well enough over the gooey scoring products to use it exclusively.
- J. N., California
I have been searching for an affordable music typesetter for some time which I could run on my system. I have looked at just about every system available, and so far your program Mup surpasses them all. The final output is superb.
- M. C., England
Your automatic formatter runs rings around anything that I've been able to get Encore or Finale to do. Both of those programs require hours of fussing with the position of things to get the score to look right. With Mup, once it's in, almost no additional work is needed to get good output.
- D. M., California


Input an expression and press enter.
Decimal numbers, +, -, *, /, % and parentheses("(" and ")") can be used.
=


Follow these steps to view the members in your organization:
The Team Management page displays.
Click the buttons in the top-right of the page to toggle between tile and list view.


Placeholder for the introduction about the blog. Placeholder for the introduction about the blog. Placeholder for the introduction about the blog. Placeholder for the introduction about the blog
Disclaimer: Higher EQ side effects include increased happiness, excellence at work, and better leadership skills.
The common denominator between cats and web devs? They both like boxes of course!


UPLOAD MY FRIDGE
SPECIAL FEATURES
Get notifications when food is about to expire.
Easily add ingredients by scanning your fridge.
View personalized recipe suggestions.


Microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API.
- Martin Fowler
Because monolithic apps lack:
- Scalability
- Flexibility
- Modularity
- Portability
- Decentralization
MetaProgramming
DSL
Dynamic
Optional Type
@GrabResolver("https://oss.jfrog.org/artifactory/repo")
@Grab("io.ratpack:ratpack-groovy:0.9.4")
import static ratpack.groovy.Groovy.*
ratpack {
handlers {
get {
render "Hello World"
}
}
}
http://localhost:5050
v0.9.11 (released 12/01)
npm install generator -angular -ratpack
dependencies {
compile("org.springframework.boot:spring-boot-starter-web:1.1.9.RELEASE")
}
package hello;
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
@Controller
@EnableAutoConfiguration
public class SampleController {
@RequestMapping("/")
@ResponseBody
String home() {
return "Hello World!";
}
public static void main(String[] args) throws Exception {
SpringApplication.run(SampleController.class, args);
}
}
Great.. but not so Groovy!!!
//App.groovy
@RestController
class SampleController {
@RequestMapping("/")
String home() {
return "Hello World!"
}
}
$ spring run App.groovy
$ curl localhost:8080
Hello World!
by Graeme Rocher in S2GX - 2014
A single missing semicolon brought down the entire (monolithic) Netflix website for several hours in 2008. #reInvent
— Chris Eng (@chriseng) November 13, 2014
NetFlix
( NetFlix OSS)
Monolithic Side
µService-ish
Airport
Aircraft
Reservation
Billing
Ground/Catering
J2EE, EJB 2.1, Thick Client
Decade old app
Unscalable
Complicated Release Cycle
One Man Army
Ap
Ac
Res
Bill
G/C
Grails Apps
CI
Independent
Decentralized Ownership


Why Pairing?
Pairing is a collaborative process between DBC'ers where two individuals of varying strengths are able to work together to accomplish a common goal.
How to pair
Usually there will be one person driving and the other will be navigating.
The driver is the person who actually works at the keyboard.
The navigator guides the driver and has the big picture view of the project.
Pairing Resources
Reflection
I'm still getting used to occupying the roles of driver and navigator--it's hard not to want to type something in when navigating rather than explaining it, and it's equally difficult to stay focused on what the navigator is saying when driving--but with each pairing session I think I'm improving. In my GPS, we alternated roles whenever appropriate on the fly, and for challenge 5 since I was having trouble dealing with screensharing and updating the HTML page and using devtools at the same time, I mostly navigated. I still have a lot to improve, but I'm looking forward to getting better with each of my pairs.


.hdr 1. PARSE IN RED
.hoc 1.1. About The Parse Dialect
The 'parse' facility of Red helps us to build mini-languages (DSLs
- domain-specific languages). It lets us specify syntax, and also provides
a simpler alternative to regular expressions when processing strings.
Parse is built-in to Red, so we can use it as part of a larger Red program.
Here is an example showing how simple and lightweight it can be: we have a
2-character string, which should contain a product code of the form "A",
"B" or "C" followed by either "1", "2", or "3", such as "A2" or "C3". The
following code does the validation, and Parse returns false if the string
is incorrect:
product: "C3"
parse/case product [["A" | "B" | "C"] ["1" | "2" | "3" ]] ;-- '|' means 'or'
The input to Parse is a series (the data we are processing in some way) and
a set of grammar rules.
The rules are similar to BNF specifications, but can also contain Red code
and commands to copy and skip through the input.
Though Parse has things in common with compiler-compilers, it has no
built-in facilities for e.g. symbol-table handling. It is simpler to use,
however. In fact, major parts of Red are themselves created with Parse,
such as Draw and Vid.
In these notes, I will look at string and block input series, though
any $$series!$$ types are allowed, except $$image!$$ and $$vector!$$.
If your input format has nothing to do with Red (e.g. HTML files, exported
spreadsheets, strings from a data-entry form, etc.) then you will use
string input to Parse. For some tasks, there might be lots of low-level
rules, such as stating that an integer consists of several digits, or that
a series of spaces separates items.
On the other hand, the really interesting stuff is to build a DSL to be
used within Red. If your input is blocks of Red, then Parse works at a
higher level. It knows that spaces separate items, and that 03:10:15 is a
time, for example. In fact most of the literal types are recognised. This
is normally the approach used to build a DSL.
Red is heavily based on REBOL of course, and Red's Parse has extra features
over REBOL 2's version. REBOL users please note that the string-split
feature in REBOL 2 has been moved from Parse into a separate $$split$$
function, and that parse in Red is the same as parse/all in REBOL.
For more information on Parse:
Introducing Parse, by Nenad Rakocevic.
http://www.red-lang.org/2013/11/041-introducing-parse.html
The Parse chapter, from the REBOL 2 documentation:
http://www.rebol.com/docs/core23/rebolcore-15.html
.top
.hoc 1.2. Parsing - An Introduction
The syntax rules for programming languages are often specified in some kind
of BNF.
Basically, we need to create rules which express:
** sequence: one item is followed by another item.
** choice: an item can be a selection from several things.
** repetition: an item can be made from a repetition of items. Sometimes
it is helpful to be able to express 'one or more of' and 'zero or more of'.
** sub-rules. It is convenient to express sub-rules, breaking up complex
syntax into manageable chunks. Sometimes it is useful to use recursive
rules for nested input.
Here is how these concepts occur in a fragment of a BASIC-style language:
if a<b then c=42
print "values ", a, b+2, c
Informally, we can say:
** A program consists of any number of statements.
** An 'if-statement' is a sequence of "if", a condition, "then", and a
statement.
** A 'print-statement' is a sequence. It starts with the word "print", and
is followed by any number of items, with a "," between them. Each item is
a selection from a quoted string and a numeric expression.
We would probably write sub-rules (sometimes called 'classes' in
syntax-analysis) for a statement, a print-statement, an if-statement, a
numeric-expression etc. This simplifies things for humans, and allows
re-use for commonly-occurring items.
Now we will look at some Parse examples.
.top
.hoc 1.3. Getting Started
Here is a tiny Red program which uses Parse:
Red [ "Parsing"]
parse-rules: ["move-" "north"] ;-- sequence
input: "move-north"
print parse input parse-rules ;-- prints true
input: "move-south"
print parse input parse-rules ;-- prints false
It begins with Red[ ], like all Red programs. We will omit this in the
following code fragments.
Parse is a function which returns $$true$$ if its input matches the rules,
otherwise $$false$$.
If we wanted to allow any direction, we could write a sub-rule. We choose
a name for it (using Red's rules for naming), and use [ | | | ....
] for a choice:
parse-rules: ["move-" direction]
direction: ["north" | "south" | "east" | "west"] ;-- choice
input: "move-south"
print parse input parse-rules ;-- true
Note that string-matching is case-insensitive. For case-sensitive
matching, use the /case refinement.
We could have written the above as:
parse-rules: ["move-" ["north" | "south" | "east" | "west"]]
input: "move-south"
print parse input parse-rules
but a sub-rule provides manageable chunks for humans.
With string input, spaces and newlines have no special significance. For
example, if we want a space to be a separator, we must say so in the
rules. With block input, things are different - this is covered later.
.top
.hoc 1.4. Sequence, selection, repetition: Some, Any, |
Whether the input is a string or a block, the action of these words is
identical. To specify a sequence, we write:
[item1 item2 item3 etc...]
'Item' can be primitive thing, or can be a sub-rule.
To specify a selection, we write:
[item1 | item2 | item3 | etc...]
To specify repetition, we write:
[some[ item1 item2 item3 etc]]
'some' requires at least one occurrence.
Note that we can write such rules as:
[some "A" "B"]
but here, 'some' only applies to the first item, matching "AB" "AAB" etc,
but not "ABAB". I will opt for always using [ ] for 'some', even if they
only enclose one item.
We can also use 'any', which specifies zero or more repetitions, as in:
[any["A" "B"]] ;-- e.g. "ABAB" "AB" ""
'Some' and 'any' will terminate when they encounter an item that does not
match, so in the case of some["A" "B"]
** "ABABABC" input - 'some' will match "AB" then "AB" etc. successfully,
then terminate when it reaches "C"
** "C" input - 'some' will not match because there are no "AB"s . If we
used 'any', the match would succeed, terminating on "C".
There are other convenient forms of rules, as in:
[3 "A"] - a count, matches "AAA" only.
[1 3 "A"] - a range, matches "A" or "AA" or "AAA".
[0 3 "A"] - a range, but zero occurrences are matched, as in "".
["A" | none] - a selection, matching "A" or "".
- This lets us detect a missing "A" specifically.
.top
.hoc 1.5. Characters, Numbers, Names
This is the relatively low-level (lexical analysis) area. We can specify,
for example, than an integer is a series of digits (at least one). We can
make use of $$charset!$$:
digit: charset "0123456789" ;-- any of these. (could also use '-'
integer: [some digit] ;-- one or more
Charset! is often used for speed reasons. We could also have used the
slower:
digit: [ "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
]
Here is how we can specify a typical variable name, which starts with a
letter, then has letters or digits following:
letter: charset [#"A" - #"Z" #"a" - #"z"] ;-- A to Z and a to z
alpha-numeric: [letter | digit]
var-name: [letter [any [alpha-numeric]]]
(We can use the set functions 'union', 'intersect' etc for higher speed).
.top
.hoc 1.6. Calculator Example With Strings
Here is a toy example. A calculation is made up of +, -, a memory (mem),
and integers. Some calculations:
+33-22
-44
+55+22-56+mem+1
There are 2 types of statement: memory and display, as in
mem=+33+55
display mem+100
There are no extra spaces, and a statement is followed by a newline. Of
course, we can write such calculations in straight Red - this is merely an
example of parsing. Here is one possible set of parse rules, followed by
some code in our tiny language:
program: [some [statement] ] ;-- at least one statement
statement: [[mem-instruction | display-instruction] newline]
mem-instruction: ["mem=" calculation]
display-instruction: ["display" space calculation]
calculation: [[some[pair]]]
pair: [operator primitive] ;-- all primitives preceded by op
operator: [ "+" | "-"]
primitive: [ num |"mem" ] ;-- e.g. 123, mem
digit: charset "0123456789"
num: [1 6 digit ] ;-- 1 to 6 digits in a num
code: {mem=+3-4+1
mem=+mem+1
display -100-mem+101
}
either parse code program [
print "Checked OK"
] [
print "Error"
]
Some points about the rules:
** program: we used 'some'. This disallows programs with no statements.
If we wanted, we can specifically check this case using 'none', perhaps to
display a targetted error message. The rule would then be
program: [some [statement] | none ]
** statement: there are two types, either must be followed by a newline.
Note that space and newline are pre-defined values in Red.
** calculation: most of the work is done here. The smallest legal
calculation is e.g. +3. A calculations consists of 'some' pairs, in which
a pair is an operator (only '+' and '-' in this version) followed by a
primitive item.
** primitive: either a 6-digit number, or the text "mem". We are using
string input here, and we allow a maximum of 6 digits. But what about
floating-point? We could try to write the syntax for this, but a better
approach would be to use block input, and let Red recognise the types it
already knows about. This is shown later.
** I could have used less rules, but personally I find the extra names
improves clarity.
.top
.hoc 1.7. Inserting Red Code: ( ) , Copy, Set
We can insert Red code in our rules by enclosing it in parentheses. For
example, if we modify our calculator 'num' rule to:
num: [1 6 digit (print "got num")]
we will see "got num" displayed 4 times with our input of
in: {mem=+3+1234
display -4+3-mem
}
Note that if the rule is entered, but no match happens, code at the end of
the rule is not executed. At the console, for example:
<< rule: [(print "A") "start" (print "B") ] ;-- match "start"
<< parse "start" rule
A
B
== true ;-- matches OK
<< parse "st-art" rule
A
== false ;-- no match, B not displayed
Similarly, in a selection, if we have
some-rule: ["begin" | "end"]
and we add some code like this:
some-rule: ["begin" | "end" (print "In some-rule") ]
it will only be executed when "end" is matched. To see the message in
either case, we should also put it immediately after "begin".
Within (...) we can put any Red code, such as using variables and calling
functions.
The 'copy' word can be used to access the matched text. It is followed by
a variable name, and must directly precede a rule. (i.e. don't put any
bracketed code between 'copy' and a rule. Here is an example:
num: [copy number 1 6 digit (print[ "number: " number]) ]
digit: charset "0123456789"
parse "123" num
The rule is '1 6 digit', and it is preceded by a copy. We are free to
choose the variable name for copy. When the rule succeeds (as it does
above) the print is executed, showing 123.
Here is another example:
operator: [copy op "+" | copy op "-"]
Note the copy in each selection. Our 'op' variable can be referred to in
another rule. Later we will use 'set', which is similar to 'copy'.
There is also a 'copy' in Red, but the Parse copy is different.
Here is the same grammar, with 'copy' and parenthesised code used to
perform the execution:
total: 0
memory: 0
use-num: func [] [
either op = "-" [;-- update the total + or -
total: total - to integer! prim
] [
total: total + to integer! prim
]
]
program: [some [statement]]
statement: [[mem-instruction | display-instruction] newline]
mem-instruction: ["mem=" calculation (memory: total)] ;-- update memory
display-instruction:
["display" space calculation (print ["display: " total])]
calculation: [(total: 0) [some [pair]]] ;-- initialise the calculation
pair: [operator primitive]
operator: [copy op "+" | copy op "-"] ;-- remember the op
primitive:
[copy prim num (use-num) | copy prim "mem" (prim: memory use-num)]
digit: charset "0123456789"
num: [1 6 digit]
code: {mem=+3-4+1
mem=+mem+1
display -100-mem+101
}
print "Code:"
print code
either parse code program [
print "Checked OK"
] [
print "Error"
]
and here is the output:
Code:
mem=+3-4+1
mem=+mem+1
display -100-mem+101
display: 0
Checked OK
A function was used to do the addition or subtraction, but similar code
could have been embedded in the rules.
Finally, we will put some calculator code in a file, and read it in. We
create a file named (for example) calc-code.txt, and put our code there, as
in:
mem=+3-4+1
mem=+mem+1
display -100-mem+101
Now we modify our program to read the file:
code: read %calc-code.txt ;-- in Red, % identifies a file name
parse code program
.top
.hoc 1.8. Calculator With Block Type: Copy And Set
The above calculator worked, but the use of 6-digit integers was
unrealstic. Also, what if we wanted to change our calculator to work with
$$float!$$ or $$time!$$ types? Their syntax is not simple. In such
situations, we would use block input. Here is some input for the block
version:
code: [mem = + 4 - 4 + 1
mem = + mem + 1
display - 100 - mem + 101
]
We have to put spaces between items now. In fact, the input code is now
quite close to Red, and there are various ways of interpreting it.
However, we will continue with Parse, and compare it to the string version
above. Here is the Parse code:
memory: 0
total: 0
use-num: func [] [
either op = '- [
total: total - prim
] [
total: total + prim
]
]
program: [some [statement]]
statement: [[mem-instruction | display-instruction]]
mem-instruction: ['mem '= calculation (memory: total)]
display-instruction: ['display calculation (print ["display: " total])]
calculation: [(total: 0) [some [pair]]]
pair: [operator primitive]
operator: [set op '+ | set op '- ]
primitive:
[set prim integer! (use-num) | set prim 'mem (prim: memory use-num)]
The differences from the string version are:
** we have removed references to space and newline. We use the Red
approach of spaces separating items.
** the 'primitive' rule now uses the Red $$integer!$$ type. All literal
types (e.g. $$pair!$$, $$time!$$, $$float!$$ etc can be similarly matched.
We can use $$any-type!$$ to match any item in the input.
** to match a word - such as mem, we use 'mem. Word matching is
case-insensitive.
** we used 'set' rather than 'copy'. In the above, the 'copy' variable is
made into a series type, even if it holds a single item, whereas the type
of the 'set' variable is what we want here (i.e $$integer!$$ in the
'primitive' match).
Strictly, the value of 'copy' is the collection of matched items, whereas
'set' uses the first matched item. Here are two examples
parse "Stuff---" ["Stuff" copy d some "-" (print [type? d d])]
parse "Stuff---" ["Stuff" set d some "-" (print [type? d d])]
In the first example, 'copy' contains the whole match "---" as a string,
and in the second, 'set' contains the first matched item as the character
#"-".
Here are some copy/set examples using blocks:
parse [Stuff 12 34] ['Stuff copy matched some integer!
(print [type? matched matched])]
parse [Stuff 12 34] ['Stuff set matched some integer!
(print [type? matched matched])]
The output is:
block 12 34
integer 12
We can also read data from a file into a block with $$load$$, and use it
directly in Parse, as in:
parse load %block-in.txt program
Where block-in.txt holds:
mem = + 4 - 4 + 1
mem = + mem + 1
display - 100 - mem + 101 - 2222
.top
.hoc 1.9. Literal Types In String Input
Parse rules used with strings cannot contain type names ($$pair!$$,
$$integer!$$, $$float!$$ etc). However, some literal values (not type
names) can be used. These are $$url!$$, $$email!$$, and $$tag!$$. Tag
values are the most common, as they are useful in HTML processing. Here
are some examples. They are all 'true':
print parse "Stuff>atag<" ["Stuff" >atag<]
print parse "Stuffhttp://me.com" ["Stuff" http://me.com]
print parse<EMAIL_ADDRESS>["Stuff"<EMAIL_ADDRESS>Note the reduction of quotes in the rules, though we could also use:
print parse "Stuff>atag<" ["Stuff" ">atag<"]
.top
.hoc 2.1. Keywords inside/outside Parentheses
We have seen that rules can contain Red code in parentheses, and also
commands - such as 'copy' outside parentheses. There are a number of other
commands (keywords) that belong to Parse. Sometimes they have the same
name as Red words, but they belong to Parse, and in general they have a
different meaning. You have seen 'copy', 'set', 'some', 'any', etc and now
we will look at others. Many of them allow us to manipulate the input
series.
A full list is available in:
Introducing Parse, by Nenad Rakocevic.
http://www.
red-lang.org/2013/11/041-introducing-parse.html
.top
.hoc 2.2. Skipping Input: Skip, To, Thru
These words let us move through the input.
'Skip' - this skips one item in the input series. For example:
rule: ["a" skip "b"]
print parse "axb" rule ;-- true
Above, the rule states:
- match an "a"
- skip over any character
- match a "b"
Using the above rule with different data:
print parse "axc" rule ;-- false - no b
print parse "axxb" rule ;-- false - no a after first x
Here is a block input example, which matches an integer, skips the next
item (an integer here), then matches a string. Parse returns 'true':
print parse [123 456 "Hello"] [integer! skip string! ]
Now some more 'skip' examples, all true, using a range:
print parse "axxxb" ["a" 1 3 skip "b"] ;-- a, do 3 skips, b
print parse "xxxa" [3 skip "a"] ;-- 3, skips, a
The 'thru' facility skips up to a specified item, as in:
parse "axxxbc" ["a" thru "b" "c"] ;--true: a, skip to b inclusive, c
In the above, 'b' is also skipped, and matching continues after it.
Note that this also works for multi-character strings in rules, as in:
parse "axxxxxbeec" ["a" thru "bee" "c"] ;-- skips to bee, matches c
and from the start, here using a sub-rule:
animal: ["black " "cat"]
parse "whatever---black cat" [thru animal] ;-- true
Alongside 'thru' there is the similar 'to', which does not include the item
which ends the skip. In the following example, the first 'b' is detected
but is not part of the skip. The second 'b' in the rule will match it:
parse "axxxxxb" ["a" to "b" "b" ] ;-- up to b, not including it.
Here is an example which copies the title of a web page:
html-code: ">html< >title<My Great Page>/title< Contents
here... >/html<"
parse html-code [thru >title< copy the-title to >/title<]
print ["Title is: " the-title] ;-- prints: My Great Page
We used the tag type in the rule, but could have used e.g.
">title<". Note the use of 'to'. If we used 'thru', then the
result is:
My Great Page>/title<
.top
.hoc 2.3. Using Variable:
We can create a variable, and set its value. This is a Parse feature.
Here are some examples. First we look at getting a position in the series:
parse "ABCDEFG" [thru "D" place: (print place) ] ;-- EFG printed
We created the 'place:' variable. Here, we skip to "D", including it.
Then, 'place' becomes a reference to the current input position. Here,
this is from "E" to the end.
Here is an example which finds the positions of items between START and
STOP. It uses the $$index?$$ series function to get a numeric position
from the reference to the series.
parse [A B START C D E STOP F G] [
thru 'START pos1: to 'STOP pos2:
(print [index? pos1 "-" (index? pos2) - 1 ]) ;-- prints 4 - 6
]
If we display the two positions as references without using $$index?$$, we
would get:
C D E STOP F G - STOP F G
Here is another example of finding positions, this time in HTML text. We
are interested in >h1< items.
page: {>html< >title< My Great Page>/title<
>h1< Big Heading A<>/h1<>p<Stuff in A >/p<
>h1< Big Heading B<>/h1<>p<Stuff in B >/p<
>/html<
}
;-- positions of text in an h1
parse page [ any [thru >h1< h1-at: (print ["h1 at: " index? h1-at])]]
;-- position of the > in >h1<
parse page [ any [to ">h1" h1-at: thru "<" (print ["h1 at: " index?
h1-at])]]
The first example uses an unquoted tag in the rule, and 'thru' includes the
whole tag.
The second example uses a quoted string to find ">h1", notes the
position, then moves to the closing "<".
Note that if we try to do the second example with 'to', as in:
any[ to >h1< ...]
Then parse gets stuck, repeatedly finding the same >h1<.
.top
.hoc 2.4. Using :Variable
Here we look at modifying the input series. This example finds the start
and end of the page's title text, and uses these references to modify the
input series:
parse page [thru <title> begin: to </title> ending:
(change/part begin "A Better Title" ending)
]
.top
.hoc 2.5. Using a Variable
We have looked at the use of ':word' and 'word:'. If we use a word
without a colon, its value is looked up and used, as in:
a-word: 3
print parse "xxxa" [a-word skip "a"] ;-- true
We could use this approach for counts, match-values etc.
.top
.hoc 2.5. Remove, Insert, Change
These Parse keywords modify the input series. They can be more convenient
than using Red code in parentheses.
We can remove the matched input, as in:
inp: "XXX-------"
parse inp [any "X" remove any "-"] ;
print inp ;-- prints XXX
We can insert an item (e.g. a string, a block) at current input position.
Scanning continues past the insertion.
inp: "XXX-------"
parse inp [any "X" insert "ABC" any "-"] ;
print inp ;-- prints XXXABCabc-------
We can change the match input to a given value:
inp: [12 "a string" "b string" 22 44] ;-- unordered strings, integers
parse inp [some[string! | change integer! "NUMBER" ]]
print inp
print ""
The output is:
NUMBER a string b string NUMBER NUMBER
.top
.hoc 2.6. Collect And Keep
Parse has its own $$collect$$ and $$keep$$ functions, similar to those in Red.
Here we parse a block of various types of item, and keep only the
integers. Keep can be used several times. Note that we match an integer
before the more general $$any-type!$$. There is also a 'pick' option for
'keep', which allows control over the storing of the selection.
in: [12 3x44 "a string" 13 a-word 14]
;-- prints 12 13 14
print parse in [collect[some[ keep integer! | any-type!]]]
The 'collect' function returns a block via Parse, i.e. the normal Parse
$$logic!$$ result is not returned.
.top
.hoc 2.7. Parse into/ahead (nested blocks)
Programming languages usually have some way of delimiting nested code, such
as curly-brackets in C++, Java. It is possible that your DSL might need nested
items. We can make use of Red's square brackets for this. Here is an example of
a nested structure. We can make the parser go into nested blocks with 'into'.
First we look 'ahead' to see if the next item is a block.
;-- a series of: integers or nested integers
list: [22 33 [44 [55] 66] 77]
nested-rule: [ any[ item ]]
item: [copy num integer! (print num)
| ahead block! (print "got a block")
into nested-rule (print "out of block")]
parse list nested-rule
The output is:
33
got a block
44
got a block
55
out of block
66
out of block
77
.top
.hoc 3.1. Debugging - parse-trace
To look into how your rules are working, you can insert printing to provide
a trace, as in:
primitive: [ num | "mem" ] ;-- original rule
;-- with prints
primitive: [num (print "got num") | "mem" (print "got mem")]
You can also use the 'parse-trace' wrapper for Parse, as in:
parse-trace some-input a-rule
This displays a detailed trace of the parse process.


Add tracing information to the pipeline execution.
Can be used with or without a body.
When called
with a body it:
- Executes the body under a new tracing span
- Adds the passed parameters to this tracing span
- Returns the value of the execution of the body
When called
without a body it:
- Does not create a new tracing span
- Adds the information from the passed parameters to the currently active tracing span
- Returns an object that can be used to customize the span further


At Lil Peeps we offer you the possibility to calculate your individual taxi fare estimation within a couple of seconds - for free.
Our fare estimate takes into account the amount of passengers, the distance, and the duration of the ride
First, we compute the route, duration, and distance of the trip.
We then use these factors to calculate the trip's fare.
You'll then have the option to register with us and pay for the trip!
Give us a call or send us an email and we will get back to you as soon as possible!
123-456-6789


This is a quick start seed for an Angular project including many common libraries for getting up to speed fast.
Honestly moreso because loading Bootstrap is a pain and you have better things to do than wade through docs all day to make it play nice. Have fun!


CSE 190 M ASCII Animation Viewer
Play Controls:
Start
Stop
Animation:
Blank
Exercise
Juggler
Bike
Dive
Size:
Tiny
Small
Medium
Large
Extra Large
XXL
Speed:
Turbo


class SoundComponent : Component
Component that defines which sound should be played.
SoundComponent(soundType: SoundType)
Type of sound
val soundType: SoundType


Fuel storage tanks brought down as demolition continues at Total site in Colwick
The work is due for completion at the end of the year
by Matthew BunnDemolition work is progressing well at a major fuel storage site in Colwick, which could be used for storage and warehousing in the future.
The Total Petroleum centre off Colwick Loop Road was once used to distribute fuel across the country, but a decommissioning process started in the summer.
The site did include storage tanks - which are now being brought down - loading bays and a control room.
It is anticipated the work will be completed by the end of the year and the area has been marketed by property agency Savills.
Offers have been made on the site, but while it is not yet known what will be put in the depot's place, suggestions have included warehousing.
Last month, a Total spokesman said: "Whilst we are considering offers for our site in Nottingham, work to complete the decommissioning process is ongoing and this is due to be completed on schedule by the end of the year.”


Caroline Flack gets welcome home snog from Lewis Burton and isn't love grand?
Caroline Flack looked chuffed as pie to land back in Blighty after Love Island filming in Cape Town, as she was greeted with a big ol’ smooch from boyfriend Lewis Burton.
The presenter had been in South Africa as prep for the winter version of the reality show kicked into gear, with a whistlestop tour of her latest office.
Rolling a suitcase through the arrivals terminal in Heathrow this week, Caroline was flanked by her crew as she sported a bright grin on her return to London.
Perhaps she’d just seen who was waiting for her on the other side of passport control?
Chilling with the chauffeurs, tennis player Lewis was patiently awaiting the return of his love as he embraced Caroline, who was dressed for the chill in a green coat, tights and boots.
Lewis, 27, who was dressed rather comfortably in a grey beanie and tracksuit, held his girlfriend as the two had a mid-terminal make-out session in front of curious punters.
Advertisement Advertisement
Hey, who cares who’s watching when you’re in love, right?
The star began dating her model beau earlier this year, with the pair going strong as they enjoyed a romantic getaway to Ibiza.
And even though they’ve not been shy in showing off their love, they are ‘100% not engaged’, you got it?
After the two made their relationship Instagram official back in August, a source told The Sun: ‘Caroline and Lewis were introduced through mutual friends and have really hit it off. They’ve been on several dates now and are getting on really well.
‘Lewis has been a true gent to Caroline and has patiently waited to see her.’
Burton is the first guy Caroline has been linked to since her brief fling with Danny Cipriani ended, as the TV presenter confirmed she was ‘dating’ following her split last year from fiance Andrew Brady.
She told OK! magazine: ‘I’m dating. Even though I’ve had ups and downs in my love life, I do still adore love.’
Hear hear!
You know what she probably doesn’t love right now? The inside of an airplane.
Only two days ago the presenter revealed she was overseas as we prepared for the next season of the ITV smash to hit screens.
Advertisement Advertisement
While the series isn’t scheduled to hit screens until early next year, Caroline recently confirmed she was already working on her part – which included some rather heinously-long 13-hour flights to South Africa.
The flagship summer series is based in Spain, only a couple hours flight away, where Caroline can easily dip in and out of the villa, do some classic slow-motion walks and hair flicks, while also hosting the regular Aftersun programme.
That’s all a little more complicated now she’s got a longer commute ahead of her.
Speaking to Metro.co.uk at the recent ITV Palooza in London, the ever-positive Caroline explained her jam-packed schedule.
‘It’s a 13 hour flight [to South Africa],’ the Flack Attack said.
’I’ve got to go back and forth the whole time to do Aftersun over here.
The former X Factor host also shared that it’s ‘a long old flight just to do that walking’, but at least that’s the optimum time to binge-watch The Crown, right?
Winter Love Island will see the famous villa in Majorca swapped for the sunny shores of South Africa as another group of British singletons fly out in the hopes of finding true love.
Advertisement
The new series is not without its controversies, however, as former contestant Yewande Biala is convinced the winter version of the show will actually flop.
‘Because it’s once a year, you can’t miss it, you have to watch it [while] on Twitter,’ she said.  Whereas if it’s all the time, you’re like “It doesn’t matter, there’s going to be another one in two months’ time”.’
Eh, don’t be so sure! We cannot wait.
Winter Love Island airs January 2020 on ITV2.
Got a showbiz story?
If you've got a story, video or pictures get in touch with the Metro.co.uk Entertainment team by emailing us<EMAIL_ADDRESS>calling 020 3615 2145 or by visiting our Submit Stuff page - we'd love to hear from you.


Stuyvesant Softdev School Project
Tools Used: HTML5, CSS, Python, Flask, Jinja, SQLite, RestAPI
Student Opportunity Bulletin Board
Gives both teachers and students a hub to post about interesting events taking place.
Website uses google oauth api to store logins, and the google calendar api to keep
track of deadlines
Group project, worked with classmates Sophie Nichol, Lauren Pehlivanian, and Jason Zheng


Customize your devops journey by adopting to processes, tools and platforms of your choice.
Run your workloads on public, private or hybrid cloud.
Stay secured while staying agile.
Future proof your workforce by training them on devops, cloud and security solutions.
We provide end to end solutions listed below for your workloads running on cloud, on-premise or in a hybrid environment.
We live in a world where change is the only constant and for the technology,
this phenomenon is on steroids! DevOps is breaking barriers to accelerate product
development along with increased collaboration, communication and automation
among teams. At Loves Cloud, devops encompasses everything from source control
management to CI/CD pipelines to Docker and all the way till monitoring,
logging and continuous security.
Read More...
While DevOps is good at breaking barriers, cloud is your platform to be truly
agile in your product development approach. Look no further to experiment or to move
your data or your disaster recovery options to cloud. At Loves Cloud, we advocate
managed services over servers to harness power of cloud for your product and services
while maintaining security, cost and performance as your top priorities.
Read More...
Secure your applications, data and infrastructure by adopting security by design approach. Integrate security in your devops and your cloud solutions by following DevSecOps. Alongside ensure compliance to frameworks and regulations such as GDPR, ISO, HIPPA, PCI-DSS etc. Loves Cloud provides end to end security and compliance solutions for all your requirements. Read More...
Loves Cloud provides curated corporate training solutions for DevOps, Cloud Solutions and Security.
These are hands-on, assignment and project based training solutions using real world use-cases.
These trainings are tailored to your organizational needs such as certification requirement or
consulting requirements for a technology, tool or platform.
Read More...
Loves Cloud is a devops, cloud & security solutions company. It is based in Noida, India and founded in 2017. We are a small team of certified architects and consultants who specialize in making cloud journey smooth, less expensive and more productive for our customers along with their products and services. We work together with you to plan, execute, maintain and optimize all things devops, cloud & security!
Connect with usConnect with us at<EMAIL_ADDRESS>to get started!


I make things
I've always been good with technology. When I wanted a computer, but couldn't afford to buy one, I scrounged parts and built one. I learned how to build websites using html 2. I learned a lot of things, but somehow I never learned to code. I made the switch because I wanted a challenging career that offered me the opportunity to learn and grow.
I love projects that are meaningful, and want to work for a company that is making an impact, and doing something for the betterment of society. Most of my career experience is in non-profits, and I'd love to continue in that vein.


Habitat
Inhabits rocky areas. In old places, he can find bones. It also happens that it can be found in dark caves.


[gecode-users] Parameter/Options passing to engines through script
Luca Di Gaspero
l.digaspero at uniud.it
Mon Jul 8 19:37:50 CEST 2013
Hi Christian,
> I think this is not a good idea: this would make the use of LNS depend on
> the fact that one uses a Script-derived class.
> But this is not general enough, as Script is just a convenience class for
> the commandline driver. In order to be fully general it also should work for
> any subclass of Space.
Actually the LNS engine is currently only moderately dependent on Space: it will ask for a decorated Space implementing two additional methods Space* relax() and void relaxable_var in a similar way as the master() and slave() methods for restarts. We also provide some standard convenience template decorator class which takes a generic Space and require the redefinition of those specific methods by multiple inheritance in a neat way.
> Did you think about extending the Search::Options class with what you need
> and then add the appropriate commandline options to control the parameters
> in the search options? Maybe you just tell us what options you need?
We actually did it for the non-scriptable variant of the meta-engine. That is the LNS<template<class> class E, class T>(T*, Search::Options& o) is meant to be used with a specific subclass of Search::Options, called LNSOptions, which inherits from InstanceOptions and augments it with LNS-specific parameters. This has been done by dynamic_cast<LNSOptions*>(&o)-ing (and checking whether the correct class has been provided).
However, the problem we are currently facing is that we would like to use that meta-engine also with the Script<Space>::run static method (because it is integrated in a specific GUI and we want to reuse it as much as we can), but the LNSOptions class will be not sent through it to the end-level engine (as it will be dispatched and some of the (standard) options coming, e.g., from the command-line driver, are copied in a fresh Search::Option object (around line 300 in script.hpp) that is provided to the (meta-)engine.
Moreover, apart of the LNS specific parameters, the possibility to marshall customized parameters directly to the engine from the command-line will ease the development of engines by different contributors: of course I can list the parameters we need for LNS, but I had also in mind to contribute further hybrid solvers for which different parameters should be provided, therefore I was looking to some more flexible way to achieve this goal.
So, I would like to agree with you some parameter passing mechanism that could be general enough for this purpose. Once this issue is solved, Tommaso Urli (the coauthor of this engine) and myself will be very happy to contribute the LNS code :-) [apart of jokes, if you would like to access the current version of the engine for searching a solution to the problem, I will send you the source code].
Thanks and all the best,
Luca
--
Luca Di Gaspero, PhD http://www.diegm.uniud.it/digaspero/
DIEGM, Università di Udine email: luca.digaspero at uniud.it
via delle Scienze, 208 tel: +39-0432-558242
33100 Udine, ITALY fax: +39-0432-558251
-
PGP Key ID 1EE94BEA registered at http://pgpkeys.mit.edu
More information about the users
mailing list


Congruence subgroup \(\Gamma_H(N)\)#
AUTHORS:
Jordi Quer
David Loeffler
- class sage.modular.arithgroup.congroup_gammaH.GammaH_class(level, H, Hlist=None)#
Bases:
CongruenceSubgroup
The congruence subgroup \(\Gamma_H(N)\) for some subgroup \(H \trianglelefteq (\ZZ / N\ZZ)^\times\), which is the subgroup of \(\SL_2(\ZZ)\) consisting of matrices of the form \(\begin{pmatrix} a & b \\ c & d \end{pmatrix}\) with \(N \mid c\) and \(a, d \in H\).
- atkin_lehner_matrix(Q)#
Return the matrix of the Atkin–Lehner–Li operator \(W_Q\) associated to an exact divisor \(Q\) of \(N\), where \(N\) is the level of this group; that is, \(gcd(Q, N/Q) = 1\).
Note
We follow the conventions of [AL1978] here, so \(W_Q\) is given by the action of any matrix of the form \(\begin{pmatrix} Qx & y \\ Nz & Qw \end{pmatrix}\) where \(x,y,z,w\) are integers such that \(y = 1 \bmod Q\), \(x = 1 \bmod N/Q\), and \(det(W_Q) = Q\). For convenience, we actually always choose \(x = y = 1\).
INPUT:
Q
(integer): an integer dividing \(N\), where \(N\) is the level of this group. If this divisor does not satisfy \(gcd(Q, N/Q) = 1\), it will be replaced by the unique integer with this property having the same prime factors as \(Q\).
EXAMPLES:
sage: Gamma1(994).atkin_lehner_matrix(71) [ 71 1] [4970 71] sage: Gamma1(996).atkin_lehner_matrix(2) [ 4 1] [-996 -248] sage: Gamma1(15).atkin_lehner_matrix(7) Traceback (most recent call last): ... ValueError: Q must divide the level
- characters_mod_H(sign=None, galois_orbits=False)#
Return the characters of \((\ZZ / N\ZZ)^*\), of the specified sign, which are trivial on H.
INPUT:
sign
(default: None): if not None, return only characters of the given signgalois_orbits
(default: False): if True, return only one character from each Galois orbit.
EXAMPLES:
sage: GammaH(5, [-1]).characters_mod_H() [Dirichlet character modulo 5 of conductor 5 mapping 2 |--> -1, Dirichlet character modulo 5 of conductor 1 mapping 2 |--> 1] sage: Gamma1(31).characters_mod_H(galois_orbits=True,sign=-1) [Dirichlet character modulo 31 of conductor 31 mapping 3 |--> zeta30, Dirichlet character modulo 31 of conductor 31 mapping 3 |--> zeta30^3, Dirichlet character modulo 31 of conductor 31 mapping 3 |--> zeta30^5, Dirichlet character modulo 31 of conductor 31 mapping 3 |--> -1] sage: GammaH(31, [-1]).characters_mod_H(sign=-1) []
- coset_reps()#
Return a set of coset representatives for self \ SL2Z.
EXAMPLES:
sage: list(Gamma1(3).coset_reps()) [ [1 0] [-1 0] [ 0 -1] [ 0 1] [1 0] [-1 0] [ 0 -1] [ 0 1] [0 1], [ 0 -1], [ 1 0], [-1 0], [1 1], [-1 -1], [ 1 2], [-1 -2] ] sage: len(list(Gamma1(31).coset_reps())) == 31**2 - 1 True
- dimension_cusp_forms(k=2)#
Return the dimension of the space of weight k cusp forms for this group. For \(k \ge 2\), this is given by a standard formula in terms of k and various invariants of the group; see Diamond + Shurman, “A First Course in Modular Forms”, section 3.5 and 3.6. If k is not given, default to k = 2.
For dimensions of spaces of cusp forms with character for Gamma1, use the dimension_cusp_forms method of the Gamma1 class, or the standalone function dimension_cusp_forms().
For weight 1 cusp forms, there is no simple formula for the dimensions, so we first try to rule out nonzero cusp forms existing via Riemann-Roch, and if this fails, we trigger computation of the cusp form space using Schaeffer’s algorithm; this can be quite expensive in large levels.
EXAMPLES:
sage: GammaH(31, [23]).dimension_cusp_forms(10) 69 sage: GammaH(31, [7]).dimension_cusp_forms(1) 1
- dimension_new_cusp_forms(k=2, p=0)#
Return the dimension of the space of new (or \(p\)-new) weight \(k\) cusp forms for this congruence subgroup.
INPUT:
k
- an integer (default: 2), the weight. Not fully implemented for k = 1.p
- integer (default: 0); if nonzero, compute the \(p\)-new subspace.
OUTPUT: Integer
EXAMPLES:
sage: GammaH(33,[2]).dimension_new_cusp_forms() 3 sage: Gamma1(4*25).dimension_new_cusp_forms(2, p=5) 225 sage: Gamma1(33).dimension_new_cusp_forms(2) 19 sage: Gamma1(33).dimension_new_cusp_forms(2,p=11) 21
- divisor_subgroups()#
Given this congruence subgroup \(\Gamma_H(N)\), return all subgroups \(\Gamma_G(M)\) for \(M\) a divisor of \(N\) and such that \(G\) is equal to the image of \(H\) modulo \(M\).
EXAMPLES:
sage: G = GammaH(33,[2]); G Congruence Subgroup Gamma_H(33) with H generated by [2] sage: G._list_of_elements_in_H() [1, 2, 4, 8, 16, 17, 25, 29, 31, 32] sage: G.divisor_subgroups() [Modular Group SL(2,Z), Congruence Subgroup Gamma0(3), Congruence Subgroup Gamma0(11), Congruence Subgroup Gamma_H(33) with H generated by [2]]
- extend(M)#
Return the subgroup of \(\Gamma_0(M)\), for \(M\) a multiple of \(N\), obtained by taking the preimage of this group under the reduction map; in other words, the intersection of this group with \(\Gamma_0(M)\).
EXAMPLES:
sage: G = GammaH(33, [2]) sage: G.extend(99) Congruence Subgroup Gamma_H(99) with H generated by [2, 17, 68] sage: G.extend(11) Traceback (most recent call last): ... ValueError: M (=11) must be a multiple of the level (33) of self
- gamma0_coset_reps()#
Return a set of coset representatives for self \ Gamma0(N), where N is the level of self.
EXAMPLES:
sage: GammaH(108, [1,-1]).gamma0_coset_reps() [ [1 0] [-43 -2] [ 31 2] [-49 -5] [ 25 3] [-19 -3] [0 1], [108 5], [108 7], [108 11], [108 13], [108 17], [-17 -3] [ 47 10] [ 13 3] [ 41 11] [ 7 2] [-37 -12] [108 19], [108 23], [108 25], [108 29], [108 31], [108 35], [-35 -12] [ 29 11] [ -5 -2] [ 23 10] [-11 -5] [ 53 26] [108 37], [108 41], [108 43], [108 47], [108 49], [108 53] ]
- generators(algorithm='farey')#
Return generators for this congruence subgroup. The result is cached.
INPUT:
algorithm
(string): eitherfarey
(default) ortodd-coxeter
.
If
algorithm
is set to"farey"
, then the generators will be calculated using Farey symbols, which will always return a minimal generating set. Seefarey_symbol
for more information.If
algorithm
is set to"todd-coxeter"
, a simpler algorithm based on Todd-Coxeter enumeration will be used. This tends to return far larger sets of generators.EXAMPLES:
sage: GammaH(7, [2]).generators() [ [1 1] [ 2 -1] [ 4 -3] [0 1], [ 7 -3], [ 7 -5] ] sage: GammaH(7, [2]).generators(algorithm="todd-coxeter") [ [1 1] [-13 4] [ 15 4] [-3 -1] [ 1 -1] [1 0] [1 1] [-3 -1] [0 1], [ 42 -13], [-49 -13], [ 7 2], [ 0 1], [7 1], [0 1], [ 7 2], [-13 4] [-5 -1] [-5 -2] [-10 3] [ 1 0] [ 2 -1] [1 0] [ 42 -13], [21 4], [28 11], [ 63 -19], [-7 1], [ 7 -3], [7 1], [-3 -1] [ 15 -4] [ 2 -1] [-5 1] [ 8 -3] [11 5] [-13 -4] [ 7 2], [ 49 -13], [ 7 -3], [14 -3], [-21 8], [35 16], [-42 -13] ]
- image_mod_n()#
Return the image of this group in \(SL(2, \ZZ / N\ZZ)\).
EXAMPLES:
sage: Gamma0(3).image_mod_n() Matrix group over Ring of integers modulo 3 with 2 generators ( [2 0] [1 1] [0 2], [0 1] )
- index()#
Return the index of
self
in SL2Z.EXAMPLES:
sage: [G.index() for G in Gamma0(40).gamma_h_subgroups()] [72, 144, 144, 144, 144, 288, 288, 288, 288, 144, 288, 288, 576, 576, 144, 288, 288, 576, 576, 144, 288, 288, 576, 576, 288, 576, 1152]
- is_even()#
Return True precisely if this subgroup contains the matrix -1.
EXAMPLES:
sage: GammaH(10, [3]).is_even() True sage: GammaH(14, [1]).is_even() False
- is_subgroup(other)#
Return True if self is a subgroup of right, and False otherwise.
EXAMPLES:
sage: GammaH(24,[7]).is_subgroup(SL2Z) True sage: GammaH(24,[7]).is_subgroup(Gamma0(8)) True sage: GammaH(24, []).is_subgroup(GammaH(24, [7])) True sage: GammaH(24, []).is_subgroup(Gamma1(24)) True sage: GammaH(24, [17]).is_subgroup(GammaH(24, [7])) False sage: GammaH(1371, [169]).is_subgroup(GammaH(457, [169])) True
- ncusps()#
Return the number of orbits of cusps (regular or otherwise) for this subgroup.
EXAMPLES:
sage: GammaH(33,[2]).ncusps() 8 sage: GammaH(32079, [21676]).ncusps() 28800
AUTHORS:
Jordi Quer
- nirregcusps()#
Return the number of irregular cusps for this subgroup.
EXAMPLES:
sage: GammaH(3212, [2045, 2773]).nirregcusps() 720
- nregcusps()#
Return the number of orbits of regular cusps for this subgroup. A cusp is regular if we may find a parabolic element generating the stabiliser of that cusp whose eigenvalues are both +1 rather than -1. If G contains -1, all cusps are regular.
EXAMPLES:
sage: GammaH(20, [17]).nregcusps() 4 sage: GammaH(20, [17]).nirregcusps() 2 sage: GammaH(3212, [2045, 2773]).nregcusps() 1440 sage: GammaH(3212, [2045, 2773]).nirregcusps() 720
AUTHOR:
Jordi Quer
- nu2()#
Return the number of orbits of elliptic points of order 2 for this group.
EXAMPLES:
sage: [H.nu2() for n in [1..10] for H in Gamma0(n).gamma_h_subgroups()] [1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0] sage: GammaH(33,[2]).nu2() 0 sage: GammaH(5,[2]).nu2() 2
AUTHORS:
Jordi Quer
- nu3()#
Return the number of orbits of elliptic points of order 3 for this group.
EXAMPLES:
sage: [H.nu3() for n in [1..10] for H in Gamma0(n).gamma_h_subgroups()] [1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] sage: GammaH(33,[2]).nu3() 0 sage: GammaH(7,[2]).nu3() 2
AUTHORS:
Jordi Quer
- reduce_cusp(c)#
Compute a minimal representative for the given cusp c. Returns a cusp c’ which is equivalent to the given cusp, and is in lowest terms with minimal positive denominator, and minimal positive numerator for that denominator.
Two cusps \(u_1/v_1\) and \(u_2/v_2\) are equivalent modulo \(\Gamma_H(N)\) if and only if
\[v_1 = h v_2 \bmod N\quad \text{and}\quad u_1 = h^{-1} u_2 \bmod {\rm gcd}(v_1,N)\]or
\[v_1 = -h v_2 \bmod N\quad \text{and}\quad u_1 = -h^{-1} u_2 \bmod {\rm gcd}(v_1,N)\]for some \(h \in H\).
EXAMPLES:
sage: GammaH(6,[5]).reduce_cusp(5/3) 1/3 sage: GammaH(12,[5]).reduce_cusp(Cusp(8,9)) 1/3 sage: GammaH(12,[5]).reduce_cusp(5/12) Infinity sage: GammaH(12,[]).reduce_cusp(Cusp(5,12)) 5/12 sage: GammaH(21,[5]).reduce_cusp(Cusp(-9/14)) 1/7 sage: Gamma1(5).reduce_cusp(oo) Infinity sage: Gamma1(5).reduce_cusp(0) 0
- restrict(M)#
Return the subgroup of \(\Gamma_0(M)\), for \(M\) a divisor of \(N\), obtained by taking the image of this group under reduction modulo \(N\).
EXAMPLES:
sage: G = GammaH(33,[2]) sage: G.restrict(11) Congruence Subgroup Gamma0(11) sage: G.restrict(1) Modular Group SL(2,Z) sage: G.restrict(15) Traceback (most recent call last): ... ValueError: M (=15) must be a divisor of the level (33) of self
- to_even_subgroup()#
Return the smallest even subgroup of \(SL(2, \ZZ)\) containing self.
EXAMPLES:
sage: GammaH(11, [4]).to_even_subgroup() Congruence Subgroup Gamma0(11) sage: Gamma1(11).to_even_subgroup() Congruence Subgroup Gamma_H(11) with H generated by [10]
- sage.modular.arithgroup.congroup_gammaH.GammaH_constructor(level, H)#
Return the congruence subgroup \(\Gamma_H(N)\), which is the subgroup of \(SL_2(\ZZ)\) consisting of matrices of the form \(\begin{pmatrix} a & b \\ c & d \end{pmatrix}\) with \(N | c\) and \(a, d \in H\), for \(H\) a specified subgroup of \((\ZZ/N\ZZ)^\times\).
INPUT:
level – an integer
- H – either 0, 1, or a list
If H is a list, return \(\Gamma_H(N)\), where \(H\) is the subgroup of \((\ZZ/N\ZZ)^*\) generated by the elements of the list.
If H = 0, returns \(\Gamma_0(N)\).
If H = 1, returns \(\Gamma_1(N)\).
EXAMPLES:
sage: GammaH(11,0) # indirect doctest Congruence Subgroup Gamma0(11) sage: GammaH(11,1) Congruence Subgroup Gamma1(11) sage: GammaH(11,[10]) Congruence Subgroup Gamma_H(11) with H generated by [10] sage: GammaH(11,[10,1]) Congruence Subgroup Gamma_H(11) with H generated by [10] sage: GammaH(14,[10]) Traceback (most recent call last): ... ArithmeticError: The generators [10] must be units modulo 14
- sage.modular.arithgroup.congroup_gammaH.is_GammaH(x)#
Return True if x is a congruence subgroup of type GammaH.
EXAMPLES:
sage: from sage.modular.arithgroup.all import is_GammaH sage: is_GammaH(GammaH(13, [2])) True sage: is_GammaH(Gamma0(6)) True sage: is_GammaH(Gamma1(6)) True sage: is_GammaH(sage.modular.arithgroup.congroup_generic.CongruenceSubgroup(5)) False
- sage.modular.arithgroup.congroup_gammaH.mumu(N)#
Return 0 if any cube divides \(N\). Otherwise return \((-2)^v\) where \(v\) is the number of primes that exactly divide \(N\).
This is similar to the Möbius function.
INPUT:
N
– an integer at least 1
OUTPUT: Integer
EXAMPLES:
sage: from sage.modular.arithgroup.congroup_gammaH import mumu sage: mumu(27) 0 sage: mumu(6*25) 4 sage: mumu(7*9*25) -2 sage: mumu(9*25) 1


Circle size shows number of job applicants
Vertical position shows number of employees
Horizontal position shows job growth


Functions to generate the data set, base plot, and tire pressure
base_pressure_plot
Base pressure chart
bike_tire_pressures()
Compute front and rear tire pressures based on data for bike and rider.
droop_pressure_psi()
Compute the 15% droop tire pressure based on wheel load and tire size
generate_base_pressure_plot()
Generate the base plot of inflation curves for all tire sizes
generate_inflation_data()
Generate the dataset for drawing the inflation curves
tire_sizes_mm()
Nominal tire sizes
Functions to generate the user info
plot_bike_inflation()
Plot and label front and rear wheel inflation data for a bike setup
plot_2_bike_inflation()
Plot and label front and rear wheel inflation data for comparing 2 bike setups
Functions to format data for plotting
check_pressure()
Check if pressure exceeds certain levels
rider_expand_limits()
rider_expand_limits
dual_pressure()
Y axis label formatting function
dual_pressure_point()
Data point formatting function
dual_weight()
X axis label formatting function
plot_title()
Display a generic title and optionally add bike summary info
theme_dg_pale()
Modifications to theme_bw to add a bit of color
theme_bw
Metric/imperial unit conversion
lb_to_kg()
Convert pounds to kilograms
psi_to_bar()
Convert PSI to Bar


Donate
Home
About
Short Codes
Blog
Contact
Sign In
Email
Password
Remember me
Sign in
New User? Sign up here!


The EOF Line Feed plugin appends a line feed character (\n) to the end of every document when saved, unless the document is already terminated by a line feed.
A number of tools expect text files to end with a line feed character. NetBeans allows the cursor to occupy and modify, including delete, the last line in a text file, and will then not ensure that the file is terminated by a line feed.
The goal of this plugin is to ensure that all text files are terminated by a line feed. It is not to provide the ability to specify rules or otherwise adjust this behaviour. If you regularly edit files that should not be terminated by a line feed you probably should not be using this plugin.


Super Galactic Age Calculator
Enter your Age in Earth Years:
Enter your birthday:
example: 04 12 1982
Check your age
To find out your remaining time, answer the following questions:
Do you know the muffin man?
Yes
No
Do you own a wingsuit?
Yes
No
Years left


SUTHeader Struct Reference
internal structures.
More...
List of all members.
|
Public Attributes |
| unsigned char | magic [8] |
| | ubertexture data.
|
| unsigned char | minorVer |
| | must be '''U''T''X''''
''''
'
|
| unsigned char | majorVer |
| | must be 0
|
| unsigned short | metaDataStart |
| | must be 1
|
| unsigned short | metaDataSize |
| | location of any extra data.
|
| unsigned short | atlasStart |
| | size in bytes of any extra data.
|
| unsigned short | atlasSize |
| | location in the file where the atlas starts.
|
| unsigned short | chunkStart |
| | size of the atlas in 2K chunks.
|
| unsigned int | basicCheckSum |
| | the first 2K chunk containing tile data.
|
Detailed Description
internal structures.
ubertexture header info.
Definition at line 40 of file GrUTLoader.cpp.
Member Data Documentation
location in the file where the atlas starts.
Definition at line 49 of file GrUTLoader.cpp.
the first 2K chunk containing tile data.
Definition at line 51 of file GrUTLoader.cpp.
The documentation for this struct was generated from the following file:
- C:/Bootstrap/ProjectBX/Documentation/Code/Engine/Graphics/GrUTLoader.cpp


Simba Web Design is the newly formed Web Design and Development Company in Wakanda, we are so excited to welcome our customers and everybody else to explore our works and what we have been doing prior to the formation of this small company. Simba Web Design is formed by young Expert Designers and Developers in Wakanda and can make your business website a great success. Our team of young and talented Wakandanian Web Designers and Developers will make sure your website is a good example to others by making it the best as they can.
Simba Web Design is the newly formed Web Design and Development Company in Wakanda, we are so excited to welcome our customers and everybody else to explore our works and what we have been doing prior to the formation of this small company. Simba Web Design is formed by young Expert Designers and Developers in Wakanda and can make your business website a great success. Our team of young and talented Wakandanian Web Designers and Developers will make sure your website is a good example to others by making it the best as they can. Read more


Silvertown Tunnel: Bringing London together or tearing it apart?
by Stefan BosciaLondon has just three road river crossings east of Tower Bridge.
Two of these – the Rotherhithe Tunnel and the western portion of the Blackwall Tunnel – were built for the passage of horse-drawn carts and carriages around the turn of the century.
Read more: TfL awards 1bn Silvertown Tunnel contract to Aberdeen Standard-backed firm
Legend has it that the bends in the western Blackwall Tunnel, built in 1897, were designed to stop horses from treating the tunnel like the Royal Ascot straight.
However, the east end looks close to getting its fourth – and doubtless most controversial – road river crossing after numerous failed attempts.
The £1bn Silvertown Tunnel is on the verge of getting final approval from Transport for London (TfL), with a contract with Riverlinx consortium expected to be signed imminently.
It comes after legal action from a losing bidder was recently dismissed.
The tolled underground tunnel will span between the Royal Docks precinct and Greenwich, and it will fall within the Ultra Low Emissions Zone (Ulez).
It would provide a vital link to transport goods across the river, according to its supporters.
TfL and mayor of London Sadiq Khan say it will take pressure off the nearby Blackwall Tunnel, thereby easing congestion and improving air quality.
“The Silvertown Tunnel is the best way to resolve these problems and London cannot afford to wait any longer to see it delivered,” Khan recently told the London Assembly.
However, not everybody agrees.
For members of the No to Silvertown Tunnel coalition, the cause is deeply personal.
“I live in Greenwich, very close to where the proposed tunnel is and my kids went to three of the most polluted schools in London,” coalition coordinator Victoria Rance said.
“The tunnel would make it worse and it’s our kids who are going to suffer.”
Rance’s message is simple – Silvertown is being built primarily for heavy goods vehicles (HGVs) to cross the river, meaning more of these high-polluting vehicles would be drawn to Greenwich and Woolwich, thus increasing congestion and air pollution.
The coalition also argues the tunnel will act as a disincentive for people to use public transport.
Rance, who is also a Green Party candidate for the general election, said the coalition would rather see a toll on Blackwall tunnel, more public transport options and a “smart road pricing” scheme to manage levels of traffic around London.
There are a growing number of local stakeholders who now agree with her.
Fifteen heads of local schools have signed a letter to the mayor opposing the project due to concerns about air pollution.
The Greenwich, Hackney and Newham councils councils also oppose the project.
So too does Labour Greenwich & Woolwich MP Matthew Pennycook.
“My fear is that far from alleviating congestion and air pollution, the proposed scheme will exacerbate both to the detriment of the health and quality of life of local residents,” he said.
TfL has frequently pointed to modelling that shows congestion and air pollution would decrease after the Silvertown Tunnel is built, however campaigners remain sceptical and unconvinced.
Meanwhile, business groups continue to argue the urgent need for more river crossings in East London.
John Dickie, policy director for advocacy group London First, said Greenwich is already awfully congested and polluted because of the inability of Blackwall Tunnel to handle traffic flow.
“The Silvertown Tunnel will connect communities, alleviate congestion, and open up opportunities for jobs, homes and growth,” he said.
Natalie Chapman, South England and urban policy chief at the Freight Tranport Association, said the bridge would provide a dramatic boost to a number of sectors.
“This bridge is so vital in terms of products and supply chains,” she said.
“In terms of the environment, the lorries are still going into the area now, but have to be diverted to the Dartford Crossing [in Kent].
“Putting HGVs on diversion is far worse for CO2 emissions.”
Chapman added that there needs to be a “network of river crossings” in East London.
“East London desperately needs connectivity…If we can spread out the river crossings it will also be a good thing for the environment,” she said.
While the war appears to be lost, the No to Silvertown Tunnel coalition will not be retreating any time soon.
Read more: Rival Silvertown Tunnel bidder launches legal action against TfL
The green light may be soon given to the project, but Rance and co have made it clear they will not go quietly into the night on this issue.
Main image: Getty images.


Welcom To Petra
the ancient city of Petra is one of Jordan's national treasures and by far its best known tourist attraction. Located approximately three hours south of Amman, Petra is the legacy of the Nabataeans, an industrious Arab people who settled in southern Jordan more than 2,000 years ago. Admired then for its refined culture, massive architecture and ingenious complex of dams and water channels, Petra is now a UNESCO World Heritage Site that enchants visitors from all corners of the globe. Much of Petra's appeal comes from its spectacular setting deep inside a narrow desert gorge. The site is accessed by walking through a kilometre long chasm (or siq), the walls of which soar 200m upwards.


PART IV. DIVISIONS, DEPARTMENTS, AND PROGRAMS
A. Community Colleges
[1. General Provisions]
Revision Note
Subdivision heading added by revisor.
[§304A-1101] System of community colleges; purpose. (a) The board of regents shall develop and administer a system of community colleges.
(b) The purposes of community colleges shall be to provide:
(1) Two-year college transfer and general education programs;
(2) Two- and four-year career and technical education programs;
(3) Semiprofessional, career and technical, and continuing education programs; and
(4) Such other educational programs and services as may be appropriate to such institutions.
(c) The board may confer a corresponding degree or certificate upon the successful completion of any educational program described in subsection (b) to all students who are entitled thereto. [L 2006, c 75, pt of §2]
Cross References
Apprentice instructor, responsibility, see §372-6.
Workforce development scholarship program, see §304A-505.


GPGV2
Section: GNU Privacy Guard (1)Updated: 2010-11-11
Index Return to Main Contents
NAME
gpgv2 - Verify OpenPGP signaturesSYNOPSIS
gpgv2 [options] signed_files
DESCRIPTION
gpgv2 is an OpenPGP signature verification tool.This program is actually a stripped-down version of gpg which is only able to check signatures. It is somewhat smaller than the fully-blown gpg and uses a different (and simpler) way to check that the public keys used to make the signature are valid. There are no configuration files and only a few options are implemented.
gpgv2 assumes that all keys in the keyring are trustworthy. By default it uses a keyring named oqtrustedkeys.gpgcq which is assumed to be in the home directory as defined by GnuPG or set by an option or an environment variable. An option may be used to specify another keyring or even multiple keyrings.
RETURN VALUE
The program returns 0 if everything is fine, 1 if at least one signature was bad, and other error codes for fatal errors.
OPTIONS
gpgv2 recognizes these options:
- --verbose
- -v
-
Gives more information during processing. If used
twice, the input data is listed in detail.
- --quiet
- -q
-
Try to be as quiet as possible.
- --keyring file
-
Add file to the list of keyrings.
If file begins with a tilde and a slash, these
are replaced by the HOME directory. If the filename
does not contain a slash, it is assumed to be in the
home-directory ("~/.gnupg" if --homedir is not used).
- --status-fd n
-
Write special status strings to the file descriptor n. See the
file DETAILS in the documentation for a listing of them.
- --logger-fd n
-
Write log output to file descriptor n and not to stderr.
- --ignore-time-conflict
-
GnuPG normally checks that the timestamps associated with keys and
signatures have plausible values. However, sometimes a signature seems to
be older than the key due to clock problems. This option turns these
checks into warnings.
- --homedir dir
-
Set the name of the home directory to dir. If this option is not
used, the home directory defaults to oq~/.gnupgcq. It is only
recognized when given on the command line. It also overrides any home
directory stated through the environment variable oqGNUPGHOMEcq or
(on W32 systems) by means of the Registry entry
HKCU\Software\GNU\GnuPG:HomeDir.
EXAMPLES
- gpgv2 pgpfile
- gpgv2 sigfile [datafile]
-
Verify the signature of the file. The second form is used for detached
signatures, where sigfile is the detached signature (either
ASCII-armored or binary) and datafile contains the signed data;
if datafile is "-" the signed data is expected on
stdin; if datafile is not given the name of the file
holding the signed data is constructed by cutting off the extension
(".asc", ".sig" or ".sign") from sigfile.
FILES
- ~/.gnupg/trustedkeys.gpg
-
The default keyring with the allowed keys.
ENVIRONMENT
- HOME
-
Used to locate the default home directory.
- GNUPGHOME
-
If set directory used instead of "~/.gnupg".
SEE ALSO
gpg2(1)The full documentation for this tool is maintained as a Texinfo manual. If GnuPG and the info program are properly installed at your site, the command
-
info gnupg
should give you access to the complete manual including a menu structure and an index.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:04 GMT, December 24, 2015


--- title: Events & Filters excerpt: All available events and filters. ---
Herbie is using an event manager inspired by Zend's EventManager component. During the application lifecycle the following events are triggered.
| Name | Description | |
|---|---|---|
| {{ event.order }} | {{ event.name }} | {{ event.desc }} |
Herbie is using an intercepting filter inspired by Zend's FilterChain for providing a mechanism to alter the workflow of the rendering process. During the application lifecycle The following filters are used.
| Name | Description | |
|---|---|---|
| {{ filter.order }} | {{ filter.name }} | {{ filter.desc }} |
The given architecture allows you to attach your own listeners and filters.
This can be done in your custom Herbie plugin or in the index.php
bootstrap file.


-
Download tools
Get the tools to help you start developing Store apps.
-
Get code samples
Fast track your code development with code samples.
-
Try Windows App Studio
Build a universal Windows app. No coding required.
-
Submit apps
Make your app available in the Store.

-
Preview the OS
Help your app use the new Windows Phone features.


--- layout: challenges title: CrypTools - Learn description: The best platform to learn cryptography ---


The Analytical Distance Runner
The Analytical Distance Runner focuses on races, 3000m and longer, including road,
track, and crosscountry events. Male runners who have achieved a sub-30:00 time for 10K road or the equivalent,
and female runners who have achieved a sub-35:00 time for 10K road or the equivalent are tracked. These criteria
include virtually all world and national class open runners and many top masters runners.
Subscribe to the ANALYTICAL DISTANCE RUNNER (by e-mail only). ADR is distributed on a more or less weekly basis,
depending on race results received and business trips. ADR highlights recent changes and updates to this website
as well as providing competitive rankings for 25 countries, national team rankings, prize money rankings, statistical
analyses, trivia questions, and more.
Special requests for customized statistical information should be addressed to<EMAIL_ADDRESS>Detailed runner bios, win/loss matrices, race handicapping, up-to-the-minute annual event lists, and many more
are available at reasonable costs.
Have laptop, will travel. The ADR database resides on a laptop, making it possible to provide on-site statistical
support on race day.
Race handicapping is also available for more than 100 races each year (men's and women's races counted separately). These tend to be major races and marathons involving five or (usually) more elite runners. The actual races handicapped depends on the timely receipt of elite entry rosters. An estimated time range and odds of winning are calculated for each runner. The three or four top picks are discussed in some depth. Post-race analyses of the handicapping are also provided.
For a one year subscription to either of these two e-publications, please send US$20
cash or check to:
Ken Young
PO Box 219
Petrolia CA 95558
(707) 629-3430
e-mail<EMAIL_ADDRESS>Copyright. The data contained on this web site is public domain and as such, cannot
be copyrighted. However the format the data is presented is copyrighted. Permission to reproduce the data/tables
on this website is granted provided The Analytical Distance Runner is cited as the source and the ADR website URL
be included.
RECORDS
National Records
RUNNERS
Largest Prize Money Distributions
MISCELLANEOUS
Association of Road Racing Statisticians
Criteria for Inclusion in ADR Database
NOTES
Road performances are classified as "record quality", "statistically valid", or "statistically invalid" based on the start/finish separation and the net drop of the course.
Record Quality
.....Start/finish separation is less than 30% of the race distance and the net drop is less than 1.0 m/km
Statistically Valid (suffix "a")
.....The net drop is less than 5.0 m/km and the net effect of tailwind and/or drop does not exceed 5 sec/km
Statistically Invalid (suffix "x")
.....The net drop is 5.0 m/km or more
.....The course has been shown to have been short on remeasurement
.....The course is suspect based on an analysis of the race time bias that exceeds 5 sec/km faster than expected
(-5.0 sec/km)
Only record quality or statistically valid performances are included in records/rankings lists (except for the rate time bias adjusted lists that compensate for drop, shortness, and wind-aid).
LINKS TO RELATED WEB SITES
Marathon schedules/results at www.marathonguide.com


The idea that dogs hate cats may have been born because dogs chase cats and grew because cartoons depicted ongoing battles between the two species. Or it may have been generated because some dog people strongly dislike cats and some cat people strongly disdain dogs. However, dogs and cats can live peaceably as long as owners understand the behaviors of each.
In some cases, a resident cat will isolate itself when a puppy is added to the family. In other cases, cats and dogs never get used to each other. In still other cases, cat or kitten and dog or puppy play together and build a friendship that finds them curled up together in a crate or bed and drinking out of the same bowl. The type of relationship developed in each household depends on the personality of the animals and the understanding of the owners.


{% extends 'application.html' %}
{% block body %}
Andrew Copas
Front End
Andrew is a senior at SFSU. An avid Backpacker, Andrew usually spends three to
four weeks in the Back country every year.
He is a frontend team member working with Bootstrap.
<EMAIL_ADDRESS>{% endblock %}


Welcome to #bog13 Bingo! Back by popular demand after Biology of Genomes and ASHG. Inspired by an idea from Daniel MacArthur.
Square text borrowed from here.
While you're here, check out the rest of the Interpretome (don't worry, your bingo state will be saved).
Load your 23andme file into the browser (no genotypes transferred to any server, all analysis is done in the browser; Google Chrome preferred) and explore your genetic data!
Your bingo card will be stored in a cookie on your computer, even if you close the page (so long as you don't clear cookies).
Are you sure you want to create a new bingo card?
This will reset your old card, if you have one
Click on the square to mark (again to unmark)
The bingo term must be said by the speaker (not by questioners; speaker's response to questions OK)
(Speaker does not get credit for his or her own buzzwords)
Card saves automatically at every click, stored in a cookie on your machine.
Announce your winning a bingo card on Twitter using #bog13 and/or #bingo (use the submit button below)
(Bonus points for weaving the word "bingo" into a question to the speaker)
State saved at:
People playing bingo in the last 20 minutes:
BINGO!
You've won!
Click "Submit Bingo Card" below to get a link to your card and post it on Twitter!
Submit your bingo card here to win* and post the results to Twitter.