Contents:
Awk, by Sed and Grep, out of Ed
Command-Line Syntax
Using sed
Using awk
Using sed and awk Together
If you are starting out to learn sed and awk, you can benefit from looking at how much they have in common.
They are invoked using similar syntax.
They are both stream-oriented, reading input from text files one line at a time and directing the result to standard output.
They use regular expressions for pattern matching.
They allow the user to specify instructions in a script.
One reason they have so much in common is that their origins can be found in the same line editor, ed. In this chapter, we begin by taking a brief look at ed and show how sed and awk were logical steps towards the creation of a programmable editor.
Where sed and awk differ is in the kind of instructions that control the work they do. Make no mistake - this is a major difference, and it affects the kinds of tasks that can best be performed with these programs.
This chapter looks at the command-line syntax of sed and awk and the basic structure of scripts. It also offers a tutorial, using a mailing list, that will give you a taste of script writing. It is valuable to see sed and awk scripts side-by-side before you concentrate on either one of them.
You can trace the lineage of awk to sed and grep, and through those two programs to ed, the original UNIX line editor.
Have you ever used a line editor? If so, it will be much easier for you to understand the line orientation of sed and awk. If you have used vi, a full-screen editor, then you are familiar with a number of commands that are derived from its underlying line editor, ex (which in turn is a superset of the features in ed).
Let's look at some basic operations using the line editor ed. Don't worry - this is an exercise intended to help you learn sed and awk, not an attempt to convince you of the wonders of line editors. The ed commands that are shown in this exercise are identical to the sed commands you'll learn later on. Feel free to experiment with ed on your own to get a sense of how it works. (If you're already familiar with ed, feel free to skip to the next section.)
To use a line editor, you work on one line at a time. It is important to know what line you are positioned at in the file. When you open a file using ed, it displays the number of characters in the file and positions you at the last line.
$ed test
339
There is no prompt. If you enter a command that ed does not understand, it prints a question mark as an error message. You can enter the print command, p, to display the current line.
p
label on the first box.
By default, a command affects only the current line. To make an edit, you move to the line that you want to edit and then apply the command. To move to a line, you specify its address. An address might consist of a line number, a symbol indicating a specific position in the file, or a regular expression. You can go to the first line by entering the line number 1. Then you can enter the delete command to remove that line.
1
You might think of a regular expressiond
Entering "1" makes the first line the current line, displaying it on the screen. The delete command in ed is d and here it deletes the current line. Rather than moving to a line and then editing it, you can prefix an editing command with an address that indicates which line or range of lines is the object of the command. If you enter "1d", the first line would be deleted.
You can also specify a regular expression as an address. To delete a line containing the word "regular," you could issue this command:
/regular/d
where slashes delimit the regular expression and "regular" is the string you want to match. This command deletes the first line containing "regular" and makes the line following it the current line.
NOTE: Make sure you understand that the delete command deletes the whole line. It does not just delete the word "regular" on the line.
To delete all the lines that contain the regular expression, you'd prefix the command with the letter g for global.
g/regular/d
The global command makes all lines that match the regular expression the object of the specified command.
Deleting text can take you only so far. Substituting text (replacing one bit of text with another) is much more interesting. The substitution command, s, in ed is:
[address
]s/pattern
/replacement
/flag
pattern is a regular expression that matches a string in the current line to be replaced by replacement. For example, the following command replaces the first occurrence of "regular" with "complex" on the current line.
s/regular/complex/
No address is specified, so it affects only the first occurrence on the current line. It is an error if "regular" is not found on the current line. To look for multiple occurrences on the same line, you must specify g as a flag:
s/regular/complex/g
This command changes all occurrences on the current line. An address must be specified to direct this command to act upon more than the current line. The following substitution command specifies an address:
/regular/s/regular/complex/g
This command affects the first line that matches the address in the file. Remember, the first "regular" is an address and the second is a pattern to match for the substitution command. To make it apply to all lines, use the global command, putting g before the address.
g/regular/s/regular/complex/g
Now the substitution is made everywhere - all occurrences on all lines.
NOTE: Note the different meanings of "g." The "g" at the beginning is the global command that means make the changes on all lines matched by the address. The "g" at the end is a flag that means change each occurrence on a line, not just the first.
The address and the pattern need not be the same.
g/regular expression/s/regular/complex/g
On any line that contains the string "regular expression," replace "regular" with "complex." If the address and the pattern are the same, you can tell ed by specifying two consecutive delimiters (//).
g/regular/s//complex/g
In this example, "regular" is specified as the address and the pattern to be matched for substitution is the same. If it seems that we've covered these commands quickly and that there is a lot to absorb, don't worry. We will be covering these commands again later on.
The familiar UNIX utility grep is derived from the following global command in ed:
g/re/p
which stands for "global regular expression print." Grep is a line-editing command that has been extracted from ed and made available as an external program. It is hard-wired to perform one editing command. It takes the regular expression as an argument on the command line and uses it as the address of lines to print. Here's an example, looking for lines matching "box":
$grep 'box' test
You are given a series of boxes, the first one labeled "A", label on the first box.
It prints all lines matching the regular expression.
One more interesting feature of ed is the ability to script your edits, placing them in a separate file and directing them as input to the line editor. For instance, if a series of commands were put in a file named ed-script, the following command executes the script:
ed test < ed-script
This feature makes ed a programmable editor - that is, you can script any action that you might perform manually.
Sed was created as a special-purpose editor that was meant to execute scripts exclusively; unlike ed, it cannot be used interactively. Sed differs from ed primarily in that it is stream-oriented. By default, all of the input to sed passes through and goes to standard output. The input file itself is not changed. If you actually do want to alter the input file, you typically use the shell mechanism for output redirection, and when you are satisfied with the edits you've made, replace the original file with the modified version.
ed is not stream-oriented and changes are made to the file itself. An ed script must contain commands to save the file and quit the editor. It produces no output to the screen, except what may be generated by a specific command.
The stream orientation of sed has a major impact on how addressing is applied. In ed, a command without an address affects only the current line. Sed goes through the file, a line at a time, such that each line becomes the current line, and the commands are applied to it. The result is that sed applies a command without an address to every line in the file.
Look at the following substitution command:
s/regular/complex/
If you entered this command interactively in ed, you'd substitute "complex" for the first occurrence of "regular" on the current line. In an ed script, if this was the first command in the script, it would be applied only to the last line of the file (ed's default current line). However, in a sed script, the same command applies to all lines. That is, sed commands are implicitly global. In sed, the previous example has the same result as the following global command in ed:
g/regular/s//complex/
NOTE: Understanding the difference between current-line addressing in ed and global-line addressing in sed is very important. In ed you use addressing to expand the number of lines that are the object of a command; in sed, you use addressing to restrict the number of lines affected by a command.
Sed also was designed with a number of additional commands that support script writing. We will look at many of these commands in Chapter 6, Advanced sed Commands.
Awk was developed as a programmable editor that, like sed, is stream-oriented and interprets a script of editing commands. Where awk departs from sed is in discarding the line-editor command set. It offers in its place a programming language modeled on the C language. The print statement replaces the p command, for example. The concept of addressing is carried over, such that:
/regular/ { print }
prints those lines matching "regular". The braces ({}) surround a series of one or more statements that are applied to the same address.
The advantage of using a programming language in scripts is that it offers many more ways to control what the programmable editor can do. Awk offers expressions, conditional statements, loops, and other programming constructs.
One of the most distinctive features of awk is that it parses, or breaks up, each input line and makes individual words available for processing with a script. (An editor such as vi also recognizes words, allowing you to move word by word, or make a word the object of an action, but these features can only be used interactively.)
Although awk was designed as a programmable editor, users found that awk scripts could do a wide range of other tasks as well. The authors of awk never imagined it would be used to write large programs. But, recognizing that awk was being used in this way, the authors revised the language, creating nawk to offer more support for writing larger programs and tackling general-purpose programming problems. This new version, with minor improvements, is now codified by the POSIX standard.


Coffee House to hire more women employees
New restaurant opens at Irritty today
by Staff ReporterThe Indian Coffee House Cooperative Society is planning to increase the number of women employees and start restaurants exclusively run by women.
P.V. Balakrishnan, the president of the Society, told reporters here on Friday that there were as many as 20 women working in the restaurants run by the Society in Kannur and Kozhikode districts.
The women employees were recruited on an experimental basis a few months ago. “However, they have proved themselves to be exceptional and capable of doing difficult work,” he said.
The Society had decided to increase the number of women, he said, after announcing the inauguration of another restaurant at Iritty on November 16. “However, certain questions, such as whether they can start work very early in the day or stay back late at night, bother us,” he said. Women employees also need to be provided accommodation and other facilities. Those concerns were under consideration before the opening of an exclusive hotel run by women, he added.
Mr. Balakrishnan said the implementation of the Goods and Services Tax had hit the Society hard. However, the restaurants had not changed rates and continued to provide food at affordable rates. With the inauguration of the restaurant at Iritty, the society would have a total of 29 restaurants in six districts. The Society was also thinking of launching mobile stalls at certain locations, he added.


