[gecode-users] Value intersection problem
Anden blah
anden_blah at hotmail.com
Fri Jan 23 16:44:19 CET 2009
Hi
I am trying to restrict the values of an IntView by doing the following:
...(values is given as parameter for the method containing this code, the type is const set<string>& )
vector<string> v;
for(set<string>::const_iterator setIt = values.begin(); setIt!= values.end(); setIt++)
{
v.push_back(*setIt);
}
GECODE_AUTOARRAY(int,restrictedDoms,v.size());
for(int i=0;i<v.size();i++)
{
restrictedDoms[i] = atoi(v[i].c_str());
}
Gecode::Iter::Values::Array restrictIterator(restrictedDoms, v.size());
return iv.inter_v(homeFZ, restrictIterator, false);
---
I can inspect the code and see that the values contained in "restrictedDoms" are the values 1 to 10. Furthermore I can see that iv.size() is 10 (values 1 to 10) before the call to inter_v (and unassigned of course). Then after the call to inter_v, iv is assigned, and I can see that the value it is assigned to is the first value in the restrictedDoms array.
So what am I doing wrong?
Thanks!
Andreas
p.s. Of course it is useless to intersect a variable with domain 1 to 10 with the values 1 to 10, but still the behavior is unexpected.
_________________________________________________________________
Drag n’ drop—Get easy photo sharing with Windows Live™ Photos.
http://www.microsoft.com/windows/windowslive/photos.aspx
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20090123/8136dcc8/attachment.htm>
More information about the gecode-users
mailing list


« CSS « CSS Reference
The :left
page pseudo-class matches any left page when printing a page. It allows to describe the styling of left-side pages.
Whether the page is left or right is decided by the major writing direction of the document. For example, if the first page has a major writing direction of left-to-right then it will be a :right
page and if it has a major writing direction of right-to-left then it will be a :left
page.
@page :left { margin:2in 3in; }
| Feature | Gecko | Webkit | Internet Explorer | Opera |
|---|---|---|---|---|
| Basic support | -- | ? | 8 | 9.2 |


--- layout: page title: About header-img: "img/brooklyn-bridge.png" ---
New Yorker | social justice advocate | immigrant | cat-person | avid reader | feminist


