JavaScript often abbreviated as JS, Alongside HTML and CSS, JavaScript is one of the core technologies of the World Wide Web. JavaScript enables interactive web pages and is an essential part of web applications. The vast majority of websites use it for client-side page behavior, and all major web browsers have a dedicated JavaScript engine to execute it.
The programs in this language are called scripts. They can be written right in a web page’s HTML and run automatically as the page loads. Scripts are provided and executed as plain text. They don’t need special preparation or compilation to run
Today, JavaScript can execute not only in the browser, but also on the server, or actually on any device that has a special program called the JavaScript engine. The browser has an embedded engine sometimes called a “JavaScript virtual machine”.


About Omics Pipe¶
Omics pipe is an open-source, modular computational platform that automates ‘best practice’ multi-omics data analysis pipelines published in Nature Protocols and other commonly used pipelines, such as GATK. It currently automates and provides summary reports for two RNA-seq pipelines, two miRNA-seq pipelines, variant calling from whole exome sequencing (WES), variant calling and copy number variation analysis from whole genome sequencing (WGS), two ChIP-seq pipelines and a custom RNA-seq pipeline for personalized genomic medicine reporting. It also provides automated support for interacting with the The Cancer Genome Atlas (TCGA) datasets, including automatic download and processing of the samples in this database.
Omics pipe is a Python package that can be installed on a compute cluster, a local installation or in the cloud. It can be downloaded directly from the Omics pipe website for local and cluster installation, or can be used on AWS in Amazon EC2. The modular nature of Omics pipe allows researchers to easily and efficiently add new analysis tools with Bash scripts in the form of modules that can then be used to assemble a new analysis pipeline. Omics pipe uses Ruffus to pipeline the various analysis modules together into a parallel, automated pipeline. The dependence of Omics pipe on Ruffus also allows for the restarting of only the steps in the pipeline that need updating in the event of an error. In addition, Sumatra is built into Omics pipe, which provides version control for each run of the pipeline, increasing the reproducibility and documentation of your analyses. Omics pipe interacts with the Distributed Resource Management Application API (DRMAA), which automatically submits, controls and monitors jobs to a Distributed Resource Management system, such as a compute cluster or Grid computing infrastructure. This allows you to run samples and steps in the pipeline in parallel in a computationally efficient distributed fashion, without the need to individually schedule and monitor individual jobs. For each supported pipeline in Omics pipe, results files from each step in the pipeline are generated, and an analysis summary report is generated as an HTML report using the R package knitr. The summary report provides quality control metrics and visualizations of the results for each sample to enable researchers to quickly and easily interpret the results of the pipeline.
Available Pipelines¶
- Omics Pipe Available Pipelines
- Pipelines supported by this version of omics pipe.
Users¶
Projects that have used Omics Pipe for solving biological problems. Please submit your story if you would like to share how you use the pipeline for your own research.
- The Scripps Research Institute, Lotz Lab: The Lotz Lab in the Department of Molecular and Experimental Medicine at TSRI uses Omics Pipe to perform RNA-seq and miRNA-seq analyses on human articular cartilage samples to elucidate molecular pathways dysregulated in Osteoarthritis.
- Avera Health: Researchers working in collaboration with Avera Health use Omics Pipe to analyze sequence data from multiple platforms to provide personalized medicine to breast cancer patients.
- Scripps Laboratories for tRNA Synthetase Research: Researchers working in collaboration with Scripps Laboratories for tRNA Synthetase Research use Omics Pipe to analyze ChIP-seq data to explore transcription factor binding sites under experimental conditions.
- Dorris Neuroscience Center: Researchers working in collaboration with The Maximov Lab in the Department of Molecular and Cellular Neuroscience at The Scripps Research Institute use Omics Pipe to analyze RNA-seq data to determine how extensive activity-dependent alternative mRNA splicing occurs in the transcriptome of a mouse model that is born and develops to adulthood without synaptic transmission in the forebrain.
- Sanford Burnham Medical Research Institute: Researchers working in collaboration with The Peterson Lab in the Bioinformatics and Structural Biology Program at Sanford Burnham Medical Research Institute are using Omics Pipe to perform RNA-seq based global gene expression analysis of dental plaque microbiota derived from twin pairs to identify functional networks of the dental microbiome in relation to dental health and disease.
Developers¶
Omics Pipe is developed by Kathleen Fisch, Tobias Meissner and Louis Gioia at The Su Lab in the Department of Molecular and Experimental Medicine at The Scripps Research Institute in beautiful La Jolla, CA.
Contact¶
Feedback, questions, bug reports, contributions, collaborations, etc. welcome!
Email<EMAIL_ADDRESS>Twitter: @kathleenfisch


{% extends 'base.html' %} {% load data_import %} {% load utilities %} {% block extra_js %} {% endblock %} {% block head_title %}Data selfie{% endblock %} {% block extra_modals %}
Do you a have a data type that we don't yet support? Upload any files you want to your Data Selfie.
Test results, medical imaging, and genetic data, or microbiome data are examples of data you might share. When you share new types of data in the Data Selfies, it makes it easier for us to add it as a supported data type. Of course, we'll never be able to standardize everything about our health and biology—sometimes you have data that's uniquely you!
We don't do any processing of Data Selfie files. If you're a member of the Public Data Sharing study you'll be able to share these publicly. It'll be your responsibility to understand what's being shared, we won't process them to remove potentially sensitive information.
{% if data_files %}| File | Size | Downloads | Description | |
|---|---|---|---|---|
| {{ data_file.basename }} | {{ data_file.size|filesizeformat }} | {{ data_file.access_logs.count }} | {{ data_file.user_description }} | Edit description Delete |
You have not uploaded any data selfie files.
{% endif %} Upload new files Go to Data Selfie activity page {% endblock %}


Before Change
tile_grid_size_px, "tile_grid_size_px", value_range=(0, None),
allow_floats=False)
self.tile_grid_size_px_min = tile_grid_size_px_min
self.per_channel = iap.handle_probability_param(per_channel,
"per_channel")
def _augment_batch_(self, batch, random_state, parents, hooks):
if batch.images is None:
return batch
After Change
Exponent for the contrast adjustment. Higher values darken the image.
* If a number, then that value will be used for all images.
* If a tuple ``(a, b)``, then a value from the range ``[a, b]``
will be used per image.
* If a list, then a random value will be sampled from that list
per image.
* If a ``StochasticParameter``, then a value will be sampled per
image from that parameter.