Introduction
Before going anywhere, you must choose your templating engine. Currently, APT-Jelly has direct support for both
Jakarta Commons Jelly and Freemarker, and indirect support for Velocity
(through the merging capabilities of Jelly). The bottom line is that you'll probably want to choose Freemarker, unless you have a specific reason
for going with Jelly or Velocity. The examples in the documentation use Freemarker, but correlating examples in Jelly will be referenced where
practical. Unless explicitly stated, all APT-Jelly features and usages are applicable to both Freemarker and Jelly. For a more in-depth analysis
of your templating choices, see templating choices.
You will also want to be familiar with the Annotation Processing Tool (APT).
I'd suggest reading through the getting started page, and pay particular attention to the section on "how the apt tool operates" so as to be
familiar with what's going on in the background while generating artifacts and to be able to understand any error messages or warnings that may
turn up. You would also be well-advised to be familiar the APT Mirror
API not only to know the properties and structure of the objects available in the template data model, but also to be somewhat familiar with the
vocabulary of Java syntax.
So, shall we get started? As an admittedly contrived example, let's go through the process of generating a class that prints to
System.out a list of all classes and methods in a given source base.
Step 1: Creating the Template
We first write our template:
<@javaSource name="net.sf.jelly.apt.examples.ClassAndMethodPrinter">
package net.sf.jelly.apt.examples;
public class ClassAndMethodPrinter {
public static void main(String[] args) {
<@forAllTypes var="type">
System.out.println("${type.qualifiedName}");
<@forAllMethods var="method">
System.out.println("${type.qualifiedName}.${method.simpleName}");
</@forAllMethods>
</@forAllTypes>
}
}
</@javaSource>
Example Freemarker template for the ClassAndMethodPrinter. Click here to see
the corresponding Jelly template.
Pretty simple, no? You should be familiar with the different parts of the template. The "javaSource" directive declares that we are going to be
generating the source code for a Java class named "net.sf.jelly.apt.examples.ClassAndMethodPrinter". The body of this directive will be directed
to this Java source file, so this is where we see the Java code, including the package declaration, the class declaration, and the
main method that will do the strenuous work of printing the names of the classes and methods.
The "forAllTypes" directive iterates through each type declaration in the source base. By default, interfaces are excluded, so this will only iterate
through each class declaration. The "var" parameter on this directive indicates the name of the context variable that will be used as a reference to
the declaration over which we are currently iterating. (For more information on the "forAllTypes" directive, including how to include interfaces, see
the directive documentation.) The first thing we do for each class declaration is output the Java code that will
print out the name of the class to System.out. Note the use of the reference (sometimes called interpolation) to the
qualified name of the type.
We now iterate through each method in the current declaration with the "forAllMethods" directive (again, the context variable name is set with the "var"
parameter). We then output the Java code that writes the method to System.out in the form of
"fully.qualified.Class.[method name]".
And that's it. We close off the directives and save the file.
Step 2: Invoking APT
Now that the template is written, APT can be invoked as is described in the getting
started guide.
The name of the AnnotationProcessorFactory to use is "net.sf.jelly.apt.freemarker.FreemarkerProcessorFactory". (For a
jelly script, it's "net.sf.jelly.apt.APTJellyProcessorFactory".) The location of the template must also be passed in as a parameter using
either the "-Atemplate" option or the "-AtemplateURL" option. The first option is the path to
the template on the local filesystem. The second is a URL to the template. If both are specified, only the filesystem option will be used.
Please also note the following when invoking APT:
-
Because APT-Jelly doesn't specify the set of annotations that it processes (it processes all of them), invoking APT using the discovery procedure
is not an option. By design, APT-Jelly must be invoked using the "-factory" option. This is to eliminate any ambiguity
that could be caused when invoking APT-Jelly with other instances of AnnotationProcessorFactory that are on the path.
-
For now, APT-Jelly only processes one APT round. Any source files generated by APT-Jelly will not be processed in later rounds by APT-Jelly.
APT-Jelly itself has only a single jar, but depending on which templating engine you choose, you will need to include on the classpath the
dependencies for that engine. See the dependencies list for details. Since we're using Freemarker for our example,
the "freemarker" jar is the only dependency.
Of course, we also to include on our classpath any other jars that the source code itself depends on. For our simple example, we will assume that
our source code depends on another third-party libary that is packaged into a jar named "third-party.jar".
So as an example, let's assume our script is saved to the file "class-method-printer.fmt" and that the engine jars are named "apt-jelly.jar",
and "freemarker.jar" and put in the "lib" directory, as are all other dependant jars (in our case, just "third-party.jar").
To invoke our script on the source files found in the "src/java" directory, putting all generated artifacts into the "target/gen" directory, and
compiling all class files (including the class file associated with our generated source file) into the "target/classes" directory, we invoke
something like the following command (note it's all one line, and make sure the directory "target/classes" exists):
user@host:~>apt -cp lib/apt-jelly.jar:lib/freemarker.jar:lib/third-party.jar -s target/gen -factory
net.sf.jelly.apt.freemarker.FreemarkerProcessorFactory -Atemplate=class-method-printer.fmt -d target/classes src/java/*.java
If everything worked as it should, you'll can now invoke the main method on your generated class:
user@host:~>java -cp target/classes net.sf.jelly.apt.examples.ClassAndMethodPrinter
And you can see the generated source code in target/gen/net/sf/jelly/apt/examples/ClassAndMethodPrinter.java
NOTE: You probably noticed that the apt command is kind of verbose. You'll probably want to invoke apt using an Ant
task or IDE tool of some kind. How to do so is beyond the scope of this document, although you may be interested to know that there is a standard
ant task for APT being shipped with Ant 1.7. As of this writing, Ant 1.7 is still in beta, but the APT task works well.
Further Reading
|


---
layout: page
title: Projects
permalink: projects.html
---
Amoeba
Android FloatingActionButton with organic animations
(Work in progress)
Github
AndE
A simple, minimal file browser.
A minimal file browser app with a thumb-friendly design with essential file management options and a scrollable layout.
Google Play
MyFi
Works only on rooted phones and uses NFC to share wifi login credentials with friends with just a tap.
Google Play
Research
maybe
Make smart choices during runtime using the maybe
statement
Project link
Navjack
A city-scale sensing network using discarded mobile phones
Project link
Smartphone Disaster Mode
Using smartphones to guide users to safety during a disaster scenario
Project link


1. Pre-requirements for amplix
Install does not meet required environment to proceed.
Please check bellow steps for install and try again.
- Install the Java SDK(1.8.0 or later).
- Install MYSQL database
-
Download and extract file.
Download amplixbi.zip and extract to folder.
unzip amplixbi.zip
Copy extracted folder to application installation location, for example /opt
mv amplixbi /opt/
2. Prepare database
- Install and Start MySQL database
-
Login as root user with the following command.
mysql -uroot -p
-
Create empty database with the following command on the above database command shell.
CREATE DATABASE amplix_meta;
CREATE USER 'amplix'@'localhost' IDENTIFIED BY 'password';
-
Grant permission to database
GRANT ALL PRIVILEGES ON amplix_meta.* TO 'amplix'@'localhost';
FLUSH PRIVILEGES;
-
Create Sample database user and database (Optional)
CREATE DATABASE foodmeart;
CREATE USER 'foodmart'@'localhost' IDENTIFIED BY 'password';
Grant permission to foodmart user and database
GRANT ALL PRIVILEGES ON foodmart.* TO 'amplix'@'localhost';
GRANT ALL PRIVILEGES ON foodmart.* TO 'foodmart'@'localhost';
FLUSH PRIVILEGES;
3. Start Application.
-
Open Shell Command prompt. Execute following command.
./bin/RUN_startup.sh
./bin/RUN_startup.bat
-
Open this installation wizard on web browser, and follow instruction.
http://localhost:8080/amplix/install/
4. Stop Application.
-
To stop application, run the following command.
./bin/RUN_shutdown.sh
./bin/RUN_shutdown.bat


Booking App
Home
(current)
My Bookings
All Bookings
My Profile
Users
Login
Register
Hello
[[${#request.remoteUser}]]
Logout
Id
Username
Password
Email
Role
Enabled?
password hidden
Edit
Delete
Id
Adults
Children
Check-in
Check-out
All inclusive
Room class
Room number
Total price
Selected room
View
Edit
Delete
Back to Users


|
Contiki 2.5
|
The default Contiki UDP API is difficult to use. More...
Functions | |
| int | simple_udp_send (struct simple_udp_connection *c, const void *data, uint16_t datalen) |
| Send a UDP packet. | |
| int | simple_udp_sendto (struct simple_udp_connection *c, const void *data, uint16_t datalen, const uip_ipaddr_t *to) |
| Send a UDP packet to a specified IP address. | |
| int | simple_udp_register (struct simple_udp_connection *c, uint16_t local_port, uip_ipaddr_t *remote_addr, uint16_t remote_port, simple_udp_callback receive_callback) |
| Register a UDP connection. |
The default Contiki UDP API is difficult to use.
The simple-udp module provides a significantly simpler API.
| int simple_udp_register | ( | struct simple_udp_connection * | c, |
| uint16_t | local_port, | ||
| uip_ipaddr_t * | remote_addr, | ||
| uint16_t | remote_port, | ||
| simple_udp_callback | receive_callback | ||
| ) |
Register a UDP connection.
| c | A pointer to a struct simple_udp_connection |
| local_port | The local UDP port in host byte order |
| remote_addr | The remote IP address |
| remote_port | The remote UDP port in host byte order |
| receive_callback | A pointer to a function to be called for incoming packets |
| 0 | If no UDP connection could be allocated |
| 1 | If the connection was successfully allocated |
This function registers a UDP connection and attaches a callback function to it. The callback function will be called for incoming packets. The local UDP port can be set to 0 to indicate that an ephemeral UDP port should be allocated. The remote IP address can be NULL, to indicate that packets from any IP address should be accepted.
Definition at line 136 of file simple-udp.c.
References NULL, PROCESS_CONTEXT_BEGIN, PROCESS_CONTEXT_END, udp_bind, udp_new(), UIP_HTONS, and uip_ipaddr_copy.
| int simple_udp_send | ( | struct simple_udp_connection * | c, |
| const void * | data, | ||
| uint16_t | datalen | ||
| ) |
Send a UDP packet.
| c | A pointer to a struct simple_udp_connection |
| data | A pointer to the data to be sent |
| datalen | The length of the data |
This function sends a UDP packet. The packet will be sent to the IP address and with the UDP ports that were specified when the connection wa registered with simple_udp_register().
Definition at line 80 of file simple-udp.c.
| int simple_udp_sendto | ( | struct simple_udp_connection * | c, |
| const void * | data, | ||
| uint16_t | datalen, | ||
| const uip_ipaddr_t * | to | ||
| ) |
Send a UDP packet to a specified IP address.
| c | A pointer to a struct simple_udp_connection |
| data | A pointer to the data to be sent |
| datalen | The length of the data |
| to | The IP address of the receiver |
This function sends a UDP packet to a specified IP address. The packet will be sent with the UDP ports that were specified when the connection wa registered with simple_udp_register().
Definition at line 105 of file simple-udp.c.


Find your GP
Prototypes
Simple search (one-thing-per-page)
Use when a no-javascript solution is needed.
Enhanced search (javascript typeahead)
Use this to search on any data item instantly. This works contextually alongside other elements on the page. This requires javascript.
Pattern principals
- allow users to search by name or location
- do not assume the GP location will be in proximiy to a users home address
- confirm the practice is correct before listing GPs
- allow people to complete the transaction even if they don't know their GP


interface that takes an instance of T and typically will end up with a stream of bytes being
produced, depending on what DataInput is backed by.Implementations are often nested static classes
of Class\ in order to have access to private data
these methods affect only code that relies on DateTimeUtils.currentTimeMillis()
NOTE: manipulation of DateTimeUtils.currentTimeMillis() is not thread safe
to begin with, so neither is this
Usage of this method is not encouraged because this only
works if the TimeInterval represents a duration. If the time interval
is period, this might return unexpected values.


${category}
${title}
${body}
Click here when you are done reading
Time left: 60 sec
${answer1}
1: Bad - contains no useful information
2: Fair - marginally useful information
3: Good - partially answers the question
4: Excellent - fully answers the question
This is the best answer
${answer2}
1: Bad - contains no useful information
2: Fair - marginally useful information
3: Good - partially answers the question
4: Excellent - fully answers the question
This is the best answer
${answer3}
1: Bad - contains no useful information
2: Fair - marginally useful information
3: Good - partially answers the question
4: Excellent - fully answers the question
This is the best answer
Please Review The Following:
-- You must choose a rating for each answer
-- You must check check at least one answer as a best answer


There's a rare case when swap is actually successful but it ends up with MakerPaymentSpendFailed failed event with bad-txns-inputs-spent error from Electrum server.
It can happen when request is sent, but MM2 is stopped and event is not saved (there should be very small time window, however it's still possible).
1 of possible workarounds is to search for payment spend if it's found than there's no point in making extra requests.


On occasion, a home or building may have a Woodpecker problem or a rock dove (pigeon) problem. although we can exclude specific areas of your home such as chimneys and porch beams, we do not try to trap and relocate birds. after all, they are birds and will simply fly back
Putting a plastic or ceramic owl on your roof to scare away woodpeckers and rock dove (pigeons) only works in the short run, if it works at all. woodpeckers and rock dove (pigeons) simply habituate to (become comfortable with) the plastic owl and learn to ignore it .
Sadly, at some point you may have a dead animal on your property. if you do, your first clue will usually be the smell. decaying flesh has a very strong odor. dead animals may be found on your property for many reasons. a larger animal may be hit by a car and limp onto your property before it dies from internal bleeding. a smaller animal may become trapped in your attic or under your house and die from a lack of food and water, or from someone else putting out poison.
Contact SONORAN WILDLIFE SOLUTIONS if you need exclusion work done for woodpeckers and rock dove (pigeons), for advice on a bird or need a dead animal removed in Northwest Tucson, Oro Valley, Dove Mountain, Catalina, SaddleBrooke, and the surrounding areas
Sonoran Wildlife Solutions
520-229-7976
sonoranwildlifesolutions@gmail.com


{% extends 'base.html' %} {% load i18n %} {% load form_as_div %} {% block content %}
{% blocktrans with user.username as username %} Do you really want to delete your team {{ username }}? There is no way to undo this! {% endblocktrans %}
{% blocktrans %} Please enter your password for confirmation. {% endblocktrans %}


My responsibilities with the Volkswagen Canada mainly involve pushing regular updates of products and services live through the Adobe CQ5 Content Management System back-end. The site also contains custom pages built on PHP and mySQL, and styled with CSS and Javascript. My team at Red Urban has taken great lengths to innovate and customize the integrated components of the site, as well as optimize the site for performance and create a more efficient update procedure. Occasionally, we repurpose custom builds or adaptations from Volkswagen Germany, USA, or Britain.
Javascript, CSS, PHP.


"""
The :mod:`hotspots.hs_docking` module contains functionality which
faciliates the **automatic** application of insights from Fragment
Hotspot Maps to docking.
This module is designed to extend the existing CSD python API
More information about the CSD python API is available:
- The Cambridge Structural Database C.R. Groom, I. J. Bruno, M. P. Lightfoot and S. C. Ward, Acta Crystallographica Section B, B72, 171-179, 2016 [DOI: 10.1107/S2052520616003954]
- CSD python API 2.0.0 `documentation <https://downloads.ccdc.cam.ac.uk/documentation/API/>`_
More information about the GOLD method is available:
- Development and Validation of a Genetic Algorithm for Flexible Docking G. Jones, P. Willett, R. C. Glen, A. R. Leach and R. Taylor, J. Mol. Biol., 267, 727-748, 1997 [DOI: 10.1006/jmbi.1996.0897]
"""
from __future__ import print_function
import os
import tempfile
import numpy as np
from ccdc import docking
from ccdc import io
from ccdc import molecule
from ccdc.utilities import _private_importer
from hotspots.result import Extractor, Results
with _private_importer():
import DockingLib
DockingLib.licence_check()
[docs]class DockerSettings(docking.Docker.Settings):
"""
A class to handle the integration of Fragment Hotspot Map data with GOLD
This class is designed to mirror the existing CSD python API for smooth integration. For use, import this class
as the docking settings rather than directly from the Docking API.
>>> from ccdc.docking import Docker
>>> from ccdc.protein import Protein
>>> from hotspots.calculation import Runner
>>> from hotspots.hs_docking import DockerSettings
>>> protein = Protein.from_file("1hcl.pdb")
>>> runner = Runner()
>>> hs = runner.from_protein(protein)
>>> docker.settings.add_protein_file("1hcl.pdb")
>>> docker.settings.add_ligand_file("dock_me.mol2", ndocks=25)
>>> constraints = docker.settings.HotspotHBondConstraint.from_hotspot(protein=docker.settings.proteins[0], hr=hs)
>>> docker.settings.add_constraint(constraints)
>>> docker.dock()
>>> docker.Results(docker.settings).ligands
"""
[docs] class HotspotHBondConstraint(docking.Docker.Settings.Constraint):
"""
A protein HBond constraint constructed from a hotspot
Assign Protein Hbond constraints based on the highest scoring interactions.
:param list atoms: list of :class:`ccdc.molecule.Atom` instances from the protein. *NB: The atoms should be donatable hydrogens or acceptor atoms.*
:param weight: the penalty to be applied for no atom of the list forming an HBond.
:param min_hbond_score: the minimal score of an HBond to be considered a valid HBond.
"""
def __init__(self, atoms, weight=5.0, min_hbond_score=0.001, _constraint=None):
self.atoms = atoms[:]
for a in self.atoms:
if not self._is_protein_atom(a):
raise RuntimeError('One of the atoms is not in the protein')
if (
not (a.atomic_number == 1 and a.neighbours[0].is_donor) and
not (a.is_acceptor)
):
raise RuntimeError('One of the atoms does not form an HBond')
self._add_to_protein = atoms[0]._molecule
self.weight = weight
self.min_hbond_score = min_hbond_score
if _constraint is None:
_constraint = DockingLib.GoldProteinHBondConstraint()
_constraint.from_string(self._to_string())
super(self.__class__, self).__init__(_constraint)
@staticmethod
def _from_file(path, protein, weight, min_hbond_score=0.001, max=2):
"""
create a hotspot constraint from file
:return:
"""
constraints = Results._ConstraintData.read(path)
return [DockerSettings.HotspotHBondConstraint(atoms=[protein.atoms[index]],
weight=float(weight),
min_hbond_score=float(min_hbond_score))
for i, index in enumerate(constraints.score_by_index.values()) if i < max]
[docs] @staticmethod
def create(protein, hr, max_constraints=2, weight=5.0, min_hbond_score=0.001, cutoff=10):
"""
creates a :class:`hotspots.hs_docking.HotspotHBondConstraint`
:param `ccdc.protein.Protein` protein: the protein to be used for docking
:param `hotspots.calculation.Result` hr: a result from Fragment Hotspot Maps
:param int max_constraints: max number of constraints
:param float weight: the constraint weight (default to be determined)
:param float min_hbond_score: float between 0.0 (bad) and 1.0 (good) determining the minimum hydrogen bond quality in the solutions.
:param cutoff: minimum score required to assign the constraint
:return list: list of :class:`hotspots.hs_docking.HotspotHBondConstraint`
"""
# for atm in protein.atoms:
# atm.partial_charge = int(0)
# prot = hr.score(protein)
#
# coords = np.array([a.coordinates for a in prot.atoms])
# atm_dic = {atm.partial_charge: atm for atm in prot.atoms
# if type(atm.partial_charge) is float
# and ((atm.atomic_number == 1 and atm.neighbours[0].is_donor) or atm.is_acceptor)
# and _is_solvent_accessible(coords, atm, min_distance=2)
# }
#
# print(atm_dic)
#
# if len(atm_dic) > max_constraints:
# scores = sorted([f[0] for f in atm_dic.items()], reverse=True)[:max_constraints]
# else:
# scores = sorted([f[0] for f in atm_dic.items()], reverse=True)
constraints = hr._docking_constraint_atoms(p=protein, max_constraints=max_constraints)
return [DockerSettings.HotspotHBondConstraint(atoms=[protein.atoms[constraints.score_by_index[a]]],
weight=weight,
min_hbond_score=min_hbond_score)
for a in constraints.score_by_index.keys() if a > cutoff]
def _to_string(self):
s = '%.4f %.4f %s' % (
self.weight, self.min_hbond_score, ' '.join(str(a.index + 1) for a in self.atoms)
)
return s
def _add_fitting_points_from_file(self, path='fit_pts.mol2'):
"""
creates fitting pts from a .mol2 file
:param str path: path to fitting pts file
"""
self.fitting_points_file = path
[docs] def generate_fitting_points(self, hr, volume=400, threshold=17, mode='threshold'):
"""
uses the Fragment Hotspot Maps to generate GOLD fitting points.
GOLD fitting points are used to help place the molecules into the protein cavity. Pre-generating these fitting
points using the Fragment Hotspot Maps helps to biast results towards making Hotspot interactions.
:param `hotspots.result.Result` hr: a Fragment Hotspot Maps result
:param int volume: volume of the occupied by fitting points in Angstroms ^ 3
:param float threshold: points above this value will be included in the fitting points
:param str mode: 'threshold'- assigns fitting points based on a score cutoff or 'bcv'- assigns fitting points from best continuous volume analysis (recommended)
"""
temp = tempfile.mkdtemp()
mol = molecule.Molecule(identifier="fitting_pts")
if mode == 'threshold':
dic = hr.super_grids["apolar"].grid_value_by_coordinates(threshold=threshold)
elif mode == 'bcv':
extractor = Extractor(hr=hr, volume=volume, mode="global")
bv = extractor.extracted_hotspots[0].best_island
dic = bv.grid_value_by_coordinates(threshold=17)
else:
raise TypeError("{} not supported, see documentation for details".format(mode))
for score, v in dic.items():
for pts in v:
atm = molecule.Atom(atomic_symbol='C',
atomic_number=14,
label='{:.2f}'.format(score),
coordinates=pts)
atm.partial_charge = score
mol.add_atom(atom=atm)
fname = os.path.join(temp, 'fit_pts.mol2')
with io.MoleculeWriter(fname) as w:
w.write(mol)
self.fitting_points_file = fname
# def _is_solvent_accessible(protein_coords, atm, min_distance=2):
# """
# given a protein and an atom of a protein, determine if the atom is accessible to solvent
#
# :param protein:
# :param atm:
# :return:
# """
# if str(atm.atomic_symbol) == 'H':
# atm_position = np.array(atm.coordinates)
# neighbour = np.array(atm.neighbours[0].coordinates)
# direction = np.subtract(atm_position, neighbour) * 2
# position = np.array([direction + atm_position])
# distance = min(np.linalg.norm(protein_coords - position, axis=1))
# if distance > min_distance:
# return True
# else:
# return False
#
# else:
# return True
docking.Docker.Settings = DockerSettings


new Isntit(rulesopt, optionsopt)
A simple javascript validation library
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
rules |
Rules |
<optional> |
{} | Validation rules |
options |
Options |
<optional> |
{} | Runtime options |
Methods
(static) getCheckers() → {Checkers}
Get the collection of steps and checkers currently in use.
Returns:
The current Checkers.
- Type
- Checkers
(static) isEmpty(obj) → {boolean}
Check if an object is considered as empty.
Parameters:
| Name | Type | Description |
|---|---|---|
obj |
* | Any javascript object |
Returns:
Return if given object is empty or not.
- Type
- boolean
(static) printf(str, replacements) → {string}
Parse a string to replace placeholders.
Parameters:
| Name | Type | Description |
|---|---|---|
str |
string | The string to parse for `%{placeholder}`. |
replacements |
Object.<string, string> | A collection of placeholder: value. |
Returns:
The string with
placeholders replaced with
corresponding values.
If there is no match for
placeholder: value in
replacements, then `%{placeholder}`
will remain in the string.
- Type
- string
(static) registerChecker(checker, name, step, checkersSteps)
Register a checker. You may add a checker to a new or existing step or override an existing checker.
Parameters:
| Name | Type | Description |
|---|---|---|
checker |
Checker | The checker to register. |
name |
string | The name to use. |
step |
string | The step to register this checker to |
checkersSteps |
Array.<string> | A list of steps to use dureing validation. Note that the order matters. |
checkRules(rules) → {boolean}
Check that the format of given rules comply with the
registered checkers's TypeRule definitions.
Note : this method is only enabled when the source code is build with `config.env !== 'production'`
Note : this method is only enabled when the source code is build with `config.env !== 'production'`
Parameters:
| Name | Type | Description |
|---|---|---|
rules |
Rules | The Rules set to check |
- Source:
Returns:
Whether given Rules set comply with the Checkers type definitions.
- Type
- boolean
validate(data, rulesopt) → {boolean|Object.<string, string>}
Validate given data.
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
data |
Object.<string, *> | The data to validate. | ||
rules |
Rules |
<optional> |
this.rules | The rules to validate aginst. If omited, the rules passed to the constructor are used. |
Returns:
Returns true if all data validates or a collection of fieldName-errorMessage pairs.
- Type
- boolean | Object.<string, string>


Nodes are 1 of the 2 fundamental components in a graph
Get an array of edges that contain this node
Examples
var adjacent = node.adjacentEdges()
Returns Array<GraphEdge> array of adjacent edges
Get an array of nodes that share an edge in common with this node
Examples
var adjacent = node.adjacentNodes()
Returns Array<GraphNode> array of adjacent nodes
Test if a node is connected to another node by an edge
Parameters
node
GraphNode test adjacency between this and the supplied parameterExamples
var isAdjacent = node.isAdjacentToNode(anotherNode);
Returns boolean true or false, adjacent or not
The degree of a node is the number of adjacent edges, circular edges are counted twice
Examples
var degree = node.degree();
Returns number number of adjacent edges


--- title: Curation Magic keywords: fastai sidebar: home_sidebar summary: "Automagically curate test sets based on user given constraints" description: "Automagically curate test sets based on user given constraints" ---
Did you ever need to sub-sample a pool of samples according to a strict set of conditions? Perhaps when designing a test set for an experiment? This package provides an easy way to sub-sample a dataframe.
The user provides two dataframes: the first has the sample pool, and the second has queries over these samples, with the specification of the intended amount of samples that should satisfy each query in the curated set.
pip install curation_magic
Our goal is to curate a subset from a general pool of samples, that will satisfy a list of conditions as close as possible.
The pool of samples is given in a dataframe, which we'll call df_samples, it has one row per sample, and the columns represent all sort of meta data and features of the samples.
Let's see an example, where our general pool is the list of passengers on board the titanic (originally published by Kaggle):
# Load dataframe from file.
import pandas as pd
df_samples = pd.read_csv('csvs/titanic.csv').drop(columns='Name')
print(df_samples.head().to_markdown())
The conditions are given in a second dataframe, df_cond_abs. Each row of df_cond_abs is indexed by a query that can be applied to the df_samples (i.e. by using df_samples.query(query_string)). For each query the user specifies constraints supplied, regarding how many samples in the curated subset should satisfy the query. The constraints are given as a lower-bound and upper bound, as well as the penalty per violation (by default 1 if the penalty column not supplied). Ignore the index_ref column for now.
# Get absolute numbers constraints
df_cond_abs = pd.read_csv('csvs/curation_conditions_abs.csv').set_index('query')
print(df_cond_abs.to_markdown())
The function get_query_features_df applies all the queries on the df_samples dataframe, and we obtain df_bool, a boolean dataframe which has the samples as rows and the queries as columns. df_bool indicates which sample matches which query.
df_bool = curator.get_query_features_df(df_samples, df_cond_abs.index)
print(df_bool.head().to_markdown())
We can use this table to quickly see how many samples in our pool satisfy each query:
df_bool.sum()
abc = curator.AbsBoundariesCurator(df_samples, df_cond_abs)
# Note, we are using here the interior-point solver which is
# faster but less accurate than the default simplex solver.
included, summary = abc.run(method='interior-point')
# The summary shows how many were included from every query,
# and the total number of violations.
print(summary.to_markdown())
As you can see above, the linear solver had 9 violations, but after we decoded the solution (round the $x_j$ values and decide which samples to include), there were 13 violations in total. The optimal LP target value is always going to be a lower bound on the integer progam target.
We see that our pool has only 3 women from first-class (Pclass=1) who did not survive, so we are bound to have at least 5 violations there, since our condition on this set asks for 8 members. Our final curated set has 196 members instead of 200.
We are also missing 4 non-surviving women in general. Let's see if we can fix up this amount. We can tweak the optimization by giving a larger penalty for each violation of this constraint. Say 5 penalty points vs. only 1 penalty for the other conditions.
df_cond_abs['penalty_per_violation'] = 1
df_cond_abs.loc["Survived == 0 & Sex == 'female'", 'penalty_per_violation'] = 5
cc = curator.AbsBoundariesCurator(df_samples, df_cond_abs)
included, summary = cc.run(method='interior-point')
print(summary.to_markdown())
Goodie! This constraing is now satisfied, and we reduced the integral gap to 0 (since the actual penalty = theoretical penalty), which means we are at the optimal solution!
Now we can go back to the original samples dataframe, and add a new column indicating which samples would participate in the final set:
df_subset = df_samples[included]
print(len(df_subset))
The fact that the condition boundaties are given in absolute integer numbers is actually a limitation: Say we are willing to have some flexibility with regard to the number of negatives we curate (i.e. anything in the range 90-110 is fine), but within the chosen set of negatives, we would like 49-51% to be females. Since we don't know how many negatives we'll turn up with, there is no way to put a tight bound (in absolute numbers) on the number of negative female samples.
What we want is to be able to bound a query relative to the (yet unknown) number of samples that satisfy a previous query. So an alternative way to provide boundaries is in the form of a fraction relative to the resulting set satisfying a different query.
# Get relative fraction constraints
df_cond_rel = pd.read_csv('csvs/curation_conditions_rel.csv').set_index('query')
print(df_cond_rel.reset_index().to_markdown())
Here, index_ref column is referencing a previous constraint id. For example, in line 4, we ask that the number of samples satisfying the query [Survived == 0 & Sex == 'female'] would be at least 49% and no more than 51% of the samples satisfying query 2 [Survived == 0]. This is how we were able to define a condition relevant to the negative set without knowing how many negative we'll have at the end!
We still have to ground the solution in some absolute number of desired sample, so we used integer boundaries for the first query above, simply by setting index_ref=-1 (otherwise the solution is not well defined and the LP solver might not converge).
Let's run the RelBoundariesCurator to solve this (here with the simplex method):
cc = curator.RelBoundariesCurator(df_samples, df_cond_rel)
included, summary = cc.run()
print(summary.to_markdown())


Phenology, Data Fusion, Cartography, Geo-Statistics, Data Science, Web Development
Python, JavaScript, MATLAB, IDL, Machine Learning
GEE, AWS, Google Cloud Platform, Spark
ArcGIS, QGIS, SNAP, ENVI, Photoshop
Volleyball, Tennis, Hiking, Jogging
Ukulele, Jazz, Indie, Hip Hop, K-Pop
Traveling, Cooking, Analog Photography, Video Games
The first globally to use PlanetScope for phenological analysis over semi-arid grasslands
My responsibilities: Tested and documented the functionalities of TRAILS platform
My responsibilities: Conducted research/literature review and GIS analyses to generate new indicators/layers and demonstrated the outcomes with Esri Story Maps
My responsibilities: Developed python packages for cloud-based data preprocessing and time series analysis of Landsat data
5-month internship at Esri headquarters in California
ReadWanna get a data science job? Let's first get and Git and GitHub up and running. With this tutorial, you will be learning by doing. Plus, no prior knowledge is required!
Read


| Location | Site Name | Site Description | Max | Min | Mean | Standard Deviation | User |
|---|---|---|---|---|---|---|---|
| [[${site.getSiteLatitude().toString()}]], [[${site.getSiteLongitude().toString()}]] | University Station | Under the sea. Down here all the fish is happy, as off through the waves they roll. The fish on the land ain't happy; they sad 'cause they in their bowl, but fish in the bowl is lucky. They in for a worser fate. One day when the boss get hungry, guess who's gon' be on the plate? | 99 | 29 | 50 | 2 |


Beginners programming ContentKit
Beginning your journey towards learning to code
Hello and welcome to the "Beginners programming" ContentKit. This kit contains resources that you can use the learn and teach general programming principles and the JavaScript language. The material is divided into three sections:
- Guides: This section contains a full 8-part tutorial series that you can work through on your own, or use for collaborative learning or teaching a class. This section also contains a number of demos to demonstrate the topics in action.
- Slides: This section contains a slide deck that can be used to give a presentation on the main topic of the TopicKit.
- Slide script: This section contains notes to go along with the slide deck. We have kept these separate from the slides so they are easier to translate.
How to use this ContentKit
If you are a self-learning student, you can just open up the Guides and start learning. If you get stuck, try talking to other students, or follow some of the advice in the Getting help section below.
If you are a teacher, then a general practice for using the Content Kit is as follows:
- Make sure all the students have got a computer available, with a text editor and modern web browser available on them.
- Internet access is very useful, but not essential for this course. You should make sure that you have the complete set of course material available offline, in case Internet access is not availalble. Put it on a USB stick or CD perhaps, so it can be easily shared around all the students before the course starts.
- Get all the students to open up the Guides landing page in their browser, ready to get started.
- You should open up the Guides landing page in your browser too, but in addition have the Slides open in another tab, and also have the Slide script available to refer to in case you need guidance on presenting the slides (ideally have these open on another monitor or computer, or print them out and keep a set beside your computer.)
- Each lesson should take between 1 hour and 1 hour 30 minutes to go through.
- As well as testing the students with the exercises that you'll find in the Guides, you should feel free to add your own test questions.
- To make finding where you are up and allowing your students to follow along easier, we've included numbers on the left hand side of the Guides that match up to the slide numbers and slide script numbers. Use these to find where you are in relation to the slides if you are following along and get lost.
Getting help
When you get stuck with a programming problem and need somewhere to turn for help, life can be frustrating unless you know where to go. If you don't have a programming genius friend you can call, here are some other suggestions:
- Search wisely. Professional developers spend a large amount of time searching the Web for answers — you aren't expected to memorise everything! If you don't know how to write a piece of code or you're getting an error, go to your favourite search engine and try
- Searching for the exact error message you are getting, perhaps along with the API, method, property, etc. you are using.
- Searching for the language you are working in, plus a brief description of what you are trying to do. For example "JavaScript splitting string of text"
- Searching for the name of the library you are trying to use, along with a description of the kind of resource you are looking for, e.g. "Ember.js beginners tutorial"
- Ask a question on a forum and see if you can get an answer for it. Stack Overflow is currently the most popular forum type site for programmers. Ask your question on there. Better still, search on there first, as your question may have already been answered.
- Find a local meetup to attend, so you can get to know other people locally who are into the same programming you are doing. It is really helpful to get a network of people around you. Again, search online, for things like "JavaScript Manchester", or "Python Colarado".
Translations
No translations as yet. If you are interested in submitting one, please add it to the l10n directory in the repo, and submit a pull request.
Contact us
These resources are created in collaboration between the Mozilla MDN Technical Writers and Tech Evangelism teams. If you want to reach out to us, get in touch via the #mdn IRC channel and the dev-mdc mailing list.


CSS Buttons!
Buttons
A really very long text
Short Text
Reset
Submit
Edit
Anchors
A really very long text
Short Text
Word
Edit


Sometimes you will face issue while pushing or pulling code to git or bitbucket via your code editor or might be from terminal intself, and if the error says "access denied" then it could be due to ssh service is disabled or ssh is removed from agent. In that case you can try the following command to resolve that issue
Get-Service -Name ssh-agent | Set-Service -StartupType Manual
ssh-agent
ssh-add
git config --global core.sshCommand C:/Windows/System32/OpenSSH/ssh.exe
If you dont have ssh key setup already for git then you can follow this article for adding ssh key in github.
For bitbucket follow this article to add ssh key


The theory was first published in 2005 a press released under the name of Cliff Arnall, who at the time was a tutor at the Centre for Lifelong Learning – a Further Education centre associated with Cardiff University. Later, however, the Guardian printed a statement from the university distancing itself from the psychology professor: "Cardiff University asked us to point out that Cliff Arnall... was a former part-time tutor at the university but left in February."Blue Monday, which falls on 18 January in 2016, is allegedly the most depressing day of the year. Understandably, tightened purse strings following the festive splurge...


passionate to create, innovate and develop beautiful technology pushed me to these...
Curiosity led me to this. Most of my projects were inspiration from courses online and viewing different websites i fell in love with. the journey has been cool so far, soon to begin Andrei Neagoie's REACT section (Zero to Mastery)


Classes
AntCallBack
AntCallBack.Reference
AntFetch
AntFetch.Reference
Assert
For
ForDelegate
ForEach
IfTask
IfTask.ElseIf
OutOfDate
OutOfDate.CollectionEnum
OutOfDate.MyMapper
RunTargetTask
Switch
Throw
TimestampSelector
TryCatchTask
TryCatchTask.CatchBlock |


Stubborn is an interactive clock that is animated and alive. Its hands roam randomly, alert users when they have an event, and dance to music; only showing the time when the clock is touched.
I built Stubborn for my final project in 4.031: Design Studio - Objects & Interaction, where we were tasked with building a physical representation of time that users could interact with.
Learn more about the class I built this for here:


{% extends "site.html" %} {% block title %}payment claim{% endblock %} {% block content %}
Your payment will be reassociated with the accounts you a currently connected to.


Dear Senators and Representatives:
Please support any amendment that would strike out Sections 628, 629 and 630 from the Government Appropriations. These sections would undermine the FCC's Net Neutrality rules and prevent the agency from enforcing these critical protections. It is unacceptable to use a budget bill to circumvent the FCC's open rulemaking process that millions of citizens participated in.
The American people have called for strong net neutrality rules. Congress should let the FCC do its job, and not engage in unproductive partisan brinksmanship.
Thank you,
[Your name here]


Over the course of my career, I’ve worked with both small businesses and agency clients on creating and designing websites, photography, advertising and social media marketing. At my last contract job with Wunderman Thompson Austin, I worked for companies such as Dell and Office Depot/Office Max in building online dynamic advertisements for their various campaigns. Please shoot me an email to see a sample of these ads as they are proprietary.


{% extends "base_layout.html" %} {% block head_scripts %} {% endblock %} {% block page_detail %} {% include "show_flashed_messages.html" %} Test Images See flower classification predictions for a random sample of images from our test image dataset. #Flowers #Predictions Refresh {% for file, classification in results %} {% else %} There are no images to test. {% endfor %} {% endblock %}
See flower classification predictions for a random sample of images from our test image dataset.
There are no images to test.


{{^user}}
Welcome! Please
log in
.
{{> all_polls }} {{#user}}
Voting App
Home
(current)
My Polls
New Poll
Hello, {{ user.displayName }}.


#include <db_cxx.h> int DbEnv::repmgr_set_socket(int (*approval_func)(DB_ENV *dbenv, DB_REPMGR_SOCKET socket, int *result, u_int32_t flags));
The DbEnv::repmgr_set_socket()
method
specifies a socket callback. The socket callback enables an
application to exert additional control over the connections used by
Replication Manager.
Replication Manager creates IPv6 connections whenever possible but also supports IPv4. In cases where there are multiple addresses defined for a site, Replication Manager attempts connections first on any IPv6 addresses and then on any IPv4 addresses until one succeeds. Replication Manager relies on platform configuration settings and defaults to govern the use of IPv4-mapped IPv6 addresses in cases where one site is using IPv6 and the other site is using IPv4.
If your application requires more precise control over connections, you can use this method to provide a socket callback. The socket callback provides access to each socket before it is used in a connection attempt and provides the ability to accept or reject the socket. Within the socket callback's approval_func, you can test socket properties such as address characteristics (e.g. whether it is IPv6 or IPv4) and socket options. You can optionally change the IPV6_V6ONLY socket option to enable or disable use of IPv4-mapped IPv6 addresses. If the socket callback rejects a socket or if a connection attempt does not succeed, Replication Manager tries any other addresses defined for the site.
The only supported change to the socket in this callback is the IPV6_V6ONLY socket option. Any other changes may adversely affect the operation of Replication Manager's TCP/IP communications infrastructure.
The DbEnv::repmgr_set_socket()
method
configures operations performed using the specified
DbEnv handle, not all operations
performed on the underlying database environment.
The DbEnv::repmgr_set_socket()
method either returns a non-zero error value or throws an
exception that encapsulates a non-zero error value on
failure, and returns 0 on success.
Berkeley DB is not re-entrant. The callback function for this method should not attempt to make library calls (for example, to release locks or close open handles). Re-entering Berkeley DB is not guaranteed to work correctly, and the results are undefined.
The approval_func callback function determines whether a particular socket should be used in a connection attempt to a site. The parameters to approval_func are as follows:
dbenv
The dbenv parameter is the enclosing database environment handle.
socket
The socket parameter is the socket that is about to be used in a connection attempt to a site.
result
The result parameter is an output parameter indicating whether to use this socket. Set it to 0 to reject this socket or to a non-zero value to accept this socket.
flags
The flags parameter is currently unused.
The approval function must return 0 on success and non-zero on failure. If the approval function fails, the environment will panic.
The DbEnv::repmgr_set_socket()
method may fail and throw a DbException
exception, encapsulating one of the following non-zero errors, or return one
of the following non-zero errors:


Store all types of files
With MySpace you get 50GB of online storage for free. You can save all your documents, photos, presentations.
Access files anywhere
MySpace is available for PC, Mac, iOS, Android. No matter which platform you are on, Myspace is with you.


Home
(current)
BCP Tracker
New BCP Plan
Logout
<%= name %>
My Critical Systems
×
All fields marked with * are mandatory
What systems that you undertake in your daily role?
System Name*
<%- system -%>
System Description
<%- description -%>
Program*
<%- program -%>
Clinical Unit*
<%- unit -%>
Comment/Contact
<%- comment -%>
Activities
Add
Function
Activity
Level of Dependance
<%- table -%>


projects
acounts
Hi, we are Carlos and Ricardo.
this are some of our projects
project 1
project2
project3
follow us in github


TO THE NEW
Home
Quick Help
Bug Report
Title:
*
Description:
*
Operating System:
Windows 7
Windows 8
Windows 10
Product:
*
Formoid
Forman
Distro
Version:
*
License:
Free
Business
Severity:
Critical
Medium
None
Attatchments:


There are three types of window in RadCon.
The Log window provides the user with information.
An Edit window allows the user to edit text files
A Trees windows allows the user to view a set of trees.
Although RadCon allows multiple windows to be open only one of them can be the active window - the window on whose associated contents any choosen menu command operates.
The active window is easily identified it is the front window and a tick occurs next to its name in the list of windows in the Window menu. The active window can be changed by selecting it in the Window menu or by clicking on the window the user wishes to become active.
The Log window is a text window to which RadCon writes information for the user.
Although the contents of this window cannot be directly edited they can be saved to a text file for subsequent editing or inclusion in a document. The Save As Edit menu command saves the current contents of the Log window to a text file. However, there is an upper limit on the memory of the Log window and if this is exceeded any new text overwrites the oldest text in a process known as wrap round. Wrap round means that text of interest to the user may have been overwritten by the output of subsequent commands (or even the same command). The Log Output To Disk File menu command overcomes this problem by saving the the contents of the Log window, to a text file specified by the Output File... File menu command, as the text is written to the Log window.
The Log window uses the font defined by the PAUP Font File. If this is not installed a different font is used and the contents of the Log window are incorrectly displayed.
The Trees window allows the user to view a set of trees
The tree displayed in a Trees window can be changed using the buttons in the toolbar.
Click on a button in the toolbar to get more information.
The Trees window toolbar provides the user with various button controls.
The back button causes the window to display the previous tree in the set.
The edit bar displays the number of the tree currently being displayed in the window. Manually edit the number to go to a specific tree.
The forward button causes the window to display the next tree in the set.
The select button causes the tree which is currently being displayed to be selected or deselected.
The fast back button causes the window to display the previous selected tree in the set.
The fast forward button causes the window to display the next selected tree in the set.
The tree drawing button causes the trees to be drawn as slanted or rectangular.
The Edit window allows the user to manually edit a text file.
The Edit menu includes basic text editing commands.
Go to the Table of Contents.
This page is maintained by<EMAIL_ADDRESS>© Copyright 1999, 2000, 2001, Joseph L. Thorley and Mark Wilkinson. All rights reserved.


Helpful Hints
- In the simulation, you can tweak the PDE parameters in real time. You can also click on the surface to force the system
- Type a key to switch between drawing polygons and the simulation
- In drawing mode, click and drag your mouse to draw a polygon
- Drawing mode is dumb - If the polygon is not convex, problems occur
Enjoy!


SWCompression
A framework which contains implementations of (de)compression algorithms and functions which parse various archives and containers.
Developed with Swift.
Motivation
There are a couple of reasons for the project’s development.
The main reason is that it is very educational.
Secondly, if you are a Swift developer and you want to compress/decompress something in your project you have to use either wrapper around system libraries (which is probably written in Objective-C) or you have to use built-in Compression framework. You might think that last option is what you need, but, frankly that framework has a bit complicated API and somewhat questionable choice of supported compression algorithms. And yes, it is also in Objective-C.
And here comes SWCompression: no Objective-C, pure Swift.
Features
- Containers:
- ZIP
- TAR
- 7-Zip
- Decompression algorithms:
- LZMA/LZMA2
- Deflate
- BZip2
- Compression algorithms:
- Deflate
- BZip2
- Archives:
- XZ
- GZip
- Zlib
- Platform independent.
- Written with Swift only.
By the way, it seems like GZip, Deflate and Zlib implementations are specification compliant.
Installation
SWCompression can be integrated into your project either using CocoaPods, Carthage or Swift Package Manager.
CocoaPods
Add to your Podfile pod 'SWCompression'
.
There are several sub-podspecs in case you need only parts of framework’s functionality. Available subspecs:
- SWCompression/LZMA
- SWCompression/XZ
- SWCompression/Deflate
- SWCompression/Gzip
- SWCompression/Zlib
- SWCompression/BZip2
- SWCompression/ZIP
- SWCompression/TAR
- SWCompression/SevenZip
You can add some or all of them instead of pod 'SWCompression'
Also, do not forget to include use_frameworks!
line in your Podfile.
To complete installation, run pod install
.
Carthage
Add to your Cartfile github "tsolomko/SWCompression"
.
Then run carthage update
.
Finally, drag and drop SWCompression.framework
from Carthage/Build
folder
into the Embedded Binaries
section on your targets’ General
tab.
Swift Package Manager
Add to you package dependecies .Package(url: "https://github.com/tsolomko/SWCompression.git")
,
for example like this:
import PackageDescription
let package = Package(
name: "PackageName",
dependencies: [
.Package(url: "https://github.com/tsolomko/SWCompression.git", majorVersion: 3)
]
)
More info about SPM you can find at Swift Package Manager’s Documentation.
Options for CocoaPods users
Both ZIP and 7-Zip containers have compression method which is most likely to be used when compressing files into them. This is Deflate for ZIP and LZMA/LZMA2 for 7-Zip. Thus, SWCompression/ZIP subspec have SWCompression/Deflate subspec as a dependency and SWCompression/LZMA subspec as a dependency for SWCompression/SevenZip.
But both these containers support other compression methods, some of them are implemented in SWCompression. For CocoaPods configurations some sort of ‘optional dependecies’ are provided for such compression methods.
‘Optional dependency’ in this context means that SWCompression/ZIP or SWCompression/7-Zip will support particular compression methods only if a corresponding subspec is expicitly specified in your Podfile and installed.
List of ‘optional dependecies’.
For SWCompression/ZIP:
- SWCompression/BZip2
- SWCompression/LZMA
For SWCompression/SevenZip:
- SWCompression/BZip2
- SWCompression/Deflate
Note: If you use Carthage or Swift Package Manager you always have the full package, and ZIP will be built with both additional BZip2 and LZMA support as well as 7-Zip will be build with both additional Deflate and BZip2 support.
Usage
Basics
If you’d like to decompress deflated
data just use:
let data = try! Data(contentsOf: URL(fileURLWithPath: "path/to/file"),
options: .mappedIfSafe)
let decompressedData = try? Deflate.decompress(data: data)
Note: It is highly recommended to specify Data.ReadingOptions.mappedIfSafe
,
especially if you are working with large files, so you don’t run out of system memory.
However, it is unlikely that you will encounter deflated data outside of any archive. So, in case of GZip archive you should use:
let decompressedData = try? GzipArchive.unarchive(archiveData: data)
One final note: every SWCompression function can throw an error and you are responsible for handling them.
Documentation
Every function or class of public API of SWCompression is documented. This documentation can be found at its own website.
Handling Errors
If you look at list of available error types and their cases, you may be frightened by their number.
However, most of these cases (such as XZError.wrongMagic
) exist for diagnostic purposes.
Thus, you only need to handle the most common type of error for your archive/algorithm. For example:
do {
let data = try Data(contentsOf: URL(fileURLWithPath: "path/to/file"),
options: .mappedIfSafe)
let decompressedData = XZArchive.unarchive(archive: data)
} catch let error as XZError {
<handle XZ related error here>
} catch let error {
<handle all other errors here>
}
Sophisticated example
There is a small program, swcomp, which uses SWCompression for unarchiving several types of archives.
Performace
Usage of whole module optimizations is recommended for best performance. These optimizations are enabled by default for Release configurations.
Tests Results document contains results of performance testing of various algorithms.
Running tests locally
If you want to run tests locally you need to clone this repository and do some additional steps:
git submodule update --init --recursive
cd Tests/Test\ Files
git lfs pull
These commands fetch example archives and other files which are used for testing.
These files are stored in a separate repository.
Git LFS is also used for storing them which basically is the reason for having them in other repository.
Otherwise, using Swift Package Manager to install SWCompression is a bit challenging
(requires installing git-lfs locally with --skip-smudge
option to solve the problem).
Known issues
wrongCRC
andwrongCheck
errors for XZ and GZip multi-member archives contain only last member’s data as their associated value instead of all successfully processed members.
Comment: Philosophy for such errors is that by the time these errors are thrown, decompression was already performed, so we can still provide the result of decompression to the caller. It is intended to fix this problem, but solution requires backwards-incompatible API changes so it is delayed until 4.0 release.
Future plans
- Container API rework.
- Better Deflate compression.
- Something else…
References
- pyflate
- Deflate specification
- GZip specification
- Zlib specfication
- LZMA SDK and specification
- XZ specification
- Wikipedia article about LZMA
- .ZIP Application Note
- ISO/IEC 21320-1
- List of defined ZIP extra fields
- Wikipedia article about TAR
- Pax specification
- Basic TAR specification
- Apache Commons Compress
- A walk through the SA-IS Suffix Array Construction Algorithm
- Wikipedia article about BZip2


| WinAPI Wrapper |
There are two kinds of dialog boxes. The typical dialog boxes are modal - they hold the execution of the program. A modal dialog box has its own message loop and it disables all application windows. A dialog box can also be modeless. In this case the dialog box acts as a typical window, and has no message loop on its own. Modeless dialog boxes can be used as application windows while modal dialog boxes can be used as popup windows blocking all other windows.
Creating dialog boxes with the WinAPI Wrapper is very similar to creating regular windows, because the dialog box classes are in fact derived from the Window class. See Creating windows and controls for more information on how to create regular windows.
The main difference between dialog boxes and regular windows is that dialog boxes don't receive certain messages, like for instance WM_CREATE, WM_PAINT, WM_CLOSE, WM_KEYDOWN or WM_KEYUP. Dialog boxes receive WM_INITDIALOG instead of WM_CREATE during creation. Dialog boxes are build from dialog box templates, typically stored in application resources.
Another difference is that HandleMessage in dialog boxes doesn't have to call its ancestor's version (there is no DefWindowProc for dialog boxes).
Modal dialog boxes are derived from the Dialog class and modeless dialog boxes are derived from the ModelessDialog class. Modal dialog boxes have a Go function that is called to execute them and they call the EndDialog function to destroy themselves, while modeless dialog boxes are much more like regular windows (they destroy themselves calling Destroy).
The following example shows a simple modal dialog box:
class MyDialog: public Dialog { public: MyDialog(): Dialog( IDD_MYDIALOG ) { } virtual void OnCommand( int nIdentifier, int nNotifyCode, HWND hwndControl ) { switch ( nIdentifier ) { case IDOK: EndDialog(); break; } } };
To pop a dialog defined above and wait until the user closes it (perhaps clicking "OK"), you would call:
MyDialog dlg; dlg.Go();
The Go function returns "return code" that is the argument of the EndDialog function. Notice that the modal dialog is created statically. This is possible, because the dialog dies right before the Go function returns, but it does not destroy the dialog object. This way the dialog can "return" additional values entered by the user within the actual dialog object.
A typical modeless dialog is shown below:
class MyDialog: public ModelessDialog { public: MyDialog( HWND hwndParent = 0 ) { Create( IDD_DIALOG, hwndParent ); } virtual void OnCommand( int nIdentifier, int nNotifyCode, HWND hwndControl ) { switch ( nIdentifier ) { case IDOK: Destroy(); break; } } private: ~MyDialog() { } };
The main difference between the modeless dialog box class above and a modal dialog class is that the modeless dialog is created and destroyed like a regular window in the WinAPI Wrapper, unlike the modal dialog which object is created statically and its creation and destruction has nothing to do with the dialog object, but rather with the Go function. The following piece of code creates the dialog window defined above:
new MyDialog;
The object of the MyDialog class will be later destroyed (deleted) as a result of window destruction initiated by Destroy.
The difference between a modeless dialog and a regular window is that the modeless dialog is - like any other dialog - created from a template (and thus it receives WM_INITDIALOG instead of WM_CREATE) and that it does not have to propagate unhandled messages to the ancestor of HandleMessage.


| Mixin | Description |
|---|---|
fill-color($color) |
Sets the fill color of a card. |
outline($color, $thickness) |
Sets the color and thickness of a card's outline (but does not remove its shadow). |
shape-radius($radius, $rtl-reflexive) |
Sets the rounded shape to card with given radius size. Set $rtl-reflexive to true to flip
radius values in RTL context, defaults to false. |
media-aspect-ratio($x, $y) |
Maintains the given aspect ratio on a mdc-card__media subelement by dynamically scaling its
height relative to its width. |


| Time | Activity | Venue |
|---|---|---|
| 07:30 - 08:30 | Registration | Main Auditorium |
| 08:30 - 09:30 | Opening Ceremony | Main Auditorium |
| 09:00 - 09:30 | Debater/Adjudicator Logistical Briefing | Main Auditorium |
| 09:30 - 10:00 | Round 1 Matchup & Preparations | Main Auditorium |
| 10:00 - 12:00 | Round 1 Debates | Classrooms |
| 12:00 - 13:00 | Lunch | Canteen |
| 13:00 - 14:00 | Round 2 Matchup & Preparations | Main Auditorium |
| 14:00 - 16:00 | Round 2 Debates | Classrooms |
| 16:00 - 16:30 | Break | Canteen |
| 16:30 - 17:00 | Round 3 Matchup & Preparations | Main Auditorium |
| 17:00 - 19:00 | Round 3 Debates | Classrooms |
| 19:00 | Day One Finished |
| Time | Activity | Venue |
|---|---|---|
| 07:30 - 08:30 | Teams Check In | Main Auditorium |
| 08:30 - 09:00 | Round 4 Matchup & Preparations | Main Auditorium |
| 09:00 - 11:00 | Round 4 Debates | Classrooms |
| 11:00 - 12:00 | Lunch | Canteen |
| 12:00 - 12:30 | Round 5 Matchup & Preparations | Main Auditorium |
| 12:30 - 14:30 | Round 5 Debates | Classrooms |
| 14:30 - 15:00 | Break | Canteen |
| 15:00 - 16:30 | Thailand National Debate Council | Meeting Room |
| 16:30 - 17:00 | Breaks Announcement | Main Auditorium |
| 17:00 - 17:30 | Quarter Finals Matchup & Preparations | Classrooms |
| 17:30 - 19:00 | Quarter Final Debates | Classrooms |
| 19:00 - 21:00 | Dinner & Break Night Party | Auditorium |
| Time | Activity | Venue |
|---|---|---|
| 07:30 - 08:00 | Teams Check In | Main Auditorium |
| 08:00 - 09:00 | Semi Finals Matchup & Preparations | Main Auditorium |
| Rookie Finals Matchup & Preparations | ||
| 09:00 - 11:00 | Semi Finals / Rookie Finals Debates | Classrooms |
| 11:00 - 12:00 | Lunch | Auditorium Foyer |
| 12:00 - 13:00 | Grand Final Matchup & Preparations | Main Auditorium |
| 13:00 - 15:00 | Grand Final | Main Auditorium |
| 15:00 - 15:15 | Break | Auditorium Foyer |
| 15:15 - 17:00 | Award Ceremony | Main Auditorium |


{% extends "bg_base.html" %} {% block content %}
This is a tool use to analyse datas from git-repositories. It is a local tool developed using python and flask.
1. You need to copy the .git directory in your git repository to the [path_to_pyrepo]/app/local/projects directory.
2. Go to the root directory of pyrepo and run the script run.py
3. Open your web browser and visit localhost:9999
4. Enjoy it ^_^!


Syntax:
prog1 first-form form* => result-1
prog2 first-form second-form form* => result-2
Arguments and Values:
first-form---a form; evaluated as described below.
second-form---a form; evaluated as described below.
forms---an implicit progn; evaluated as described below.
result-1---the primary value resulting from the evaluation of first-form.
result-2---the primary value resulting from the evaluation of second-form.
Description:
prog1 evaluates first-form and then forms, yielding as its only value the primary value yielded by first-form.
prog2 evaluates first-form, then second-form, and then forms, yielding as its only value the primary value yielded by first-form.
Examples:
(setq temp 1) => 1 (prog1 temp (print temp) (incf temp) (print temp)) >> 1 >> 2 => 1 (prog1 temp (setq temp nil)) => 2 temp => NIL (prog1 (values 1 2 3) 4) => 1 (setq temp (list 'a 'b 'c)) (prog1 (car temp) (setf (car temp) 'alpha)) => A temp => (ALPHA B C) (flet ((swap-symbol-values (x y) (setf (symbol-value x) (prog1 (symbol-value y) (setf (symbol-value y) (symbol-value x)))))) (let ((*foo* 1) (*bar* 2)) (declare (special *foo* *bar*)) (swap-symbol-values '*foo* '*bar*) (values *foo* *bar*))) => 2, 1 (setq temp 1) => 1 (prog2 (incf temp) (incf temp) (incf temp)) => 3 temp => 4 (prog2 1 (values 2 3 4) 5) => 2
Side Effects: None.
Affected By: None.
Exceptional Situations: None.
See Also:
Notes:
prog1 and prog2 are typically used to evaluate one or more forms with side effects and return a value that must be computed before some or all of the side effects happen.
(prog1 form*) == (values (multiple-value-prog1 form*)) (prog2 form1 form*) == (let () form1 (prog1 form*))


Done uploading to S3!
Failed to upload to S3. Check you have configured the correct bucket in app/Config.ts
Step Functions State Machine execution ARN:
{{executionArn}}
Timed out polling Step Functions execution ARN: Check you have configured the S3 upload event to trigger the "ImageProcessingStart" Lambda function
State Machine execution Status:
{{executionStatus}}


A main target rule (e.g “exe
”
Or “lib
”) creates a top-level target. It's quite likely that you'll want to declare your own and
there are two ways to do that.
The first way applies when
your target rule should just produce a target of specific type. In that case, a
rule is already defined for you! When you define a new type, Boost.Build
automatically defines a corresponding rule. The name of the rule is
obtained from the name of the type, by downcasing all letters and
replacing underscores with dashes.
For example, if you create a module
obfuscate.jam
containing:
import type ; type.register OBFUSCATED_CPP : ocpp ; import generators ; generators.register-standard obfuscate.file : CPP : OBFUSCATED_CPP ;
and import that module, you'll be able to use the rule "obfuscated-cpp" in Jamfiles, which will convert source to the OBFUSCATED_CPP type.
The second way is to write a wrapper rule that calls any of the existing rules. For example, suppose you have only one library per directory and want all cpp files in the directory to be compiled into that library. You can achieve this effect with:
lib codegen : [ glob *.cpp ] ;
but if you want to make it even simpler, you could add the following
definition to the project-root.jam
file:
rule glib ( name : extra-sources * : requirements * ) { lib $(name) : [ glob *.cpp ] $(extra-sources) : $(requirements) ; }
which would allow you to reduce the Jamfile to
glib codegen ;
Note that because you can associate a custom generator with a target
type, the logic of building can be rather compiler.
For example, the
boostbook
module declares a target type
BOOSTBOOK_MAIN
and a custom generator for that
type. You can use that as example if your main target rule is
non-trivial.


| {{booking.booking_date | date:'dd/MMM/yyyy'}} |
{{booking.booking_id}} |
{{booking.user.displayName}} |
{{tm.displayName}},
|
{{booking.school_name}} |
{{booking.total_booking_amount}} |
{{vm.calculatePaidAmount(booking.amount_paid)}} |
{{vm.calculatePendingAmount(booking.amount_paid, booking.total_booking_amount)}} |
{{vm.calculateExpenses(booking)}} |
{{vm.onTripExpenses(booking)}} |
{{vm.calculateExpenses(booking) + vm.onTripExpenses(booking)}} |
{{vm.calculateBalance(booking)}} |
{{booking.billing[0].bill_amount}} |
{{booking.billing[0].gst_percentage}} |
VIEW |
PRINT BILL |


My very first html5 project
This is going to be a paragraph
The backgroud is grey i think? maybe blue
Give me a number
Click here!
This is the first commit using terminal


Learning Unity
The project has started off right where it should, with a healthy amount of Unity tutorials. Our team members are fairly new to Unity and to get things rolling we started with a tutorial called RollaBall, giving us exposure to fundamental unity API functions for working with game objects within the editor.
After having fun creating our first game in unity we learned how to set up a scene in the editor for various VR/AR platforms via Unity's asset store.
Taking the Leap
The entire team was excited to hear that everyone in the capstone would receive a Magic Leap One to test the capabilities of remote AR collaboration during the pandemic quarantine. It is amazing to have the opportunity to experiment with this technology and potentially incorporate it into our projects.
Embarking on our Quest
Exploring the Oculus Quest is another first for the team. The mobility and accessibility of the Quest is of great interest to the group and we are excited to how we can use this innovative new frontier of wireless VR in our project.
Wind in the Sails
Brainstorming ideas for our project's focus was more difficult than we anticipated having both VR and AR headsets at our disposal. During the initial discussions, it was clear that we wanted to create an application that would allow users to be social with one another and use the XR technologies to bridge the isolation everyone is facing.
During our discussions we discovered a common interest for the outdoors and we are fortunate to live in an area with many beautiful natural features. From the inspiration of the Puget Sound, Hands on Deck, a VR sailing experience, was born.
Team 6 is very excited to be taking on this project and welcomes you to follow us on our development through these blog posts.


pbmtoplot(1) pbmtoplot(1) NAME pbmtoplot - convert a portable bitmap into a Unix plot(5) file SYNOPSIS pbmtoplot [pbmfile] DESCRIPTION Reads a portable bitmap as input. Produces a Unix plot file. Note that there is no plottopbm tool - this transformation is one-way. SEE ALSO pbm(5), plot(5) AUTHOR Copyright (C) 1990 by Arthur David Olson. 1 September 1990 pbmtoplot(1)


NITRO UI
Modal
A modal is a dialog box/popup window that is displayed on top of the current page
Small
320px
Default
480px
Medium
640px
Large
960px
Modal Heading
✕
Woohoo, you're reading this text in a modal!
Close
Save changes
Modal Heading
✕
Woohoo, you're reading this text in a modal!
Close
Save changes
Modal Heading
✕
Woohoo, you're reading this text in a modal!
Close
Save changes
Modal Heading
✕
Woohoo, you're reading this text in a modal!
Close
Save changes


This shows all of the things you can see using xosLib
Close Detail View
{% include 'xosAdmin.html' %}


{% extends "base.html" %} {% load staticfiles %} {% load boards_tags %} {% load humanize %} {% block title %}
Member since {{ profile.member_since|naturaltime }}
You don't have any following right now.


Ticket prices are calculated using the following rules:
- Full price ticket: $12
- Matinee ticket: $9
- Senior discount (over 62): $2
- Student discount: $1
- Military discount: $2
- 3D ticket: $3 extra
- Children under two are free
Multiple discounts do not apply.


@(name: String) @main("About")(name){
The main target of this web-application is, to increase the popularity of unknown or even badly known music artists. The functionality includes user entertainment through music, user communication with comments, user upload suggestion ... All tracks we publish are free to use.


An Introduction to Gridsome
Raymond Camden
- Lead Developer Evangelist for HERE
- Enterprise Cat Demo Builder
- Second best "Just Dance 2019" player (in my house)
- Web: www.raymondcamden.com
- Twitter: @raymondcamden
Summary
Warning - Soap Box
What is Gridsome?
- Static Site Generator
- Turns into a Vue SPA
- Can be used for sites, apps, PWAs
- Powered by GraphQL
- gridsome.org
Pre-reqs
- Vue
- GraphQL
- "Knowing how GraphQL works is a plus, but not required. Gridsome is a great way to learn it."
Installation
npm install --global @gridsome/cli
New Project
gridsome create something
cd something
gridsome develop
Publish Project
gridsome build
Your site is now available at dist
!
Demo
Pages
- Single File Components
- Automatic Routing
- vue-meta included
- Can be made dynamically too
pages/Foo.vue becomes /foo
pages/Foo/Index.vue becomes /foo
pages/Foo/Goo.vue becomes /foo/goo
Demo
Linking
- Use <g-link>
- Wrapper for <router-link>
- Prefetch when link is in view
- Use a "regular" <a> for external links and anchors
My Cats
Demo
Layouts
- Wrap pages
- Can de declared globally or included in a page SFC
- Use <slot /> for the content
- Can have props!
- Can have multiple slots
- A "master" layout can be defined by adding App.vue
Demo
Components
- Put them in
src/components
- Import them
- And that's it
Data
- GraphQL server available during development
- Import data from different places
- Gridsome does a crap ton of stuff with it
- Use data in pages/components
- GraphQL Explorer automatically deployed
"Borrowed" from docs
Importing
- Importing from an API - built in
- Importing from anything else - plugin!
Importing Dynamically
- Make use of
gridsome.server.js
- Hit your API (or whatever), make a collection, add to it
- That collection is part of your GraphQL store
const axios = require('axios')
module.exports = function (api) {
api.loadSource(async actions => {
const { data } = await axios.get('https://api.example.com/posts')
const collection = actions.addCollection({
typeName: 'BlogPosts'
})
for (const item of data) {
collection.addNode({
id: item.id,
title: item.title
})
}
})
}
Markdown Specific Example
- Install the plugin:
npm i @gridsome/source-filesystem
- Install a Markdown handlers:
npm i @gridsome/transformer-remark
- Define plugin options in
gridsome.config.js
module.exports = {
siteName: 'Gridsome',
plugins: [
{
use: '@gridsome/source-filesystem',
options: {
typeName: 'BlogPost',
path: 'blog/*.md'
}
}
]
}
Templates
- Defines a path for a GraphQL collection
- Maps to a component with the same name under
templates/
Demo
Recap
- Import data into GraphQL
- Template defines a path for output and contents of files
- We aren't displaying the actual data!
Querying Data
<page-query>
<static-query>
The Query
query {
posts: allWordPressPost {
edges {
node {
id
title
}
}
}
}
Demo
Another Recap
- You find and import your data
- You query your data
- You optionally define a template to "map" your data
Dynamic Pages
- Pages via JavaScript
- Without using GraphQL
- But can use GraphQL data
- Uses
createPages
and createPage
Images
- Use <g-image>
- Automatically creates srcset versions and serves best for device
- Blurred Base64 version until in viewport (lazy loading)
- Built in resizing/cropping
- Only local images
But wait, There's more...
- Dynamic Routing
- Populating Head
- Client-side Data
- Pagination
- More and more (see docs)
Finding Help
- Docs: https://gridsome.org/docs/
- Discord: https://discord.gg/daeay6n
- Stack Overflow: https://stackoverflow.com/questions/tagged/gridsome
Thank You!
- raymondcamden.com
- @raymondcamden


WIN Virtual Library
Eat Better, Feel Better: My Recipes for Wellness and Healing, Inside and Out
Giada De Laurentiis
Eat Better, Feel Better: My Recipes for Wellness and Healing, Inside and Out
Giada De Laurentiis
Eat Better, Feel Better: My Recipes for Wellness and Healing, Inside and Out
Giada De Laurentiis


The band is coming out bigger and badder.Dont miss out on th opporturnity to share in the experience.


Use of the term ObamaCare versus ACA
Since 2009 we found over 8,000 tweets mentioning ACA or ObamaCare. Given the confusion over whether or not these are the same thing, we setout to understand how the different parties were talking about the two policies. Not surprisingly, we overwhelmingly found that Democrats tweet about "ACA" or "Affordable Care Act", while Republicans tweet about ObamaCare.
Sentiments while Tweeting
We analyzed the sentiments of the text that congresspeople were tweeting out. While we noticed that most of the tweets are neutral, we generally found that people tend to tweet while they are angry, which resulted in a lower sentiment score. Additionally, we found that there are similar sentiment patterns between Republicans and Democrats.
Immigration
Looking at the volume of immigration tweets over time by party, we can see that they follow 1 of 2 patterns: either the volume of Democrat and Republican tweets peaks at the same time, or Democrats peak while Republicans dip. Examining these peaks gives us insight into starkly disparate party views on immigration.
Planned Parenthood
Planned parenthood has been a hot topic over the last three years, with a ton of mis information on both sides of the aisle. Given how many Democrats talk about women's health and planned parenthood funding, we hypothesized that democrats would tweet about Planned Parenthood alot. However, we were surprised to find that it was, in fact, republicans who tweet at 1.5X the rate of democrats on planned parenthood.


{% block head %}
{% block title%}{% endblock%}
{% endblock%}
Home
About
Professors
Courses
Wang Peiyu
{% block page_content%} {% endblock%} {% block scripts%} {% endblock%}


Toggle navigation
Fin' IT!
User Profile
Settings
Logout
Home
Dashboard
Stats
New Transaction
Forum
Admin
UI Elements
Panels and Wells
Buttons
Notifications
Typography
Icons
Grid
Sample Pages
Login Page
New transaction
Title:
Amount:
Account Type:
Cash
Debit
Credit
E-wallet
Description:
Date:
To
From
Whom:


Ananya Panday’s Latest Look Is A Perfect Combo Of HOT & Cool!
Ananya aced the look like always and we are totally loving every bit of it!
by Koimoi.com TeamAnanya Panday is a bonafide trendsetter and much of this can be credited to how she always creates her own statement. She is extremely popular in the youth for her immense fashion sense and is hailed as the ‘Youth Influencer’.
Ananya who is busy promoting her latest movie “Pati Patni Aur Woh” stepped out for the event last evening in a head-turning all-black ensemble.
Although it is not arduous for Ananya to swaddle herself in the trendiest of outfits and showcase her sense of style every time she steps out, she does it with so much ease and the outcome is impeccable- looking like a vision always. Dressed in a corseted black dress that highlighted her frame and high heels, Ananya was at her sartorial best. Keeping the accessories to a bare minimum, she allowed her outfit to take the center stage. Ananya paired her look with open, brown smokey eyes, nude lips and sculpted cheeks.
The teen sensation took to her Instagram handle to share her ravishing photos and captioned it, “It was the bumble bee and butterfly that survived, not the dinosaur 🐝 ”
“be as picky with people as u are with ur pictures 🤪”
Evidently, being a la mode and glamorous, Ananya aced the look like always and we are totally loving every bit of it!
The Youth icon recently launched the “Swachh Social Media” initiative on the account of Gandhi Jayanti with her initiative So Positive. On the work front, Ananya will be seen in Pati Patni Aur Woh opposite Kartik Aryan which is slated to release in December 2019 and Khaali Peeli opposite Ishaan Khatter that will hit the screens on 12th June 2020.


Good Robotics Cloud is a platform for integrating indavidual robots into a managed collective with shared perceptual resources...blahblah
Good Robotics Cloud enables robot builders to cloud source mapping, weather, and recognition. Good Robotics Cloud is a data collection system that collects real time data and makes it available to a global community.
Interplanetary Exploration is an immersive social network for robots combining realtime data from sources all over the world into a central community. Users create their own robots to add into the platform, and play in gamified missions to explore the Universe in new and exciting ways.


| Package | Description |
|---|---|
| edu.cmu.sphinx.linguist.language.classes | |
| edu.cmu.sphinx.linguist.language.grammar |
Provides classes and interfaces that can be used to represent a graph of words and word transitions.
|
| edu.cmu.sphinx.linguist.language.ngram |
Provides classes and interfaces that represent a stochastic language model
|
| edu.cmu.sphinx.linguist.language.ngram.large |
Provides an implementation of the LanguageModel interface.
|
| edu.cmu.sphinx.linguist.lextree |
Provides an implementation of the
Linguist that
represents the search space as a lex tree. |
| edu.cmu.sphinx.result |
Provides a set of classes that represent the result of a recognition.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ClassBasedLanguageModel
An LM that computes a probability of a word sequence by converting words to
classes and asking the class-based probability from a delegate LM.
|
| Constructor and Description |
|---|
ClassBasedLanguageModel(ClassMap classMap,
LanguageModel classLM) |
| Constructor and Description |
|---|
LMGrammar(LanguageModel languageModel,
boolean showGrammar,
boolean optimizeGrammar,
boolean addSilenceWords,
boolean addFillerWords,
Dictionary dictionary) |
| Modifier and Type | Class and Description |
|---|---|
class |
DynamicTrigramModel
3-gram language model that can change its content at runtime.
|
class |
InterpolatedLanguageModel
Simple interpolated LM implementation.
|
class |
KeywordOptimizerModel |
class |
NetworkLanguageModel |
class |
SimpleNGramModel
An ASCII ARPA language model loader.
|
| Constructor and Description |
|---|
KeywordOptimizerModel(LanguageModel parent) |
| Constructor and Description |
|---|
InterpolatedLanguageModel(List<LanguageModel> languageModels,
float[] floats) |
| Modifier and Type | Class and Description |
|---|---|
class |
KeywordOptimizerLargeNGramModel
Use a largeNGramModel that also can be adjusted depending on context.
|
class |
LargeNGramModel
Language model that uses a binary NGram language model file ("DMP file")
generated by the SphinxBase sphinx_lm_convert.
|
class |
LargeTrigramModel
A wrapper for LargeNGramModel base on the old LargeTrigramModel class.
|
| Modifier and Type | Method and Description |
|---|---|
LanguageModel |
LexTreeLinguist.getLanguageModel()
Retrieves the language model for this linguist
|
| Constructor and Description |
|---|
LexTreeLinguist(AcousticModel acousticModel,
UnitManager unitManager,
LanguageModel languageModel,
Dictionary dictionary,
boolean fullWordHistories,
boolean wantUnigramSmear,
double wordInsertionProbability,
double silenceInsertionProbability,
double fillerInsertionProbability,
double unitInsertionProbability,
float languageWeight,
boolean addFillerWords,
boolean generateUnitStates,
float unigramSmearWeight,
int maxArcCacheSize) |
| Modifier and Type | Field and Description |
|---|---|
protected LanguageModel |
LatticeRescorer.model |
| Constructor and Description |
|---|
LatticeRescorer(Lattice lattice,
LanguageModel model)
Create a new Lattice optimizer
|
Copyright © 2017. All rights reserved.


Setting my default map location for notifications and searches
Setting map location is only used when logged in.