|
The Red Matrix
|
Public Member Functions | |
| __construct () | |
| get_baseurl ($ssl=false) | |
| set_baseurl ($url) | |
| get_hostname () | |
| set_hostname ($h) | |
| set_path ($p) | |
| get_path () | |
| set_account ($acct) | |
| get_account () | |
| set_channel ($channel) | |
| get_channel () | |
| set_observer ($xchan) | |
| get_observer () | |
| set_perms ($perms) | |
| get_perms () | |
| get_apps () | |
| set_apps ($arr) | |
| set_groups ($g) | |
| get_groups () | |
| set_widget ($title, $html, $location= 'aside') | |
| get_widgets ($location= '') | |
| set_pager_total ($n) | |
| set_pager_itemspage ($n) | |
| build_pagehead () | |
| set_curl_code ($code) | |
| get_curl_code () | |
| set_curl_headers ($headers) | |
| get_curl_headers () | |
| register_template_engine ($class, $name= '') | |
| template_engine ($name= '') | |
| get_template_engine () | |
| set_template_engine ($engine= 'smarty3') | |
| get_template_ldelim ($engine= 'smarty3') | |
| get_template_rdelim ($engine= 'smarty3') | |
| head_set_icon ($icon) | |
| head_get_icon () | |
Public Attributes | |
| $account = null | |
| $channel = null | |
| $observer = null | |
| $profile_uid = 0 | |
| $layout = array() | |
| $groups | |
| $language | |
| $module_loaded = false | |
| $query_string | |
| $config | |
| $page | |
| $profile | |
| $user | |
| $cid | |
| $contact | |
| $contacts | |
| $content | |
| $data = array() | |
| $error = false | |
| $cmd | |
| $argv | |
| $argc | |
| $module | |
| $pager | |
| $strings | |
| $hooks | |
| $timezone | |
| $interactive = true | |
| $plugins | |
| $identities | |
| $css_sources = array() | |
| $js_sources = array() | |
| $theme_info = array() | |
| $nav_sel | |
| $category | |
| $sourcename = '' | |
| $videowidth = 425 | |
| $videoheight = 350 | |
| $force_max_items = 0 | |
| $theme_thread_allow = true | |
| $template_engines = array() | |
| $template_engine_instance = array() | |
Private Attributes | |
| $perms = null | |
| $widgets = array() | |
| $widgetlist = null | |
| $apps = array() | |
| $theme | |
| $ldelim | |
| $rdelim | |
| $scheme | |
| $hostname | |
| $baseurl | |
| $path | |
| $db | |
| $curl_code | |
| $curl_headers | |
| $cached_profile_image | |
| $cached_profile_picdate | |
class: App
Our main application structure for the life of this page Primarily deals with the URL that got us here and tries to make some sense of it, and stores our page contents and config storage and anything else that might need to be passed around before we spit the page out.
| App::__construct | ( | ) |
Figure out if we are running at the top of a domain or in a sub-directory and adjust accordingly
Break the URL path into C style argc/argv style arguments for our modules. Given "http://example.com/module/arg1/arg2", $this->argc will be 3 (integer) and $this->argv will contain: [0] => 'module' [1] => 'arg1' [2] => 'arg2'
There will always be one argument. If provided a naked domain URL, $this->argv[0] is set to "home".
See if there is any page number information, and initialise pagination
Detect mobile devices
register template engines
| App::build_pagehead | ( | ) |
| App::get_account | ( | ) |
| App::get_apps | ( | ) |
| App::get_baseurl | ( | $ssl = false | ) |
Referenced by build_pagehead().
| App::get_channel | ( | ) |
| App::get_curl_code | ( | ) |
| App::get_curl_headers | ( | ) |
| App::get_groups | ( | ) |
| App::get_hostname | ( | ) |
| App::get_observer | ( | ) |
| App::get_path | ( | ) |
| App::get_perms | ( | ) |
| App::get_template_engine | ( | ) |
| App::get_template_ldelim | ( | $engine = 'smarty3' | ) |
| App::get_template_rdelim | ( | $engine = 'smarty3' | ) |
| App::get_widgets | ( | $location = '' | ) |
| App::head_get_icon | ( | ) |
Referenced by build_pagehead().
| App::head_set_icon | ( | $icon | ) |
Referenced by __construct().
| App::register_template_engine | ( | $class, | |
$name = '' |
|||
| ) |
register template engine class if $name is "", is used class static property $class::$name
| string | $class | |
| string | $name |
Referenced by __construct().
| App::set_account | ( | $acct | ) |
| App::set_apps | ( | $arr | ) |
| App::set_baseurl | ( | $url | ) |
| App::set_channel | ( | $channel | ) |
| App::set_curl_code | ( | $code | ) |
| App::set_curl_headers | ( | $headers | ) |
| App::set_groups | ( | $g | ) |
| App::set_hostname | ( | $h | ) |
| App::set_observer | ( | $xchan | ) |
| App::set_pager_itemspage | ( | $n | ) |
| App::set_pager_total | ( | $n | ) |
| App::set_path | ( | $p | ) |
| App::set_perms | ( | $perms | ) |
| App::set_template_engine | ( | $engine = 'smarty3' | ) |
| App::set_widget | ( | $title, | |
| $html, | |||
$location = 'aside' |
|||
| ) |
| App::template_engine | ( | $name = '' | ) |
| App::$account = null |
Referenced by get_account().
|
private |
Referenced by get_apps().
| App::$argc |
| App::$argv |
|
private |
Referenced by get_baseurl().
|
private |
|
private |
| App::$category |
| App::$channel = null |
Referenced by get_channel(), and set_channel().
| App::$cid |
| App::$cmd |
| App::$config |
| App::$contact |
| App::$contacts |
| App::$content |
| App::$css_sources = array() |
|
private |
Referenced by get_curl_code().
|
private |
Referenced by get_curl_headers().
| App::$data = array() |
|
private |
| App::$error = false |
| App::$force_max_items = 0 |
| App::$groups |
Referenced by get_groups().
| App::$hooks |
|
private |
Referenced by get_hostname().
| App::$identities |
| App::$interactive = true |
| App::$js_sources = array() |
| App::$language |
| App::$layout = array() |
|
private |
| App::$module |
| App::$module_loaded = false |
| App::$nav_sel |
| App::$observer = null |
Referenced by get_observer().
| App::$page |
| App::$pager |
|
private |
Referenced by __construct(), and get_path().
|
private |
Referenced by get_perms(), and set_perms().
| App::$plugins |
| App::$profile |
| App::$profile_uid = 0 |
| App::$query_string |
|
private |
|
private |
Referenced by get_baseurl().
| App::$sourcename = '' |
| App::$strings |
| App::$template_engine_instance = array() |
| App::$template_engines = array() |
|
private |
| App::$theme_info = array() |
| App::$theme_thread_allow = true |
| App::$timezone |
| App::$user |
| App::$videoheight = 350 |
| App::$videowidth = 425 |
|
private |
|
private |
Referenced by get_widgets().


