OxO is an database of ontology cross-references (xrefs) extracted from public ontologies and databases. Most of these cross-references have been extracted from ontologies in the Ontology Lookup Service by searching for database cross-reference annotations on terms. We have supplemented these cross-references with mappings from a subset of vocabularies in the UMLS.
The semantics of a cross-reference are weakly specified, in most cases they mean some kind of operational equivalence, but there is no guarantee. Sometimes cross-references are used to indicate other types of relationships such as parent/child or that the terms are related in some other way (such as linking a disease concept to a pathway accession that is somehow related to that disease). OxO aims to provide simple and convenient access to cross-references, but is not a mapping prediction service, so always treat these xrefs with caution, especially if you are seeking true equivalence between two ontologies.
OxO gives you access to existing mappings, you can also explore the neighbourhood of a mapping using the distance controller. By default OxO shows you direct asserted mappings, but you can use the slider on various pages to look for mappings that are up to three hops away. You may see some terms that don't have labels associated to them, we are doing our best to find labels for all of these terms, but sometimes the labels are missing from the sources that we extract mappings from.
OxO is developed by the Samples, Phenotypes and Ontologies team. If you have any questions about OxO please contact us.


Bre Pettis and Kio Stark
THE CULT OF DONE MANIFESTO
- There are three states of being. Not knowing, action and completion.
- There is no editing stage.
- Pretending you know what you’re doing is almost the same as knowing what you are doing,
so just accept that you know what you are doing
what you’re doing even if you don’t and do it
- Banish procrastination. If you wait more
than a week to get an idea done, abandon it.
- The point of being done is not to finish but
to get other things done.
- Once you’re done you can throw it away.
- Laugh at perfection. It’s boring and keeps
you from being done.
- People without dirty hands are wrong.
Doing something makes you right.
- Failure counts as done. So do mistakes.
- Destruction is a variant of done.
- If you have an idea and publish it on the
internet, that counts as a ghost of done.
- Done is the engine of more.


WORD
X
HOME
ABOUT
CONTACT
WORD
X
WE ARE GREAT AT SPREADING THE WORD
The Developement Of Language Is Part Of The Developement Of
The Personality, For Words Are The Natural Means Of
Expressing Thoughts And Establishing Understanding Between
People
Maria Montessori
SIGN UP
WORD
X


Hi, everyone! Welcome back to my Machine Learning page today. I have been playing around with Caffe for a while, and as you already knew, I made a couple of posts on my experience in installing Caffe and making use of its state-of-the-art pre-trained Models for your own Machine Learning projects. Yeah, it’s really great that Caffe came bundled with many cool stuff inside which leaves developers like us nothing to mess with the Networks. But of course, there comes sometime that you want to set up your own Network, using your own dataset for training and evaluating. And it turns out that using all the things which Caffe provides us doesn’t help Caffe look less like a blackbox, and it’s pretty hard to figure things out from the beginning. And that’s why I decided to make this post, to give you a helping hand to literally make use of Caffe.
Before getting into the details, for ones that missed my old posts on Caffe, you can check it out anytime, through the links below:
Now, let’s get down to business. In today’s post, I will mainly tell you about two points below:
Downloading your own dataset
Preparing your data before training
Training with your prepared data
So, I will go straight to each part right below.
1. Downloading your data
I think there’s a lot of ways which everyone of you managed to get your own dataset. If your dataset has been already placed on your hard disk, then you can skip the Downloading section and jump right into the Preparing section. Here I’m assuming that you do not have any dataset of your own, and you’re intending to use some dataset from free sources like ImageNet or Flickr or Kaggle. Then it’s likely that: you can directly download the dataset (from sources like Kaggle), or you will be provided a text file which contains URLs of all the images (from sources like Flickr or ImageNet). The latter seems to be harder, but don’t worry, it won’t be that hard.
This kind of download is quite easy. Here I will use the Dogs vs. Cats dataset from Kaggle for example. You can access the dataset from the Download page: Dogs vs. Cats. All you have to do is just register an account, then you can download the whole dataset. There are two of them, one for training purpose, which was named train, and one for evaluating, which was named test1 respectively. I suggest that you should download the training set only. I will explain why when we come to the Preparing section. The file size is quite large so it should take a while to finish. And that’s it. You have the dataset stored on your hard disk!
As you could see above, it’s great if every dataset was zipped and provided directly to developers. But in fact, due to the copyright of the images (as well as other data types), providing data that way isn’t simple, especially when we talk about an extremely large dataset like ImageNet. So data providers have another way, which is providing you the URLs only, and you will have to access to the image hosts yourself to download the data. I will use a very famous site for example, which is ImageNet, the site which holds the annual ILSVRC. You can read more about ILSVRC here.
First, let’s go to the ImageNet’s URLs download page: Download Image URLs. All you need to know to get the URLs is something called WordNet ID (or wnid). You can read more about ImageNet’s dataset and WordNet to grab some more details because this post will be too long if I explain it here. To make it simple right now, ImageNet uses WordNet’s synset, such as n02084071, n02121620 which represents dogs and cats respectively, to name its classes. To find out what the synset of a particular noun, just access Noun to Synset, then search for any noun you want, then you will see the corresponding synset.
Once you knew the synset, you can download the URLs by going to this page:
http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=[wnid], which [wnid] is the synset of the object you want to download data for. For example, let’s use two synsets above, to download the URLs of the Dogs and Cats images of ImageNet:
Dogs: http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=n02084071
Cats: http://www.image-net.org/api/text/imagenet.synset.geturls?wnid=n02121620
If you access the links above, you will see something like this:
So, the next thing to do is just simple, you have to copy those URLs and paste somewhere, let’s say a text file or something. With ones who are familiar with Linux commands, you can see that we can use wget to grab all the images with ease. But there’s some problem here: using wget is hard to rename the images as wget will use the name right in each URL to name each image. Training your own data with CNN on Caffe may not require any naming rules, but if you have intention to use your own data in other places, for example, the state-of-the-art Faster R-CNN, then the naming convention does matter! And as far as I know, we can manually rename all the images while downloading using wget, but it requires some experience in Linux commands, and to be honest, I tried and failed. But don’t worry, I found the solution for that!
You know that Caffe provides us so many useful tools, to help us do all the heavy things so that we can use all the pre-trained Models without worrying about the data preparation, which means that, if you want to play with MNIST, Caffe provides you the script to download MNIST, if you want to play with CIFAR-10, Caffe got a script to download CIFAR-10 too. So, we can make use of the tools Caffe provides, and modify a little to make it work with our data. Not so bad, right?
All you have to do, is to make use of the tool which Caffe uses to download Flickr’s images for fine-tuning (I will tell you about fine-tuning in the second part, so don’t care about that term). Open your terminal, and type the commands below (make sure that you are in the root folder of Caffe):
What we just did, is to create the neccessary folders for storing the script (./examples/DogsCats) and the images (*./data/DogsCats), then we copied the script to download Flickr’s images to our new folder. Obviously, we have to make some changes in order to make it work properly, just some minor changes.
First, let’s go to ./examples/DogsCats folder, unzip the flickr_style.csv.gz to get a CSV file named flickr_style.csv. Open it up, take a look at the file. There are five columns but just three of them are actually used: image_url, label and _split. The image_url column stores all the URLs to all the images, the label column stores the label values, and the _split column tells whether each image is used for training or evaluating purpose.
As I mentioned earlier, we are not only downloading the images, but also renaming it, so we will use an additional column to store the name associating with each image URL, which I chose column A for that task. Before making any changes, let’s deleting all the records, except the first row. Then, let’s name cell A1 image_name. Next, in the image_url column, paste all the URLs of each class. Note that we won’t paste all the URLs of all classes at once, since we have to labeling them. After pasting all the URLs of one class, let’s say the Dogs class with n02084071 synset, we will fill the image_name column. Start from cell A2, let’s fill that it will n02084071_0 then drag until you see the last URL in image_url column. Don’t forget to add the .jpg extension when you finish (just use the CONCATENATE function).
Next, we will label the images we have just added URLs for. In the label column, let’s fill with 0 until the last row containing URL. Since all URLs we pasted belong to Dogs, so they will have the same label. And lastly, let’s fill in the _split column. In case of the Dogs’ images, we have 1603 images in total, so let’s fill train for the first 1200 images and test for the rest (here the train:test ratio I chose is 0.75:0.25). After all, your CSV should look similar to this:
And we can continue with other classes’ images, don’t forget to increase the value of label column each time you add another class’s URLs.
So, we have done with the CSV file, let’s go ahead and modify the Python script (make sure that you are in the root folder of Caffe):
First, let’s replace all the phrase data/finetune_flickr_style with *data/DogsCats. That value tells where to store the downloaded images, so we have to point to our new created folder. Next, make some changes like below:
That’s it. And now we are ready to download the images, and have them renamed the way we wanted:
It will take a while for the script to run. Note that many of the URLs are inaccessible at the time of writing, since many of them were added quite so long ago. So if you notice that the number of downloaded images is not equal to the number of URLs, don’t be confused.
 So now your dataset is ready for the next stage!
