Abstract
BACKGROUND: Chronic injury in kidney transplants remains a major cause of allograft loss. The aim of this study was to identify a gene set capable of predicting renal allografts at risk of progressive injury due to fibrosis.
METHODS: This Genomics of Chronic Allograft Rejection (GoCAR) study is a prospective, multicentre study. We prospectively collected biopsies from renal allograft recipients (n=204) with stable renal function 3 months after transplantation. We used microarray analysis to investigate gene expression in 159 of these tissue samples. We aimed to identify genes that correlated with the Chronic Allograft Damage Index (CADI) score at 12 months, but not fibrosis at the time of the biopsy. We applied a penalised regression model in combination with permutation-based approach to derive an optimal gene set to predict allograft fibrosis. The GoCAR study is registered with ClinicalTrials.gov, number NCT00611702.
FINDINGS: We identified a set of 13 genes that was independently predictive for the development of fibrosis at 1 year (ie, CADI-12 ≥2). The gene set had high predictive capacity (area under the curve [AUC] 0·967), which was superior to that of baseline clinical variables (AUC 0·706) and clinical and pathological variables (AUC 0·806). Furthermore routine pathological variables were unable to identify which histologically normal allografts would progress to fibrosis (AUC 0·754), whereas the predictive gene set accurately discriminated between transplants at high and low risk of progression (AUC 0·916). The 13 genes also accurately predicted early allograft loss (AUC 0·842 at 2 years and 0·844 at 3 years). We validated the predictive value of this gene set in an independent cohort from the GoCAR study (n=45, AUC 0·866) and two independent, publically available expression datasets (n=282, AUC 0·831 and n=24, AUC 0·972).
INTERPRETATION: Our results suggest that this set of 13 genes could be used to identify kidney transplant recipients at risk of allograft loss before the development of irreversible damage, thus allowing therapy to be modified to prevent progression to fibrosis.
FUNDING: National Institutes of Health.


Large (≥1200px)
Medium (≥992px)
Small (≥768px)
Mobile (<768px)
One, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one, one.
Two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two, two.
Three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three, three.
Four, four, four, four, four, four, four, four, four, four, four, four, four, four, four.
Five, five, five, five, five, five, five, five, five, five, five, five, five, five, five.
Six, six, six, six, six, six, six, six, six, six, six, six, six, six, six, six, six, six.
Seven, seven, seven, seven, seven, seven, seven, seven, seven, seven, seven, seven, seven.
Eight, eight, eight, eight, eight, eight, eight, eight, eight, eight, eight, eight, eight.
Nine, nine, nine, nine, nine, nine, nine, nine, nine, nine, nine, nine, nine, nine, nine.


Empower United Services Privacy & Security Policy
This Empower United Services Privacy & Security Policy ("Policy") outlines the general policy and practices for the types of information that Empower United Services, Inc. ("Empower United Services", "we", "us" or "our") gathers, how we use that information, and the options that our users ("you" or "your") have regarding our use of, and your ability to correct, such information.
Empower United Services will not sell, rent, share, or give away any of your personal information without your consent. It is our overriding privacy principle that any personal information provided to us by you is just that: personal and private. In order for us to provide some of our services we may need to provide information that you supply to us, to external parties. When such sharing is necessary, we will provide you with explicit notice, and whenever possible, the ability to opt-out.
Empower United Services’s website and services are not intended for, nor designed to attract, individuals under the age of eighteen. Empower United Services does not knowingly collect personally identifiable information from any person under the age of eighteen.
PERSONS TO WHOM THIS PRIVACY POLICY APPLIES:
This Policy applies to all (i) visitors to our website, (ii) users of our services (i.e., subscribers to any of our plans), and (iii) information we collect from visitors to the websites of users of our services. Our users’ websites may have their own privacy policies and may not be covered by this Policy. We strongly encourage visitors to these third party websites to make themselves aware of such websites’ separate privacy policies.
INFORMATION DESIGNATED AS PUBLIC:
As part of our services, you may decide to provide information to us specifically to be shared with third parties. For example, you may allow us to build statistical reports based on what malicious visitors have visited your site(s). In these cases, we will try to make it clear whenever any information you provide to us will be made public.
INFORMATION COLLECTION:
Empower United Services is the owner of the service information collected on this site and through any Empower United Services service. As visitors browse our website, or our users’ websites if they are protected by Empower United Services, we normally log these visitors’ interactions in order to provide better services to our users (e.g., using visitor log data in order to detect new threats and malicious third parties).
BILLING INFORMATION:
Empower United Services collects and maintains certain information from our users for the purposes of billing. We may report this information to third party processors for the limited purpose of receiving payment. We do not store full credit card numbers or personal account numbers (PANs).
COOKIES:
Our site uses "cookies” in order to provide a better service to you. Cookies are placed by your browser on your computer’s hard drive to assign a unique identification to that computer. For example, we may use cookies to help direct you to the appropriate part of our website, by indicating that you are a repeat visitor to our website. We also may use that information to present you with services that are customized to your preferences. Empower United Services does not store information we consider personal or private in a cookie, unless that information is obscured.
Some portions of our website are functional without cookies. You may delete Empower United Services’s cookies yourself through your browser’s cookie manager. However, disabling cookies will reset your session, disable auto-login, and may adversely affect other functions on the Empower United Services website and the services we provide to you.
As part of our services, Empower United Services may also place cookies on the computers of visitors to your Empower United Services-protected website. We do this to in order to identify malicious visitors, to reduce the chance of blocking legitimate users, and to provide customized services.
DATA AGGREGATION:
Empower United Services may aggregate data we acquire about our users and the visitors to their websites. For example, we may assemble data to determine how Web crawlers index the Internet and whether they are engaged in malicious activity. If we assemble this sort of data and provide it to external parties, our users’ personal information will never be attached to or included in such aggregated data. Please note, data that our users provide to us, such as log files of their site’s visitors, may be included in the aggregate data, reports, and statistics.
PROMOTIONAL PARTNERS AND THIRD PARTY APPS:
From time to time, Empower United Services may notify you about an offer from one of our promotional partners (e.g., Apps Marketplace partners) via our website or email. While we may target particular types of users for these offers, we do all of the targeting within our systems and not externally. Our business partners will not have any access to the targeting information, including the names of the people who may be interested in a particular product or service. Until you affirmatively respond to a promotional offer, we will not share any identifying information about you to any of these partners.
If you install an app from one of our third party partners, Empower United Services may provide your email address to that partner for account creation and communication with that partner.
Note that in both cases, these partners may have their own privacy policies and partners are not covered by this Policy. We encourage you to read such privacy policies.
THIRD PARTY WEBSITES:
The Empower United Services website and other websites contain links to the sites of third parties. We are not responsible for the privacy practices of these external websites. We encourage you to be aware when you leave our website, and to read the privacy statements of these external websites.
LAW ENFORCEMENT:
It is possible that we may be required by court order to provide information about our customers to third parties. Empower United Services may also be required to provide information pursuant to law, applicable regulation, subpoena or other legal process. It is our corporate policy to ensure adherence to the due process of law in all such legal requests. If we are required to provide information under these circumstances, we will, whenever possible, attempt to inform users whose information we are compelled to produce.
DATA SECURITY, DATA INTEGRITY, AND ACCESS:
We take all reasonable steps to protect our users’ information from loss, misuse and unauthorized access, disclosure, alteration and destruction. We have put in place appropriate physical, electronic and managerial procedures to safeguard and secure such information. Empower United Services only processes personal information in a way that is compatible with and relevant for the purpose for which it was collected or authorized by the individual. Empower United Services allows our users and website visitors access to their own personal information, and allows them to correct, amend, or delete inaccurate personal information, except where the burden or expense of providing such access would be disproportionate to the risks to the privacy of the individual, or where the rights of persons other than the individual risk being violated.
Note however, that Empower United Services may choose to outsource certain business functions to third party vendors, including website and marketing analytics. When we do, notwithstanding the foregoing, we will ensure that such vendors are bound by appropriate confidentiality restrictions to protect the information covered by this Policy.
EFFECTIVE DATE:
This Policy was last updated and is effective as of February 23, 2016.
CONTACT INFORMATION:
Attention: Trust and Compliance
Empower United Services, Inc.
9 Chamkoria str.
Sofia, Bulgaria


You may take this text as a copied and pasted one, but it is not so. Appearances are deceitful. For real, this text was created by our copywriters, so you could see in details how would the final product look •••
-
Resolving the issue with synchronization in old version.
16.07.20147 Comments -
Look for the latest update in coming days.
16.07.20147 CommentsYou may take this text as a copied and pasted one, but it is not so. Appearances are deceitful. For real, this text was created by our copywriters, so you could see in details how would the final product look •••
-
The meeting of developers of cross-platform apps.
16.07.20147 CommentsYou may take this text as a copied and pasted one, but it is not so. Appearances are deceitful. For real, this text was created by our copywriters, so you could see in details how would the final product look •••
-
The new functional sketches.
16.07.20147 CommentsYou may take this text as a copied and pasted one, but it is not so. Appearances are deceitful. For real, this text was created by our copywriters, so you could see in details how would the final product look •••


Are you sure you want to navigate away from this page? Be aware, if you press "Yes" now, ALL your changes will be lost! Press OK to continue, or Cancel to keep your enterd data.
Are you sure you want to navigate away from this page? Be aware, if you press "Yes" now, ALL your changes will be lost! Press OK to continue, or Cancel to keep your enterd data.
Successfully Paid
Please confirm your payment by clicking below button.