class: center, middle # IEMS 5780
Building and Deploying Scalable
Machine Learning Services ### Lecture 9 - Concurrent Programming (II) #### Albert Au Yeung
8th November, 2019 --- class: middle, center # Asychronous Programming --- class: equal-split # Asynchronous Programming - Consider the two models of programming we have came across so far - Ref: http://krondo.com/in-which-we-begin-at-the-beginning/ .column-left[
- The single thread synchronous model - Everything is executed sequentially - Latter tasks can consume output of earlier tasks that have completed ] .column-right[
- The multi-thread or multi-process parallel model - Tasks are executed in parallel - If tasks need to communicate with each other they need shared objects ] --- class: split # Asynchronous Programming .column-left[ - There is also a model called **asynchronous programming** - All tasks run in a single thread, but their execution can be **interleaved** - NO two tasks will be executed at exactly the same time - **The programmer would decide** when to switch from one task to another task (in contrast to the multi-thread model) - **Why** do we need such a model? ] .column-right[
] --- class: split # Asynchronous Programming .column-left[ - Both **computation** and **I/O** operations will be involved in many tasks (e.g. sorting a list of numbers vs. loading data from a DB) - For a **
single-threaded synchronous model
** - One task has to wait until another task has finished, even when the previous task is blocking - For a **
multi-threading model
** - Different threads must either carry out independent tasks, or use some sophisticated way to communicate among each other ] .column-right[
- A task may invoke quite a lot of blocking function calls during with the CPU is idling ] --- class: split # Asynchronous Programming .column-left[ - An asynchronous program will **switch** to perform another task when one task is blocked by some I/O operations - Such a program will only **block** when no tasks at hand can make any progress (e.g. all tasks are waiting for downloading something from the Internet) - Thus, an asynchronous program is also called a **non-blocking** program ] .column-right[
The asynchronous model
] --- # Asynchronous Programming ### When should we use asynchronous programming? 1. The number of tasks to execute is **large**, so it is likely that there is always at least one task that can make progress 2. The tasks perform a lot of **I/O** operations (thus using a synchronous model will waste a lot of time) 3. The tasks are **independent** from one another, no or little inter-task communication is needed - Sounds like what a **server** needs to do when facing a lot of **clients**! --- # Revisit the TCP server ```python import socket server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((socket.gethostname(), 50001)) server_socket.listen(10) while True: (client_socket, address) = server_socket.accept() data = client_socket.recv(1024) client_socket.sendall(data) client_socket.close() ``` - We have discussed how to use multi-threading or multi-processing to implement the TCP server - How about using the **asynchronous model**? --- # Non-blocking Socket Operations - By default, all socket methods are **blocking** (e.g. `accept()`, `recv()`, `send()`) - We can switch to use sockets **asynchronously** by using the `setblocking()` method - Then all socket methods will return **immediately** (!?) ```python # Create a TCP/IP socket server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.setblocking(0) ... ``` --- # Non-blocking Socket Operations - What happen after we set sockets to non-blocking? - `accept()`, `recv()`, `send()` may return **without having done anything**! - We need a way to know whether calling that method will result in something done - Only call `accept()` when a client is trying to connect - Only call `recv()` when some data is ready to be read - Only call `send()` when we have successfully connected - **Soluton 1:** using the `select()` function in the `select` module - Ref: https://docs.python.org/3.6/library/select.html --- class: split # Using `select` .column-left[
(From W. Richard Stevens. Unix Network Programming. 1990)
] .column-right[ - `select()` is a function that you should use when you want to do **I/O multiplexing** - **I/O multiplexing**: switching between different I/O tasks when they are ready for reading or writing ] --- # Using `select` - To use select, you need to prepare **three** lists - A list of sockets you want to **read from** - A list of sockets you want to **write to** - A list of sockets you want to **check for errors** - It also returns three lists: - A list of sockets you can read from - A list of sockets you can write to - A list of sockets with errors ```python readables, writables, w_errors = select(inputs, outputs, [], 60) # 60 is timeout in seconds, empty lists will be returned upon timeout ``` - Note: on Unix/Linux systems, `select()` works on file handlers too (because everything is a file) --- # Using `select` ```python import socket from select import select server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.setblocking(0) server.bind(('localhost', 56789)) server.listen(10) inputs = [server] # we want to accept (read) from this socket outputs = [] # nothing we want to write to so far while True: readables, writables, w_errors = select(inputs, outputs, [], 60) ... ``` --- # Using `select` ```python while True: readables, writables, w_errors = select(inputs, outputs, [], 60) for soc in readables: if soc is server: # server socket is readable, someone is connecting client_socket, address = soc.accept() client_socket.setblocking(0) # also set to non-blocking inputs.append(client_socket) # a socket that we want to read from else: # It is a client socket, let's read from it data = soc.recv(1024) if data: # Handle the data else: # Empty string, client has disconnected # Close this socket, remove it from all lists ``` --- # Using `select` - Continue... ```python for soc in writables: # This should be a client socket # Send something to it if you want to soc.send("Hello from Server") for soc in w_errors: # Socket has error # We should close the socket and remove it from all lists ... ``` - See complete example at [https://pymotw.com/3/select/](https://pymotw.com/3/select/) --- class: middle, center # Asynchronous I/O --- # Introduction - `asyncio` is included in the standard library starting from Python 3.4 - A single-thread asynchronous model of programming - `asyncio` allows you to switch between different **coroutines** when there are blocking calls - Before diving into `asyncio`, let's learn about **generators** and **coroutines**
(Ref: https://eng.paxos.com/python-3s-killer-feature-asyncio)
--- class: split # Iterators .column-left[ - In Python, we can use a for loop to loop over: - a list (e.g. `[1, 2, 3, 4, 5]`) - a dictionary (e.g. `{1: "a", 2: "b"}`) - a file (e.g. `for line in infile: ...`) - Things that can be iterated over are called **iterable objects** - We can turn iterable objects into **iterators** using the `iter()` function ] .column-right[ ```python >>> l = iter([1, 2, 3, 4]) >>> l
>>> next(l) 1 >>> next(l) 2 >>> next(l) 3 >>> next(l) 4 ``` ] --- # Generators ### **Generator** functions provide a simplified way to create iterators - Generator returns a sequence of values, one at a time - It *generates* a new value **on-the-fly**, without the need to store all values in memory - Consider the `range()` function. How would you implement that? --- # Generators ### Our first attempt to implement the `range()` function ```python def my_range_1(n): nums = [] i = 0 while i < n: nums.append(i) i += 1 return nums ``` - **Problem**: if `n` is large (say 1,000,000), you end up creating a huge list of integers that eats up a lot of memory --- # Generators ### A better approach ```python def my_range_2(n): i = 0 while i < n: yield i i += 1 ``` - `yield` is used in place of `return`, now the function becomes a **generator** - When the line `yield i` is reached, the function will return the value of `i`, and **pause**, until we call its `next()` function again --- # Generators ```python nums = my_range_2(100) print(nums) # Prints something like
next(nums) # returns 0 next(nums) # returns 1 ... ``` - Your function becomes an **iterator**, which can be iterated over to return a new value at a time - The function is **NOT terminated**, because it remembers its current state - Now, you notice that a `for` loop is just a loop that helps you to call the `next()` function automatically if given a generator --- # Generators ### Another example: ```python def get_odds(n): """Return odd numbers up to n""" i = 0 while i < n: i += 1 if i % 2 == 0: continue yield i o = get_odds(100) next(o) # returns 1 next(o) # returns 3 ... ``` --- # Generators - You can also chain iterators: ```python def get_every_two_odds(odds): i = 0 for o in odds: if i % 2 == 0: yield o i += 1 nums = get_every_two_odds(get_odds(100)) next(nums) # returns 1 next(nums) # returns 5 next(nums) # returns 9 ``` --- # From Generators to Coroutines - For generators, we use the `yield` keyword to specify where the function should return a value and stop, waiting for the next call of `next()` - What if we want something the other way round: we want a function to pause and wait for something to **be sent** to it? - Consider an example: we would like to write function that returns whether a given number `x` is a divsor of a given number `n` (e.g. if n = 10, x = 2, then this function returns `True`) ```python def is_divisor(x, n): return n % x == 0 is_divisor(2, 10) # returns True is_divisor(3, 32) # returns False is_divisor(5, 55) # returns True ``` --- # From Generators to Coroutines - We can also re-write this in the form of a **coroutine**, one that would **wait for an input** to be sent into it ```python def is_divisor(n): while True: x = yield yield n % x == 0 d = is_divisor(55) next(d) d.send(2) # returns False next(d) d.send(5) # returns True next(d) d.send(11) # returns True ``` --- class: split # Coroutines .column-left[ ```python def is_divisor(n): while True: x = yield yield n % x == 0 d = is_divisor(55) next(d) d.send(2) # returns False next(d) d.send(5) # returns True next(d) d.send(11) # returns True ``` ] .column-right[ - The first `yield` is for waiting input to be sent into the function - The second `yield` is for emitting a value - We need to call `next()` to make the function arrives at the line `x = yield` again. ] --- # Coroutines - Another way to implement the `is_divisor` coroutine ```python def is_divisor(n): x = 1 while True: divisible = False if n % x == 0: divisible = True x = yield divisible d = is_divisor(55) next(d) # this would return True d.send(2) # returns False d.send(5) # returns True d.send(11) # returns True ``` --- class: split # Coroutines .column-left[ ```python def is_divisor(n): cnt = -1 x = 1 while True: divisible = False if n % x == 0: cnt += 1 divisible = True x = yield (divisible, cnt) d = is_divisor(55) next(d) # this would return True d.send(2) # returns (False, 0) d.send(5) # returns (True, 1) d.send(11) # returns (True, 2) ``` ] .column-right[ - A coroutine stores its internal **state** - For example, we can count how many times we see a divisor of `n` ] --- # More on Coroutines - **Coroutines** can be considered as generalized **subroutines** (a sequence of instructions that carry out some tasks) - Coroutines have **multiple entry points** for suspending and resuming execution (unlike subroutines) - Coroutines allows a programmer to **explicitly** handle context changes (when to switch from one task to another task) - (Compare this with multi-threading or multi-processing) --- class: split # Event Loop .column-left[ - We will discuss more about `asyncio` in the next lecture, but let's get to know about the **event loop** first - Event loop: *"a programming construct that waits for and dispatches events or messages in a program"* - It keeps on waiting for events to happen, and execute different tasks depending on what event happens Ref: [A guide to asynchronous programming in Python with asyncio](https://medium.freecodecamp.org/a-guide-to-asynchronous-programming-in-python-with-asyncio-232e2afa44f6) ] .column-right[
] --- class: middle, center # `asyncio` --- # `asyncio` - A framework for asynchronous programming in Python - For writing **single-threaded** concurrent code using coroutines - Some important concepts: 1. Event Loop 2. Coroutines 3. Futures / Tasks --- # Event Loop - An event loop is the **central execution device** in `asyncio` - It is a program construct that waits for something (**events**) to happen, and then act on them - It can register **tasks** to be executed, execute them, deplay or cancel them - It allows two or more functions to run together **co-operatively** - Example of **events**: - A client has connected to the server - A client has sent a certain request - Finished downloading a file from a remote server - Each event may be associated with some functions (**callbacks**), which will be invoked when the event is triggered --- # Futures / Tasks ### A **future** is an object that is supposed to have a **result** in the future - **Task** is a scheduler, it schedule the execution of a coroutine - Responsible for executing a coroutine object in an event loop - A task will suspend a coroutine if the it has to wait for some futures to be completed - The event loop only runs **one** task at a time - When a task waits for the completion of a future, the event loop executes a new task (if available) --- # Example ```python import asyncio async def fake_io_operation(): # simulate some long I/O operations print("Perform I/O now...") await asyncio.sleep(1) print("I/O completed") async def compute_square(x): print("Compute square of %d" % x) await fake_io_operation() print("Square of %d is %d" % (x, x*x)) tasks = [] for i in [4, 5, 6, 7]: tasks.append(asyncio.ensure_future(compute_square(i))) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(tasks)) loop.close() ``` --- class: split # Example (continue) .column-left[ ```python import asyncio async def fake_io_operation(): print("Perform I/O now...") await asyncio.sleep(1) print("I/O completed") async def compute_square(x): print("Compute square of %d" % x) await fake_io_operation() print("Square of %d is %d" % (x, x*x)) ... ``` ] .column-right[ - The `async` keyword changes a function into a **coroutine** (a *native coroutine*) - `await something` will suspect the coroutine at that point, until that *something* is completed - Calling a **coroutine function** does not start it, it will just return a **coroutine object** ] --- class: split # Example (continue) .column-left[ ```python ... tasks = [] for i in [4, 5, 6, 7]: tasks.append( asyncio.ensure_future( compute_square(i))) loop = asyncio.get_event_loop() loop.run_until_complete( asyncio.wait(tasks)) loop.close() ``` ] .column-right[ - `ensure_future` creates a task that wraps a **coroutine** (in this case the `computer_square()` function) - `asyncio.wait(tasks)` wraps all tasks in a **coroutine** so that they can be passed to the event loop - `run_until_complete` will run all the **tasks** passed to it until everything is completed ] --- class: split # Example (continue) .column-left[ - What would happen if we execute the above script? - Observations: - When one task reaches the `asyncio.sleep(1)` line, **another** task is executed - When all tasks reaches that line, the whole program is **blocked** (why?) - The program terminates when all tasks are completed ] .column-right[ ```bash Compute square of 4 Perform I/O now... Compute square of 5 Perform I/O now... Compute square of 6 Perform I/O now... Compute square of 7 Perform I/O now... I/O completed 16 I/O completed 25 I/O completed 36 I/O completed 49 ``` ] --- # Another Example - Consider another example (from https://docs.python.org/3/library/asyncio-task.html) ```python import asyncio async def compute(x, y): print("Compute %s + %s ..." % (x, y)) await asyncio.sleep(1.0) return x + y async def print_sum(x, y): result = await compute(x, y) print("%s + %s = %s" % (x, y, result)) loop = asyncio.get_event_loop() loop.run_until_complete(print_sum(1, 2)) loop.close() ``` --- # Another Example (continue)
--- class: split # Getting the Result of a Coroutine .column-left[ - What if you want to get back the results of the coroutines? ```python ... tasks = [] for i in [4, 5, 6, 7]: tasks.append( asyncio.ensure_future(compute_square(i))) loop = asyncio.get_event_loop() results, _ = loop.run_until_complete( asyncio.wait(tasks)) loop.close() for f in results: print(f.result()) ``` ] .column-right[ ```bash Compute square of 4 Perform I/O now... Compute square of 5 Perform I/O now... Compute square of 6 Perform I/O now... Compute square of 7 Perform I/O now... I/O completed I/O completed I/O completed I/O completed 16 25 49 36 ``` ] --- # Using `asyncio.gather()` - `asyncio.gather()` focuses on gathering all results for you - It may not run the coroutines in order, but the results will be in order as the input ```python ... loop = asyncio.get_event_loop() coros = [compute_square(i) for i in range(5)] all_futures = asyncio.gather(*coros) loop = asyncio.get_event_loop() results = loop.run_until_complete(several_futures) loop.close() # results is a list: [0, 1, 4, 9, 16] ``` --- # Event Loop - Notice that we must use `run_until_complete()` to make sure that all tasks have been completed - `ensure_future()` creates a future from the coroutine function, it also tries to execute the task - What if we do not wait for the completion of the task(s) (try removing the line with `run_until_complete()`)? ```bash Task was destroyed but it is pending! task:
> Task was destroyed but it is pending! task:
> Task was destroyed but it is pending! task:
> Task was destroyed but it is pending! task:
> sys:1: RuntimeWarning: coroutine 'compute_square' was never awaited ``` --- # Concurrent Execution of Many Tasks - Do we get speed up using `asyncio`? Let's try a test ```python import asyncio async def long_task(x): print("Wait for 1/{:d} seconds...".format(x)) await asyncio.sleep(1.0 / x) return 1.0 / x coroutines = [long_task(i) for i in range(1, 101)] loop = asyncio.get_event_loop() all_futures = asyncio.gather(*coroutines) loop.run_until_complete(all_futures) loop.close() ``` --- # Concurrent Execution of Many Tasks - We can measure the time of the execution of the script by: ```bash $ time python3 example.py ... real 0m1.099s user 0m0.100s sys 0m0.004s ``` - If the tasks are executed sequentially, it would require 1 + 1/2 + 1/3 + ... + 1/100 = **5.187 seconds** - When a task has to wait, the event loop will start to execute another task, thus almost all tasks are started at the same time. --- class: center, middle # End of Lecture 9


|
YAGP 0.2
|
An unknown tag or error. More...
Inherits SharpGEDParser.Model.LineSet.
Public Types | |
| enum | ErrorCode { Exception = 1, UntermIdent, MissIdent, MultChan, InvXref, MissName, ChanDate, InvNCHI, MultNCHI, MultId, MissFile, MissForm, RefSourText, EmbSourEven, MultCHIL, MissHEAD, EmbSourPage, MultHUSB, MultWIFE, MultRESN, InvRestrict, InvExtra, InvSex, EmptyLine, LineTooLong, InvLevel, EmptyFile, MissTag, IdentCollide, UnsuppLB, MissCharSet, BOMMismatch, ForceASCII, NonStdAlias, CustTagsSeen, EmptyName, SlashInName, UntermSurname } |
| Possible error codes. More... | |
Properties | |
| ErrorCode | Error [get, set] |
| Any error code associated with the record. More... | |
| string | Tag [get, set] |
| The tag associated with the record. More... | |
| Properties inherited from SharpGEDParser.Model.LineSet | |
| int | Beg [get, set] |
| Beginning line number of the set. More... | |
| int | End [get, set] |
| Ending line number of the set. More... | |
| int | LineCount [get] |
| Number of lines in the set. More... | |
An unknown tag or error.
If this represents an unknown tag, the ErrorCode will be zero.
If this represents an error, the ErrorCode will have a non-zero value. Some errors may not have a line range, being a global or breaking problem.
|
strong |
Possible error codes.
|
getset |
Any error code associated with the record.
|
getset |
The tag associated with the record.


{% load define_action %} {% assign ""|add:source_type|add:" "|add:year as source_text %} {% assign "Learn more about these programmes in the "|add:source_type|add:" as PDF" as pdf_text %} {% assign "Learn more about these programmes in the "|add:source_type|add:" as Excel" as excel_text %} {% assign "Dataset Guide for "|add:source_type as guide_text %}
A department's programmes are the activities that it spends money on during the financial year. Different programmes have different budgets, depending on their objectives and available budgets. More detail on the programmes is available in the department's {{ source_type }} documents.


Comment on Metro Transit service
Thank you for your submission.
We have received your request and/or feedback.
= Required Field
Thank you for submitting a comment. We value your feedback and share this information with appropriate departments to look into or address. If you require a response, please check yes and staff will follow up with you within a week.
Give us your suggestions and comments!
Use the form below to commend an employee for excellent performance or to register a complaint about bus or rail service. You can also submit comments by calling Customer Relations at<PHONE_NUMBER> on weekdays between 8 a.m. and 4:30 p.m.
Note: Metro Transit does not provide trip planning assistance by e-mail. For route and schedule information, use the online Trip Planner or call a transit information expert at<PHONE_NUMBER>.
> Comment on this website (metrotransit.org)
If you know your route, get real-time departure information with NexTrip.
Instructions
Please complete the following information. A comment and a first name are required to submit this form. Please include an email address if you would like a response to your comment.


Hi all,
i have a problem with a new emonTX that i finish(most) this days.
-i use the new emonTX pcb (buy it mounth ago)
-complete it but with out AC-AC components on it (just ct1 and ct2)
-i use it with out AC-AC adaptor (obviously)
-use the CT1 interface
-clip it on the phase(not on null) cable of the power grid
-program it with the emonT singleCT example (i use arduino 1.0)
-i use the arduino 1.0 framework
On the zero consum, the monitor give me 0 or 1 or 2 values
If i turn on the flatiron (2000 watts) the monitor give me 8 value
Is there anybody can help me please ?
Thanks all in advance
Denis
p.s. this famous burder resistor is allready on the pcb ? or i must add it ?
Re: new emonTX pcb
Somthing is wrong. Could you post a photo of your emonTx board? That way I can check it all look correct. It should look like this: https://picasaweb.google.com/113226203437598291129/EmonTxV20SingleCTBuild#5670751021382405762
Re: new emonTX pcb
Thanks a lot Glyn
here is the pic:
p.s. just today was arrived the missing MCP1702 ...thanks
Denis
Re: new emonTX pcb
CT1 and CT2 channels look like they have been assembled Ok. The the colours on the voltage divider resistors R2 and R3 for channel CT 2 look a bit odd but I think its just a different shade of violet. They should be 470K which is yellow, violet, yellow, gold/silver. If in doubt you can always check the resistance with a multimeter.
The image on the page details which components do what: http://openenergymonitor.org/emon/node/234
CT3 is missing the 15 ohm burden resistor and 10uF capacitor. But CT1 and CT2 should still work.
So basicly it should work OK. Can you post a photo of how you have clipped the CT round the AC cable? and maybe a shot of the underside of the board?
Re: new emonTX pcb
Thanks again for the help
...so here is the other side: (click on it to see it biger ...i hope:-)
here is the clip picture ... and please can you confirm me the pinout of the AC-AC adaptor if is ok like this ?
and here is again all ... i just begin to put also the AC-AC part:
Thanks again
Denis
Re: new emonTX pcb
What you are doing wit the AC-AC adapter is very dangerous. You should get a proper UK to European plug converter before testing.
The emonTx build look ok. Try again uploading the emonTx single CT example and using the middle (CT2) connection.
Re: new emonTX pcb
Dear Glyn,
now i'm finish the AC-AC adaptor part and i just test it with a 1500 watts
and i just program the emonTX_1CT_Voltage file ... here is the result:
Re: new emonTX pcb
Ah, that looks like it's working better now. Which country do you live? Is your AC voltage 210V?
Calibrating the emonTx is discussed here: http://openenergymonitor.org/emon/node/330


1 type derived from RunspacePoolInternal
System.Management.Automation (1)
engine\remoting\client\RemoteRunspacePoolInternal.cs (1)
26
internal class RemoteRunspacePoolInternal :
RunspacePoolInternal
, IDisposable
2 instantiations of RunspacePoolInternal
System.Management.Automation (2)
engine\hostifaces\RunspacePool.cs (2)
549
_internalPool = new
RunspacePoolInternal
(minRunspaces, maxRunspaces, host);
586
_internalPool = new
RunspacePoolInternal
(minRunspaces,
1 reference to RunspacePoolInternal
System.Management.Automation (1)
engine\hostifaces\RunspacePool.cs (1)
507
private readonly
RunspacePoolInternal
_internalPool;


{% extends 'global/base.html' %} {% block content %}
The event for {{ city|title }} has already happened and the webpage is no longer live.
{% else %}The event page for {{ city|title }} will be coming soon.
{% endif %}If you want to contact the organizers of this event, you can email them at {{ city|lower }}@djangogirls.org


Rugby: Bok stalwart Louw announces international retirement
CAPE TOWN: South Africa loose-forward Francois Louw confirmed his retirement from international rugby on Sunday, the second of the Springboks' World Cup-winning side to call time on their careers in the green and gold.
Louw, who came off the replacement bench for captain Siya Kolisi in the 32-12 victory over England in the World Cup decider on Nov. 2, won 76 test caps having made his debut in 2010.
"I couldn't have asked for a more fulfilling career with the Springboks and I bow out with a full heart," he said in a media release from South Africa Rugby.
"I've had an amazing journey in international rugby. I've made friends for life in the game and created incredible memories with great people."
Bok coach Rassie Erasmus was full of praise for the contribution of the Bath loose-forward to their World Cup campaign.
"Flo was a real warrior of the back row. He was always ready to go where the fire was hottest and was the kind of tough-minded character that you'd always want beside you," Erasmus said.
"He has been a tremendous servant of South African rugby and we're losing a lot with his retirement, not just in how he played, but in the calmness, insight and character that he brought to the group."
Louw's retirement follows that of prop Tendai Mtawarira, who won the last of his 117 caps in the World Cup final.


This manages the available study views. Views show a subset of attributes, and can be authorized for a group of users.


02 Mar 2015
Items Covered:
- Growing Complexity
- Interactive Debugging for Solution Delivery
- Transactions
Growing Complexity Guided By Tests
Tags.all.map(&:name) == Tags.all.map{|tag| tag.name}
def create
@todo = Todo.new(params[:todo])
if @todo.save
location_string = @todo.name.split('at').last.strip
@todo.tags.create(name: "location#(location_string)")
redrect_to root_path
else
render :new
end
end
strip method removes all spaces.
def create
@todo = Todo.new(params[:todo])
if @todo.save
location_string = @todo.name.split('at').last.strip
locations = location_string.split('and')
locations.each do |location|
@todo.tags.create(name: "location:#(location)")
redrect_to root_path
else
render :new
end
end
When to use each vs map
each is used for when you want to iterate through a an collection of data, an
array for example but you dont want to manipulate the result.
map is ideal for when iterating over a collection and then you need to alter of manipulate those returned values for input into another problem.
When to use split vs regex
Use split when searching for one element
And regex when searching for more than one.
Interactive Debugging for Solution Discovery
After writing and implementing your test cases, you should run sanity checks within your browser.
If bugs are identified, you should run write tests to isolate it the bug.
Use Binding.pry to in your controller being tested, after the problematic line.
Binding.pry is really just irb so you now have a means to experiment with your code
until you find the right solution.
For a good regex tutorial:
Regex Tutorial
Rubular
.split method cannot run on nil so Ruby 1.9 introduced .try(:split),
which will run .split if not nil.
Transactions
Wrapping batch operations into transactions:
To update the queue in MyFlix, the position entered must be an integer.
If not, the entire page will fail to update. This is unlike normal transactions
where we can include a validation error.
This is where the concept of transactions come in. If all actions in the transaction
do not save, it will rollback.
Transactions are protective blocks where SQL statements are only permanent if
they can all succeed as one atomic action. The classic example is a transfer between
two accounts where you can only have a deposit if the withdrawal succeeded and vice versa.
Transactions enforce the integrity of the database and guard the data against program errors or database break-downs.
So basically you should use transaction blocks whenever you have a number of statements that must be executed together
or not at all.
28 Feb 2015
Use Faker to Generate Fake Data
Creating fake data when your model has uniqueness validations will throw errors
if your data is not unique.
Fabricator(:todo) do
name { "cooking" }
user
end
Fabricator(:user) do
email {<EMAIL_ADDRESS>#This will throw an error eventually if email record already exists.
end
Examples
Creating a category:
Fabricator(:category) do
name { Faker::Name.name }
end
Creating a video:
Fabricator(:video) do
title { Faker::Lorem.words(5).join(" ") }
description { Faker::Lorem.paragraph(2) }
end
Creating an invitation:
Fabricator(:invitation) do
recipient_name { Faker::Name.name }
recipient_email { Faker::Internet.email }
message { Faker::Lorem.paragraphs(2).join(" ") }
end
Read more: Faker Docs
26 Feb 2015
It's typical to create many objects during testing and the more attributes you have
the more cumbersome it could be to maintain, moreover, if an attribute changes, it then becomes very difficult
to update all those tests.
To make this better, we can use an object generator framework called Fabrication.
Steps:
1. Create a folder under specs called "Fabricators"
2. create fabricator_todo.rb
Fabricator(:todo) do
name { "cooking" }
end
3. You can also create a user each time a todo is created:
Fabricator(:todo) do
name { "cooking" }
user { Fabricate(:user) }
end
or
Fabricator(:todo) do
name { "cooking" }
user
end
In your test suite:
If you want to create an object in your database:
describe "#display_text" do
let(:todo) { fabricate(:todo) }
subject { todo.display_text }
If you would rather create an object in memory, you could:
describe "#display_text" do
let(:todo) { fabricate.build(:todo) }
subject { todo.display_text }
23 Feb 2015
Single Assertion principle states:
A test suite should only have one assertion, so that if there is a failure
they fail separately. If you find yourself using "and" then you are probably
testing too much at once:
get :index
assigns(:todos).should == (cook, sleep)
There is an exception to this rule - when the assertions are very related concerning the same object:
get :new
assigns(:todo).should be_new_record
assigns(:todo).should be instance_of(Todo)
20 Feb 2015
An Alternative Style of Rspec
- using let, before, subject, etc.
Uses lazy evaluation which means it doesn't evaluate the :todo
or the subject until it has to ...namingly when it reaches it or before.
To avoid lazy evaluation, you could do:
let!(:todo) {Todo.create(name: "cook dinner")}
Pros:
is more concise and separates the common set up code using lets
Cons:
For a lengthy test suite it may be hard to connect the test with the description.
Using let
Step 1. Eliminate the repetition of Todo.create in each test:
describe "#display_text" do
let(:todo) { Todo.create(name: "cook dinner") }
Step 2. Replace todo.display_ text
describe "#display_text" do
let(:todo) { Todo.create(name: "cook dinner") }
let(:subject) { todo.display_text }
or
Step3. Replace todo.display_text
describe "#display_text" do
let(:todo) { Todo.create(name: "cook dinner") }
subject { todo.display_text }
Using before for case specific tests
context "displays the name when there's no tags" do
it "displays the name when there's no tags" do
subject.should == "cook dinner"
end
end
context "displays the only tag with word 'tags' when there's one tag"
before do
todo.tags.create(name: "home")
todo.tags.create(name: "urgent")
end
it "displays name with multiple tags" do
subject.should == "cook dinner (tags: home, urgent)"
end
end
Change lengthy context to more succinct:
context "displays the only tag with word 'tags' when there's one tag"
to =>
Remove the "it -text-" because its in context with the description
context "one tag" do
before { todo.tags.create(name: "home") }
it { should == "cook dinner (tag: home)" }
end


Set default for always
option of decorators. Default can be overridden in decorator options.
If set to true, the validation will not use default messages. Error message always will be undefined if its not explicitly set.
If set to true then class-validator will print extra warning messages to the console when something is not right.
If set to true, instead of stripping non-whitelisted properties validator will throw an error
Settings true will cause fail validation of unknown objects.
Groups to be used during validation of the object.
If set to true then validator will skip validation of all properties that are null or undefined in the validating object.
If set to true then validator will skip validation of all properties that are null in the validating object.
If set to true then validator will skip validation of all properties that are undefined in the validating object.
When set to true, validation of the given property will stop after encountering the first error. Defaults to false.
If [groups]{@link ValidatorOptions#groups} is not given or is empty, ignore decorators with at least one group.
ValidationError special options.
If set to true validator will strip validated object of any properties that do not have any decorators.
Tip: if no other decorator is suitable for your property use @Allow decorator.
Generated using TypeDoc
Options passed to validator during validation.


Welcome!
<EMAIL_ADDRESS>Aashis Kumar Chittawat
AEC 6th sem
<EMAIL_ADDRESS>Dip Jyoti Dutta
AEC 6th sem
<EMAIL_ADDRESS>Gaurab Paul
AEC 6th sem
<EMAIL_ADDRESS>Mrinab Dey
AEC 6th sem
<EMAIL_ADDRESS>Pankaj Kumar Sah
AEC 6th sem
❮
❯


./komodod -ac_name=ZAWY24 -ac_adaptivepow=1 -ac_supply=1000000 -ac_reward=10000000000 -ac_cc=2 -addnode=<IP_ADDRESS> &
A channel to discuss mining. For useful links and more info click the pinned messages to the right.
100 messages
Before 05-Dec-19 12:00 AM
BlackJesus19-Jun-18 03:22 PM
the latter half of my statement is a major change for orphan interest
Definitely I feel like this will be a defining moment for privacy cryptos specifically zksnarks vs. ring signatures
They have clearly taken divergent dev paths now. Funny thing is we know where the asic path leads. stares at BTC/BCH
ComputerGenie19-Jun-18 03:24 PM
If your stratum and your interweb connections are good, orphans are quite minimal
I think I've had like 3 this year and that includes days of 1M+ Sols in rentals
BlackJesus19-Jun-18 03:25 PM
granted a community split will be less likely I think in privacy cryptos due to the dev team coming from inception with ico's
orphans are rare
I know you ordered a ton of z9's You going to do 50/50
with your amount you certainly have to be pointing a decent size at zcash
ComputerGenie19-Jun-18 03:29 PM
as it stands now, the plan is that 1 mini will be on a custom stratum for asset chains (I still haven't started writing it yet, though), the GPU power will go towards Stanford's folding program, and most (if not all) of the minis will be on KMD
short of some outstanding profit margin jump, I can't see me aiming anything at zcash
BlackJesus19-Jun-18 03:35 PM
gotcha, same I see komodo on par and most likely better then ethereum. And we all know where ethereum peaked at :/.
Losses today are major gains tommorow.
ComputerGenie19-Jun-18 03:36 PM
well, if you look at value expected (assuming a rehitting of ath), ZEC = 4:1 and KMD = 6:1
BlackJesus19-Jun-18 03:36 PM
true.
ComputerGenie19-Jun-18 03:38 PM
and if you expand to 10x, KMD will hit $19.50 long before ZEC hits $1,982.5
BlackJesus19-Jun-18 03:38 PM
That's very true.
I fully expect komodo to go through a fomo phase unlike any other coin.
Due to the self generating interest.
ComputerGenie19-Jun-18 03:40 PM
it's literally the reason that I'm dumping so much under $2.25 in order to buy minis and Z9s too (when they come out)
I'm betting on a far greater future return than holding
BlackJesus19-Jun-18 03:41 PM
oh wow.
I'm planning to buy z9's as well.
ComputerGenie19-Jun-18 03:41 PM
Assuming most mini buyers head to ZEC, I should make it all back before Jan 1
BlackJesus19-Jun-18 03:42 PM
the majority will definitely be on ZEC
ComputerGenie19-Jun-18 03:44 PM
The evil side of me has a true hope that one of the ASIC makers (hopefully BM since I'm buying so many from them) make their fw open source and they can support RAM upgrades and the KN changers get crushed
even if 3GB of RAM sends the BM prices up by 10x, they're still more powerful and profitable than GPUs
BlackJesus19-Jun-18 03:46 PM
what is a kn changer
ComputerGenie19-Jun-18 03:47 PM
a few coins are changing the K and N values of their algo to be "more ASIC resistant", based on the myth that ASIC have like no RAM
Alright19-Jun-18 03:47 PM
There are supposive firmware dumps of z9s floating around(edited)
BlackJesus19-Jun-18 03:48 PM
oh yea, I heard about that to break asics they were upgrading the k and n values
ComputerGenie19-Jun-18 03:52 PM
it doesn't "break" anything; in simplest terms, it just makes a more "complex" computation that requires more RAM and power to solve
with 200 and 9 as values, a 1080TI uses 50 MB of RAM and can do ~740 Sol/s
with 144 and 5 as values, a 1080TI uses 2.5 GB of RAM and can do ~58 Sol/s
BlackJesus19-Jun-18 03:52 PM
that's dumb why would zcash do tht
Right now they are doing their best to reduce the memory intensiveness of shielded transactions
making the base algorithm more memory intensive seems extremely counterintuitive
ComputerGenie19-Jun-18 03:53 PM
it reality, the change is driven by 2 camps
those that own GPUs already
those that hate Bitmain
UPS air is a bit faster and more expensive than FedEx boat
conversely FedEx pre-clears shipments, so less overall issues with customs
It's a coin flip, really; but, since BM has the account page feked for what they link to FedEx when you order I went with UPS this time around
SHossain20-Jun-18 04:09 PM
I will never use FedEx anymore in life if I have other alternatives. Would even pay more for other companies.
xRobeSx20-Jun-18 05:41 PM
whats your beef with fedex shossain?
ComputerGenie20-Jun-18 05:45 PM
besides the hidden fees?
xRobeSx20-Jun-18 05:52 PM
I'm not disagreeing, just wondering. I've never really noticed fedex fee's being much more than anyone else's.. but most of my shipping comes from amazon
I just saw my email from Bitmain. It says that my power supply was shipped but not the z9 mini... hmm
ComputerGenie20-Jun-18 05:55 PM
every international shipment I've ever gotten through FedEx, they "pre clear" customs and then try to charge me for it after
FishyGuts20-Jun-18 10:24 PM
I feel like I need to hang out in here more often.
None of my minis have shipped. I am sad fishy.
I did half my order with UPS and half with DHL. I hope DHL gets it right. I've always used them in the past but not so much for international.
ComputerGenie20-Jun-18 10:43 PM
DHL will likely get shipped FedEX part way
! |🆉🆉🆉🆉🆉.🆉🆉| ! - crackers20-Jun-18 10:51 PM
Ups z9’s on route woop
ComputerGenie20-Jun-18 11:17 PM
@crackhead, how many did you order?
! |🆉🆉🆉🆉🆉.🆉🆉| ! - crackers20-Jun-18 11:26 PM
Limit was 1 :/
For the first batch
All the coins will have run away from the algo by the time everyone get them
Only to do it all again when they produce the new algos too
blackjok3r21-Jun-18 12:54 AM
haha... maybe they will all just get pointed at KMD if all other coins change. Should give our hash rate a nice boost
jansako21-Jun-18 09:06 AM
Hi folks, anyone here knows about a Dutch company 'Whinkel' (www.whinkel.be)? Looks like I got hoodwhinkel'd by them... ordered ~10K EUR worth in miners, they stopped communicating not long after the Bitmain news...
Cryptoon21-Jun-18 01:41 PM
Bel direct 03-808 46 89 voor onze Personal Whinkel Assistants.
Bent u het eens met de TrustScore van Whinkel? Geef uw mening vandaag en hoor wat 189 klanten al gezegd hebben.

Voor degene die hun geld terug willen en mee willen doen aan een juridische vervolging van Whinkel B.V. , stuur even een mailtje naar whinkel.vervolgen(at)gmail(punt)com
@jansako if you want I know some lawyers in Belgium
ComputerGenie21-Jun-18 01:46 PM
is confused as to why you'd even buy one 2nd-hand retail
"Your package is awaiting release from the clearing agency for formal entry at the export location."
Yay, customs lag in China; because, who wants miners anyway
Cryptoon21-Jun-18 02:09 PM
How much hash coming your way in the first batch?
ComputerGenie21-Jun-18 02:10 PM
1 from batch 1 and 2 from batch 1.5
Cryptoon21-Jun-18 02:11 PM
ah so not that much initially
Thought I read that you had something like 50+ units coming your way
ComputerGenie21-Jun-18 02:12 PM
In the july/aug batch I have 45
45 confirmed; I'd like to push it to 60
Cryptoon21-Jun-18 02:13 PM
If I had that much hash coming my way
I would probably be too tempted to point them at shitcoin x or y and mess around a bit
ComputerGenie21-Jun-18 02:13 PM
I might do that after they pay themselves off
Cryptoon21-Jun-18 02:14 PM
So after a month or so? ;p
I'm curious to see how many 51% incidents we will see the coming months
ComputerGenie21-Jun-18 02:14 PM
at current markets, like 4 months
Cryptoon21-Jun-18 02:14 PM
And how miners will adjust to new equilibria
As some will change algo etc
ComputerGenie21-Jun-18 02:15 PM
I'm still of the belief that manufactures will not be too far behind in adding RAM and 3 variables
unless ZEC moons, they almost have to in order to sell any more units past Jan 1
meanwhile, GPU fanboys are betting on the misguided notion that real miners will not be willing to pay up to 10x extra for ASICs that earn 14x ROI over GPUs
Cryptoon21-Jun-18 02:32 PM
Wasnt a Z9 mini already 10x more performant for only like twice the price?
ComputerGenie21-Jun-18 02:35 PM
current batches (with PSU included) are ~ $30 more than 1 single 1080TI card
by the time you count hw, minis are cheaper than 1 card and ~13.5x the sols
per sols, you need 14 1080TIs to match 1 mini
and 10k sol GPUs are at 13x the energy costs too
a mini at $8,500 is still a discount over GPUs
Cryptoon21-Jun-18 02:38 PM
damn
Was pretty close to buying a 10k 1080ti rig back in march
Good thing I was too lazy to do more research first
ComputerGenie21-Jun-18 02:39 PM
a single 10k rig is too much overclock for my taste
Cryptoon21-Jun-18 02:40 PM
10k usd
not sols
ComputerGenie21-Jun-18 02:40 PM
ahh
Cryptoon21-Jun-18 02:40 PM
That would have been money down the drain (in hindsight)
ComputerGenie21-Jun-18 02:41 PM
not really, you could always use it to fold or stick it on a donkey coin
I'll likely put most of my GPUs back to folding before the end of the year


← Back to home page
Miscellaneous
Belle
Brom
(sold)
Bayyard
(sold)
Crispin
(sold)
Casper
(sold)
Mace
(sold)
Maddox
(sold)
Guilliare
(sold)
Leo Frick
Fendrel
(sold)
Rowan
(sold)
Ice Cream Girl
(sold)
Maplehurst
(sold)
Surfer Boy
(sold)
Tristan
(sold)


THE PLACES YOU FREQUENTLY VISIT
Some quick example text to build on the card title and make up the bulk of the card's content.
Get Current DetailsSome quick example text to build on the card title and make up the bulk of the card's content.
Get Current DetailsSome quick example text to build on the card title and make up the bulk of the card's content.
Get Current DetailsSome quick example text to build on the card title and make up the bulk of the card's content.
Go somewhereSome quick example text to build on the card title and make up the bulk of the card's content.
Go somewhereSome quick example text to build on the card title and make up the bulk of the card's content.
Go somewhereSome quick example text to build on the card title and make up the bulk of the card's content.
Go somewhere


We'd love to hear from you!
I'm baby williamsburg umami literally crucifix, plaid kinfolk stumptown. Lyft distillery copper mug hella, taxidermy kickstarter pork belly.


Any contributions to MNE, whether bug fixes, improvements to the documentation, or new functionality, can be done via pull requests on GitHub. The workflow for this is described here. [Many thanks to Astropy for providing clear instructions that we have adapted for our use here!]
The only absolutely necessary configuration step is identifying yourself and your contact info:
$ git config --global user.name "Your Name"
$ git config --global user.email<EMAIL_ADDRESS>If you are going to Set up and configure a GitHub account eventually, this email address should be the same as the one used to sign up for a GitHub account. For more information about configuring your git installation, see Customizing git.
The following sections cover the installation of the git software, the basic configuration, and links to resources to learn more about using git. However, you can also directly go to the GitHub help pages which offer a great introduction to git and GitHub.
In the present document, we refer to the mne-python/master
branch, as the
trunk.
You need to do this only once for each package you want to contribute to. The instructions here are very similar to the instructions at https://help.github.com/fork-a-repo/ – please see that page for more details. We’re repeating some of it here just to give the specifics for the mne-python project, and to suggest some default names.
If you don’t have a GitHub account, go to the GitHub page, and make one.
You then need to configure your account to allow write access – see the Generating SSH keys help on GitHub Help.
Now you should fork the core mne-python.git
repository:
Log into your GitHub account.
Go to the mne-python GitHub home.
Click on the fork button:
Now, after a short pause and some ‘Hardcore forking action’, you should find yourself at the home page for your own forked copy of mne-python.
Briefly, this is done using:
$ git clone git@github.com:your-user-name/mne-python.git
$ cd mne-python
$ git remote add upstream git://github.com/mne-tools/mne-python.git
These steps can be broken out to be more explicit as:
Clone your fork to the local computer:
$ git clone git@github.com:your-user-name/mne-python.git
Change directory to your new repo:
$ cd mne-python
Then type:
$ git branch -a
to show you all branches. You’ll get something like:
* master
remotes/origin/master
This tells you that you are currently on the master
branch, and
that you also have a remote
connection to origin/master
.
What remote repository is remote/origin
? Try git remote -v
to
see the URLs for the remote. They will point to your GitHub fork.
Now you want to connect to the mne-python repository, so you can merge in changes from the trunk:
$ cd mne-python
$ git remote add upstream git://github.com/mne-tools/mne-python.git
upstream
here is just the arbitrary name we’re using to refer to the
main mne-python repository.
Note that we’ve used git://
for the URL rather than git@
. The
git://
URL is read only. This means we that we can’t accidentally (or
deliberately) write to the upstream repo, and we are only going to use it
to merge into our own code.
Just for your own satisfaction, show yourself that you now have a new
‘remote’, with git remote -v show
, giving you something like:
upstream git://github.com/mne-tools/mne-python.git (fetch)
upstream git://github.com/mne-tools/mne-python.git (push)
origin git@github.com:your-user-name/mne-python.git (fetch)
origin git@github.com:your-user-name/mne-python.git (push)
Your fork is now set up correctly.
Install mne with editing permissions using the installed folder:
To be able to conveniently edit your files after installing mne, install using the following setting:
$ python setup.py develop --user
To make changes in the code, edit the relevant files and restart the ipython kernel for changes to take effect.
Ensure unit tests pass
Make sure before starting to code that all unit tests pass with pytest:
$ make test
That’s it! You are now ready to hack away.
This section gives a summary of the workflow once you have successfully forked the repository, and details are given for each of these steps in the following sections.
master
branch for anything. Consider deleting it.bugfix-for-issue-14
or refactor-database-code
.This way of working helps to keep work well organized, with readable history. This in turn makes it easier for project maintainers (that might be you) to see what you’ve done, and why you did it.
See linux git workflow and ipython git workflow for some explanation.
It may sound strange, but deleting your own master
branch can help reduce
confusion about which branch you are on. See deleting master on github for
details.
From time to time you should fetch the upstream (trunk) changes from GitHub:
$ git fetch upstream
This will pull down any commits you don’t have, and set the remote branches to
point to the right commit. For example, ‘trunk’ is the branch referred to by
(remote/branchname) upstream/master
- and if there have been commits since
you last checked, upstream/master
will change after you do the fetch.
When you are ready to make some changes to the code, you should start a new branch. Branches that are for a collection of related edits are often called ‘feature branches’.
Making an new branch for each set of related changes will make it easier for someone reviewing your branch to see what you are doing.
Choose an informative name for the branch to remind yourself and the rest of
us what the changes in the branch are for. For example add-ability-to-fly
,
or buxfix-for-issue-42
.
# Update the mirror of trunk
$ git fetch upstream
# Make new feature branch starting at current trunk
$ git branch my-new-feature upstream/master
$ git checkout my-new-feature
Generally, you will want to keep your feature branches on your public GitHub
fork. To do this, you git push this new branch up to your
github repo. Generally (if you followed the instructions in these pages, and
by default), git will have a link to your GitHub repo, called origin
. You
push up to your own repo on GitHub with:
$ git push origin my-new-feature
In git > 1.7 you can ensure that the link is correctly set by using the
--set-upstream
option:
$ git push --set-upstream origin my-new-feature
From now on git will know that my-new-feature
is related to the
my-new-feature
branch in the GitHub repo.
$ git add my_new_file
$ git commit -am 'FIX: some message'
$ git push
Make some changes
See which files have changed with git status
(see git status).
You’ll see a listing like this one:
# On branch ny-new-feature
# Changed but not updated:
# (use "git add <file>..." to update what will be committed)
# (use "git checkout -- <file>..." to discard changes in working directory)
#
# modified: README
#
# Untracked files:
# (use "git add <file>..." to include in what will be committed)
#
# INSTALL
no changes added to commit (use "git add" and/or "git commit -a")
Check what the actual changes are with git diff
(git diff).
Add any new files to version control git add new_file_name
(see
git add).
Add any modified files that you want to commit using
git add modified_file_name
(see git add).
Once you are ready to commit, check with git status
which files are
about to be committed:
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# modified: README
Then use git commit -m 'A commit message'
. The m
flag just
signals that you’re going to type a message on the command line. The git
commit manual page might also be useful.
It is also good practice to prefix commits with the type of change, such as
FIX:
, STY:
, or ENH:
for fixes, style changes, or enhancements.
To push the changes up to your forked repo on GitHub, do a git
push
(see git push).
When you are ready to ask for someone to review your code and consider a merge:
Go to the URL of your forked repo, say
https://github.com/your-user-name/mne-python
.
Use the ‘Switch Branches’ dropdown menu near the top left of the page to select the branch with your changes:
Click on the ‘Pull request’ button:
Enter a title for the set of changes, and some explanation of what you’ve done. Say if there is anything you’d like particular attention for - like a complicated change or some code you are not happy with.
If you don’t think your request is ready to be merged, prefix WIP:
to
the title of the pull request, and note it also in your pull request
message. This is still a good way of getting some preliminary code review.
Submitting a pull request early on in feature development can save a great
deal of time for you, as the code maintainers may have “suggestions” about
how the code should be written (features, style, etc.) that are easier to
implement from the start.
Finally, make travis happy. Ensure that builds in all four jobs pass. To make code python3 compatible, refer to externals/six.py
. Use virtual environments to test code on different python versions. Please remember that travis only runs a subset of the tests and is thus not a substitute for running the entire test suite locally.
For the code to be mergeable, please rebase w.r.t master branch.
Once, you are ready, prefix MRG:
to the title of the pull request to indicate that you are ready for the pull request to be merged.
If you are uncertain about what would or would not be appropriate to contribute to MNE, don’t hesitate to either send a pull request, or open an issue on the mne-python GitHub site to discuss potential changes.
Let’s say you thought of some work you’d like to do. You
Updating the mirror of trunk and Making a new feature branch called
cool-feature
. At this stage trunk is at some commit, let’s call it E. Now
you make some new commits on your cool-feature
branch, let’s call them A,
B, C. Maybe your changes take a while, or you come back to them after a while.
In the meantime, trunk has progressed from commit E to commit (say) G:
A---B---C cool-feature
/
D---E---F---G trunk
At this stage you consider merging trunk into your feature branch, and you remember that this here page sternly advises you not to do that, because the history will get messy. Most of the time you can just ask for a review, and not worry that trunk has got a little ahead. But sometimes, the changes in trunk might affect your changes, and you need to harmonize them. In this situation you may prefer to do a rebase.
Rebase takes your changes (A, B, C) and replays them as if they had been made
to the current state of trunk
. In other words, in this case, it takes the
changes represented by A, B, C and replays them on top of G. After the rebase,
your history will look like this:
A'--B'--C' cool-feature
/
D---E---F---G trunk
See rebase without tears for more detail.
To do a rebase on trunk:
# Update the mirror of trunk
$ git fetch upstream
# Go to the feature branch
$ git checkout cool-feature
# Make a backup in case you mess up
$ git branch tmp cool-feature
# Rebase cool-feature onto trunk
$ git rebase --onto upstream/master upstream/master cool-feature
In this situation, where you are already on branch cool-feature
, the last
command can be written more succinctly as:
$ git rebase upstream/master
When all looks good you can delete your backup branch:
$ git branch -D tmp
If it doesn’t look good you may need to have a look at Recovering from mess-ups.
If you have made changes to files that have also changed in trunk, this may generate merge conflicts that you need to resolve - see the git rebase man page for some instructions at the end of the “Description” section. There is some related help on merging in the git user manual - see resolving a merge.
 If the branch you rebased is
called cool-feature
and your GitHub fork is available as the remote called origin
,
you use this command to force-push:
$ git push -f origin cool-feature
Note that this will overwrite the branch on GitHub, i.e. this is one of the few ways
you can actually lose commits with git.
Also note that it is never allowed to force push to the main mne-python repo (typically
called upstream
), because this would re-write commit history and thus cause problems
for all others.
Sometimes, you mess up merges or rebases. Luckily, in git it is relatively straightforward to recover from such mistakes.
If you mess up during a rebase:
$ git rebase --abort
If you notice you messed up after the rebase:
# Reset branch back to the saved point
$ git reset --hard tmp
If you forgot to make a backup branch:
# Look at the reflog of the branch
$ git reflog show cool-feature
8630830 cool-feature@{0}: commit: BUG: io: close file handles immediately
278dd2a cool-feature@{1}: rebase finished: refs/heads/my-feature-branch onto 11ee694744f2552d
26aa21a cool-feature@{2}: commit: BUG: lib: make seek_gzip_factory not leak gzip obj
...
# Reset the branch to where it was before the botched rebase
$ git reset --hard cool-feature@{2}
Otherwise, googling the issue may be helpful (especially links to Stack Overflow).
Note
Do this only for your own feature branches.
 Or perhaps the you made several false starts you would like the posterity not to see.
This can be done via interactive rebasing.
Suppose that the commit history looks like this:
$ git log --oneline
eadc391 Fix some remaining bugs
a815645 Modify it so that it works
2dec1ac Fix a few bugs + disable
13d7934 First implementation
6ad92e5 * masked is now an instance of a new object, MaskedConstant
29001ed Add pre-nep for a copule of structured_array_extensions.
...
and 6ad92e5
is the last commit in the cool-feature
branch. Suppose we
want to make the following changes:
13d7934
to something more sensible.2dec1ac
, a815645
, eadc391
into a single one.We do as follows:
# make a backup of the current state
$ git branch tmp HEAD
# interactive rebase
$ git rebase -i 6ad92e5
This will open an editor with the following text in it:
pick 13d7934 First implementation
pick 2dec1ac Fix a few bugs + disable
pick a815645 Modify it so that it works
pick eadc391 Fix some remaining bugs
# Rebase 6ad92e5..eadc391 onto 6ad92e5
#
# Commands:
# p, pick = use commit
# r, reword = use commit, but edit the commit message
# e, edit = use commit, but stop for amending
# s, squash = use commit, but meld into previous commit
# f, fixup = like "squash", but discard this commit's log message
#
# If you remove a line here THAT COMMIT WILL BE LOST.
# However, if you remove everything, the rebase will be aborted.
#
To achieve what we want, we will make the following changes to it:
r 13d7934 First implementation
pick 2dec1ac Fix a few bugs + disable
f a815645 Modify it so that it works
f eadc391 Fix some remaining bugs
This means that (i) we want to edit the commit message for 13d7934
, and
(ii) collapse the last three commits into one. Now we save and quit the
editor.
Git will then immediately bring up an editor for editing the commit message. After revising it, we get the output:
[detached HEAD 721fc64] FOO: First implementation
2 files changed, 199 insertions(+), 66 deletions(-)
[detached HEAD 0f22701] Fix a few bugs + disable
1 files changed, 79 insertions(+), 61 deletions(-)
Successfully rebased and updated refs/heads/my-feature-branch.
and the history looks now like this:
0f22701 Fix a few bugs + disable
721fc64 ENH: Sophisticated feature
6ad92e5 * masked is now an instance of a new object, MaskedConstant
If it went wrong, recovery is again possible as explained above.
To fetch a pull request on the main repository to your local working directory as a new branch, just do:
$ git fetch upstream pull/<pull request number>/head:<local-branch>
As an example, to pull the realtime pull request which has a url
https://github.com/mne-tools/mne-python/pull/615/
, do:
$ git fetch upstream pull/615/head:realtime
If you want to fetch a pull request to your own fork, replace
upstream
with origin
. That’s it!
The builds when the pull request is in WIP state can be safely skipped. The important thing is to ensure that the builds pass when the PR is ready to be merged. To skip a Travis build, add [ci skip]
to the commit message:
FIX: some changes [ci skip]
This will help prevent clogging up Travis and Appveyor and also save the environment.


Color Segmentation using GMM
This article is written by Chethan Parameshwara.
Table of Contents:
- Due Date
- Introduction
- What you need to do
- Problem Statement
- Submission Guidelines
- Collaboration Policy
## Due Date
10:59AM, Tuesday, September 17, 2018
Have you ever played with these adorable Nao robots?
Nao robots are star players in RoboCup, an annual autonomous robot soccer competitions.
We are planning to build the Maryland RoboCup team to compete in RoboCup 2019 so we need your help.
Would you like to help us in Nao’s soccer training? We need to train Nao to detect a soccer ball and estimate the depth of the ball to know how far to kick it.
Nao’s training has two phases:
- Color Segmentation using Gaussian Mixture Model (GMM)
- Depth Estimation
## What you need to do
To make logistics easier, we have collected camera data from Nao robot on behalf of you and saved the data in form of color images. as you can see our lab setup.
If your submission does not comply with the following guidelines, you’ll be given ZERO credit
File tree and naming
Your submission on Canvas must be a zip file, following the naming convention YourDirectoryID_proj1.zip. For example, xyz123_proj1.zip. The file must have the following directory structure, based on the starter files
[ ]
Report
For each section of the homework, explain briefly what you did, and describe any interesting problems you encountered and/or solutions you implemented. You must include the following details in your writeup:
[ ]
As usual, your report must be full English sentences,not commented code. There is a word limit of 750 words and no minimum length requirement
## Collaboration Policy
You are encouraged to discuss the ideas with your peers. However, the code should be your own, and should be the result of you exercising your own understanding of it. If you reference anyone else’s code in writing your project, you must properly cite it in your code (in comments) and your writeup. For the full honor code refer to the CMSC426 Fall 2018 website


BACKGROUND
Select the variable whose behavior you want to know
Infrastructure
Bank Catchment
Credits
Commercial-Branches
2011-2020 Behavior * The data for 2020 is estimated according to the first reported quarters.
– “Over the last three decades Mexico has underperformed in terms of growth, inclusion and poverty
reduction compared to similar countries. Its economic growth averaged just above 2 percent a year
between 1980 and 2018, limiting progress in convergence relative to high income economies.
Beyond the health and human life consequences, which are massive across countries, the COVID-19 pandemic brought demand and supply shocks to the Mexican economy with deep impacts on firms, employment, and households…” – The World Bank (source)
On this chart, you can see a brief demonstration of above statement. We know Mexico has a lot of potential to introduce new technologies, as well to endure its financial services, however, anyone attempting such things would need the right information to do so.
Beyond the health and human life consequences, which are massive across countries, the COVID-19 pandemic brought demand and supply shocks to the Mexican economy with deep impacts on firms, employment, and households…” – The World Bank (source)
On this chart, you can see a brief demonstration of above statement. We know Mexico has a lot of potential to introduce new technologies, as well to endure its financial services, however, anyone attempting such things would need the right information to do so.
Fortunately, you are in the right place!


YOUR PLANT HEALTH
At Water My Plants, we strive to make sure you're provided the best product possible for you and your plants!


--- layout: default title: Rules rootdir: .. --- {% if site.s4e %}
Roleplaying is Magic, Season Four Edition was our biggest and best, released as a Web Edition, along with a printable Character Sheet
Edition Three of Roleplaying is Magic brings {% if site.s3e_pdf %}a high-quality PDF,{% endif %} a printable Character Sheet, and a GM Screen.
We also have the S3E Web Edition, perfect for browsing on your computer or mobile device
The second edition of Roleplaying is Magic, we have {% if site.s2e_pdf %}a high-quality PDF and{% endif %} an ePub version, along with printable Character Sheets.
We also have the S2E Web Edition, perfect for browsing on your computer or mobile device
Season One, where it all started. Here's the original, high-quality PDF


{% extends "account/base.html" %}
{% import "bootstrap/forms.html" as bootstrap %}
{% block head_title %}{{ gettext("Change Password") }}{% endblock %}
{% block body %}
{% if token_fail %}
{{ gettext("The password reset link you followed is invalid or has been used already.") }}{{ gettext("Expired or Invalid Reset") }}
{% trans %}The password reset link you follow is invalid, possibly because it has already been used. Please request a new password reset.{% endtrans %}
{% else %} {% if form %}{{ gettext("Use the form below to set a new password for your account.") }}
{{ gettext("Your password has been successfully updated.") }}


Ready for your own randonly generated password?
Click here if your native language is English.
Click here if your native language is Chinese.
Click here if your native language is Arabic.


Selected value of the picker:
Set value of the picker as JSON object string {"year":"2015", "month": "1", "day": "1"}:
Here is a (badly) themed one.


Preparation time
30 mins to 1 hour
Cooking time
30 mins to 1 hour
Serves
Serves 4
Dietary
Deliciously tart plums match perfectly with rich marzipan and puff pastry - this is a dessert for showing off your skills.
For the rough puff pastry, place the flour in a mound on the work surface and make a well in the centre.
Place the butter and salt into the well and work them together with the fingertips of one hand, gradually drawing the flour into the centre with the other hand.
When the cubes of butter have become small pieces and the dough is grainy, gradually add the iced water and mix lightly until it just comes together. Form the pastry into a ball, flatten slightly, wrap in cling film and refrigerate for 20 minutes.
Flour the work surface and roll out the pastry into a 40cm/16in x 20cm/8in rectangle.
Fold it into three like a business letter and give it a quarter-turn.
Roll the block of pastry out as before, and fold it into three again.
These are the first two turns - wrap the block in cling film and refrigerate it for 30 minutes.
Give the chilled pastry another two turns, rolling and folding as before.
Wrap the pastry in cling film and refrigerate for at least 30 minutes before using.
Meanwhile, for the tart filling, place the sugar and water into a saucepan and bring to a gentle simmer, stirring continuously until the sugar has dissolved.
Bring the syrup to the boil and cook until it reaches110C/220F when measured with a sugar thermometer (this is the soft ball stage).
Place the ground almonds into a bowl along with the egg white and almond extract.
Pour on the sugar syrup and mix vigorously to form a thick paste. Then set aside in the fridge until completely cold.
Preheat the oven to 210C/425F/Gas 7.
Roll the rough puff pastry to a thickness of 3mm/1/8in. Cut out four 12cm/4½in circles and transfer to a baking sheet.
Lightly score the centre of the pastry with a knife then brush with beaten egg.
Dust the work surface with icing sugar, then roll the marzipan out to a thickness of 5mm/¼in. Cut four 11cm/4in circles and place in the centre of the pastry.
Cover the marzipan with the plum slices, tightly overlapping, in a circle.
Place in the oven and bake for 15-18 minutes until the pastry is risen and golden-brown.
Meanwhile, for the star anise caramel, place the sugar and star anise into a frying pan and cook, without stirring, until the sugar has melted and is just golden brown.
Whisk in the butter and double cream (CAUTION: the mixture will be extremely hot. You may want to wear an oven glove) and bring to a simmer.
Cook for 3-5 minutes until just thickened then pass through a fine sieve into a clean pan.
To serve, place the tart in the centre of a small plate and spoon the sauce around the edge. Finish with a spoonful of ice cream in the centre of the tart.


settings
Settings
settings_backup_restore
Convert from backup
exit_to_app
Exit
visibility_off
visibility
Preview
Click here to apply the update.
mic_off
mic
Microphone audio
volume_off
volume_up
System Audio
Choose a video source
Start recording!
Stop


The application Mobile Phone Data for Logistics Analytics has been successful within the Connected digital additive manufacturing competition
View application and feedback View the grant terms and conditions
Confirm the contact details, proposed start date and location of the project.
We will assign the project a Monitoring Officer.
We need bank details for those partners eligible for funding.
We will review your financial information.
Once we have approved your finances you can change your project spend profile.
Your Project Manager will need to upload the following:
Once all tasks are complete the Project Manager can review and accept the grant offer letter on behalf of the project.


Try this:
int x = Int32.Parse(TextBoxD1.Text);
or better yet:
int x = 0;
Int32.TryParse(TextBoxD1.Text, out x);
Also, since Int32.TryParse
returns a bool
you can use its return value to make decisions about the results of the parsing attempt:
int x = 0;
if (Int32.TryParse(TextBoxD1.Text, out x))
{
// you know that the parsing attempt
// was successful
}
If you are curious, the difference between Parse
and TryParse
is best summed up like this:
The TryParse method is like the Parse method, except the TryParse method does not throw an exception if the conversion fails. It eliminates the need to use exception handling to test for a FormatException in the event that s is invalid and cannot be successfully parsed. - MSDN
It marks the string as a verbatim string literal - anything in the string that would normally be interpreted as an escape sequence is ignored.
So "C:\\Users\\Rich"
is the same as @"C:\Users\Rich"
There is one exception: an escape sequence is needed for the double quote. To escape a double quote, you need to put two double quotes in a row. For instance, @""""
evaluates to "
.
In Python 2.7 (and before), print
is a statement that takes a number of arguments. It prints the arguments with a space in between.
So if you do
print "box:", box
It first prints the string "box:", then a space, then whatever box
prints as (the result of its __str__
function).
If you do
print ("box:", box)
You have given one argument, a tuple consisting of two elements ("box:" and the object box
).
Tuples print as their representation (mostly used for debugging), so it calls the __repr__
of its elements rather than their __str__
(which should give a user-friendly message).
That's the difference you see: (The width is: 100, and the height is: 200)
is the result of your box's __str__
, but <__main__.Rectangle instance at 0x0293BDC8>
is its __repr__
.
In Python 3 and higher, print()
is a normal function as any other (so print(2, 3)
prints "2 3"
and print 2, 3
is a syntax error). If you want to have that in Python 2.7, put
from __future__ import print_function
at the top of your source file, to make it slightly more ready for the present.
There are many ways to do this. To fix your current code using %
-formatting, you need to pass in a tuple:
Pass it as a tuple:
print("Total score for %s is %s" % (name, score))
A tuple with a single element looks like ('this',)
.
Here are some other common ways of doing it:
Pass it as a dictionary:
print("Total score for %(n)s is %(s)s" % {'n': name, 's': score})
There's also new-style string formatting, which might be a little easier to read:
Use new-style string formatting:
print("Total score for {} is {}".format(name, score))
Use new-style string formatting with numbers (useful for reordering or printing the same one multiple times):
print("Total score for {0} is {1}".format(name, score))
Use new-style string formatting with explicit names:
print("Total score for {n} is {s}".format(n=name, s=score))
Concatenate strings:
print("Total score for " + str(name) + " is " + str(score))
The clearest two, in my opinion:
Just pass the values as parameters:
print("Total score for", name, "is", score)
If you don't want spaces to be inserted automatically by print
in the above example, change the sep
parameter:
print("Total score for ", name, " is ", score, sep='')
If you're using Python 2, won't be able to use the last two because print
isn't a function in Python 2. You can, however, import this behavior from __future__
:
from __future__ import print_function
Use the new f
-string formatting in Python 3.6:
print(f'Total score for {name} is {score}')


MontanaCycling.Org
The Official Website For Competitive
Cycling in Montana
2003 Series Standings
2003
2002 Montana Road Cup Series Winners
Scott Herzig and Becky Broeder above.
2003 Montana Cyclocross Series Winners
Kathleen Jones (ICO) and Geoff Proctor (Montana Velo)
Final Series
Standings For the Montana Cyclocross Series
Final Results and Series Standings, Missoula Cyclocross Series
For 2003 FINAL Road Standings Click Here
|2003
Calendar |2003 Results | Club
Contacts |
| Training rides | Past Years Archives | Series
Standings |
| Contact Us | Links | Email List Server |
| Home |


Top 10 Most Sold Sedans In October 2019 – Dzire, Amaze, Ciaz on Top
by Surendhar MMaruti Suzuki Dzire continued to lead the way ahead of Honda Amaze, Maruti Suzuki Ciaz, Hyundai Verna and others
The sedan segment as a whole is running on a rough patch and is worsened by the downward sales spiral the auto industry has been experiencing for the last year or so. In October 2019, Maruti Suzuki’s Dzire continued to be on top of the monthly charts as 19,569 units were sold.
When compared to the same month in 2018, the Dzire posted year-on-year volume increase of 12% as 17,404 units were retailed back then. The Amaze posted just over one-fourth of the total sales of its main competitor Dzire, as 5,134 units meant that it was positioned in second place.
In comparison to the corresponding month last year when 5,542 units were sold, the Dzire registered 7% YoY decline. The festive season did help in Honda improving on the volume numbers of the Amaze as it ended up well ahead of its other rivals and the C-segment sedans including Honda City.
| Sedans | October 2019 Sales | October 2018 Sales |
| Maruti Suzuki Dzire | 19,569 | 17,404 |
| Honda Amaze | 5,134 | 5,542 |
| Maruti Suzuki Ciaz | 2,371 | 3,892 |
| Hyundai Verna | 2,174 | 3,301 |
| Honda City | 1,887 | 3,612 |
| Hyundai Xcent | 1,388 | 3,143 |
| Tata Tigor | 1,152 | 2,927 |
| Skoda Rapid | 815 | 1,205 |
| Volkswagen Vento | 729 | 480 |
| Volkswagen Ameo | 584 | 923 |
The C-sedan space is suffering the same fate as the monthly average has reduced drastically in recent years. The Maruti Suzuki Ciaz was the most sold model in October 2010 with 2,371 units as against 3,892 units with a massive year-on-year sales fall of 39% and it was the same case with its main rivals.
Hyundai’s Verna was the fourth most sold sedan in the country last month with just 2,174 units. When compared to the same month in 2018, the South Korean company registered 3,301 units with YoY de-growth of 34% and it finished ahead of Honda City.
The popular model of the Japanese manufacturer recorded 1,887 units last month as against 3,612 units with 48% YoY decline. The next-generation City is expected to launch in India next year with a complete exterior and interior makeover and it could revive its sales fortunes.
Hyundai’s Xcent finished sixth with 1,388 units ahead of Tata Tigor, Skoda Rapid and the Volkswagen duo. The Xcent will also get its major upgrade most likely sometime in 2020.


"x" "1" "EL-TERRAS,A, BRAUN,R, STENZ,E AND SCHUSTER,G, MUTAGENICITY OFANTIVIRAL SUBSTANCES OF NUCLEOBASE ANALOG TYPE IN SALMONELLA TYPHIMURIUMEMPLOYING METABOLIC"


The mixed Cardiff City fans' reaction as Neil Harris announced as Neil Warnock's successor
Neil Harris has signed a contract with Cardiff City until the summer of 2022
by Josh ChalliesCardiff City have announced the appointment of former Millwall boss Neil Harris as their new manager, following the departure of Neil Warnock last week.
Harris, who walked away from the South London side earlier this season, arrives with plenty of issues to resolve in the Welsh capital after what has been a difficult return to the second tier after suffering Premier League relegation back in May.
With matches against the likes of Stoke City and Barnsley on the horizon, the opportunity is there for Cardiff to build some momentum and for Harris to bring back some positivity to the club's fortunes.
However, the immediate reaction to his arrival in South Wales has not proven to be too popular for many supporters on social media, who have been left uninspired by his arrival.
Others, meanwhile, are slightly more optimistic and are rightly prepared to give Harris a chance before issuing their verdict on his new position, although it is clear that the general consensus is that he will have to win over the majority of the fanbase.
The best way to do that is by securing victories and he has a week to prepare for his first match with the Bluebirds, who travel to face high-flying Charlton Athletic next weekend.


| aes_linetype_size_shape {ggplot2} | R Documentation |
The linetype
, size
, and shape
aesthetics modify the appearance of
lines and/or points. They also apply to the outlines of polygons (linetype
and size
) or to text (size
).
The linetype
aesthetic can be specified with either an integer (0-6), a
name (0 = blank, 1 = solid, 2 = dashed, 3 = dotted, 4 = dotdash, 5 = longdash,
6 = twodash), a mapping to a discrete variable, or a string of an even number
(up to eight) of hexadecimal digits which give the lengths in consecutive
positions in the string. See examples for a hex string demonstration.
The size
aesthetic can be specified with a numerical value (in millimetres)
or via a mapping to a continuous variable.
The shape
aesthetic can be specified with an integer (between 0 and 25),
a single character (which uses that character as the plotting symbol),
a .
to draw the smallest rectangle that is visible (i.e., about one pixel),
an NA
to draw nothing, or a mapping to a discrete variable. Symbols and
filled shapes are described in the examples below.
geom_line()
and geom_point()
for geoms commonly used
with these aesthetics.
aes_group_order()
for using linetype
, size
, or
shape
for grouping.
Run vignette("ggplot2-specs")
to see an overview of other aesthestics that
can be modified.
df <- data.frame(x = 1:10 , y = 1:10) p <- ggplot(df, aes(x, y)) p + geom_line(linetype = 2) p + geom_line(linetype = "dotdash") # An example with hex strings; the string "33" specifies three units on followed # by three off and "3313" specifies three units on followed by three off followed # by one on and finally three off. p + geom_line(linetype = "3313") # Mapping line type from a grouping variable ggplot(economics_long, aes(date, value01)) + geom_line(aes(linetype = variable)) # Size examples p <- ggplot(mtcars, aes(wt, mpg)) p + geom_point(size = 4) p + geom_point(aes(size = qsec)) p + geom_point(size = 2.5) + geom_hline(yintercept = 25, size = 3.5) # Shape examples p + geom_point() p + geom_point(shape = 5) p + geom_point(shape = "k", size = 3) p + geom_point(shape = ".") p + geom_point(shape = NA) p + geom_point(aes(shape = factor(cyl))) # A look at all 25 symbols df2 <- data.frame(x = 1:5 , y = 1:25, z = 1:25) p <- ggplot(df2, aes(x, y)) p + geom_point(aes(shape = z), size = 4) + scale_shape_identity() # While all symbols have a foreground colour, symbols 19-25 also take a # background colour (fill) p + geom_point(aes(shape = z), size = 4, colour = "Red") + scale_shape_identity() p + geom_point(aes(shape = z), size = 4, colour = "Red", fill = "Black") + scale_shape_identity()


Vray
Indigo
Kerkythea
KeyShot
Maxwell
Podium
Vray
Purge unused layers
Purge unused groups
Options
History
Debug
Donate to the author
Group layer(s)
Merge layers
Lock/Unlock layer(s)
Select layer's entities
Only visible in active scene
Visible in existing scenes
Hidden in existing scenes
Visible in new scenes
Hidden in new scenes
Layer0


Class: Concurrent::WrappingExecutor
- Inherits:
-
Synchronization::Object
- Object
- Synchronization::Object
- Concurrent::WrappingExecutor
- Defined in:
- lib/concurrent-ruby-edge/concurrent/executor/wrapping_executor.rb
Overview
A delegating executor which modifies each task with arguments before the task is given to the target executor it delegates to.
Instance Method Summary collapse
-
#can_overflow? ⇒ Boolean
Does the task queue have a maximum size?.
-
#initialize(executor) {|*args, &task| ... } ⇒ WrappingExecutor
constructor
A new instance of WrappingExecutor.
-
#post(*args) { ... } ⇒ Boolean
Submit a task to the executor for asynchronous processing.
-
#serialized? ⇒ Boolean
Does this executor guarantee serialization of its operations?.
Constructor Details
#initialize(executor) {|*args, &task| ... } ⇒ WrappingExecutor
Returns a new instance of WrappingExecutor.
23 24 25 26 27 |
# File 'lib/concurrent-ruby-edge/concurrent/executor/wrapping_executor.rb', line 23 def initialize(executor, &wrapper) super() @Wrapper = wrapper @Executor = executor end |
Instance Method Details
#can_overflow? ⇒ Boolean
Does the task queue have a maximum size?
38 39 40 |
# File 'lib/concurrent-ruby-edge/concurrent/executor/wrapping_executor.rb', line 38 def can_overflow? @Executor.can_overflow? end |
#post(*args) { ... } ⇒ Boolean
Submit a task to the executor for asynchronous processing.
32 33 34 35 |
# File 'lib/concurrent-ruby-edge/concurrent/executor/wrapping_executor.rb', line 32 def post(*args, &task) *args, task = @Wrapper.call(*args, &task) @Executor.post(*args, &task) end |
#serialized? ⇒ Boolean
Does this executor guarantee serialization of its operations?
43 44 45 |
# File 'lib/concurrent-ruby-edge/concurrent/executor/wrapping_executor.rb', line 43 def serialized? @Executor.serialized? end |


Skip to content
Amazing Video Quizzes and Poll
A Videogular-Questions example -
github
Simple Example
|
Caesar Example
|
Single Question
|
Question Multiple
|
Question Stars
|
Question Text
|
Question Range
|
Poll Simple


Multivariate normal distributions are really nice. (Invertible) affine transformations, marginalization, and conditioning all preserve a multivariate normal distribution.
In this post, I want to discuss marginalization and conditioning. In particular, I want to point out that computing the marginal distribution is easy when we parametrize with the covariance matrix, and computing the conditional distribution is easy when we parametrize with the precision matrix.
Suppose is distributed multivariate normal
The marginal distribution of is really easy to compute:
The conditional distribution is again multivariate normal, but with mean and covariance given by
What do these formulas look like when we parametrize by precision matrix? (The precision matrix is the inverse of the covariance matrix: .)
If we write
then we have the following relations:
In terms of , the marginal distribution of has precision matrix , and the conditional distribution has precision matrix . Notice the duality! The marginal distribution has covariance and precision , and the conditional distribution has covariance and precision .
Choosing the parametrization (covariance or precision) depends on whether your application requires computing marginal or conditional distributions. In Gaussian Markov random fields, for example, conditional distributions are important, so using a precision parametrization makes life easier.
Written on April 13th, 2018 by Scott Roy


randnext
Syntax
randnext ( var v : real, seq : 1 .. 10 )
Description
The randnext procedure is used when you need several sequences of pseudo-random numbers, and you need to be able to exactly repeat these sequences for a number of simulations. The randnext procedure is the same as rand, except seq specifies one of ten independent and repeatable sequences of pseudo-random real numbers.
The randseed procedure is used to start one of these sequences at a particular point.
See also
randseed, randint, rand and randnext.


Tic-Tac-Toe
Home
|
Tic-Tac-Toe
|
Registration Form
|
Contact Us
|
FAQ
's turn!
Play Again?
Player 1
Player 2
Won
0
0


KarmaSoc offers the following services, but not limited to: Internet-based social networking services; Internet-based social introduction and social networking services; On-line social networking services; Online social networking services provided through a community website; Online social networking services accessible by means of downloadable mobile applications; Providing a social networking website for entertainment purposes; Providing on-line computer databases and on-line searchable databases in the field of social networking
KarmaSoc is a social network platform that incentivizes EVERY user for their constructive social activity, rewards them for registering local businesses to avail the offered deals, and offers them the ability to open ecommerce shop to trade within or their extended network.
Social networks have several pain areas, which KarmaSoc aims to address: · Firms earn millions at the expense of users · Only active and professional social users make money and not all · Users fell they are wasting time checking social media · Rewarding and incentivizing mechanisms and can be abused · Products and Service providers have trouble finding buyers Our goal is to be a leading global social networking platform where every user will be a true partner and earn rewards by socializing constructively. For those who do not want to earn rewards, they can donate to a charity of their choice.
KarmaSoc is a social networking and ecommerce platform currently built as a Progressive Web App (PWA). Users can post various types of social content and segregate them for clarity. The ecommerce platform allows users to open shops for free and promote their products and services within their network eliminating the need for external marketing channels to acquire customers. Local deals are shown on a map to cater the needs of users seeking savings.
KarmaSoc has a unique proprietary pricing algorithm that drives the rewards and incentives mechanism, which is critical to our business model and robust systematic growth. The PWA comes with a powerful technology stack with a scalable elastic architecture. We use Nodejs with microservices containerized with docker. Devops is automated and is seamlessly deployed into AWS using Kubernetes. We use mongodb and MySQL as our databases.
Target market includes the saturated yet evolving US social media segment where 68% of total population is registered. The market also includes all small businesses that want to promote deals locally and represent their brand as community supporters. We also cover aspiring entrepreneurs who want to start an online business and offer products and services. We aim niche demographics ages 13-34 (96 million), housewives, and all those who want to reap benefits for their time spent on social networks. This demographic has the highest chances of converting as people can use the money earned to purchase games or other necessary products. We also target those who do not want rewards but can donate to charities of their liking making a positive social impact.
Our sources of revenue are multi pronged. User’s active social involvement generates advertisement income. Users can open ecommerce shops and pay commissions on sales and pay for promoting their brands. Businesses register and pay consistent membership fees to promote their deals locally. KarmaSoc will reach the targeted market through comprehensive marketing strategies, including advertisements, digital marketing, blogs, word of mouth referrals, and innovative techniques such as appointing representatives in each educational institute and volunteers in each region. Users will act sales agents to register local businesses.
Among competitors are traditional social platforms such as Facebook, Google+, YouTube, Groupon, Yext, Nextdoor, FourSquare, among others, which do not incentivize users and allow only active and professional users to benefit monetarily. We also compete with evolving blockchain technology firms including, Steemit, Synereo, Nexus, and Yours, which incentivize users for their content. KarmaSoc is distinct from any of these firms as we do not fully rely on an incentivizing business model but are developing a sustainable growth model offering innovative ways for users to be actively involved, thereby mutually benefiting each other.
Incubated and developed a world-class PWA. Social functionalities, local deals on a map, and ecommerce are functional. Various useful sections are created for ease of navigation and to eliminate messy content segregation. Local businesses can promote deals on a map as per user’s geo-location. Aspiring entrepreneurs can open ecommerce shops.
KarmaSoc will be a global app and will penetrate each market strategically. We will be one-stop shop for all types of incentives. Funding will help achieve these goals and also help with hiring, creating a native app, enhancing the current version of PWA, getting direct access to deals from companies, and offering cash back programs. Lastly, we are working on a Proof of Concept to use blockchain technology to implement micropayments. We intend to issue an ICO (Initial Coin Offering) to raise capital and be in the forefront of blockchain technology.


Converts Between GeoJSON and simple feature objects.
| Version: | 1.2.1 |
| Depends: | R (≥ 3.3.0) |
| Imports: | curl, Rcpp |
| LinkingTo: | jsonify (≥ 0.1.1), rapidjsonr (≥ 1.1), Rcpp |
| Suggests: | covr, jsonify, knitr, rmarkdown, testthat |
| Published: | 2018-11-22 |
| Author: | David Cooley [aut, cre] |
| Maintainer: | David Cooley <dcooley at symbolix.com.au> |
| License: | GPL-3 |
| NeedsCompilation: | yes |
| Materials: | README NEWS |
| CRAN checks: | geojsonsf results |
| Reference manual: | geojsonsf.pdf |
| Vignettes: |
Converting between GeoJSON and sf |
| Package source: | geojsonsf_1.2.1.tar.gz |
| Windows binaries: | r-devel: geojsonsf_1.2.1.zip, r-release: geojsonsf_1.2.1.zip, r-oldrel: geojsonsf_1.2.1.zip |
| OS X binaries: | r-release: geojsonsf_1.2.1.tgz, r-oldrel: geojsonsf_1.2.1.tgz |
| Old sources: | geojsonsf archive |
| Reverse imports: | echor |
| Reverse suggests: | mapdeck, vapour |
Please use the canonical form https://CRAN.R-project.org/package=geojsonsf to link to this page.


This is a small list of graphics demos that I programmed for fun, primarily focusing on shader programming.