2. Preparing the data before training
So we just managed to have the desired dataset stored on your hard disk. And believe me or not, we have just completed the most time-consuming task! Before we can train our Network using the data we have just downloaded, there’s some things we need to do. First, we need to convert the downloaded images into the format that the Networks can read. In fact, the Networks in Caffe accepts not just one kind of input data. As far as I know, there are three different ways to prepare our images so that the Networks can read them, and I’m gonna tell you about two of them: normal format and LMDB format. And second, we need to provide one special image called the mean image. Okay, let’s get into each of them.
Let’s first talk about the data conversion. As I said above, we have two choices. You can choose whether to use the normal format (leave the images untouched after downloaded), or to convert them to LMDB format. In both cases, you have to create two files called train.txt and text.txt. What the two files do is to tell our Network where to look for each image and its corresponding class. To understand better, let’s go and create them.
I’m gonna use the Dogs vs Cats dataset which we downloaded from Kaggle (because we haven’t touched it yet, have we?). Let’s create two similar folders just like we did above with ImageNet’s images, one for storing the images, and one for storing the necessary scripts:
Then, let’s place the zip file which we downloaded from Kaggle into ./data/DogsCatsKaggle folder and upzip it. After unzipped, all of the images will be stored into the subfolder called train. Next, we’re gonna create the train.txt and test.txt files. Let’s go into the ./examples/DogsCatsKaggle folder and create a Python file, name it create_kaggle_txt.py and fill the codes below:
Then, all you have to do is to execute the Python script you have just created above:
Now let’s jump into ./data/DogsCatsKaggle, you will see train.txt and test.txt has been created. And that’s just it. We have finished creating the two mapping files for Dogs vs Cats dataset from Kaggle!
So, what about the Dogs and Cats images from ImageNet? Well, you may want to take a look at ./data/DogsCats. Voila! When were the two files created? - You may ask. They were created when you ran the script to download the images!  That was great, right? Now we got the images, the mapping text files ready, there’s only one step left to deal with the data: create the mean image.
Why do we need the mean image anyway? First, that’s just one type of Data Normalization, a technique to process our data before training. As I told you in previous post, the final goal of the learning process is finding the global minimum of the cost function. There’s many factors that affect the learning process, one of which is how well our data was pre-processed. The better it is pre-processed, the more likely our Model will learn faster and better.
The goal of computing the mean image is to make our data have zero mean. What does that mean? For example, we have a set of training data like this: \(x^{(1)}, x^{(2)}, \dots, x^{(m)}\). Let’s call \(x_\mu\) the mean value, which means:
Next, a new set of data will be created, where each \(x_{new}^{(i)}=x^{(i)}-x_\mu\). It’s easy to see that the mean value of the new dataset is zero:
So, above I just showed you a short explanation about one type for Data Normalization, which subtracting by the mean value to get a new dataset with zero mean. I will talk more about Data Normalization in future post. Now, how do we compute the mean image? As you may guess, of course Caffe provides some script to deal with some particular dataset. And we’re gonna make use of it with some modifications! But before we can compute the mean image, we must convert our images into LMDB format first.
But first, why LMDB? Why is LMDB converting considered recommended, especially when we are working with large image database? To make it short, because it helps improving the performance of our Network. At present, performance is not all about accuracy anymore, but required to be both fast and accurate. With a same Network and a same dataset, how the data was prepared will decide how fast our Network learns. And LMDB conversion is one way (among many) which helps accomplish that. And the trade-off? The converted LMDB file will double the size of your downloaded images, since your images were decompressed before being converted (that’s one reason why our Network performs faster with LMDB file, right?)
Next, let’s copy the necessary script that we will make use of. I will use Dogs vs Cats dataset from Kaggle for example.
To convert the downloaded Dogs vs Cats dataset to LMDB format using the script above, we will have to make some changes. But it’s not a big deal at all because all we have to change is just the correct path to our images and the mapping text files. Below is the lines which I have applied changes for your reference:
Next, let’s go ahead and run the script above:
It will take a while for the conversion to complete. After the process completes, take a look at ./examples/DogsCatsKaggle folder, you will see two new folders which are named dogscatskaggle_train_lmdb and dogscatskaggle_val_lmdb, and new LMDB files were placed inside each folder, created from the training data and test data respectively.
After creating LMDB files, making the mean image is no other than one last simple task to complete. All we have to do is to copy and apply some tiny changes into the script which computes the mean image.
And here’s what it looks after modified:
And, only one last command to execute:
And that’s it. Let’s go into ./data/DogsCatsKaggle folder, you will see one new file called dogscatskaggle_mean.binaryproto, which means that the mean image was created successfully!
3. Training with your prepared data
So now you nearly got everything ready to train the Network with the data prepared by yourself. The last thing is, of course, the Network! At this time, you may want to create a Network of your own, and train it using the data above (of your own, too!). But I recommend you try some available Networks which is provided by Caffe, some of which are very famous such as VGG16 or AlexNet. Let’s pick AlexNet for now since it’s quite simpler than VGG16, which will make it train faster. We need to create one new folder and copy the necessary files for Network definition. And for your information, Caffe uses the protobuf format to define the Networks, which you can read for details here: Protocol Buffers.
Let’s first modify the solver.prototxt first. This file stores the necessary information which the Network needs to know before training, such as the path to the Network definition file, the learning rate, momentum, weight decay iterations, etc. But all you need to do is just to change the file paths:
Next, we will make change to the Network definition file, which is the train_val.prototxt file. In fact, it was nearly set up and we only need to modify a little bit. First, we have to tell it where to look for your prepared data. And second, we must change the output layer, since our dataset only contains two classes (change this accordingly if you have a different dataset with me). Now open up the file, you will see the first two layers are the data layers, which provide the input to the Network. Stanford University has an excelent tutorial on defining the Network in Caffe at here: Caffe Tutorial.
Let’s change the path to the mean image and two LMDB folders which we created above:
And there’s only one place left to change: the output layer. Let’s look through the file to find the layer named fc8, that’s the last layer of our Network. It now has 1000 outputs because it was created to train on full ImageNet’s images. Let’s change the number of output according to our dataset:
Then save the file and that’s it, you can now train the Network with your own dataset! We can’t wait to do it, can we?
Our Network should be running flawlessly now. And all we have to do is wait until it’s done! We have come a long way until this point. So I think we deserve a cup of coffee or something. That was so fantastic! You all did a great job today.
So in today’s post, I have shown you how to train the Network in Caffe, using your own dataset. We went through from how to download the data from URLs file (or directly from host), how to prepare the data to be read by the Network and how to make change to the Network to make it work using our dataset. As you could see, it was not so hard, but it did require some time to dig into. I hope this post can save you quite some of your previous times, and instead, you can spend them on improving your Network’s performance. And that’s all for today. Thank you for reading such a long post. And I’m gonna see you again in the coming post!


CSW - OGC CSW (Catalog Service for the Web)
(GDAL/OGR >= 2.0)
This driver can connect to a OGC CSW service. It supports CSW 2.0.2 protocol.
GDAL/OGR must be built with Curl support in order to the
CSW driver to be compiled. And the GML driver should be set-up for read support
(thus requiring GDAL/OGR to be built with Xerces or Expat support).
It retrieves records with Dublin Core metadata.
Dataset name syntax
The minimal syntax to open a CSW datasource is : CSW: and the URL open option,
or CSW:http://path/to/CSW/endpoint
The following open options are available:
- URL: URL to the CSW server endpoint (if not specified in the connection string already)
- ELEMENTSETNAME=brief/summary/full: Level of details of properties. Defaults to full.
- FULL_EXTENT_RECORDS_AS_NON_SPATIAL=YES/NO: Whether records with
(-180,-90,180,90) extent should be considered non-spatial. Defaults to NO.
- OUTPUT_SCHEMA=URL : Value of outputSchema parameter, in the restricted
set supported by the serve. Special value gmd can be used as a shortcut for
http://www.isotc211.org/2005/gmd, csw for http://www.opengis.net/cat/csw/2.0.2.
When this open option is set, a raw_xml field will be filled with the
XML content of each record. Other metadata fields will remain empty.
- MAX_RECORDS=value : Maximum number of records to retrieve in a single time.
Defaults to 500. Servers might have a lower accepted value.
Filtering
The driver will forward any spatial filter set with SetSpatialFilter() to
the server. It also makes its best effort to do the same for attribute
filters set with SetAttributeFilter() when possible
(turning OGR SQL language into OGC filter description).
The anytext field can be queried to do a search in any text field. Note that
we always return it as null content however in OGR side, to avoid duplicating information.
Issues
Some servers do not respect EPSG axis order, in particular latitude, longitude
order for WGS 84 geodetic coordinates, so it might be needed to specify
the GML_INVERT_AXIS_ORDER_IF_LAT_LONG=NO configuration option in those cases.
Examples
Listing all the records of a CSW server:
ogrinfo -ro -al -noextent CSW:http://catalog.data.gov/csw
Listing all the records of a CSW server with spatial and an attribute filter on a give field:
ogrinfo -ro -al -noextent CSW:http://catalog.data.gov/csw -spat 2 49 2 49 -where "subject LIKE '%mineralogy%'"
Listing all the records of a CSW server that matches a text on any text field:
ogrinfo -ro -al -q CSW:http://catalog.data.gov/csw -spat 2 49 2 49 -where "anytext LIKE '%France%'"
Listing all the records of a CSW server as ISO 19115/19119:
ogrinfo -ro -al -q CSW:http://catalog.data.gov/csw -oo OUTPUT_SCHEMA=gmd
See Also


Previous
Next
Bootstrap 4.3.1
jQuery 3.4.1