{% extends 'base.html' %} {% load static %} {% block content %}
Your password has been set. You may go ahead and sign in now.


I give most of it away to friend and family. This just a small sample.


The Python extension module posix_ipc gives Python access to POSIX inter-process semaphores, shared memory and message queues on systems that support the POSIX Realtime Extensions a.k.a. POSIX 1003.1b-1993. That includes most (all?) Linuxes with kernel ≥ 2.6, FreeBSD ≥ 7.2, and OpenSolaris ≥ 2008.05.
macOS/OS X and other Unix-y platforms (including Windows + Cygwin 1.7) provide partial (or partially broken) support. See the platform notes below for more details.
This module works under Python 2.7 and 3.x. It is released under a BSD license.
You can download posix_ipc version 1.0.4 [MD5 sum] [SHA1 sum] which contains the source code, setup.py, installation instructions, tests, and sample code. The exact same posix_ipc tarball is also available on PyPI. You can also find the posix_ipc source code on GitHub.
You might want to read all of the changes in this version and about some known bugs.
Note that this module doesn't support unnamed (anonymous) POSIX semaphores.
You might be interested in the very similar module sysv_ipc which provides Python access to IPC using System V semaphores, shared memory and message queues. System V IPC has broader OS support but is not as easy to use.
Jump to semaphores, shared memory, or message queues.
O_TRUNC is only useful when creating SharedMemory objects.
As far as I know, this is only False under macOS.
As far as I know, this is only False under macOS.
In addition to standard Python errors (e.g. ValueError), this module raises custom errors. These errors cover situations specific to IPC.
This is a handle to a semaphore.
name must be None or a string. If it is None, the module chooses a random unused name. If it is a string, it should begin with a slash and be valid according to pathname rules on your system, e.g. /wuthering_heights_by_semaphore
The flags specify whether you want to create a new semaphore or open an existing one.
The timeout (which can be a float) specifies how many seconds this call should wait, if at all.
This behavior is unaffected by whether or not the platform supports sem_timedwait() (see below).
On platforms that don't support the sem_timedwait() API, a timeout > 0 is treated as infinite. The call will not return until its wait condition is satisfied.
Most platforms provide sem_timedwait(). macOS is a notable exception. The module's Boolean constant SEMAPHORE_TIMEOUT_SUPPORTED is True on platforms that support sem_timedwait().