crypto package¶
Submodules¶
crypto.aes_credential_wrapper module¶
Concrete implementation of Credential Wrapper providing a wrapper that uses AES to wrap the credential source
Classes:
-
class
crypto.aes_credential_wrapper.
AESCredentialWrapper
[source]¶ Bases:
crypto.credential_wrapper.CredentialWrapper
An implementation of an AES based Credential Wrapper
This can be used to encrypt and decrypt a PublicKeyCredentialSource
-
generate_key
() → bytes[source]¶ Generates a new wrapping key by selecting 32 bytes at random
Returns: 32 bytes at random to use as an AES key Return type: bytes
-
unwrap
(key: bytes, wrapped_credential: bytes) → ctap.credential_source.PublicKeyCredentialSource[source]¶ unwraps by decrypting a wrapped credential
Parameters: Returns: Decrypted PublicKeyCredentialSource
Return type:
-
wrap
(key: bytes, credential: ctap.credential_source.PublicKeyCredentialSource) → bytes[source]¶ wraps a PublicKeyCredentialSource in an encrypted block. This is used for a non-resident key.
Parameters: - key (bytes) – AES Key
- credential (PublicKeyCredentialSource) – credential to wrap
Returns: Encrypted credential
Return type:
-
crypto.algs module¶
Enum containing acceptable COSE encoded algorithms
- Enums:
- PUBLIC_KEY_ALG
-
class
crypto.algs.
PUBLIC_KEY_ALG
[source]¶ Bases:
enum.Enum
COSE Public Key algorithm values
-
A128GCM
= 1¶
-
A128KW
= -3¶
-
A192GCM
= 2¶
-
A192KW
= -4¶
-
A256GCM
= 3¶
-
A256KW
= -5¶
-
AES_CCM_16_128_128
= 30¶
-
AES_CCM_16_128_256
= 31¶
-
AES_CCM_16_64_128
= 10¶
-
AES_CCM_16_64_256
= 11¶
-
AES_CCM_64_128_128
= 32¶
-
AES_CCM_64_128_256
= 33¶
-
AES_CCM_64_64_128
= 12¶
-
AES_CCM_64_64_256
= 13¶
-
AES_MAC_128_128
= 25¶
-
AES_MAC_128_64
= 14¶
-
AES_MAC_256_128
= 26¶
-
AES_MAC_256_64
= 15¶
-
ChaCha20_Poly1305
= 24¶
-
ECDH_ES_A128KW
= -29¶
-
ECDH_ES_A192KW
= -30¶
-
ECDH_ES_A256KW
= -31¶
-
ECDH_ES_HKDF_256
= -25¶
-
ECDH_ES_HKDF_512
= -26¶
-
ECDH_SS_A128KW
= -32¶
-
ECDH_SS_A192KW
= -33¶
-
ECDH_SS_A256KW
= -34¶
-
ECDH_SS_HKDF_256
= -27¶
-
ECDH_SS_HKDF_512
= -28¶
-
ES256
= -7¶
-
ES384
= -35¶
-
ES512
= -36¶
-
EdDSA
= -8¶
-
HMAC_256_256
= 5¶
-
HMAC_256_64
= 4¶
-
HMAC_384_384
= 6¶
-
HMAC_512_512
= 7¶
-
HSS_LMS
= -46¶
-
PS256
= -37¶
-
PS384
= -38¶
-
PS512
= -39¶
-
RS256
= -257¶
-
RS384
= -258¶
-
RS512
= -259¶
-
RSAES_OAEP_with_RFC_8017_default_parameters
= -40¶
-
RSAES_OAEP_with_SHA_256
= -41¶
-
RSAES_OAEP_with_SHA_512
= -42¶
-
direct
= -6¶
-
direct_HKDF_AES_128
= -12¶
-
direct_HKDF_AES_256
= -13¶
-
direct_HKDF_SHA_256
= -10¶
-
direct_HKDF_SHA_512
= -11¶
-
crypto.credential_wrapper module¶
Abstract Credential Wrapper provides functionality for encrypting (wrapping) and decrypting (unwrapping) PublicKeyCredentialSources as used by WebAuthN to store credential sources on the Relying Party server
-
class
crypto.credential_wrapper.
CredentialWrapper
[source]¶ Bases:
abc.ABC
Abstract Credential Wrapper defining functions needed to wrap and unwrap credential sources
-
generate_key
() → bytes[source]¶ Generates a new wrapping key
Returns: bytes containing wrapping key Return type: bytes
-
unwrap
(key: bytes, wrapped_credential: bytes) → ctap.credential_source.PublicKeyCredentialSource[source]¶ Unwrap a wrapped public key credential source by decrypting it with the specified key
Parameters: Returns: decrypted and instantiated credential source
Return type:
-
wrap
(key: bytes, credential: ctap.credential_source.PublicKeyCredentialSource) → bytes[source]¶ Wrap a public key credential source by encrypting it with the specified key
Parameters: - key (bytes) – AES key bytes to use in encryption
- credential (PublicKeyCredentialSource) – credential to be encrypted
Returns: encrypted credential
Return type:
-
crypto.crypto_provider module¶
Authenticator Crypto Provider
Abstract classes that provide framework for Crypto Providers
Classes:
- Variables:
- CRYPTO_PROVIDERS - Global map of COSE algorithms to Crypto
- Provider instances
-
class
crypto.crypto_provider.
AuthenticatorCryptoKeyPair
(public_key: crypto.crypto_provider.AuthenticatorCryptoPublicKey, private_key: crypto.crypto_provider.AuthenticatorCryptoPrivateKey)[source]¶ Bases:
abc.ABC
Abstract class containing a key pair of AuthenticatorPublicKey and AuthenticatorPrivateKey.
This is used a convenience method
-
get_encoded
() → bytes[source]¶ Gets the key pair in a byte encoded form
Note this may only encode the private key if the public key can be derived from the private key, as is often the case with ECC
Returns: encoding sufficient information to reconstruct the public and private key Return type: bytes
-
get_private_key
() → crypto.crypto_provider.AuthenticatorCryptoPrivateKey[source]¶ Returns the private key
Returns: private key Return type: AuthenticatorCryptoPrivateKey
-
get_public_key
() → crypto.crypto_provider.AuthenticatorCryptoPublicKey[source]¶ Return the public key
Returns: public key Return type: AuthenticatorCryptoPublicKey
-
-
class
crypto.crypto_provider.
AuthenticatorCryptoPrivateKey
(private_key)[source]¶ Bases:
abc.ABC
Abstract class representing the Private Key.
Wraps the underlying crypto private key
-
get_encoded
() → bytes[source]¶ Gets the private key in a byte encoded form
Returns: private key encoded as bytes Return type: bytes
-
-
class
crypto.crypto_provider.
AuthenticatorCryptoProvider
[source]¶ Bases:
abc.ABC
Abstract class for CryptoProviders that will be used by the Authenticator
-
classmethod
add_provider
(provider: crypto.crypto_provider.AuthenticatorCryptoProvider)[source]¶ Adds a crypto provider to the global list of available providers
Providers are indexed by algorithm.
TODO Consider how to prioritise between TPM and software based provivders that provide the same algorithm
Parameters: provider (AuthenticatorCryptoProvider) – Subclass of AuthenticatorCryptoProvider to add to the list
-
create_new_key_pair
(relying_party: str = None) → crypto.crypto_provider.AuthenticatorCryptoKeyPair[source]¶ Generate a new key pair using this crypto provider
This will implement the necessary algorithm for key generation and wrap the private and public keys in teh AuthenticatorPublicKey and AuthenticatorPrivateKey classes, before constructing an AuthenticatorCryptoKeyPair object
Parameters: relying_party (str, optional) – if set may be used during key generation as an internal identifier, for example, on a TPM. Default is None Returns: appropriately wrapped key pair Return type: AuthenticatorCryptoKeyPair
-
get_alg
() → int[source]¶ Get the COSE algorithm that this crypto provider provides
Returns: COSE algorithm identifier Return type: int
-
load_key_pair
(data: bytes) → crypto.crypto_provider.AuthenticatorCryptoKeyPair[source]¶ Loads a key pair from it byte representation
The data contained within bytes will be encoded appropriately for the underlying crypto provider and may or may not include both keys.
It is only guaranteed to provide sufficient data to reconstruct both keys, but that might require reconstructing the public key from the private key if that is how the crypto provider chooses to store the key pair
Parameters: data (bytes) – bytes containing sufficient information to reconstruct the key pair Returns: Instantiated key pair Return type: AuthenticatorCryptoKeyPair
-
public_key_from_cose
(cose_data: dict) → crypto.crypto_provider.AuthenticatorCryptoPublicKey[source]¶ Creates a public key from its COSE representation
This should interogate the COSE dictionary to reconstruct the public key as appropriate for the format and algorithm.
Parameters: cose_data (dict) – COSE encoded public key Returns: Public key instantited and wrapped Return type: AuthenticatorCryptoPublicKey
-
classmethod
-
class
crypto.crypto_provider.
AuthenticatorCryptoPublicKey
(public_key)[source]¶ Bases:
abc.ABC
Abstract Public Key to be used by the Authenticator
This should be subclassed to provide appropriate functionality for implemented crypto algorithms. This is not intended to be instantiated itself.
-
static
from_cose
(cose_data: {}) → crypto.crypto_provider.AuthenticatorCryptoPublicKey[source]¶ Loads a public key from its COSE encoding
Returns: crypto public key instance Return type: AuthenticatorCryptoPublicKey
-
static
crypto.es256_crypto_provider module¶
ES256 Crypto Provider
Concrete implementation of ES256 crypto functions using python cryptography
Classes:
-
class
crypto.es256_crypto_provider.
ECCryptoKeyPair
(private_key: cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePrivateKey)[source]¶ Bases:
crypto.crypto_provider.AuthenticatorCryptoKeyPair
Creates Elliptic Curve Key Pair
-
class
crypto.es256_crypto_provider.
ECCryptoPrivateKey
(private_key: cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePrivateKey)[source]¶ Bases:
crypto.crypto_provider.AuthenticatorCryptoPrivateKey
Represents an Elliptic Curve private key
-
exchange
(other_public_key: cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePublicKey) → bytes[source]¶ Performs first part of DH Key Exchange. This is required for the PIN handling in CTAP. Note, this is not required for non-ES256 classes since the algorithm for PIN handling is fixed
This is not a standard ECDH key exchange, only part of it as per CTAP
Parameters: other_public_key (EllipticCurvePublicKey) – The other public key in the exchange Returns: hashed result of exchange as per CTAP standard Return type: bytes
-
get_encoded
() → bytes[source]¶ Gets the private key in a byte encoded form
Returns: private key encoded as bytes Return type: bytes
-
-
class
crypto.es256_crypto_provider.
ECCryptoPublicKey
(public_key: cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePublicKey)[source]¶ Bases:
crypto.crypto_provider.AuthenticatorCryptoPublicKey
Elliptic Curve Public Key
-
static
from_cose
(cose_data: {}) → crypto.es256_crypto_provider.ECCryptoPublicKey[source]¶ Instantiates an instance of this class from a COSE encoded public key.
Returns: instance of the public key Return type: ECCryptoPublicKey
-
static
-
class
crypto.es256_crypto_provider.
ES256CryptoProvider
[source]¶ Bases:
crypto.crypto_provider.AuthenticatorCryptoProvider
Instaniates an ES256 Crypto Provider
-
create_new_key_pair
(relying_party: str = None) → crypto.crypto_provider.AuthenticatorCryptoKeyPair[source]¶ Generate a new key pair using this crypto provider
This will implement the necessary algorithm for key generation and wrap the private and public keys in teh AuthenticatorPublicKey and AuthenticatorPrivateKey classes, before constructing an AuthenticatorCryptoKeyPair object
Parameters: relying_party (str, optional) – if set may be used during key generation as an internal identifier, for example, on a TPM. Default is None Returns: appropriately wrapped key pair Return type: AuthenticatorCryptoKeyPair
-
load_key_pair
(data: bytes) → crypto.es256_crypto_provider.ECCryptoKeyPair[source]¶ Loads a key pair from it byte representation
The data contained within bytes will be encoded appropriately for the underlying crypto provider and may or may not include both keys.
It is only guaranteed to provide sufficient data to reconstruct both keys, but that might require reconstructing the public key from the private key if that is how the crypto provider chooses to store the key pair
Parameters: data (bytes) – bytes containing sufficient information to reconstruct the key pair Returns: Instantiated key pair Return type: AuthenticatorCryptoKeyPair
-
public_key_from_cose
(cose_data: {}) → crypto.es256_crypto_provider.ECCryptoPublicKey[source]¶ Creates a public key from its COSE representation
This should interogate the COSE dictionary to reconstruct the public key as appropriate for the format and algorithm.
Parameters: cose_data (dict) – COSE encoded public key Returns: Public key instantited and wrapped Return type: AuthenticatorCryptoPublicKey
-
crypto.tpm_es256_crypto_provider module¶
TPM Based ES256 Crypto Provider
Concrete implementation of a TPM based ES256 crypto functions
Classes:
-
class
crypto.tpm_es256_crypto_provider.
TPMECCryptoKeyPair
(private_key: crypto.tpm.ibmtpm.DICERelyingPartyKey, tpm: crypto.tpm.ibmtpm.TPM)[source]¶ Bases:
crypto.crypto_provider.AuthenticatorCryptoKeyPair
Creates Elliptic Curve Key Pair
-
class
crypto.tpm_es256_crypto_provider.
TPMECCryptoPrivateKey
(private_key: crypto.tpm.ibmtpm.DICERelyingPartyKey, tpm: crypto.tpm.ibmtpm.TPM)[source]¶ Bases:
crypto.crypto_provider.AuthenticatorCryptoPrivateKey
Represents an Elliptic Curve private key
-
get_encoded
() → bytes[source]¶ Gets the private key in a byte encoded form
Returns: private key encoded as bytes Return type: bytes
-
-
class
crypto.tpm_es256_crypto_provider.
TPMECCryptoPublicKey
(public_key: cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePublicKey)[source]¶ Bases:
crypto.crypto_provider.AuthenticatorCryptoPublicKey
Elliptic Curve Public Key
-
static
from_cose
(cose_data: {}) → ECCryptoPublicKey[source]¶ Instantiates an instance of this class from a COSE encoded public key.
Returns: instance of the public key Return type: ECCryptoPublicKey
-
static
-
class
crypto.tpm_es256_crypto_provider.
TPMES256CryptoProvider
[source]¶ Bases:
crypto.crypto_provider.AuthenticatorCryptoProvider
Instaniates an ES256 Crypto Provider
-
create_new_key_pair
(relying_party: str = None) → crypto.crypto_provider.AuthenticatorCryptoKeyPair[source]¶ Generate a new key pair using this crypto provider
This will implement the necessary algorithm for key generation and wrap the private and public keys in teh AuthenticatorPublicKey and AuthenticatorPrivateKey classes, before constructing an AuthenticatorCryptoKeyPair object
Parameters: relying_party (str, optional) – if set may be used during key generation as an internal identifier, for example, on a TPM. Default is None Returns: appropriately wrapped key pair Return type: AuthenticatorCryptoKeyPair
-
create_user_key
(username: str, password: str) → str[source]¶ Creates a TPM user key and returns it encoded as string for storage
Parameters: Returns: JSON encoded string of the user key
Return type: (str)
-
load_key_pair
(data: bytes) → crypto.tpm_es256_crypto_provider.TPMECCryptoKeyPair[source]¶ Loads a key pair from it byte representation
The data contained within bytes will be encoded appropriately for the underlying crypto provider and may or may not include both keys.
It is only guaranteed to provide sufficient data to reconstruct both keys, but that might require reconstructing the public key from the private key if that is how the crypto provider chooses to store the key pair
Parameters: data (bytes) – bytes containing sufficient information to reconstruct the key pair Returns: Instantiated key pair Return type: AuthenticatorCryptoKeyPair
-
load_user_key
(key_data: str)[source]¶ Loads the user key from JSON encoded key data
Parameters: key_data (str) – JSON encoded string data
-
public_key_from_cose
(cose_data: {}) → crypto.tpm_es256_crypto_provider.TPMECCryptoPublicKey[source]¶ Creates a public key from its COSE representation
This should interogate the COSE dictionary to reconstruct the public key as appropriate for the format and algorithm.
Parameters: cose_data (dict) – COSE encoded public key Returns: Public key instantited and wrapped Return type: AuthenticatorCryptoPublicKey
-