The speed dial supports many advanced usage scenarios. This demo shows many of them mixed together... and even includes a Toolbar - SpeedDial combination.
Each action item supports a tooltip using the standard approach as can be seen above.
The speed dial also supports hiding using the standard ng-hide
attribute. View
the source to see how to apply the animation effect.
You can easily use ng-repeat
with the speed dial, but it requires a slightly
different HTML structure in order to support the necessary DOM changes/styling.
Simply ensure that your ng-repeat
is on a div
(or any other tag)
that wraps your items.
You can also easily setup the speed dial to open on hover using the
ng-mouseenter
and ng-mouseleave
attributes.
If you want the user to be able to hover over the empty area where the
actions will eventually appear, you must also add the
md-hover-full
class to the speed dial element.
Notice that in "full hover" mode, you cannot click on the last "Test" buttons on the toolbar as they are hidden by the speed dial. See the example code and docs for more information.
You can also use the buttons to open a dialog. When clicked, the buttons above will open a dialog showing a message which item was clicked.


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Yugo-Tech Conversion Gas Systems Inc.
Legal/Operating Name:
Yugo-Tech Conversion Gas Systems Inc.
Mailing Address:
16-1050 Britannia Rd EMISSISSAUGA, Ontario
L4W 4N9
Location Address:
16-1050 Britannia Rd EMISSISSAUGA, Ontario
L4W 4N9
Tel.:<PHONE_NUMBER>
Fax:<PHONE_NUMBER>
Company Profile
Yugo-Tech is a Canadian designer, manufacturer, supplier and installer of both natural gas (CNG) and propane (LPG) vehicle conversion systems. Yugo-Tech was incorporated as a company in Mississauga, Ontario, Canada in July 1987 by Mr. Joco Djurdjevic. Mr. Djurdjevic was previously with CNG Fuel Systems, which was one of the largest natural gas vehicle conversion design companies at that time. With the demise of CNG Fuel Systems in 1987, Yugo-Tech became one of the largest natural gas vehicle conversion equipment installers in Ontario. In 1995 Yugo-Tech entered into the propane conversion industry with an agreement with Superior Propane, one of the largest propane distributors in Canada. Yugo-Tech now handles all of the Superior Propane vehicle conversions in the Toronto and Southern Ontario area. Yugo-Tech works closely in conjunction with the local Gas and Propane Utilities in the development new industry products.
The following is a list of a few of the major companies using Yugo-Tech conversion systems and components in the local area:
Ontario Hydro; Canada Post; Peel Regional Police Dept.; Fed Ex Courier; City of Etobicoke; Windsor Public Utilities; Natural Gas Conversion Co. (Conn. USA); City of Regina; Contract Cable; Union Gas; Centra Gas; Gaz Metropolitan (Montreal); City of Brampton; Minnigasco (Minneapolis USA); Ontario Bus Industries; Bus Industries of America; Atripco Courier; Region of Peel.
Products
Yugo-Tech manufactures conversion systems for both natural gas (CNG) and propane (LPG) alternate fuels. Yugo-Tech manufactures a wide variety of equipment to suit the requirements of the market. For the export market, we specialize in manufacturing "custom" conversion systems to suit the technical requirements of the target market that will fit into the local economy of the host country.
Yugo-Tech manufactures in house electronic Computer Interface Modules (CIM) that are the only "programmable" modules in the industry. These modules are ideally suited for export, as they can be programmed for different types of vehicles on location, thus reducing the need for
excess inventory. The programmability also allows for the fine tuning of the conversion for maximum vehicle performance and minimum emissions. Yugo-Tech also manufactures many other smaller components such as switches, gauges and brackets. Yugo Tech holds patents
on several innovative equipment designs.
Yugo-Tech is introducing the industries first, Sequential Injection, conversion system to the market. The new conversion system is being marketed as the "SEQUIN" conversion, which is an acronym for SEQUential INjection. This system is fully OBD 11 compatible and therefore
eliminates the "check engine light" problems associated with the conversion systems of the past. This system offers unrivalled features with improved engine performance, reduced emissions and driveability. The system is truly an invisible conversion system, offering all the features that the vehicle manufacturers fueling system offers. Computer controlled Sequential Fuel Injection is the only appropriate method of
converting the new generation vehicles with their constant upgrading and refinements of the engine diagnostic systems.
Yugo-Tech has designed and developed a conversion system for two-stroke engines for use on "Autorickshaws" and motorcycles. This conversion system is aimed mainly at the markets in the Far East where the two-stroke engines are used in abundance to power Autorickshaws and motorcycles. These vehicles make up the majority of the vehicles in these markets and therefore generate the majority of
the air pollution.
Current Geographic Marketing Activity
At the present time Yugo-Tech exports to the Unites States in limited quantities. We are set up and represented in India, Pakistan, China, Bangladesh, Egypt and are developing representation in Indonesia and Thailand. At the present time we are involved in Pilot Projects in
both Pakistan and India.
Geographic Marketing Properties/Marketing Strategy
For the international export market, Yugo-Tech will design and develop custom conversion systems to suit the technical requirements of the target market vehicles that will be affordable to the economics of the host country market. This will allow the use of appropriate conversion technology to reduce the harmful tailpipe emissions and reduce vehicle-operating costs at a cost that will promote the use of alternate fuels
and conversion systems.
In North America, Yugo-Tech is promoting the use of the Sequential Injection conversion system. Yugo-Tech feels this system is so advanced that it will be the only technical approach that will allow the conversion of new vehicles as we enter into the next century.
Technology Showcase
"SEQUIN"
YUGO-TECH'S THIRD GENERATION NATURAL GAS CONVERSION SYSTEM
The name SEQUIN is an acronym for "SEQUential INjection". The SEQUIN conversion system is Yugo-Tech's Third Generation Vehicle Conversion System, and as the name indicates, is a Sequential Natural Gas or Propane Injection Conversion System. This system was design and developed by Yugo-Tech to meet the ever increasing demands of the modern engines that are equipped with computer controlled fuel
injection and on-board diagnostics. The stringent demands from these new vehicles can no longer be satisfied by the old traditional "fumigation" technology conversion systems. To meet the new mandatory emission requirements, the modern sophisticated engines of today, demand precise fueling that only electronically controlled fuel injection can deliver.
The SEQUIN Conversion System is a computer controlled, sequential natural gas or Propane injection system that is compatible with the North American OBD II diagnostics systems as well as the "enhanced diagnostics" introduced in all 1998 vehicles. The SEQUIN Conversion System is designed to be expandable, allowing it to address not only the sophisticated vehicles of today, but the future vehicles of tomorrow.
The SEQUIN Natural Gas Conversion System is designed to be a "dual" fuel, aftermarket conversion system, allowing the expanded use of natural gas or Propane for vehicles. Vehicle manufacturers have traditionally marketed only "dedicated" alternate fueled vehicles. The use of dedicated, natural gas vehicles at present, does not allow for vehicle user flexibility, due to the lack of the natural gas refueling infrastructure . Until there
are adequate natural gas retail refueling stations to overcome this dilemma, the "dual" fuel conversion concept is the only practical choice for the consumer and the only choice that will expand the natural gas vehicle industry.
The SEQUIN Alternate Fuel Conversion System is a full sequential injection system that operates, utilizing the vehicle manufacturers computer logic. The alternate fuel injectors are driven from the manufacturer's injector driver's signals, within the computer. Yugo-Tech has developed a
computer interface module that modifies the manufacturer's injector driver signals to compensate for the different properties of the alternate fuel as related to gasoline. This provides the precise alternate fuel delivery and also allows the manufacturers diagnostics to diagnose its own system/s and sensors without affecting the alternate fuel injection system. This approach eliminates the traditional "reverse engineering" that was the
norm with the "fumigation" style systems and prevents the dash warnings for emission violations. Because the injectors are driven by the OEM computer and the computer monitors all of the on board sensors, the SEQUIN is naturally closed loop.
Future development of the SEQUIN Conversion System will provide "smart" electronics that will allow the system to self learn from the vehicles on board sensors. This will greatly enhance the systems performance and ease the installation and adjustments by the installers. The SEQUIN Natural Gas Injection Conversion System is truly the aftermarket conversion system that will allow the alternate fuel conversion
industry to grow and to move into the next century.
Full profile
Full profile
Contact information
Company description
811119 - Other Automotive Mechanical and Electrical Repair and Maintenance
Product / Service / Licensing
quality reduction is Cairo.
Yugo-Tech designed and developed a natural gas injection conversion system to convert these vehicles to eliminate the
offensive and harmful exhaust smoke.
Market profile
Industry sector market interests:
- Environment
- Transportation
Geographic markets:
Export experience:
- Bangladesh
- China
- Egypt
- India
- Indonesia
- Iran, Islamic Republic of
- Pakistan
- Russian Federation
- United States
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
811119 - Other Automotive Mechanical and Electrical Repair and Maintenance
Products, services and licensing
Product / Service / Licensing
quality reduction is Cairo.
Yugo-Tech designed and developed a natural gas injection conversion system to convert these vehicles to eliminate the
offensive and harmful exhaust smoke.
Market
Market profile
Industry sector market interests:
- Environment
- Transportation
Geographic markets:
Export experience:
- Bangladesh
- China
- Egypt
- India
- Indonesia
- Iran, Islamic Republic of
- Pakistan
- Russian Federation
- United States