Note, however, that once a semaphore has been unlinked, calls to open() with the same name should refer to a new semaphore. Sound confusing? It is, and you'd probably be wise structure your code so as to avoid this situation.
These semaphores support the context manager protocol so they can be used with Python's with statement, just like Python's threading.Semaphore. For instance --
with posix_ipc.Semaphore(name) as sem: # Do something...
Entering the context acquires the semaphore, exiting the context releases the semaphore. See demo4/child.py for a complete example.
This is a handle to a shared memory segment. POSIX shared memory segments masquerade as files, and so the handle to a shared memory segment is just a file descriptor that can be mmapped.
name must be None or a string. If it is None, the module chooses a random unused name. If it is a string, it should begin with a slash and be valid according to pathname rules on your system, e.g. /four_yorkshiremen_sharing_memories
On some systems you need to have write access to the path.
The flags specify whether you want to create a new shared memory segment or open an existing one.
If you pass a non-zero size, the segment will be (re)sized accordingly, regardless of whether or not it's a new or existing segment. Prior to version 1.0.4, this documentation incorrectly stated that size was ignored if the segment already existed.
To (re)size the segment, posix_ipc calls ftruncate(). The same function is available to Python via os.ftruncate(). If you prefer to handle segment (re)sizing yourself, leave the SharedMemory parameter size at its default of 0 and call os.ftruncate() when and how you like.
Note that under macOS (up to and including 10.12 at least), you can only call ftruncate() once on a segment during its lifetime. This is a limitation of macOS, not posix_ipc.
When opening an existing shared memory segment, one can also specify the flag O_TRUNC to truncate the shared memory to zero bytes. macOS does not support O_TRUNC.

Closing the file descriptor has no effect on any mmap objects that were created from it. See the demo for an example.
The POSIX specification for shm_unlink() says, "Even if the object continues to exist after the last shm_unlink(), reuse of the name shall subsequently cause shm_open() to behave as if no shared memory object of this name exists (that is, shm_open() will fail if O_CREAT is not set, or will create a new shared memory object if O_CREAT is set)."
I'll bet a virtual cup of coffee that this tricky part of the standard is not well or consistently implemented in every OS. Caveat emptor.
This is a handle to a message queue.
name must be None or a string. If it is None, the module chooses a random unused name. If it is a string, it should begin with a slash and be valid according to pathname rules on your system, e.g. /my_message_queue
On some systems you need to have write access to the path.
The flags specify whether you want to create a new queue or open an existing one.
Max_messages defines how many messages can be in the queue at one time. When the queue is full, calls to .send() will wait.
Max_message_size defines the maximum size (in bytes) of a message.
Read and write default to True. If read/write is False, calling .receive()/.send() on this object is not permitted. This doesn't affect other handles to the same queue.
The message string can contain embedded NULLs (ASCII 0x00). Under Python 3, the message can also be a bytes object.
The timeout (which can be a float) specifies how many seconds this call should wait if the queue is full. Timeouts are irrelevant when the block flag is False.
The priority allows you to order messages in the queue. The highest priority message is received first. By default, messages are sent at the lowest priority (0).
If the queue is empty, the call will not return immediately. The optional timeout parameter controls the wait just as for the function send(). It defaults to None.
Message queues accept only one notification request at a time. If another process has already requested notifications from this queue, this call will fail with a BusyError.
The operating system delivers (at most) one notification per request. If you want subsequent notifications, you must request them by calling request_notification() again.