Why Samsung SMART service solutions?
Samsung SMART service solutions offer a broad range of methods to solve document-handling issues that may arise in the workplace and provide quick, communicative services to ensure optimal print operations for businesses. By offering customized solutions specially designed for every stakeholder involved in the document printing process, from IT an IT administrator and an end-user to a service provider. Samsung provides the ideal solution to various problems at virtually any point in the process while drastically reducing service waiting time. This means minimal workforce downtime for increased business productivity and an improved bottom line.


ED WOOD A film review by Tim Voon Copyright 1997 Tim Voon
Starring: Johnny Depp, Martin Landau, Sarah Jessica Parker, Patricia Arquette, Jeffrey Jones, Bill Murray. Screenplay: Scott Alexander and Larry Karaszewski. Director: Tim Burton.
Ed Wood is a man with an impossible dream, a Don Quixote of the movies.
This man made movies that nobody wanted to see because they were darn awful. He is a man with a childlike naivety about life and movies, who is unable to see how bad his productions actually were. Despite his continued failures, he persists with his dream to make pictures that he wanted to see. To become the Orson Welles of sci-fi\ horror flicks. One cannot help but admire his persistence and dedication, but at the same time be dismayed and heartbroken at his inability to learn from his mistakes.
He is a man with all heart and vision. A dreamer who is driven by his great passion and love for film making; but somehow, in the midst of his shabby directing, all of his good intentions become blurred and misplaced. That perhaps his talent lay not in the quality of his movies, but in the heart of the man himself.
He is in essence a child with a dream. Despite numerous failures and poor quality work, it is the dream which matters and that cannot be taken from him. To remain true to himself and what he believed in.
Sensitive direction from Burton, and exceptional performances by Landau and Depp.
Rating: A failed artist who would sing 'Don't cry for me Hollywood' on a burning flying saucer over L.A.
Timothy Voon e-mail<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Inverse Quantum Fourier Transforms¶
In quantum computing, a Quantum Fourier Transform (QFT) is a linear transformation on quantum bits, and is the quantum analogue of the discrete Fourier transform. QFT is a part of many quantum algorithms, such as Shor’s algorithm for factoring and computing the discrete logarithm, and the Quantum Phase Estimation (QPE) algorithm for estimating the eigenvalues of a unitary operator. A QFT can be performed efficiently on a quantum computer, with a particular decomposition into a product of simpler unitary matrices. It has been shown how, using a simple decomposition, the discrete Fourier transform on \(2^n\) amplitudes can be implemented as a quantum circuit consisting of only \(O(n^2)\) Hadamard gates and controlled phase shift gates, where \(n\) is the number of qubits, in contrast with the classical discrete Fourier transform, which takes \(O(n2^n)\) gates, where in the classical case \(n\) is the number of bits. The best quantum Fourier transform algorithms currently known require only \(O(n\log n)\) gates to achieve an efficient approximation.
Most of the properties of the QFT follow from the fact that it is a unitary transformation. This implies that, if \(F\) is the matrix representing the QFT, then \(FF^\dagger = F^{\dagger}F=I\), where \(F^\dagger\) is the Hermitian adjoint of \(F\) and \(I\) is the identity matrix. It follows that \(F^{-1} = F^\dagger\). Since there is an efficient quantum circuit implementing the QFT, the circuit can be run in reverse to perform the Inverse Quantum Fourier Transform (IQFT). Thus, both transforms can be efficiently performed on a quantum computer.
As mentioned above, the Quantum Phase Estimation (QPE) algorithm uses the QFT for estimating the eigenvalues of a unitary operator. More precisely, QPE uses the Inverse Quantum Fourier Transform (IQFT). IQFTs in Aqua are pluggable objects. Among the IQFTs provided by Aqua, the user can choose which IQFT to use when instantiating QPE or any other algorithm that requires the use of an IQFT. Furthermore, researchers interested in contributing new algorithms to Aqua can plug their own IQFT implementation.
Extending the IQFT Library
Consistent with its unique design, Aqua has a modular and
extensible architecture. Algorithms and their supporting objects, such as IQFTs,
are pluggable modules in Aqua. This is done in order to encourage researchers and
developers interested in
Contributing to Aqua to extend the Aqua framework with their novel research contributions.
New IQFTs are typically installed in the qiskit_aqua/utils/iqfts
folder and derive from the IQFT
class. Aqua also allows for
Dynamically Discovered Components: new IQFTs can register themselves
as Aqua extensions and be dynamically discovered at run time independent of their
location in the file system.
Aqua comes with two IQFTs:
The iqft
section in the Input File becomes relevant
only for algorithms that require an IQFT. This is reflected also in the
GUI, which enables the iqft
section for the IQFT configuration
only when an algorithm requiring an IQFT is selected. When the iqft
section is
indeed enabled, then the user can choose which IQFT to apply by assigning a str
value
to the name
field of the iqft
section.
Standard IQFT¶
The standard version of the IQFT is simply the inverse of a plain QFT. It generates the inverse of a QFT circuit with no approximation. The standard IQFT takes no parameters and is not configurable.
Declarative Name
When referring to the standard IQFT declaratively inside Aqua, its code name
, by which Aqua dynamically discovers and loads it,
is STANDARD
.
Approximate IQFT¶
This form of IQFT generates the inverse of an Approximate Quantum Fourier Transform (AQFT) as described in arXiv:1803.04933. The degree of approximation can be configured using the following parameter:
degree = 0 | 1 | ...
This parameter controls the level of approximation of the IQFT,
expressed as a non-negative int
value.
The value provided will reduce the depth of neighbor terms allowed in the
IQFT circuit. The default value is 0
, which results in no approximation — in which
case the resulting IQFT is exactly the same as the standard IQFT.
Each value above 0
, however ,
reduces by the corresponding amount the range of the neighbor terms allowed,
which in turn reduces the circuit complexity.
Declarative Name
When referring to the approximate IQFT declaratively inside Aqua, its code name
,
by which Aqua dynamically discovers and loads it, is APPROXIMATE
.