Generative Music
Generate MIDIs from data. [github]
This repo takes data and transforms it into midi files (uses midiutil library). MIDI files are then transformed into .wav audio with fluidsynth and a soundfont.
Currently the transformation of the input data is a basic linear transformation. In my case, the data is from temp and humidity sensors running on a Raspberry pi. The RaspberryPi repo shows an example of source data.
That same repo also has code to
create a hyperlocal FM radio station that can broadcast media files.
Playing Sounds:
To play the music, you will need:
- The ability to play MIDI files (it appears Mac OS can no longer play MIDI files by default. You’ll need FluidSynth (you can brew install fluid-synth.
- A Sound Font to actually play the MIDI file (you can chose which instrument). I’ve included an open-source piano in the repo: there are tons of instrument options out there.
The most up-to-date code is in the feature/csv_readings
branch.


{{events[0].attributes.description}}
Sign people in Sign Me In I'm a Team member| {{event.attributes.title}} | Sign people in | Check me in! | I'm a Team member |
|---|
We know tech@nyu events are exciting but, unfortunately, our next one isn't for at least a couple hours. You're just going to have to be patient. In the mean time, check out our full events calendar.


The API Engine team are active in the Open Source community.
Visit our Open Source home page on Github to find out more about our Open Source projects.
Have something to say? We'd love to hear about it.


block cylindrical scanner image model geometry normalization axial reconstruction data using new different Fig. source Scanner inside STIR simulated implementation phantom sinogram Derenzo images {border-style PET algorithm reconstructed . mm cylinder diameter geometry. px;} #ffffff;} calculated sinograms detector model. mm models point OSEM blocks line normalization, profiles simulation size transaxial values (Fig. block-type crystal matrix number spheres subsets correction factors scanners LOR attenuation difference normalization. quality ratio similar uniform IEEE Monte center effect implemented library located plane results spatial COV Carlo bin crystals distributed maximum mean performed positions scatter shows single sources sphere spherical standard tangential used Cylindrical bins coordinates described higher hot inner memory px; resolution rods row subiterations. value {font-family Figure Physics ROI activity calculate font-size geometry, imaging iterative measured non-uniformity parameters phantom. reconstruction. respectively. result statistics time use ./. Block FWHM Images Nuclear SAFIR SOR accurate annular direction directions directions. double; emission increases indicate indicates intensity models. observed plotted projection provided results. scanner, scanner. significant symmetries transactions views virtual water MBq . mm. FOV. However, Institute LORs Line NEMA ROIs Table arranged bins. border-color border-width classes coefficient coincidence color common comparing comparison diameters forward gap geometric lower matrix. model, partial position. radially reason sizes smaller solid; {font-style {font-weight × (vector): Cartesian ETH Image PTV Research Results Therefore, Tsoumpas artifact average axially bar based bold class consumption counts courier; crystals—Scanner cylinder. data. decreases detectors diameter. direction, direction. distribution drawn e.g., elements em; enhances equal especially evaluate events exact function implementation, individual length manuscript. maps measurements medical method methods order peripheral phantom, position prior pt;} radial respectively, ring set shown terms tomography uniformly volume voxel


HOME
MISSION
VISION
GALLERY
PANTS FOR ME FOUNDATION
pants for me foundation is a charity organisation that sensitizes girls and women on genital hygiene.
year of founding
was founded in the year 2020.
What we do
- sensitize on genital hygiene
- offer sanitary towels to ladies
- offer quality pants to ladies
our partners
- safaricom foundation
- microsoft
- KPMG
- Telkom Kenya


T3A03-webpage-Kanata.html
HELLO THIS IS MY WEBPAGE
WELL COME TO MY WEB PAGES!!!


CSlib documentation
Client/server model of communication
The client/server model is a messaging paradigm, used
ubiquitously by web-based applications, where one or more clients
(e.g. your phone) communicate with a server (e.g. a website). In the
context of the CSlib, it can used to couple two scientific
applications (apps) together where one app acts as the "client" and
the other as the "server". The client sends messages to the server
requesting it perform specific computations and return the results.
These are key points to understand about the client/server model, as
it is implemented in the CSlib. The test apps, discussed in this
section, illustrate all these points, so they are
useful to look at to see how to morph your app so it can run as a
client and/or server.
- At run time, the client and server codes (apps) must use the same mode
of communication (obviously), i.e. they agree to communicate by files,
by sockets, or via MPI. The mode setup is performed by the initial
call to the library, made by both the client and server apps. For each
mode there are arguments for the instantiation which must be
consistent between the client and server.
- All messaging follows a single pattern, repeated as many times as
needed:
- client sends a request message
- server receives the request message
- server sends a response message
- client receives the response message
- This means the server cannot initiate a send. It also means the
client cannot send several messages in a row, then wait for a
response. Likewise the server cannot send several messages in a row
as a response, then wait for a new request.
- When the client is done, it should tell the server there are no more
requests by sending a final message. The server should respond to the
client. The client should wait to receive that final message from the
server.
- To send a message, the client or server performs two operations. The
first is to call send() with a message ID and # of fields. The second
is to call pack() or pack_parallel() once for each field. Pack() is
used if all processors have a copy of the same field data.
Pack_parallel() is used if each sending processor owns a portion of
the field data, e.g. each proc owns a subset of grid cells or
particles. In the latter case, the message that is sent to the other
app is the union of all the processor's portions.
- To receive a message, the client or server performs two operations.
The first is to call recv() which returns with a message ID, # of
fields, and info about each field. The second is to call unpack() or
unpack_parallel() once for each field (if desired). Unpack() returns
a pointer to all the field data to every processor (even if it was
sent via pack_parallel()). Unpack_parallel() copies the portion of
the field data each receiving processor owns into memory owned by the
app.
- A recv() call is always blocking. It will not return until the
message from the other app has arrived and the CSlib has stored the
message data internally. A send() call is not blocking for the
file mode. The file of send data is written and the call returns,
whether the other app reads the file immediately or not. A send()
call for the other modes (zmq, mpi/one, mpi/two) may or may not be
blocking. It depends on the size of the message and the protocols
that ZMQ and MPI use for sending/receiving large messages. If the
message is large, the sender may block until the receiver is ready to
receive the data.
- You need to pay attention to whether the memory for various library
calls is owned by the client or server apps or by the CSlib. It's
different for sends versus receives. In the case of a send() or
pack(), the app owns the memory. The CSlib makes an internal copy of
the data to send it as a message to the other app. Thus as soon as
the send() call returns, the app can re-use its memory. In the case
of a recv() or unpack(), the CSlib owns the memory because it
allocated it to receive the message from the other app. The CSlib
simply returns pointers to that internal memory to the app. The app
can examine the values or it can make its own copy if desired. In the
case of unpack_parallel() the portion of returned field data is copied
into the app's memory.
- Note that preceeding paragraph implies something important. The CSlib
re-uses its internal memory for every new send or receive call, for
both per-field info and per-field data. This means the app cannot
expect the pointers to received data returned from the recv() and
unpack() calls to remain valid, once it begins to call send(), pack(),
or pack_parallel() to send the next message. The app MUST make its
own copy of the recv() or unpack() data if persistence is required.
This is true even if the app simply wishes to in-place modify a vector
of field data to return it to the other app. To do this, the app
should make a copy of the vector, modify the copy, then send the copy.
We may add alernate memory usage options to the CSlib in the
future.


State asks U.S. Supreme Court not to review Michelle Carter's conviction
by EndPlayThe state has asked the United States Supreme Court not to review Michelle Carter's involuntary manslaughter conviction.
Carter's defense team is challenging whether Massachusetts' manslaughter law is constitutional.
Carter is currently serving a 15-month prison sentence after being convicted in the 2014 death of her boyfriend, Conrad Roy.
Roy died of carbon monoxide poisoning after locking himself in his truck.
Carter texted him numerous messages encouraging him to take his own life.
>>RELATED:
Michelle Carter's attorneys file appeal with SCOTUS
All the texts between Michelle Carter and Conrad Roy the day he died
SJC: Michelle Carter 'overpowered a vulnerable person's will to live'


Purchase order: {{ delivery?.po_product?.order?.name }} ({{ delivery?.po_product?.order?.code }})
Quantity delivered: {{ delivery?.quantity_delivered }}
Delivered by: {{ delivery?.delivered_by?.first_name }} {{ delivery?.delivered_by?.last_name }}
Date delivered: {{ delivery?.date_delivered | date:'shortDate' }}
Quantity received: {{ delivery?.quantity_received }}
Received by: {{ delivery?.received_by?.first_name }} {{ delivery?.received_by?.last_name }}
Date received: {{ delivery?.date_received | date:'shortDate' }}
- {{ item?.serial_no }}


DRIVERS WILL PROVIDE A SAFE RIDE FOR MOTHERS.
Ride For Life is a transportation system that serves mothers in Uganda by connecting mothers with drivers. Drivers will use a motocycle ambulance to serve the community especially mothers. The drivers will receive a notification from the nearest rider that is requesting a ride.


A gentle and modern Malayalam display typeface. Available in three weights, Gayathri is best suited for headlines, posters, titles and captions. Unicode compliant and libre licensed.
To contribute, see gitlab.com/smc/fonts/gayathri.


{% extends 'layout.html' %} {% block pageTitle %} Book GP appointment {% endblock %} {% block beforeContent %} {{ breadcrumb({ href: "/index", text: "Home" }) }} {% endblock %} {% block content %} {% from 'care-card/macro.njk' import careCard %} {{ careCard({ "type": "non-urgent", "heading": "Book a GP appointment online if:", "HTML": "
Tell the receptionist the reference number given to you at the end of the online request
" }) }}In these situations, ring the GP as you will get through to a receptionist .
" }) }}Call 999 immediately as there is a need for immediate treatment in a hospital.
" }) }}This is the edit I have made
Use this service to:


MPD: Police investigating shooting on Dick Taylor Street
by KNOEMONROE, La. (KNOE) - The Monroe Police Department says they are investigating a shooting in Monroe.
It happened Monday morning on Dick Taylor Street around the 3100 block of Dick Taylor.
Police say the victim was shot in the upper torso area.
Monroe police have only identified the victim as a black male. His condition was not released.
Officers were on the scene for over an hour and had the area blocked off for some time. Officers left the scene sometime before noon.
Police have not released any further details about the shooting. Detectives are continuing to investigate.
KNOE is in contact with the police department working to get details on the situation.
Dick Taylor Street is in south Monroe a few blocks from the Ouachita River.


Synchronous Client Example¶
It should be noted that each request will block waiting for the result. If asynchronous behaviour is required, please use the asynchronous client implementations. The synchronous client, works against TCP, UDP, serial ASCII, and serial RTU devices.
The synchronous client exposes the most popular methods of the modbus protocol, however, if you want to execute other methods against the device, simple create a request instance and pass it to the execute method.
Below an synchronous tcp client is demonstrated running against a reference server. If you do not have a device to test with, feel free to run a pymodbus server instance or start the reference tester in the tools directory.
#!/usr/bin/env python
'''
Pymodbus Synchronous Client Examples
--------------------------------------------------------------------------
The following is an example of how to use the synchronous modbus client
implementation from pymodbus.
It should be noted that the client can also be used with
the guard construct that is available in python 2.5 and up::
with ModbusClient('<IP_ADDRESS>') as client:
result = client.read_coils(1,10)
print result
'''
#---------------------------------------------------------------------------#
# import the various server implementations
#---------------------------------------------------------------------------#
from pymodbus.client.sync import ModbusTcpClient as ModbusClient
#from pymodbus.client.sync import ModbusUdpClient as ModbusClient
# from pymodbus.client.sync import ModbusSerialClient as ModbusClient
#---------------------------------------------------------------------------#
# configure the client logging
#---------------------------------------------------------------------------#
import logging
logging.basicConfig()
log = logging.getLogger()
log.setLevel(logging.DEBUG)
#---------------------------------------------------------------------------#
# choose the client you want
#---------------------------------------------------------------------------#
# make sure to start an implementation to hit against. For this
# you can use an existing device, the reference implementation in the tools
# directory, or start a pymodbus server.
#
# If you use the UDP or TCP clients, you can override the framer being used
# to use a custom implementation (say RTU over TCP). By default they use the
# socket framer::
#
# client = ModbusClient('localhost', port=5020, framer=ModbusRtuFramer)
#
# It should be noted that you can supply an ipv4 or an ipv6 host address for
# both the UDP and TCP clients.
#
# There are also other options that can be set on the client that controls
# how transactions are performed. The current ones are:
#
# * retries - Specify how many retries to allow per transaction (default = 3)
# * retry_on_empty - Is an empty response a retry (default = False)
# * source_address - Specifies the TCP source address to bind to
#
# Here is an example of using these options::
#
# client = ModbusClient('localhost', retries=3, retry_on_empty=True)
#---------------------------------------------------------------------------#
client = ModbusClient('localhost', port=5020)
#client = ModbusClient(method='ascii', port='/dev/pts/2', timeout=1)
# client = ModbusClient(method='rtu', port='/dev/ttyp0', timeout=1)
client.connect()
#---------------------------------------------------------------------------#
# specify slave to query
#---------------------------------------------------------------------------#
# The slave to query is specified in an optional parameter for each
# individual request. This can be done by specifying the `unit` parameter
# which defaults to `0x00`
#---------------------------------------------------------------------------#
rr = client.read_coils(1, 1, unit=0x01)
#---------------------------------------------------------------------------#
# example requests
#---------------------------------------------------------------------------#
# simply call the methods that you would like to use. An example session
# is displayed below along with some assert checks. Note that some modbus
# implementations differentiate holding/input discrete/coils and as such
# you will not be able to write to these, therefore the starting values
# are not known to these tests. Furthermore, some use the same memory
# blocks for the two sets, so a change to one is a change to the other.
# Keep both of these cases in mind when testing as the following will
# _only_ pass with the supplied async modbus server (script supplied).
#---------------------------------------------------------------------------#
rq = client.write_coil(0, True, unit=1)
rr = client.read_coils(0, 1, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.bits[0] == True) # test the expected value
rq = client.write_coils(1, [True]*8, unit=1)
rr = client.read_coils(1, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.bits == [True]*8) # test the expected value
rq = client.write_coils(1, [False]*8, unit=1)
rr = client.read_coils(1, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.bits == [False]*8) # test the expected value
rr = client.read_discrete_inputs(0, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
rq = client.write_register(1, 10, unit=1)
rr = client.read_holding_registers(1, 1, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.registers[0] == 10) # test the expected value
rq = client.write_registers(1, [10]*8, unit=1)
rr = client.read_holding_registers(1, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rr.registers == [10]*8) # test the expected value
rr = client.read_input_registers(1, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
arguments = {
'read_address': 1,
'read_count': 8,
'write_address': 1,
'write_registers': [20]*8,
}
rq = client.readwrite_registers(unit=1, **arguments)
rr = client.read_holding_registers(1, 8, unit=1)
assert(rq.function_code < 0x80) # test that we are not an error
assert(rq.registers == [20]*8) # test the expected value
assert(rr.registers == [20]*8) # test the expected value
#---------------------------------------------------------------------------#
# close the client
#---------------------------------------------------------------------------#
client.close()


A formatted string is a variable which has been converted into a string (text). In python the specifics of how this is done is determined by what kind of variable you want to print.
Example 1: You have an experiment which generates a string variable called text. You want to insert this variable into a string so you can print it. This would be achieved with the following code:
message = 'The result is %s' %(text)
This will produce a variable message which if used in a text object would print the phrase ‘The result is’ followed by the variable text. In this instance %s is used as the variable being entered is a string. This is a marker which tells the script where the variable should be entered. %text tells the script which variable should be entered there.
Multiple formatted strings (of potentially different types) can be entered into one string object:
longMessage = 'Well done %s that took %0.3f seconds' %(info['name'], time)
Some of the handy formatted string types:
>>> x=5
>>> x1=5124
>>> z='someText'
>>> 'show %s' %(z)
'show someText'
>>> '%0.1f' %(x) #will show as a float to one decimal place
'5.0'
>>> '%3i' %(x) #an integer, at least 3 chars wide, padded with spaces
' 5'
>>> '%03i' %(x) #as above but pad with zeros (good for participant numbers)
'005'
See the python documentation for a more complete list.


TABLE OF INTERACTIONS WITH
RANOLAZINE
From the French ANSM drug interactions document of
September 2016, pp. 187-188
RANOLAZINE RxNorm: 35829 ATC: C01EB18 |
ANTICONVULSANT ENZYME INDUCERS CLASS CODE: N03A-001 |
Risk of large decrease of the concentrations of ranolazine |
Not recommended |
RANOLAZINE RxNorm: 35829 ATC: C01EB18 |
ATORVASTATIN RxNorm: 83367 ATC: C10AA05 |
Increased risk of undesirable effects (concentration-dependant) of the rhabodmyolysis type due to inhibition of the metabolism of the atorvastatin by the ranolazine |
Precaution for use Use weaker doses of the cholesterol lowering agent or another statin not affected by this type of interaction. |
RANOLAZINE RxNorm: 35829 ATC: C01EB18 |
DIGOXIN RxNorm: 3407 ATC: C01AA05 |
Increase of the digoxinemia |
Precaution for use Clinical and biological monitoring, and possibly EKG. Adjustment of the dosage of the digoxin if needed. |
RANOLAZINE RxNorm: 35829 ATC: C01EB18 |
IMMUNOSUPPRESSANTS CLASS CODE: L04A |
Increase of the blood concentrations of the immunosuppressant due to inhibition of its metabolism by the ranolazine |
Precaution for use Clinical and biological monitoring, and possible adjustment of the dosage of the immunosuppressant. |
RANOLAZINE RxNorm: 35829 ATC: C01EB18 |
STRONG INHIBITORS OF CYP3A4 CLASS CODE: J02-J05 |
Increase of the concentrations of ranolazine due to decrease of its metabolism by the inhibitor |
CONTRAINDICATION |
RANOLAZINE RxNorm: 35829 ATC: C01EB18 |
RIFAMPICIN RxNorm: 9384 ATC: J04AB02 |
Very large decrease of the concentrations of ranolazine. |
Not recommended |
RANOLAZINE RxNorm: 35829 ATC: C01EB18 |
SIMVASTATIN RxNorm: 36567 ATC: C10AA01 |
Increased risk of undesirable effects (concentration-dependent) of the rhabdomyolysis type due to inhibition of the metabolism of the simvastatin by the ranolazine |
Precaution for use Do not exceed the dosage of 20 mg/day of simvastatin or use another statin not affected by this type of interaction. |


3 Week 3: Drawing a boxplot
- You’ll learn how to draw basic boxplots, which are useful for comparing groups on a numeric variable.
- You’ll tinker with the appearence of your graphs.
- You’ll learn how to compute basic summaries such as group means.
3.1 Reading in data
- Download the file
VowelChoices_ij.csv
from Moodle to thedata
subdirectory of your R project directory. This file contains a part of the results of a learning experiment (Vanhove 2016) in which 80 participants were assigned to one of two learning conditions (LearningCondition
). The columnPropCorrect
contains the proportion of correct answers for each participant, and the question we want to answer concerns the difference in the performance between learners in the different conditions. - Open your R project.
- Create a new script and copy the commands with which you loaded the packages and imported the dataset from last week’s script to this new script.
- Adapt the command for importing the data so that it’ll read in the file
VowelChoices_ij.csv
and that the dataset will be known in R asd_box
. Execute these commands.
From now on, I’ll assume that you won’t enter commands directly to the R console but that you’ll first enter them into a script which you’ll then execute (= much more efficient and manageable).
Tip: Comment your code (with #
). This way you’ll be able to understand what your code accomplishes in a few months’ time, which will make it easier to recycle your scripts. You don’t have to copy my comments verbatim. “Your closest collaborator is you six months ago but you don’t reply to email.”
- Inspect the dataset in R to check that it contains 80 rows and 3 labelled columns (
Subject
,LearningCondition
,PropCorrect
).
3.2 Drawing boxplots
See Johnson (2013) for an explanation of boxplots. Here we’ll draw basic boxplots in order to compare two parts of a dataset. But you can also use boxplots to compare more than two groups. Next week we’ll add the individual data points to these boxplots which can make them more informative still.
From now on, I’ll always assume that you’ve loaded the tidyverse
and here
packages.
- The following command plots the accuracy
data (
PropCorrect
) using a separate boxplot for each condition (LearningCondition
). You already know how the first three lines work; the fourth specifies that the data should be plotted using boxplots.
# Boxplot PropCorrect vs. LearningCondition
ggplot(data = d_box,
aes(x = LearningCondition,
y = PropCorrect)) +
geom_boxplot() # summarise data with boxplots
- Label the x-axis as “Learning condition” and the y-axis as “Proportion correct answers”. I don’t provide the commands for doing so; you already know them.
3.3 Adjusting the appearance of plots
- By default,
ggplot2
(the part of thetidyverse
that takes care of plotting) produces plots with a grey background (which doesn’t seem to please anyone save for its developer). This can be changed by appending the commandtheme_bw()
(black and white) to theggplot
call:
ggplot(data = d_box,
aes(x = LearningCondition,
y = PropCorrect)) +
geom_boxplot() +
xlab("Learning condition") +
ylab("Proportion correct answers") +
theme_bw()
For other options, see http://ggplot2.tidyverse.org/reference/ggtheme.html.
- To change the font size, insert a number between the brackets of the
theme_bw()
command. Finding a suitable font size is a matter of trial and error.
ggplot(data = d_box,
aes(x = LearningCondition,
y = PropCorrect)) +
geom_boxplot() +
xlab("Learning condition") +
ylab("Proportion correct answers") +
theme_bw(15)
- When you’re happy with a plot, you can save it using
ggsave()
. You can set the width and height of the figure using thewidth
andheight
parameters, e.g.,
ggsave(here("figures", "03_boxplot.png"), width = 8, height = 4)
3.4 Computing summaries
While this is a tutorial on drawing graphs, it’s useful at this stage
to know how to obtain some basic information about the datasets you’re
working with. There are many ways to accomplish most things in R
,
and computing summaries is no exception. The alternative shown here is similar
to the way plots are constructed in ggplot2
, so hopefully it’s easy to
pick up.
First, let’s compute the number of observations in the d_box
dataset
as well as the mean of the PropCorrect
variable. The code below can
be read as follows:
Take
d_box
, THEN
summarise it as follows: compute the number of observations (
n()
) and store it asnumber
and compute the mean of
PropCorrect
and store it asmean_PropCorrect
.
|>
d_box summarise(number = n(),
mean_PropCorrect = mean(PropCorrect))
## # A tibble: 1 × 2
## number mean_PropCorrect
## <int> <dbl>
## 1 80 0.368
Thus we see that there are 80 observations in the dataset with a mean PropCorrect of about 0.37.
If we want to compute the mean for the two learning conditions separately,
we insert a corresponding group_by()
statement. The code below can thus be read
as
Take
d_box
, THEN
Group it by the values of
LearningCondition
, THEN
For each group created, create a summary containing the mean of the
PropCorrect
variable.
|>
d_box group_by(LearningCondition) |>
summarise(mean_PropCorrect = mean(PropCorrect))
## # A tibble: 2 × 2
## LearningCondition mean_PropCorrect
## <chr> <dbl>
## 1 <ij> participants 0.436
## 2 <oe> participants 0.290
The word THEN is represented by a so-called pipe operator (|>), a shortcut for which is ctrl+shift+m.
3.5 Exercise
The file Vanhove2014_CognateProfile.csv
contains data from Vanhove (2014).
163 Swiss-Germans attempted to translate 45 written Swedish words, all of which
had German, English and/or French cognates.
To check which participants already had some minimal knowledge of Swedish,
they also had to translate five words without cognates in German, English or French
(e.g., älska ‘to love’); these are known as ‘profile words’.
For the subsequent analysis, it was important to know
(a) how many participants could translate at least one such profile word correctly; and
(b) if participants who could translate at least one such profile word did better at translating cognates than those who couldn’t.
The column CorrectCognates
contains the number of correct cognate
translations per participant; the column shows whether the participant
in question was able to translate at least one profile word correctly (yes
vs. no
).
- Read in the dataset into R.
- Compute the number of participants who were able to correctly translate at least one profile word.
- Use a boxplot to compare the number of correctly translated cognate words between participants that could translate at least one profile word correctly and those that couldn’t. Label your axes appropriately.
- Compile the HTML report.
- Submit both the boxplot and the HTML report.


The coding guide in the following sections will introduce the major classes and functions in a series of lessons that build on each other. Code snippets will be provided for all 3 languages and differences will be addressed.
Content
Development process
Creating a master
Enter search terms or a module, class or function name.


All Files (95.94% covered at 2.24 hits/line)
41 files in total.
320 relevant lines.
307 lines covered and
13 lines missed
- 1
class ActivitiesController < ApplicationController
- 1
before_action :set_activity, only: [:show, :edit, :update, :destroy]
# GET /activities
# GET /activities.json
- 1
def index
- 9
@activities = Activity.all
end
# GET /activities/1
# GET /activities/1.json
- 1
def show
end
# GET /activities/new
- 1
def new
- 2
@activity = Activity.new
end
# GET /activities/1/edit
- 1
def edit
end
# POST /activities
# POST /activities.json
- 1
def create
- 2
@activity = Activity.new(activity_params)
- 2
respond_to do |format|
- 2
if @activity.save
- 2
format.html { redirect_to @activity, notice: 'Activity was successfully created.' }
- 1
format.json { render :show, status: :created, location: @activity }
else
- 2
format.html { render :new }
- 1
format.json { render json: @activity.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /activities/1
# PATCH/PUT /activities/1.json
- 1
def update
- 2
respond_to do |format|
- 2
if @activity.update(activity_params)
- 2
format.html { redirect_to @activity, notice: 'Activity was successfully updated.' }
- 1
format.json { render :show, status: :ok, location: @activity }
else
- 2
format.html { render :edit }
- 1
format.json { render json: @activity.errors, status: :unprocessable_entity }
end
end
end
# DELETE /activities/1
# DELETE /activities/1.json
- 1
def destroy
- 1
@activity.destroy
- 1
respond_to do |format|
- 2
format.html { redirect_to activities_url, notice: 'Activity was successfully destroyed.' }
- 1
format.json { head :no_content }
end
end
- 1
private
# Use callbacks to share common setup or constraints between actions.
- 1
def set_activity
- 11
@activity = Activity.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
- 1
def activity_params
- 4
params.require(:activity).permit(:customer_id, :description, :start_date, :end_date, :total_hours_of_work)
end
end
- 1
class ApplicationController < ActionController::Base
- 1
protect_from_forgery with: :exception
end
- 1
class BillsController < ApplicationController
- 1
before_action :set_bill, only: [:show, :edit, :update, :destroy]
# GET /bills
# GET /bills.json
- 1
def index
- 3
@bills = Bill.all
end
# GET /bills/1
# GET /bills/1.json
- 1
def show
end
# GET /bills/new
- 1
def new
- 2
@bill = Bill.new
end
# GET /bills/1/edit
- 1
def edit
end
# POST /bills
# POST /bills.json
- 1
def create
- 2
@bill = Bill.new(bill_params)
- 2
respond_to do |format|
- 2
if @bill.save
- 2
format.html { redirect_to @bill, notice: 'Bill was successfully created.' }
- 1
format.json { render :show, status: :created, location: @bill }
else
- 2
format.html { render :new }
- 1
format.json { render json: @bill.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /bills/1
# PATCH/PUT /bills/1.json
- 1
def update
respond_to do |format|
if @bill.update(bill_params)
format.html { redirect_to @bill, notice: 'Bill was successfully updated.' }
format.json { render :show, status: :ok, location: @bill }
else
format.html { render :edit }
format.json { render json: @bill.errors, status: :unprocessable_entity }
end
end
end
# DELETE /bills/1
# DELETE /bills/1.json
- 1
def destroy
@bill.destroy
respond_to do |format|
format.html { redirect_to bills_url, notice: 'Bill was successfully destroyed.' }
format.json { head :no_content }
end
end
- 1
private
# Use callbacks to share common setup or constraints between actions.
- 1
def set_bill
- 1
@bill = Bill.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
- 1
def bill_params
- 2
params.require(:bill).permit(:customer_id, :date_of_issue, :terms_of_payment, :hourly_rate, :tax_rate, :taxable, :withholding, :total_hours, :discount, :total_cost, :paid)
end
end
- 1
class CustomersController < ApplicationController
- 1
before_action :set_customer, only: [:show, :edit, :update, :destroy]
# GET /customers
# GET /customers.json
- 1
def index
- 15
@customers = Customer.all
end
# GET /customers/1
# GET /customers/1.json
- 1
def show
end
# GET /customers/new
- 1
def new
- 2
@customer = Customer.new
end
# GET /customers/1/edit
- 1
def edit
end
# POST /customers
# POST /customers.json
- 1
def create
- 2
@customer = Customer.new(customer_params)
- 2
respond_to do |format|
- 2
if @customer.save
- 2
format.html { redirect_to @customer, notice: 'Customer was successfully created.' }
- 1
format.json { render :show, status: :created, location: @customer }
else
- 2
format.html { render :new }
- 1
format.json { render json: @customer.errors, status: :unprocessable_entity }
end
end
end
# PATCH/PUT /customers/1
# PATCH/PUT /customers/1.json
- 1
def update
- 3
respond_to do |format|
- 3
if @customer.update(customer_params)
- 2
format.html { redirect_to @customer, notice: 'Customer was successfully updated.' }
- 1
format.json { render :show, status: :ok, location: @customer }
else
- 4
format.html { render :edit }
- 2
format.json { render json: @customer.errors, status: :unprocessable_entity }
end
end
end
# DELETE /customers/1
# DELETE /customers/1.json
- 1
def destroy
- 1
@customer.destroy
- 1
respond_to do |format|
- 2
format.html { redirect_to customers_url, notice: 'Customer was successfully destroyed.' }
- 1
format.json { head :no_content }
end
end
- 1
private
# Use callbacks to share common setup or constraints between actions.
- 1
def set_customer
- 13
@customer = Customer.find(params[:id])
end
# Never trust parameters from the scary internet, only allow the white list through.
- 1
def customer_params
- 5
params.require(:customer).permit(:name, :surname, :company, :phone_number, :address, :email, :vat_number)
end
end
- 1
class StaticPagesController < ApplicationController
- 1
def home
end
end
- 1
module ActivitiesHelper
end
- 1
module ApplicationHelper
end
- 1
module BillsHelper
end
- 1
module CustomersHelper
end
- 1
module StaticPagesHelper
end
- 1
class Activity < ApplicationRecord
- 1
belongs_to :customer
- 1
validates :customer, presence: true
- 1
validates :description, presence: true,length: { maximum: 140 }
- 1
validates :start_date, presence: true
- 1
validates :end_date, presence: true
- 1
validate :end_date_after_start_date?
- 1
validates :total_hours_of_work, presence: true,
:format => { :with => /\A\d+(?:\.\d{0,1})?\z/ },
:numericality => {:greater_than => 0}
- 1
def end_date_after_start_date?
- 11
if end_date < start_date
errors.add :end_date, "must be after start date"
end
end
- 1
def total_hours
- 17
@total_hours = customer.activities.sum(:total_hours_of_work)
end
end
- 1
class ApplicationRecord < ActiveRecord::Base
- 1
self.abstract_class = true
end
- 1
class Bill < ApplicationRecord
- 1
belongs_to :customer
- 1
validates :customer, presence: true
- 1
validates :date_of_issue, presence: true
- 1
validates :terms_of_payment, presence: true
- 1
validates :hourly_rate, presence: true,
:format => { :with => /\A\d+(?:\.\d{0,2})?\z/ },
:numericality => {:greater_than => 0}
- 1
validates :discount,presence: true, :numericality => {:greater_than => -1}
- 1
def total_hours
- 16
@activities = customer.activities
- 16
@activities.each do |a|
- 16
@total_hours = a.total_hours
end
- 16
@total_hours
end
- 1
def get_taxable
- 8
@taxable = ((self.total_hours * self.hourly_rate)).round(2)
end
- 1
def get_total_cost
- 8
@total_cost = (@taxable - (@taxable * self.discount/100)).round(2)
- 8
@total_cost = (@total_cost + (@total_cost * self.tax_rate/100) - (@total_cost * withholding/100)).round(2
)
end
end
- 1
class Customer < ApplicationRecord
- 1
has_many :activities, dependent: :destroy
- 1
has_many :bills, dependent: :destroy
- 1
validates :name, presence: true, length: { maximum: 50 }
- 1
validates :surname, presence: true, length: { maximum: 50 }
- 1
validates :company, presence: true, length: { maximum: 50 }
- 1
validates :address, presence: true, length: { maximum: 50 }
- 1
validates :phone_number, presence: true, length: { is: 10 }
- 1
validates :vat_number, presence: true, length: { is: 11}
- 1
VALID_EMAIL_REGEX =<EMAIL_ADDRESS>- 1
validates :email, presence: true, length: { maximum: 255 },
format: { with: VALID_EMAIL_REGEX }
- 1
def fullname
- 76
"#{name} #{surname}"
end
- 1
def to_s
- 76
fullname
end
end
- 1
require_relative 'boot'
- 1
require 'rails/all'
# Require the gems listed in Gemfile, including any gems
# you've limited to :test, :development, or :production.
- 1
Bundler.require(*Rails.groups)
- 1
module App
- 1
class Application < Rails::Application
# Initialize configuration defaults for originally generated Rails version.
- 1
config.load_defaults 5.1
# Settings in config/environments/* take precedence over those specified here.
# Application configuration should go into files in config/initializers
# -- all .rb files in that directory are automatically loaded.
end
end
- 1
ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
- 1
require 'bundler/setup' # Set up gems listed in the Gemfile.
# Load the Rails application.
- 1
require_relative 'application'
# Initialize the Rails application.
- 1
Rails.application.initialize!
- 1
Rails.application.configure do
# Settings specified here will take precedence over those in config/application.rb.
# The test environment is used exclusively to run your application's
# test suite. You never need to work with it otherwise. Remember that
# your test database is "scratch space" for the test suite and is wiped
# and recreated between test runs. Don't rely on the data there!
- 1
config.cache_classes = true
# Do not eager load code on boot. This avoids loading your whole application
# just for the purpose of running a single test. If you are using a tool that
# preloads Rails for running tests, you may have to set it to true.
- 1
config.eager_load = false
# Configure public file server for tests with Cache-Control for performance.
- 1
config.public_file_server.enabled = true
- 1
config.public_file_server.headers = {
'Cache-Control' => "public, max-age=#{1.hour.seconds.to_i}"
}
# Show full error reports and disable caching.
- 1
config.consider_all_requests_local = true
- 1
config.action_controller.perform_caching = false
# Raise exceptions instead of rendering exception templates.
- 1
config.action_dispatch.show_exceptions = false
# Disable request forgery protection in test environment.
- 1
config.action_controller.allow_forgery_protection = false
- 1
config.action_mailer.perform_caching = false
# Tell Action Mailer not to deliver emails to the real world.
# The :test delivery method accumulates sent emails in the
# ActionMailer::Base.deliveries array.
- 1
config.action_mailer.delivery_method = :test
# Print deprecation notices to the stderr.
- 1
config.active_support.deprecation = :stderr
# Raises error for missing translations
# config.action_view.raise_on_missing_translations = true
end
# Be sure to restart your server when you modify this file.
# ActiveSupport::Reloader.to_prepare do
# ApplicationController.renderer.defaults.merge!(
# http_host: 'example.org',
# https: false
# )
# end
# Be sure to restart your server when you modify this file.
# Version of your assets, change this if you want to expire all your assets.
- 1
Rails.application.config.assets.version = '1.0'
# Add additional assets to the asset load path.
# Rails.application.config.assets.paths << Emoji.images_path
# Add Yarn node_modules folder to the asset load path.
- 1
Rails.application.config.assets.paths << Rails.root.join('node_modules')
# Precompile additional assets.
# application.js, application.css, and all non-JS/CSS in the app/assets
# folder are already added.
# Rails.application.config.assets.precompile += %w( admin.js admin.css )
# Be sure to restart your server when you modify this file.
# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
# Rails.backtrace_cleaner.remove_silencers!
# Be sure to restart your server when you modify this file.
# Specify a serializer for the signed and encrypted cookie jars.
# Valid options are :json, :marshal, and :hybrid.
- 1
Rails.application.config.action_dispatch.cookies_serializer = :json
# Be sure to restart your server when you modify this file.
# Configure sensitive parameters which will be filtered from the log file.
- 1
Rails.application.config.filter_parameters += [:password]
# Be sure to restart your server when you modify this file.
# Add new inflection rules using the following format. Inflections
# are locale specific, and you may define rules for as many different
# locales as you wish. All of these examples are active by default:
# ActiveSupport::Inflector.inflections(:en) do |inflect|
# inflect.plural /^(ox)$/i, '\1en'
# inflect.singular /^(ox)en/i, '\1'
# inflect.irregular 'person', 'people'
# inflect.uncountable %w( fish sheep )
# end
# These inflection rules are supported but not enabled by default:
# ActiveSupport::Inflector.inflections(:en) do |inflect|
# inflect.acronym 'RESTful'
# end
# Be sure to restart your server when you modify this file.
# Add new mime types for use in respond_to blocks:
# Mime::Type.register "text/richtext", :rtf
# Be sure to restart your server when you modify this file.
# This file contains settings for ActionController::ParamsWrapper which
# is enabled by default.
# Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
- 1
ActiveSupport.on_load(:action_controller) do
- 2
wrap_parameters format: [:json]
end
# To enable root element in JSON for ActiveRecord objects.
# ActiveSupport.on_load(:active_record) do
# self.include_root_in_json = true
# end
- 1
Rails.application.routes.draw do
- 1
root 'static_pages#home'
- 1
get 'static_pages/home'
- 1
resources :bills
- 1
resources :activities
- 1
resources :customers
# For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end
- 1
Given ("I am on the page of the activities") do
- 8
visit activities_path
end
- 1
When ("I fill in the form of the activity with valid data") do
- 1
fill_in 'Description', with: 'Example activity'
- 1
select_date('2017-11-20', :from => 'Start date')
- 1
select_date('2017-11-22', :from => 'End date')
- 1
fill_in 'Total hours of work', with: '16.0'
#gli altri campi sono compilati di default
- 1
click_on 'Create Activity'
end
- 1
Then("I should see the new activity in the list") do
- 1
activity = Activity.last
- 1
expect(page.body).to have_content(activity.description)
end
- 1
When ("I fill in the form with an invalid total hours of work") do
- 1
fill_in 'Description', with: 'Example activity'
- 1
select_date('2017-11-20', :from => 'Start date')
- 1
select_date('2017-11-22', :from => 'End date')
- 1
fill_in 'Total hours of work', with: '-8.3'
- 1
click_on 'Create Activity'
end
- 1
Then("I expect to get an error message") do
- 6
expect(page.body).to have_content("error")
end
- 1
Given("I am on the page of the bills") do
- 3
visit bills_path
end
- 1
When ("I fill in the form of the bill with valid data") do
- 1
select_date('2017-11-20', :from => 'Date of issue')
- 1
fill_in 'Hourly rate', with: '10.0'
- 1
fill_in 'Discount', with: '0.0'
#gli altri campi sono compilati di default
- 1
click_on 'Create Bill'
end
- 1
Then("I should see the new bill in the list") do
- 1
bill = Bill.last
- 1
expect(page.body).to have_content(bill.hourly_rate)
end
- 1
When ("I fill in the form with an invalid hourly rate") do
- 1
select_date('2017-11-20', :from => 'Date of issue')
- 1
fill_in 'Hourly rate', with: '0.0'
- 1
fill_in 'Discount', with: '0.0'
- 1
click_on 'Create Bill'
end
- 1
Then("I should see an error") do
expect(page).to have_css('#error_explanation')
end
- 1
Given("I am on the page of the customers") do
- 12
visit customers_path
end
- 1
When("I click on {string}") do |string|
- 11
click_on string
end
- 1
When ("I fill in the form of the customer with valid data") do
- 1
fill_in 'Name', with: 'Andrea'
- 1
fill_in 'Surname', with: 'Rossi'
- 1
fill_in 'Company', with: 'Andre Rossi'
- 1
fill_in 'Address', with: 'Roma'
- 1
fill_in 'Phone number', with: '0123456789'
- 1
fill_in 'Vat number', with: '01234567890'
- 1
fill_in 'Email', with<EMAIL_ADDRESS>- 1
click_on 'Create Customer'
end
- 1
Then("I should see the new customer in the list") do
- 1
customer = Customer.last
- 1
expect(page.body).to have_content(customer.name)
end
- 1
When ("I fill in the form with an invalid phone number") do
- 1
fill_in 'Name', with: 'Andrea'
- 1
fill_in 'Surname', with: 'Rossi'
- 1
fill_in 'Company', with: 'Andre Rossi'
- 1
fill_in 'Address', with: 'Roma'
- 1
fill_in 'Phone number', with: '58'
- 1
fill_in 'Vat number', with: '01234567890'
- 1
fill_in 'Email', with<EMAIL_ADDRESS>- 1
click_on 'Create Customer'
end
- 1
Then("I should see an error") do
expect(page).to have_css('#error_explanation')
end
- 1
When('I click "Destroy"') do
- 2
first(:link, "Destroy").click
end
- 1
Then ("I should not see that activity") do
- 1
expect change(Activity, :count).by(-1)
end
- 1
Then ("I should not see that customer") do
- 1
expect change(Customer, :count).by(-1)
end
- 1
Given("there is an activity") do
- 7
@activity = FactoryBot.create(:activity)
end
- 1
When('I click "Edit"') do
- 5
first(:link, "Edit").click
end
- 1
When("I change the description to {string}") do |string|
- 2
visit edit_activity_path(@activity)
- 2
fill_in 'Description', with: string
end
- 1
Then("the description of the activity is {string}") do |string|
- 1
expect(page.body).to have_content(string)
end
- 1
Given("there is a customer") do
- 11
@customer = FactoryBot.create(:customer)
end
- 1
When("I change the name to {string}") do |string|
- 2
visit edit_customer_path(@customer)
- 2
fill_in 'Name', with: string
end
- 1
Then("the name of the customer is {string}") do |string|
- 1
expect(page.body).to have_content(string)
end
- 1
When("I change the phone_number to {string}") do |string|
- 1
visit edit_customer_path(@customer)
- 1
fill_in 'Phone number', with: string
end
- 1
Given ("I am on the home page") do
- 2
visit static_pages_home_path
end
- 1
When('I click "Customers"') do
- 1
visit customers_path
end
- 1
When('I click "Home"') do
- 1
first(:link, "Home").click
end
- 1
Then("I should see the right value of total_hours") do
- 1
expect(@activity.total_hours).to be == (@activity.total_hours_of_work)
end
#avendo una sola attività abbiamo verificato che il metodo total_hours
#ritornasse le stesse ore di lavoro dell'attività, cioè total_hours_of_work
#se avessimo creato più attività con FactoryBot avremmo dovuto confrontare
#il valore di total_hours con customer.activities.sum(:total_hours_of_work)
- 1
When('I click "Show"') do
- 2
first(:link, "Show").click
end
- 1
Given("I am viewing the details of the activity") do
- 1
visit activity_path(@activity)
end
- 1
Given("I am viewing the details of the customer") do
- 1
visit customers_path(@customer)
end
- 1
FactoryBot.define do
- 1
factory :activity do
- 1
description 'Example activity'
- 1
start_date '2017-11-19'
- 1
end_date '2017-11-20'
- 1
total_hours_of_work '16.0'
- 1
customer
end
end
- 1
FactoryBot.define do
- 1
factory :bill do
- 1
date_of_issue '2017-11-21'
- 1
terms_of_payment '30'
- 1
hourly_rate '10.0'
- 1
tax_rate '22'
- 1
withholding '20'
- 1
discount '0.0'
- 1
paid 'no'
- 1
total_hours = @total_hours
- 1
taxable = @get_taxable
- 1
total_cost = @get_total_cost
- 1
customer
end
end
- 1
FactoryBot.define do
- 1
factory :customer do
- 1
name 'Andrea'
- 1
surname 'Rossi'
- 1
company 'Andrea Rossi srl'
- 1
phone_number '0123456789'
- 1
address 'Trento'
- 1
email<EMAIL_ADDRESS>- 1
vat_number '01234567890'
end
end


Three Rafale jets handed over to India: Government
India and France signed an Euro 7.87 billion (Rs 59,000 crore approximately) deal in September 2016 for 36 Rafale jets.
by PTINEW DELHI: Three Rafale fighter jets have been handed over to the Indian Air Force and are being used to train IAF pilots and technicians in France, the government said on Wednesday. India and France signed an Euro 7.87 billion (Rs 59,000 crore approximately) deal in September 2016 for 36 Rafale jets.
While the first Rafale jet was handed over to India on October 8, the first batch of four Rafale jets will arrive in India by May 2020.


Bodyguard Jax:
I buried the gold in Dion's southern forest. We made a map to the place, divided it into 4 pieces, and took 1 piece each. It meant none of us could return there without the others...
I first knew the gold was cursed when I heard about the unfortunate deaths of my 3 comrades. So I decided to forget it all and live quietly here.
Ask about the dead comrades


"Man on the Moon" -- Andy Kaufman in a Wrestling Match - yeah - yeah - yeah - yeah
To me, Andy Kaufman was some semi-talented actor who spent a few years on a show called Taxi. I never really watched the show, except when I was channel surfing and happened to catch it for a minute or two. I couldn't even tell you any of the characters on the show - that is, except for Latka, played by Andy Kaufman. He stood out. He was a shy-looking, diminutive actor who spoke like he had just inhaled dangerous amounts of helium. And I always asked myself, 'what's the deal with this guy?'
"Man on the Moon" doesn't try to answer this question. It doesn't try to be a detailed biography of Kaufman. Rather, it is more like a visual diary that illustrates a few of the more unique chapters in this performer's life. And unique is a very good word. Kaufman's oeuvre of wacky performances include a wicked transformation into Elvis; an affable foreign mechanic named Latka; a crass lounge singing alter ego, and a trash talking wrestler who proclaimed himself to be the Inter-Gender champion because no woman could beat him. Kaufman was considered brilliant by a few and enigmatic by some, and eventually scorned by many.
But his brand of humor was not even supposed to be humor at all. Instead, Kaufman would say that they were experiments in behavior. He was sometimes funny, sometimes mean-spirited, sometimes edgy, and sometimes tasteless. But despite his many facades, he was always sincere at trying to give the public something unexpected. He wanted to shock the audience and to elicit genuine emotion. His philosophy was not about making people laugh. It was about making people react. The result was that some would roll in the aisle with laughter while the person seated next to him would be scratching his head in wonderment.
 Carrey ably transforms himself into the Kaufman persona. Though Kaufman has great schemes that he wants to set in motion, he is not always the sole architect. Helping him are is long-time friend, Bob (Paul Giamatti), an agent (Danny DeVito), and an extremely patient girlfriend (Courtney Love). Yet, Andy is always engaging in his own machinations, frequently even catching his closest friends and family members off guard. It gets to the point that even the National Enquirer ignores rumors about him because they've 'been burned too many times before.'
 In other ways, he may have been considered a visionary performer. But I think that if he lived in the 1990s, he would have been considered a very capable performance artist. This film gave me a new sense of respect for him. He was definitely fighting an uphill battle, but perhaps opened the door for people like Howard Stern and helped to make 'Professional' wrestling more mainstream. In Kaufman, there is an undeniable sweetness to him, despite his need to shock and to stay one step ahead of the audience.
I am recommending the film for two reasons. The first is because Jim Carrey delivers an Oscar-worthy performance, who not only does a hauntingly real imitation of the late Kaufman but also shows unusual dramatic depth. It's difficult to be a serious clown, but Carrey shows great restraint. Also, credit Director Milos Foreman for being able to present a film whose tone accurately mimics Kaufman's unpredictability and for giving us a thoughtful look into why Kaufman probably deserved more credit than he received.
Grade: B+ if you like Andy Kaufman or Jim Carrey. B for everyone else.
Do You Yahoo!? Talk to your friends online with Yahoo! Messenger. http://messenger.yahoo.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


This developer's contract needs to perform logical operations based on the amount of rainfall on a corn field in Colorado. First, she will craft a request to the Concurrence fleet and reserve (CCCE) token behind that request.
Developer requests are stored in the Requests contract and off-chain events are triggered each time (CCCE) token is reserved.
Incentivized by the reserved token, miners perform the needed off-chain procedures. A miner is any generic node that can take action and return results to the blockchain. A miner's response is only as powerful as the (CCCE) token staked in its favor.
As the 32 byte responses flow in from the mining pool, they are stored as a linked list in the Responses contract.
When enough Responses meet the requirements of the Request, a Combiner will aggregate all the results and use a specific algorithm to come to a Concurrence. Miners are rewarded or punished based on what results they staked token in favor of.
The agreed upon, currency backed consensus, or Concurrence, is delivered to the developer contract or other on-chain assets.


#include <scope.h>
A Scope
object represents a set of related TensorFlow ops that have the same properties such as a common name prefix.
A Scope object is a container for TensorFlow Op properties. Op constructors get a Scope object as a mandatory first argument and the constructed op acquires the properties in the object.
A simple example:
using namespace ops; Scope root = Scope::NewRootScope(); auto c1 = Const(root, { {1, 1} }); auto m = MatMul(root, c1, { {41}, {1} }); GraphDef gdef; Status s = root.ToGraphDef(&gdef); if (!s.ok()) { ... }
Scope hierarchy:
The Scope class provides various With<> functions that create a new scope. The new scope typically has one property changed while other properties are inherited from the parent scope. NewSubScope(name) method appends name
to the prefix of names for ops created within the scope, and WithOpName() changes the suffix which otherwise defaults to the type of the op.
Name examples:
Scope root = Scope::NewRootScope(); Scope linear = root.NewSubScope("linear"); // W will be named "linear/W" auto W = Variable(linear.WithOpName("W"), {2, 2}, DT_FLOAT); // b will be named "linear/b" auto b = Variable(linear.WithOpName("b"), {2}, DT_FLOAT); auto x = Const(linear, {...}); // name: "linear/Const" auto m = MatMul(linear, x, W); // name: "linear/MatMul" auto r = BiasAdd(linear, m, b); // name: "linear/BiasAdd"
Scope lifetime:
A new scope is created by calling Scope::NewRootScope. This creates some resources that are shared by all the child scopes that inherit from this scope, directly or transitively. For instance, a new scope creates a new Graph object to which operations are added when the new scope or its children are used by an Op constructor. The new scope also has a Status object which will be used to indicate errors by Op-constructor functions called on any child scope. The Op-constructor functions have to check the scope's status by calling the ok() method before proceeding to construct the op.
Thread safety:
A Scope
object is NOT thread-safe. Threads cannot concurrently call op-constructor functions on the same Scope
object.
Constructors and Destructors |
|
|---|---|
Scope(const Scope & other)
|
|
~Scope()
|
Public functions |
|
|---|---|
ClearColocation() const
|
Clear all colocation constraints.
|
ColocateWith(const Operation & op) const
|
Return a new scope.
|
ColocateWith(const Output & out) const
|
Convenience function for above.
|
ExitOnError() const
|
Return a new scope.
|
GetCompositeOpScopes(const string & composite_op_name) const
|
|
GetUniqueNameForOp(const string & default_name) const
|
string
Return a unique name, using default_name if an op name has not been specified.
|
NewSubScope(const string & child_scope_name) const
|
Return a new scope.
|
ToGraphDef(GraphDef *gdef) const
|
If status() is Status::OK(), convert the Graph object stored in this scope to a GraphDef proto and return Status::OK().
|
UpdateStatus(const Status s) const
|
void
Update the status on this scope.
|
WithAssignedDevice(const string & assigned_device) const
|
Returns a new scope.
|
WithControlDependencies(const gtl::ArraySlice< Operation > & control_deps) const
|
Return a new scope.
|
WithControlDependencies(const Output & control_dep) const
|
Same as above, but convenient to add control dependency on the operation producing the control_dep output.
|
WithDevice(const string & device) const
|
Return a new scope.
|
WithKernelLabel(const string & kernel_label) const
|
Return a new scope.
|
WithNoControlDependencies() const
|
Return a new scope.
|
WithOpName(const string & op_name) const
|
Return a new scope.
|
control_deps() const
|
const std::vector< Operation > &
|
graph() const
|
Graph *
|
graph_as_shared_ptr() const
|
std::shared_ptr< Graph >
|
ok() const
|
bool
|
operator=(const Scope & other)
|
Scope &
|
status() const
|
Public static functions |
|
|---|---|
NewRootScope()
|
Return a new scope.
|
Scope ColocateWith( const Operation & op ) const
Return a new scope.
All ops created within the returned scope will be co-located on the device where op is placed. NOTE: This function is intended to be use internal libraries only for controlling placement of ops on to devices. Public use is not encouraged because the implementation of device placement is subject to change.
Scope ExitOnError() const
Return a new scope.
The op-constructor functions taking the returned scope as the scope argument will exit as soon as an error is detected, instead of setting the status on the scope.
CompositeOpScopes GetCompositeOpScopes( const string & composite_op_name ) const
string GetUniqueNameForOp( const string & default_name ) const
Return a unique name, using default_name if an op name has not been specified.
Scope NewSubScope( const string & child_scope_name ) const
Return a new scope.
Ops created with this scope will have name/child_scope_name
as the prefix. The actual name will be unique in the current scope. All other properties are inherited from the current scope. If child_scope_name
is empty, the /
is elided.
Scope( const Scope & other )
Status ToGraphDef( GraphDef *gdef ) const
If status() is Status::OK(), convert the Graph object stored in this scope to a GraphDef proto and return Status::OK().
Otherwise, return the error status as is without performing GraphDef conversion.
void UpdateStatus( const Status s ) const
Update the status on this scope.
Note: The status object is shared between all children of this scope. If the resulting status is not Status::OK() and exit_on_error_ is set on this scope, this function exits by calling LOG(FATAL).
Scope WithAssignedDevice( const string & assigned_device ) const
Returns a new scope.
All ops created within the returned scope will have their assigned device set to assigned_device
.
Scope WithControlDependencies( const gtl::ArraySlice< Operation > & control_deps ) const
Return a new scope.
All ops created within the returned scope will have as control dependencies the union of operations in the control_deps vector and the control dependencies of the current scope.
Scope WithControlDependencies( const Output & control_dep ) const
Same as above, but convenient to add control dependency on the operation producing the control_dep output.
Scope WithDevice( const string & device ) const
Return a new scope.
All ops created within the returned scope will have the device field set to 'device'.
Scope WithKernelLabel( const string & kernel_label ) const
Return a new scope.
All ops created with the new scope will have kernel_label as the value for their '_kernel' attribute;
Scope WithNoControlDependencies() const
Return a new scope.
All ops created within the returned scope will have no control dependencies on other operations.
Scope WithOpName( const string & op_name ) const
Return a new scope.
All ops created within the returned scope will have names of the form name/op_name[_suffix]
.
const std::vector< Operation > & control_deps() const
Graph * graph() const
std::shared_ptr< Graph > graph_as_shared_ptr() const
bool ok() const
Status status() const
~Scope()
Scope NewRootScope()
Return a new scope.
This creates a new graph and all operations constructed in this graph should use the returned object as the "root" scope.