This module comes with fairly complete unit tests in the tests
directory. To run them, install posix_ipc and then run this command
from the same directory as setup.py:
python -m unittest discover
This module comes with four demonstrations. The first (in the directory demo) shows how to use shared memory and semaphores. The second (in the directory demo2) shows how to use message queues. The third (demo3) shows how to use message queue notifications. The fourth (demo4) shows how to use a semaphore in a context manager.
IPC objects are a little different from most Python objects and therefore require a little more care on the part of the programmer. When a program creates a IPC object, it creates something that resides outside of its own process, just like a file on a hard drive. It won't go away when your process ends unless you explicitly remove it. And since many operating systems don't even give you a way to enumerate existing POSIX IPC entities, it might be hard to figure out what you're leaving behind.
In short, remember to clean up after yourself.
I know it's verboten to talk about pointers in Python, but I'm going to do it anyway.
Each Semaphore object created by this module contains a C pointer to the IPC object created by the system. When you call sem.close(), the object's internal pointer is set to NULL. This leaves the object in a not-quite-useless state. You can still call sem.unlink() or print sem.name, but calls to sem.aquire() or sem.release() will raise an ExistentialError.
If you know you're not going to use a Semaphore object after calling sem.close() or sem.unlink(), you could you set your semaphore variable to the return from the function (which is always None) like so:
my_sem = my_sem.close()
That will ensure you don't have any nearly useless objects laying around that you might use by accident.
This doesn't apply to shared memory and message queues because they're referenced at the C level by a file descriptor rather than a pointer.
It appears that the read and write mode bits on IPC objects are ignored by the operating system. For instance, on macOS, OpenSolaris and Linux one can write to semaphores and message queues with a mode of 0400.
When creating a new message queue, you specify a maximum message size which defaults to QUEUE_MESSAGE_SIZE_MAX_DEFAULT (currently 8192 bytes). You can create a queue with a larger value, but be aware that posix_ipc allocates a buffer the size of the maximum message size every time receive() is called.
The posix_ipc module is just a wrapper around your system's API. If your system's implementation has quirks, the man pages for sem_open, sem_post, sem_wait, sem_close, sem_unlink, shm_open, shm_unlink, mq_open, mq_send mq_receive, mq_getattr, mq_close, mq_unlink and mq_notify will probably cover them.
For Pythonistas –
I don't know of any bugs in this code, but FreeBSD users should check the platform notes.
If you need to support Python < 2.7, try posix_ipc version 0.9.9 [MD5 sum] [SHA1 sum].
This module is just a wrapper around the operating system's functions, so if the operating system doesn't provide a function, this module can't either. The POSIX Realtime Extensions (POSIX 1003.1b-1993) are, as the name implies, an extension to POSIX and so a platform can claim "POSIX conformance" and still not support any or all of the IPC functions.
Under 7.2, posix_ipc's demos fail unless they're run as root. It's a simple permissions problem. Prefix the IPC object names with /tmp in params.txt and the problem goes away. I didn't see this behavior under FreeBSD 8.0, so it must have been fixed at some point.
If you don't have the sem and mqueuefs kernel
modules loaded, you'll get a message like this (or something
similarly discouraging) when you
try to create a semaphore or message queue:
Bad system call: 12 (core dumped)
Type kldstat to list loaded modules, and kldload sem or kldload mqueuefs if you need to load either of these. BTW, mqueuefs has some cool features.
Prior to 7.2, FreeBSD POSIX semaphore support was broken.
Under FreeBSD 11.1, I have seen segfaults during the message queue threaded notification rearm test. I don't know if posix_ipc or FreeBSD (or both!) are culprits.
macOS' implementation of POSIX IPC has some significant holes. Message queues are not supported at all. Also, sem_getvalue() and sem_timedwait() are not supported.
Versions of Cygwin prior to 1.7 didn't support POSIX IPC. Under Cygwin 1.7 beta 62 (released in early October 2009), posix_ipc compiles and runs both demos.


The shutdown function can be used to shutdown part of or the complete Sector system.
On success, the function returns a unique session key assigned by the Master. If error occurs, a negative value is returned:
| Error Name | Comment |
| E_INVALID | this Sector instance has not been initialized |
| E_AUTHORITY | no authority to run this command |
| E_CONNECTION | connot connect to the master |
The shutdown function requires "root" user.