See: Description
| Class | Description |
|---|---|
| JcaDefaultTlsCredentialedSigner |
Credentialed class for generating signatures based on the use of primitives from the JCA.
|
| JcaTlsCertificate |
Implementation class for a single X.509 certificate based on the JCA.
|
| JcaTlsCrypto |
Class for providing cryptographic services for TLS based on implementations in the JCA/JCE.
|
| JcaTlsCryptoProvider |
Basic builder class for constructing standard TlsCrypto classes.
|
| JcaTlsDSASigner |
Implementation class for generation of the raw DSA signature type using the JCA.
|
| JcaTlsDSAVerifier |
Implementation class for the verification of the raw DSA signature type using the JCA.
|
| JcaTlsDSSSigner |
JCA base class for the signers implementing the two DSA style algorithms from FIPS PUB 186-4: DSA and ECDSA.
|
| JcaTlsDSSVerifier |
JCA base class for the verifiers implementing the two DSA style algorithms from FIPS PUB 186-4: DSA and ECDSA.
|
| JcaTlsECDSASigner |
Implementation class for generation of the raw ECDSA signature type using the JCA.
|
| JcaTlsECDSAVerifier |
Implementation class for the verification of the raw ECDSA signature type using the JCA.
|
| JcaTlsEd25519Signer | |
| JcaTlsEd25519Verifier | |
| JcaTlsEd448Signer | |
| JcaTlsEd448Verifier | |
| JcaTlsEdDSASigner | |
| JcaTlsEdDSAVerifier | |
| JcaTlsHash |
Wrapper class for providing support methods for a TlsHash based on the JCA MessageDigest class.
|
| JcaTlsRSAPSSSigner |
Operator supporting the generation of RSASSA-PSS signatures.
|
| JcaTlsRSAPSSVerifier |
Operator supporting the verification of RSASSA-PSS signatures.
|
| JcaTlsRSASigner |
Operator supporting the generation of RSASSA-PKCS1-v1_5 signatures.
|
| JcaTlsRSAVerifier |
Operator supporting the verification of RSASSA-PKCS1-v1_5 signatures.
|
| JceAEADCipherImpl |
A basic wrapper for a JCE Cipher class to provide the needed AEAD cipher functionality for TLS.
|
| JceBlockCipherImpl |
A basic wrapper for a JCE Cipher class to provide the needed block cipher functionality for TLS.
|
| JceBlockCipherWithCBCImplicitIVImpl |
A basic wrapper for a JCE Cipher class to provide the needed block cipher functionality for TLS where the
cipher requires the IV to be continued between calls.
|
| JceChaCha20Poly1305 | |
| JceDefaultTlsCredentialedAgreement |
Credentialed class generating agreed secrets from a peer's public key for our end of the TLS connection using the JCE.
|
| JceDefaultTlsCredentialedDecryptor |
Credentialed class decrypting RSA encrypted secrets sent from a peer for our end of the TLS connection using the JCE.
|
| JceTlsDH |
Support class for ephemeral Diffie-Hellman using the JCE.
|
| JceTlsDHDomain |
JCE support class for Diffie-Hellman key pair generation and key agreement over a specified Diffie-Hellman configuration.
|
| JceTlsECDH |
Support class for ephemeral Elliptic Curve Diffie-Hellman using the JCE.
|
| JceTlsECDomain |
EC domain class for generating key pairs and performing key agreement.
|
| JceTlsHMAC |
Wrapper class for a JCE MAC based on HMAC to provide the necessary operations for TLS.
|
| JceTlsMAC |
A basic wrapper for a JCE Mac class to provide the needed functionality for TLS.
|
| JceTlsSecret |
JCE support class for handling TLS secrets and deriving key material and other secrets from them.
|
| JceX25519 |
Support class for X25519 using the JCE.
|
| JceX25519Domain | |
| JceX448 |
Support class for X448 using the JCE.
|
| JceX448Domain |


Go to the source code of this file.
Classes | |
| struct | compare_edge |
| A struct that provides the comparison of edge objects. It allows sorting of edges for priority queues. The sorting follows three rules: First, edges are sorted by ascending cost. Edges with the same cost are sorted preferring horizontal/vertical edges. Edges with same cost and orientation are sorted ascending by vertical/horizontal position. More... | |
| class | edge |
| A class for representing edges. More... | |
| struct | hash_edge |
| A struct that provides the hash function of edge objects. More... | |


ENVIRONMENT COMMANDS
The following commands control the XSI environment.
APROPOS
BATCH
BATCH*
BLOAD
BSAVE
CLEAR
EXIT
GET-AUTO-FLOAT-DIVIDEND
GET-DYNAMIC-CONSTRAINT-CHECKING
GET-STATIC-CONSTRAINT-CHECKING
LOAD
LOAD*
OPTIONS
RESET
SAVE
SET-AUTO-FLOAT-DIVIDEND
SET-DYNAMIC-CONSTRAINT-CHECKING
SET-STATIC-CONSTRAINT-CHECKING
SYSTEM


"x" "1" "GELDERBLOM,WC AND SNYMAN,SD, MUTAGENICITY OF POTENTIALLY CARCINOGENICMYCOTOXINS PRODUCED BY FUSARIUM MONILIFORME, MYCOTOXIN RES. 7(2):46-52,1991"


Do you need help on a certain thing?
Choose the following item to solve your problem.
Can't find what you're looking for?
Try contacting via e-mail!
--- layout: page title: Support description: Get help and information on things permalink: /support icon: far fa-life-ring ---
Choose the following item to solve your problem.
Try contacting via e-mail!


|
|
The last part of the article introduces some well known applications of the minimum cost flow problem. Some of the applications are described according to [1]. The Assignment Problem In other words, consider we have a square matrix with n rows and n columns. Each cell of the matrix contains a number. Let's denote by cij the number which lays on the intersection of i-th row and j-th column of the matrix. The task is to choose a subset of the numbers from the matrix in such a way that each row and each column has exactly one number chosen and sum of the chosen numbers is as minimal as possible. For example, assume we had a matrix like this: In this case, we would chose numbers 3, 4, and 3 with sum 10. In other words, we have to find an integral solution of the following linear programming problem: If binary variable xij = 1 we will choose the number from cell (i,j) of the given matrix. Constraints guarantee that each row and each column of the matrix will have only one number chosen. Evidently, the problem has a feasible solution (one can choose all diagonal numbers). To find the optimal solution of the problem we construct the bipartite transportation network as it is drawn in Figure 1. Each edge (i,j') of the graph has unit capacity and cost cij. All supplies and demands are equal to 1 and -1 respectively. Implicitly, minimum cost flow solution corresponds to the optimal assignment and vise versa. Thanks to left-to-right directed edges the network contains no negative cycles and one is able to solve it with complexity of O(n3). Why? Hint: use the successive shortest path algorithm. Figure 1. Full weighted bipartite network for the assignment problem. Each edge has capacity 1 and cost according to the number in the given matrix. The assignment problem can also be represented as weight matching in a weighted bipartite graph. The problem allows some extensions:
However, we should point out that, due to the specialty of the assignment problem, there are more effective algorithms to solve it. For instance, the Hungarian algorithm has complexity of O(n3), but it works much more quickly in practice. Discrete Location Problems Let's denote by dkj the distance between existing facility k and site j; and the total transportation cost per unit distance between the new facility i and the existing one k by wik. Let's denote the assignment by binary variable xij. Given an assignment x we can get a corresponding transportation cost between the new facility i and the existing facility k: Note, that is the cost of locating the new facility i at site j. Appending necessary conditions, we obtain another instance of the assignment problem. The Transportation Problem For example, suppose that we have a set of m warehouses and a set of n shops. Each warehouse i has nonnegative supply value bi while each shop j has nonnegative demand value dj. We are able to transfer goods from a warehouse i directly to a shop j by the cost cij per unit of flow. Figure 2. Formulating the transportation problem as a minimum cost flow problem. Each edge connecting a vertex i and a vertex j' has capacity uij and cost cij.There is an upper bound to the amount of flow between each warehouse i and each shop j denoted by uij. Minimizing total transportation cost is the object. Representing the flow from a warehouse i to a shop j by xij we obtain the model above. Evidently, the assignment problem is a special case of the transportation problem in the statement of matrix, which in turn is a special case of the minimum cost flow problem. Optimal Loading of a Hopping Airplane Let bij denote the number of passengers available at node i who want to go to node j, and let fij denote the fare per passenger from node i to node j. The airline would like to determine the number of passengers that the plane should carry between the various origins and destinations in order to maximize the total fare per trip while never exceeding the plane capacity. Figure 3. Formulating the hopping plane flight problem as a minimum cost flow problem. Figure 3 shows a minimum cost flow formulation of this hopping plane flight problem. The network contains data for only those arcs with nonzero costs and with finite capacities: Any arc without an associated cost has a zero cost; any arc without an associated capacity has an infinite capacity. Consider, for example, node 1. Three types of passengers are available at node 1, those whose destination is node 2, node 3, or node 4. We represent these three types of passengers by the nodes 1-2, 1-3, and 1-4 with supplies b12, b13, and b14. A passenger available at any such node, say 1-3, either boards the plane at its origin node by flowing though the arc (1-3,1) and thus incurring a cost of -f13 units, or never boards the plane which we represent by the flow through the arc (1-3,3). We invite the reader to establish one-to-one correspondence between feasible passenger routings and feasible flows in the minimum cost flow formulation of the problem. Dynamic Lot Sizing The network has K+1 vertexes: The j-th vertex, for j = 1, 2, …, K, represents the j-th planning period; node 0 represents the "source" of all production. The flow on the "production arc" (0,j) prescribes the production level aj in period j, and the flow on "inventory carrying arc" (j,j+1) prescribes the inventory level Ij to be carried from period j to period j+1. Figure 4. Network flow model of the dynamic lot-size problem. The mass balance equation for each period j models the basic accounting equation: Incoming inventory plus production in that period must equal the period's demand plus the final inventory at the end of the period. The mass balance equation for vertex 0 indicates that during the planning periods 1, 2, …, K, we must produce all of the demand (we are assuming zero beginning and zero final inventory over the planning horizon). If we impose capacities on the production and inventory in each period and suppose that the costs are linear, the problem becomes a minimum cost flow model. References |
|
|
Home |
About TopCoder |
Press Room |
Contact Us |
Careers |
Privacy |
Terms
Competitions | Cockpit |
| Copyright TopCoder, Inc. 2001-2011 |


GIF2TIFF
Section: User Commands (1)Updated: November 2, 2005
Index Return to Main Contents
NAME
gif2tiff - create a TIFF file from a GIF87 format image fileSYNOPSIS
gif2tiff [ options ] input.gif output.tifDESCRIPTION
Gif2tiff converts a file in the GIF87 format to TIFF. The TIFF image is created as a palette image, with samples compressed with the Lempel-Ziv & Welch algorithm (Compression=5). These characteristics can overridden, or explicitly specified with the options described below.OPTIONS
- -c
- Specify a compression scheme to use when writing image data: -c none for no compression, -c packbits for the PackBits compression algorithm, -c zip for the Deflate compression algorithm, and -c lzw for Lempel-Ziv & Welch (the default).
- -r
- Write data with a specified number of rows per strip; by default the number of rows/strip is selected so that each strip is approximately 8 kilobytes.
NOTES
The program is based on Paul Haeberli's fromgif program which, in turn, is based on Marcel J.E. Mol's GIF reader.BUGS
Should have more options to control output format.SEE ALSO
pal2rgb(1), tiffinfo(1), tiffcp(1), tiffmedian(1), libtiff(3)Libtiff library home page: http://www.remotesensing.org/libtiff/
Index
This document was created by man2html, using the manual pages.
Time: 05:29:04 GMT, December 24, 2015


|
Graphitti
A toolkit/software architecture to ease creating high-performance neural network simulators
|
An efficient implementation of a dynamically-allocated 2D array. More...
Go to the source code of this file.
Classes | |
| class | CompleteMatrix |
| An efficient implementation of a dynamically-allocated 2D array. More... | |
Functions | |
| const CompleteMatrix | sqrt (const CompleteMatrix &m) |
An efficient implementation of a dynamically-allocated 2D array.
//
Definition in file CompleteMatrix.h.


{% extends "base.html" %} {% load static %} {% block content %}
We've all wondered how the brain processes information. You may have asked yourself, 'How am I reading this text?' 'How can I look at an everyday object like a kiwi and tell what it is?'
Neuroscientists ask questions like this everyday, and then conduct experiments to figure out the answer.
This website will explore some common ways that neural data is analyzed in order to figure out how the brain processes information.
Scroll to learn more.
Scientists know more about how the brain works than ever before, but there are still many unanswered questions.
To answer these questions, neuroscientists measure brain activity.
 Typical neurons consist of a soma (or cell body), dendritic branches (or dendrites) that receives signal from other cells, and an axon that conducts signal away from the cell body to other neurons or to muscles.