Login Form
TITech Africa is a web service where you can learn programming on one on one instructions and guidance among other web services.
We offer you a fully equipped coding environment to get you started and other web services as they may best suite your demand.
Languages used to build and design the appearances of your websites. HTML adds the structure, and CSS styles it.
A fast, feature-rich and easy-to-use JavaScript library that handles animations and Ajax requests.
A dynamic, general-purpose language that is simple and productive. It is commonly used to build web applications.
An open source scripting language that can be embedded into HTML, and well suited for web development.


Importing data¶
Note
This tutorial assumes you have installed QIIME 2 using one of the procedures in the install documents.
In order to use QIIME 2, your input data must be stored in QIIME 2 artifacts (i.e. .qza
files). This is what enables distributed and automatic provenance tracking, as well as semantic type validation and transformations between data formats (see the core concepts page for more details about QIIME 2 artifacts). This tutorial demonstrates how to import various data formats into QIIME 2 artifacts for use with QIIME 2.
Note
This tutorial does not describe all data formats that are currently supported in QIIME 2. It is a work-in-progress that describes some of the most commonly used data formats that are available. We are also actively working on supporting additional data formats. If you need to import data in a format that is not covered here, please post to the QIIME 2 Forum for help.
Importing will typically happen with your initial data (e.g. sequences obtained from a sequencing facility), but importing can be performed at any step in your analysis pipeline. For example, if a collaborator provides you with a .biom
file, you can import it into a QIIME 2 artifact to perform “downstream” statistical analyses that operate on a feature table.
Importing can be accomplished using any of the QIIME 2 interfaces. This tutorial will focus on using the QIIME 2 command-line interface (q2cli
) to import data. Each section below briefly describes a data format, provides commands to download example data, and illustrates how to import the data into a QIIME 2 artifact.
You may want to begin by creating a directory to work in.
mkdir qiime2-importing-tutorial
cd qiime2-importing-tutorial
Sequence data¶
“EMP protocol” multiplexed single-end fastq¶
Format description¶
In the “Earth Microbiome Project (EMP) protocol” format for single-end reads, there are two fastq.gz
files, one containing sequence reads and one containing the associated barcode reads, with the sequence data still multiplexed. The order of the records in the two fastq.gz
files defines the association between a sequence read and its barcode read.
Obtaining example data¶
mkdir emp-single-end-sequences
Download URL: https://data.qiime2.org/2017.2/tutorials/moving-pictures/emp-single-end-sequences/barcodes.fastq.gz
Save as: emp-single-end-sequences/barcodes.fastq.gz
wget -O "emp-single-end-sequences/barcodes.fastq.gz" "https://data.qiime2.org/2017.2/tutorials/moving-pictures/emp-single-end-sequences/barcodes.fastq.gz"
curl -sL "https://data.qiime2.org/2017.2/tutorials/moving-pictures/emp-single-end-sequences/barcodes.fastq.gz" > "emp-single-end-sequences/barcodes.fastq.gz"
Download URL: https://data.qiime2.org/2017.2/tutorials/moving-pictures/emp-single-end-sequences/sequences.fastq.gz
Save as: emp-single-end-sequences/sequences.fastq.gz
wget -O "emp-single-end-sequences/sequences.fastq.gz" "https://data.qiime2.org/2017.2/tutorials/moving-pictures/emp-single-end-sequences/sequences.fastq.gz"
curl -sL "https://data.qiime2.org/2017.2/tutorials/moving-pictures/emp-single-end-sequences/sequences.fastq.gz" > "emp-single-end-sequences/sequences.fastq.gz"
“EMP protocol” multiplexed paired-end fastq¶
Format description¶
In the “Earth Microbiome Project (EMP) protocol” format for paired-end reads, there are three fastq.gz
files, one containing forward sequence reads, one containing reverse sequence reads, and one containing the associated barcode reads, with the sequence data still multiplexed. The order of the records in the three fastq.gz
files defines the association between the sequences reads and barcode reads.
Obtaining example data¶
mkdir emp-paired-end-sequences
Download URL: https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/forward.fastq.gz
Save as: emp-paired-end-sequences/forward.fastq.gz
wget -O "emp-paired-end-sequences/forward.fastq.gz" "https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/forward.fastq.gz"
curl -sL "https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/forward.fastq.gz" > "emp-paired-end-sequences/forward.fastq.gz"
Download URL: https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/reverse.fastq.gz
Save as: emp-paired-end-sequences/reverse.fastq.gz
wget -O "emp-paired-end-sequences/reverse.fastq.gz" "https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/reverse.fastq.gz"
curl -sL "https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/reverse.fastq.gz" > "emp-paired-end-sequences/reverse.fastq.gz"
Download URL: https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/barcodes.fastq.gz
Save as: emp-paired-end-sequences/barcodes.fastq.gz
wget -O "emp-paired-end-sequences/barcodes.fastq.gz" "https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/barcodes.fastq.gz"
curl -sL "https://data.qiime2.org/2017.2/tutorials/atacama-soils/1p/barcodes.fastq.gz" > "emp-paired-end-sequences/barcodes.fastq.gz"
Casava 1.8 single-end demultiplexed fastq¶
Format description¶
In this format, there is one fastq.gz
file for each sample in the study, and the file name includes the sample identifier. The file name for a single sample might look like L2S357_15_L001_R1_001.fastq.gz
. The underscore-separated fields in this file name are the sample identifier, the barcode sequence or a barcode identifier, the lane number, the read number, and the set number.
Obtaining example data¶
Download URL: https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/casava-18-single-end-demultiplexed.zip
Save as: casava-18-single-end-demultiplexed.zip
wget -O "casava-18-single-end-demultiplexed.zip" "https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/casava-18-single-end-demultiplexed.zip"
curl -sL "https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/casava-18-single-end-demultiplexed.zip" > "casava-18-single-end-demultiplexed.zip"
unzip -q casava-18-single-end-demultiplexed.zip
Casava 1.8 paired-end demultiplexed fastq¶
Format description¶
In this format, there are two fastq.gz
file for each sample in the study, and the file name includes the sample identifier. The forward and reverse read file names for a single sample might look like L2S357_15_L001_R1_001.fastq.gz
and L2S357_15_L001_R2_001.fastq.gz
, respectively. The underscore-separated fields in this file name are the sample identifier, the barcode sequence or a barcode identifier, the lane number, the read number, and the set number.
Obtaining example data¶
Download URL: https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/casava-18-paired-end-demultiplexed.zip
Save as: casava-18-paired-end-demultiplexed.zip
wget -O "casava-18-paired-end-demultiplexed.zip" "https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/casava-18-paired-end-demultiplexed.zip"
curl -sL "https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/casava-18-paired-end-demultiplexed.zip" > "casava-18-paired-end-demultiplexed.zip"
unzip -q casava-18-paired-end-demultiplexed.zip
Feature table data¶
BIOM v1.0.0¶
Format description¶
See the BIOM v1.0.0 format specification for details.
Obtaining example data¶
Download URL: https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/feature-table-v100.biom
Save as: feature-table-v100.biom
wget -O "feature-table-v100.biom" "https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/feature-table-v100.biom"
curl -sL "https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/feature-table-v100.biom" > "feature-table-v100.biom"
BIOM v2.1.0¶
Format description¶
See the BIOM v2.1.0 format specification for details.
Obtaining example data¶
Download URL: https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/feature-table-v210.biom
Save as: feature-table-v210.biom
wget -O "feature-table-v210.biom" "https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/feature-table-v210.biom"
curl -sL "https://data.qiime2.org/2017.2/tutorials/importing-sequence-data/feature-table-v210.biom" > "feature-table-v210.biom"