When the sum of signals that reach the dendrite from other neurons is larger than some threshold, the neuron "fires" - thus propagating the signal through the neuron’s long axon to reach other neurons.
This propagation of signal is called an action potential, or spike, and is the basis of all neural communication. A neuron can only fire a single action potential, never a half an action potential, so a spike train that measures when action potentials are fired is only ever 0 or 1.
Dendrites constantly receive new incoming signals, and therefore the action potentials that the neuron fires create a pattern over time.
One way that neuroscientists measure brain activity is by implanting electrodes into the brain that record spikes. This collection of action potentials recorded over time is called a spike train and looks something like this:
Many neuroscience experiments try to figure out how the brain works by recording responses to different conditions. The experiment we'll be examining [collected by Ying Zhang in Bob Desimone’s lab in the McGovern Institute at MIT] recorded spikes from 132 neurons in the inferior temporal cortex (a brain region known to be important for visual processing) of a Macaque monkey [1].
On each trial, the monkey was presented with one of seven different stimuli: pictures of a guitar, hand, flower, kiwi, couch, face, or car. Each neuron was recorded for 1000 ms, and the stimulus was shown 500 ms after the monkey fixated a spot at the center of a display.
Each image was presented around 60 times while the neuron spikes were recorded.
Now that we have this collection of zeros and ones, we can ask more interesting questions. Namely, what does seeing a kiwi look like in the brain? At what time can our brains tell that we’re looking at a hand? How can we be sure that these zeros and ones aren't just due to chance?
To present this data a different way, we can look at the average firing rate over an interval of time within each trial.
This makes it easier to see how neurons' firing rates differ from each other.
Some neurons fire all the time, some neurons rarely fire, but how can we tell which neurons are important for our experiment?
The first thing we want to do is look at multiple trials.
The spike train from one neuron can fire very differently from trial to trial, even when both recordings come from the same stimulus. It's therefore important to look at many recordings from the same neuron to make sure you aren't confusing random activity for activity driven by the stimuli.
If we had data from an infinite number of trials, we would be able to calculate the true average firing rate for each neuron and stimulus perfectly. However, because we only have data from around 60 trials for each stimulus, our estimate of the true average firing rate is most likely slightly off. The colored bands that you see are called 95% confidence intervals, and they are created such that the true average firing rate will be contained in the band 95% of the time.
If we have less data, then our confidence intervals have to be larger to capture the true average firing rate 95% of the time. Below you can move the slider to see the mean and confidence intervals change when you use less data. For more information about confidence intervals, see [2].
Now that we have a good idea of what the firing rate for one neuron looks like for every stimulus over many different trials, we can now look at the average of many different neurons.
Every neuron responds to stimuli differently. Some neurons naturally fire very often and have a high average firing rate, like neuron A, but other neurons naturally have a much lower average firing rate, like neuron B.
Therefore, to compare these neuron firing rates more effectively, we put them on the same scale - a process called normalization.
To do this, we calculate the mean and standard deviation of all time bins and trials for each neuron. We then normalize the neuron's activity by subtracting this mean and dividing by this standard deviation. Now instead of plotting average firing rate over time, we plot the deviations away from the average firing rate over time.
Before when we combined information from multiple trials, we only averaged together the trials when the same stimulus was shown. This allowed us to be able to tell whether or not a neuron responds differently to different stimuli. Similarly, averaging together all neurons would make it difficult for us to tell if the neurons respond differently to different stimuli.
For example, neuron A spikes a lot after the guitar and flower stimuli appear, while neuron B spikes more for the couch stimulus but overall less frequently after every stimulus appears.
However, if we average the two neurons, then we can no longer distinguish the couch, guitar, or flower stimuli as easily!
We therefore need another way of combining information from different neurons that helps us figure out the answer to our experimental question: how does the brain process and store information about different images?
Since we can’t as easily figure out if our experimental condition had an effect from averaging our entire neuron population, we need another technique.
As we saw before, the same neuron can respond very differently to multiple exposures to the same stimulus.
Thus we will use a statistical method that compares the distribution of average firing rates for each neuron and across every stimulus.
We can then run an ANalysis Of VAriance (ANOVA), a procedure that helps us figure out if the neurons actually respond differently to different stimuli or whether the recorded responses are random fluctuations.
More technically, ANOVA computes a statistic that gives us a measure of the likelihood that splitting the trials randomly could explain more of the variation in all of the trials than splitting them by stimuli.
We run a separate ANOVA for each time bin and neuron, and get a p-value that gives us the probability of calculating a statistic more extreme than the one observed if the mean firing rate responses were in fact the same for each stimulus.
In this analysis, we’re going to set a threshold (called an alpha-level) where we call a neuron "selective" if it has a p-value less than that alpha-level.
A very small p-value indicates that the neuron responded differently to different stimuli.
We expect that before the stimulus was shown there is a fraction of neurons equal to the alpha-level that would be called selective by chance.
If the fraction of selective neurons is much higher than the alpha-level after the stimulus was shown, that means that the stimuli statistically produced distinctly different neural responses in our experiment.
In our ANOVA analysis, we analysed whether the population of neurons was selective by running an ANOVA analysis separately on each neuron. Other approaches, such as neural population decoding, apply a multivariate analysis to look at the population as a whole rather than analyzing each neuron separately [3].
The brain is complicated, and neuroscientists are still trying to answer basic questions about how the brain works.
However, the data analysis techniques explored here can help us understand how long it takes information to propagate throughout the brain, how neurons respond more to certain stimuli than others, and about the proportion of neurons that statistically respond to the experimental conditions.
As we continue to collect more data and build better data analysis methods, the more we will improve our understanding of how the brain produces complex behavior.


flash_on
Stimulation
clear
Wrist X Position
call_split
Wrist Y Position
settings_ethernet
Distance
call_missed_outgoing
Direction
transfer_within_a_station
Velocity
Body


The TestNG Eclipse plug-in allows you to run your TestNG tests from Eclipse and easily monitor their execution and their output. It has its own project repository called testng-eclipse.
Follow the instructions to install the plug-in.
NOTE: since TestNG Eclipse Plugin 6.9.10, there is a new optional plug-in for M2E (Maven Eclipse Plugin) integration. It's recommended to install it if your Java project(s) are managed by Maven.
Once done, restart Eclipse and select the menu Window / Show View / Other... and you should see the TestNG view listed in the Java category.
NOTE: since TestNG Eclipse Plugin 6.9.8, the minimum required TestNG version is 6.5.1
To create a new TestNG class, select the menu File / New / TestNG:
If you currently have a Java file open in the editor or if you have a Java file selected in the Navigator, the first page of the wizard will show you a list of all the public methods of that class and it will give you the option to select the ones you want to test. Each method you select on this page will be included in the new TestNG class with a default implementation that throws an exception, so you remember to implement it.
The next page lets you specify where that file will be created, whether it should contain default implementation for some configuration methods, if you'd like a data provider and finally, if a testng.xml file should be generated.
The plug-in will make a guess about the best location where this file should be created (for example, if you are using Maven, the default location will be under src/test/java).
Once you have created classes that contain TestNG annotations and/or one or more testng.xml files, you can create a TestNG Launch Configuration. Select the Run / Run... (or Run / Debug...) menu and create a new TestNG configuration:
You should change the name of this configuration and pick a project, which can be selected by clicking on the Browse... button at the top of the window.
Runtime options:
Then you choose to launch your TestNG tests in the following ways:
Make sure the box near Class is checked and then pick a class from your project. You can click on the Browse... button and pick it directly from a list. This list only contains classes that contain TestNG annotations:
If you only want to launch one or several groups, you can type them in the text field or pick them from a list by clicking on the Browse... button
You can type the regex on the filter text field to narrow down to suite definition files matching your search from a long list of files.
This launch isn't accomplished from the Launch dialog but directly from your Outline view:
You can right-click on any test methods and select Run as... / TestNG test and only the selected method will be run (not shown on the above screenshot because I couldn't find a way to capture a contextual menu).
Method launching is also available from the Package Explorer view and from the Java Browser perspective.
Once you have selected one of these launches, you can also choose the logging of level. Then you can launch the tests by pressing the Debug (or Run) button, which will switch you to the Debug perspective and will open the main TestNG view.
In order to give you access to the most flexibility, TestNG lets you specify an XML suite file for all these launches, which you can find in the Preferences menu:
If you specify a valid suite file as "XML template file", TestNG will reuse all the settings found in this XML file, such as parallel, name, listeners, thread pool size, etc... Only the <test> tags in this file will be ignored since the plug-in will replace these by a generated <test> tag that represents the launch you chose.
The above view shows a successful run of the tests: the bar is green and no failed tests are reported. The All tests tab shows you a list of all the classes and methods that were run.
If your test run contains failures, the view will look like this:
You can use the Failed tests tab to display only these tests that failed, and when you select such a test, the stack trace will be shown on the right-hand pane. You can double click on the offending line to be taken directly to the failure in your code.
When you have hundreds of tests running, finding a specific one is not always easy, so you can type a few letters of the test method or its parameters in the Search box and the content of the tree will automatically narrow down to methods matching your search. Note in the screen shot above that the search also works on parameters provided by @DataProvider.
The Summary tab gives you statistics on your test run, such as the timings, the test names, the number of methods and classes, etc… Since the results are shown in a table, you can also sort on any criterion you like for easier parsing. This is especially handy when you are trying to determine what tests take the longest time.
The search box works in this view as well, and note that in the screen shot below, the Time column is sorted in decreasing order:
Your first option is to use the Quick Fix function:
Convert from JUnit 3
Convert from JUnit 4
The refactoring wizard contains several pages:
This page lets you generate a testng.xml automatically. You can configure whether to include your test classes individually or by package, the suite and test name and also whether these tests should run in parallel.
This page gives you an overview of the changes that are about to be performed. You can also decide to exclude certain files from the refactoring.
When you are done, press the "Finish" button. Like all Eclipse refactorings, you can undo all these changes in one click:
The preferences here are shared among projects and launch configurations.
Here are properties on each project level, it will override the same properties if defined in TestNG workbench preferences
or on the project properties page. You can override workspace settings with project specific ones:
Let's say there is maven-surefire-plugin confguration in your pom.xml:
<artifactId>maven-surefire-plugin</artifactId> <configuration> <suiteXmlFiles> <suiteXmlFile>test-suite/testng.xml</suiteXmlFile> </suiteXmlFiles> <argLine>-javaagent:${settings.localRepository}/org/aspectj/aspectjweaver/${aspectj.version}/aspectjweaver-${aspectj.version}.jar -Xmx1024m -XX:MaxPermSize=512m -Xms256m -Xmx1024m -XX:PermSize=128m -Dversion=${project.version} </argLine> <systemPropertyVariables> <foo>${foo.value}</foo> </systemPropertyVariables> <environmentVariables> <bar>${bar.value}</bar> </environmentVariables> </configuration>You can pass the following Maven configuration parameters to the TestNG process:
NOTE: as the snippet of the configuration above shows, properties placeholders (e.g. ${aspectj.version}
) in argLine
or systemPropertyVariables
will be substituted and correctly passed to the TestNG process as long as the properties are visible on the Maven project (e.g. defined in the current pom.xml
, or inherited from the parent pom.xml
, etc.).
NOTE: if your maven-surefire-plugin is defined in a Maven profile, you will need to select the Maven profile which contains the maven-surefire-plugin configuration: "Right click on the project -> Maven -> Select Maven Profiles...", then check the profile you need.


Class WsModel
WsModel Is model part of Model-View-Controller. WsModel is the base class providing the common features needed by data model objects.
Example usage:
class TestModel extends WsModel { public function __construct() { // autodetect columns, column types, etc parent::__construct(); // change some column types // change column type for column $this->columnType['enter_date'] = 'date_type'; // change column type for other column $this->columnType['is_checked'] = 'bool_type'; // leave other column types unchanged (autodetected) } } // use model $m = new TestModel(); // get one record with ID 100 from database $m->getOne(100); // show field value for retrived record echo $m->name.'\n'; // change value of one column in record with ID 100 $m->name = 'New Name'; // save changes $m->save(); // delete record with ID 100 from database $m->id = 100; $m->delete(); // same as above $m->delete(100);
- WsDatabase
- WsModel
Direct known subclasses
Ws_logged_inModel, Ws_permissionsModel, Ws_role_permModel, Ws_rolesModel, Ws_user_roleModel, Ws_userModel
public
|
|
public
|
#
setTableName( string $name )
Sets name of database table on which model references. Also updates all propertyes that hold informations about table columns: $column $columnCanBeNull $columnHeaders $foreignKeys $primaryKey |
public
boolean
|
|
public
boolean
|
|
public
boolean
|
|
public
boolean
|
|
public
boolean
|
|
public
array
|
|
public
array
|
|
public
array
|
|
public
integer
|
__destruct(),
close(),
execute(),
execute_batch(),
query()
|
public
string
|
$className
$className Name of model |
#
''
|
public
string
|
$tableName
$tableName Name of database table |
#
''
|
public
string
|
$metaName
$metaName Long name (description) of database table |
#
''
|
public
array
|
$columns
List of table columns. This list is automaticaly populated during the class initialization. |
#
array()
|
public
string
|
$primary_key
$primary_key Column that is primary key |
#
'id'
|
public
array
|
$columnCanBeNull
$columnCanBeNull List of columns that can store NULL values |
#
array()
|
public
array
|
$columnType
$columnType List of column types |
#
array()
|
public
array
|
$columnHeaders
$columnHeaders List of column headers |
#
array()
|
public
array
|
$foreignKeys
List of arrays wich represents relations between two WsModel classes. This list is automaticaly populated during the class initialization with regresion that display properti is referencing to foreign column name. |
#
array()
|
$isConnected,
$nRows
|


| Methods' Summary |
| callFunction |
calls a function and returns the result of the call.
|
| Methods' Details |
callFunction
- Description
- calls a function and returns the result of the call.
- Parameter aName
- the (programmatic) name of the function.
- Parameter aArguments
- the arguments for the function call.
Each element must be of one of the following types:
long or double
- for a numeric value.
string
- for a textual value.
long[][] or double[][]
- for an array of numeric values.
string[][]
- for an array of textual values.
any[][]
- for a mixed array, where each element must be of void,
long , double or string
type.
- ::com::sun::star::table::XCellRange
- for a SheetCellRange object that contains the
data.
- Returns
- the result of the function call.
Possible types for the result are:
- void
- if no result is available.
double
- for a numeric result.
string
- for a textual result.
any[][]
- for an array result, containing
double and
string values.
- Throws
- ::com::sun::star::container::NoSuchElementException
if the named function does not exist.
- Throws
- ::com::sun::star::lang::IllegalArgumentException
if the function can not be called with these arguments.
|
|
Top of Page
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


WELCOME TO THE PROJECT MANAGEMENT
IT IS A SAMPLE DEMONSTRATION.
click
This content is still to be developed and in process @candy.


Rubato
Home
Intervals
Note from chord
Rhythmic Recall
Rhythm game, repeat the rhythm you hear using the space bar!


Document Format Files
Data Files
IRS No.: 942838567 | State of Incorp.: DE | Fiscal Year End: 0331Type: 10-K | Act: 34 | File No.: 000-17948 | Film No.: 14861211SIC: 7372 Services-Prepackaged SoftwareOffice of Technology


Lyza Danger Gardner | @lyzadanger
Before we get to that, let's look at how it flows without JavaScript...


Mobo is a chatbox.It is a chat pet.It is also an application that can see emotions.
News: Mobo is on a super awesome spaceship to earth.
Leave us your email. We'll get back to you ASAP!


Main Text
Background
Item 6, Introduction, Rationale: Describe the rationale for the review in the context of what is already known
This section should be written in a way that is accessible to readers without specialist knowledge in that area and must clearly state – and, if helpful, illustrate – the background to the review and its aims. You should indicate why this study is necessary and what it aims to contribute to the field. If possible, a theory of change and/or conceptual model should be presented that links the key elements of the question (e.g. explaining how an intervention or exposure is linked to the outcome). The role of commissioners and other stakeholders in the formulation of the question should be described and explained. Any proposed role of stakeholders throughout the review process should also be described. It should logically lead the reader to the primary question stated in the next section.
Objective of the Systematic Review
Item 7, Introduction, objectives: Provide an explicit statement of the question(s) the review will address with reference to participants, interventions, comparators, and outcomes (PICO)
You should describe the primary question and any secondary questions when applicable. The primary question is the main question of the Systematic Review and should be the same or very similar to the Protocol title. The rationale for any secondary questions (usually linked to possible subgroup and/or heterogeneity analyses) should be explained.
Methods
Searches
Item 9, Methods, Information sources: Describe all intended information sources (e.g., electronic databases, contact with study authors, trial registers, or other grey literature sources) with planned dates of coverage
Item 10, Methods, Search Strategy: Present draft of search strategy to be used for at least one electronic database, including planned limits, such that it could be repeated
Here the proposed searches are described in sufficient detail so as to be repeatable. Details of how the search strategy was developed through scoping should be provided (possibly in an additional file). The following list is a guide to the detail required on what will be searched and how the search will be conducted.
- search terms and languages
- search strings / combinations of searches (search strings refer to combinations of terms using Boolean characters, combinations are methods used to set-up and pool different searches run separately)
- Estimating the comprehensiveness of the search
- Bibliographic databases and services to be searched (e.g. ISI Web of Science, Scopus, CAB Abstracts)
- Internet searches to be conducted (e.g. Google Scholar)
- Specialist searches – Searches for grey literature: contacts, searches of organisational websites, use of specific search terms or strings, filtering or limitations.
- Supplementary searches such as Bibliographical searches and literature provided directly by stakeholders
- Any software that will be used to conduct and record your search should be described.
Eligibility criteria and screening process
Here provide explanation about the rationale you propose to include/exclude articles based on the following aspects, so that this stage is transparent and replicable by any external reader.
Screening
State here the article screening process in terms of
- Title, abstract and full text screening methodology and how you will record and report the process from number of articles considered to number of studies included. Please note here the distinction between articles and studies (articles can report on more than one study and studies can be reported in more than one article).
- Test(s) for consistency of decisions regarding eligibility, at title, abstract, full-text level.
Inclusion
Item 8, Methods, Eligibility Criteria: Specify the study characteristics (e.g., PICO, study design, setting, time frame) and report characteristics (e.g., years considered, language, publication status) to be used as criteria for eligibility for the review
State here the criteria you will use to decide whether articles and the studies they report are eligible for inclusion in the review. Normally you should use the following subheadings;
- Eligible population(s)
- Eligible intervention(s) or exposure(s)
- Eligible comparator(s) (if appropriate)
- Eligible outcomes
- Eligible study designs
If a worksheet or checklist is to be used for the eligibility screening process this should be provided in an appendix.
Please state clearly what you will provide in your report to conform with CEE Standards (e.g. a list of studies excluded at the full text screening step with reasons for exclusion).
Describe how the Review Team members who have also authored articles to be considered within the review will be prevented from influencing decisions regarding inclusion or critical appraisal of their own work.
Study Critical Appraisal
Describe here the approach you propose to use to critically appraise and assess internal and external validity of included studies. Consideration should be given to ensuring that important aspects of validity which would influence the reliability of the evidence are taken into account, such as internal validity (freedom from bias or confounding) and external validity (generalisability of a study’s results to the current Systematic Review question). If a worksheet or checklist is used for the assessing study validity this should be provided in a table or an appendix. Describe how the information from critical appraisal will be used in any synthesis. Describe how repeatability of individual reviewer critical appraisal of study validity will be tested.
Item 14, Risk of bias in individual studies: Describe anticipated methods for assessing risk of bias of individual studies, including whether this will be done at the outcome or study level, or both; state how this information will be used in data synthesis
Data Extraction Strategy
Describe here how you will collect and record outcome data and associated meta-data from included studies. How will the repeatability of coding, meta-data and data extraction be tested? Please state that your extracted data records will be made available as additional files. Describe any processes for obtaining and confirming missing or unclear information or data from authors.
Item 11a, Study records, Data management: Describe the mechanism(s) that will be used to manage records and data throughout the review
[@Lajeunesse:2015gf] Software / R package METAGEAR for running the analyses in R
Item 11b, Study records, selection process: State the process that will be used for selecting studies (e.g., two independent reviewers) through each phase of the review (i.e., screening, eligibility, and inclusion in meta-analysis)
Item 11c, Study records, data collection process: Describe planned method of extracting data from reports (e.g., piloting forms, done independently, in duplicate), any processes for obtaining and confirming data from investigators.
Item 12, Data items: List and define all varibales for which data will be sought (e.g. PICO items, funding sources), any pre-planned data assumptions and simplifications
Item 13, Outcomes and prioritisation: List and define all outcomes for which data will be sought, including prioritization of main and additional outcomes, with rationale
Potential effect modifiers and reasons for heterogeneity
Provide a list of those effect modifiers to be considered and coded in the review and details of how the list was compiled (including consultation of external experts). The list should not be exhaustive but should state those variables thought to be most important and amenable to analysis.
Data Synthesis and presentation
Describe here the methods you propose to synthesise the collected data and any subsequent manipulation of the data set, such as sub-group or sensitivity analyses. Narrative synthesis should always be attempted and included studies described and tabulated as a minimum. The potential for meta-analysis (or any alternative form of synthesis such as qualitative or mixed methods) should have been assessed and the preferred synthesis methodology should be stated in sufficient detail for reviewers to comment. Appropriate subgroup analyses, sensitivity analyses and tests for publication bias should be planned where possible.
Item 15a, Synthesis: Describe criteria under which study data will be quantitatively synthesized
Item 15b, Synthesis: If data are appropriate for quantitative synthesis, describe planned summary measures, methods of handling data, and methods of combining data from studies, including any planned exploration of consistency (e.g., I2, Kendall’s tau)
Item 15c: Describe any proposed additional analyses (e.g., sensitivity or subgroup analyses, meta-regression)
Item 15d: If quantitative synthesis is not appropriate, describe the type of summary planned
Item 16, Meta-bias(es): Specify any planned assessment of meta-bias(es) (e.g., publication bias across studies, selective reporting within studies).
Item 17, Confidence in cumulative evidence: Describe how the strength of the body of evidence will be assessed (e.g., GRADE)
Declarations
Availability of data and materials
Following the guidelines here: https://group.springernature.com/gp/authors/research-data-policy/data-availability-statements/12330880. Below is an example:
statement type / description
Data available in a public (institutional, general or subject specific) repository that issues datasets with DOIs (non-mandated deposition)
Template / example text The [data type] data that support the findings of this study are available in [repository name e.g “figshare”] with the identifier(s) [data DOI(s) e.g. “http://doi.org/10.6084/m9.figshare.1499292_D8”][Reference number]
My statement The data that support the findings of this study are available in https://github.com/egouldo/ReproEcoDecisions with the identifiers INSERT DOI HERE. (Note, I aim to wrap a figshare DOI around the GitHub repo).
Potential Conflicts of Interest and Sources of Support
The independence of CEE Systematic Reviews is a high priority. Consequently, the potential competing interests of the Review Team should be transparent. A competing interest exists when your interpretation of data or presentation of information may be influenced by your personal or financial relationship with other people or organizations. Authors must disclose any financial competing interests; they should also reveal any non-financial competing interests that may cause them embarrassment were they to become public after the publication of the manuscript. Authors are required to complete a declaration of competing interests. All competing interests that are declared will be listed at the end of published articles. Where an author gives no competing interests, the listing will read
‘The author(s) declare that they have no competing interests’. When completing your declaration, please consider the following questions:
Financial competing interests
In the past five years have you received reimbursements, fees, funding, or salary from an organization that may in any way gain or lose financially from the publication of this manuscript, either now or in the future? Is such an organization financing this manuscript (including the article-processing charge)? If so, please specify. Do you hold any stocks or shares in an organization that may in any way gain or lose financially from the publication of this manuscript, either now or in the future? If so, please specify. Do you hold or are you currently applying for any patents relating to the content of the manuscript? Have you received reimbursements, fees, funding, or salary from an organization that holds or has applied for patents relating to the content of the manuscript? If so, please specify.
Do you have any other financial competing interests? If so, please specify.
Non-financial competing interests
Are there any non-financial competing interests (political, personal, religious, ideological, academic, intellectual, commercial or any other) to declare in relation to this manuscript? If so, please specify
Funding
Item 5a, Support, Sources: Indicate sources of financial or other support for the review
Item 5b, Support, Sponsor: Provide name for the review funder and/or sponsor
Item 5c, Support, Role of sponsor / funder: Describe roles of funder(s), sponsor(s), and/or institution(s), if any, in developing the protocol
All sources of funding for the research reported should be declared. The role of the funding body in the design of the study and collection, analysis, and interpretation of data and in writing the manuscript should be declared.
Acknowledgements
Please acknowledge anyone who contributed towards the article who does not meet the criteria for authorship, including anyone who provided professional writing services or materials.
Authors should obtain permission to acknowledge from all those mentioned in the Acknowledgements section. See our journal editorial policies for a full explanation of acknowledgements and authorship criteria. If you do not have anyone to acknowledge, please write “Not applicable” in this section.
Ethics approval and consent to participate
Manuscripts reporting studies involving human participants, human data or human tissue must:
include a statement on ethics approval and consent (even where the need for approval was waived) include the name of the ethics committee that approved the study and the committee’s reference number if appropriate Studies involving animals must include a statement on ethics approval.
See our editorial policies for more information.
If your manuscript does not report on or involve the use of any animal or human data or tissue, please state “Not applicable” in this section.
NOTE: this may be relevent.. probably under the ‘human data’ point…
Consent for publication
If your manuscript contains any individual person’s data in any form (including individual details, images or videos), consent for publication must be obtained from that person, or in the case of children, their parent or legal guardian. All presentations of case reports must have consent for publication.
You can use your institutional consent form or our consent form if you prefer. You should not send the form to us on submission, but we may request to see a copy at any stage (including after publication).
See our editorial policies for more information on consent for publication.
If your manuscript does not contain any data from any individual person, please state “Not applicable” in this section.
References
All references cited in the above sections should be listed here and formatted according to journal instructions.
Figures, Tables and Additional Files
See the Journal’s general formatting guidelines for information on how to format figures, tables and additional files.


Great Educational Books
Category
Coming Soon
New Arrivals
Special Orders
LogIn
Cart
First Name:
Middle Name:
Last Name:
Book Title:
Author Name:
Contact details:
Email:
Submit
About Us
Languages
Carriers


Namespaces | |
| namespace | DataConnection |
| namespace | Scrambles |
Classes | |
| class | Controller |
| Main Controller class, arbitrates communication between Views and Models More... | |
| class | GlobalConfig |
| Class linking connections to respective databases | |
| interface | IViewInterface |
| Easy interface between Controller and View (Form). More... | |
| class | Move |
| Represents one turn of a rubik's cube. More... | |
| class | Solve |
| class | Sound |
| Controls sound files and plays/mutes them More... | |
| class | Statistics |
| Statistics class for a given cube. Calculates certain statistics. Updates labels and statistics ListBox. More... | |
| class | TimerClass |
| Singleton Timer Class using System.Diagnostics.Stopwatch(). Singleton because of high performance cost. Access through .Instance More... | |
Enumerations | |
| enum | MoveType { MoveType.L, MoveType.R, MoveType.U, MoveType.D, MoveType.F } |
| Possible moveTypes, don't include back moves as they're not used in scrambles More... | |
| enum | CubeType { CubeType.TWO, CubeType.THREE, CubeType.FOUR } |
| CubeTypes as enums to allow further additions of non-standard cubes (like pyraminx) More... | |
|
strong |
|
strong |


FORM
This is to be used in the BODY Tag.
This Tag sets up a Container for a Form.
This Tag includes many Tags such as
BUTTON ,
INPUT ,
SELECT ,
TEXTAREA , etc.
This is a Container Tag and thus needs to be closed.
Attributes
- ACCEPT-CHARSET :
Specifies the Character encoding for the Input
Data that the Form Processor may Accept.
- ACCEPT :
Specifies a list of MIME Types separated by Commas
that the Form Processor will Handle carefully.
- ACTION :
Specifies the Absolute or Relative Loaction
of the Form Processing Application.
- ENCTYPE :
Specifies the MIME Type used to Submit (POST)
the Form to the Server. Default is
application/x-www-form-urlencoded. Use
multipart/form-data when the returned Document contains Files.
- METHOD :
Specifies how the Form Data is to be Transmitted
to the Form Processor.
- GET :
The Form Data is given to the Form Processor in the form of an
Environment Variable.
- POST :
The Form Data is given to the Form Processor in the form of a
Standard Input to a Program.
- NAME :
Gives a Name to the value you pass to the Form
Processor.
- TARGET :
Identifies in which previously Named Frame the
Output from the Form Processor should Appear .
Syntax
<FORM [ACCEPT-CHARSET="ACCEPT-CHARSET"] [ACCEPT="ACCEPT"]
[ACTION="URL"] [ENCTYPE="ENCTYPE"] [METHOD="{GET,POST}"] [NAME="NAME"]
[TARGET="TARGET"]>
...Form Elements...
</FORM>
Example
<FORM NAME="FEG1" >
Name :
<INPUT TYPE="TEXT" SIZE="25">
Address :
<TEXTAREA NAME="FEGTAR" COLS="20" ROWS="5">
</TEXTAREA>
<BUTTON TYPE="SUBMIT" NAME="BUTTON1" VALUE=
"SUBMIT">
Submit
</BUTTON>
<BUTTON TYPE="RESET" NAME="BUTTON1" VALUE=
"RESET">
Reset
</BUTTON>
</FORM>
Effect
Home
About


{% load staticfiles %}
Enter seconds for alert timeout,
or enter 0 to disable timeout.
Enter seconds for alert color,
or enter 0 to disable alert color.