Conference & arXiv
Jianqiao Zheng, Sameera Ramasinghe, Xueqian Li, Simon Lucey.
Trading Positional Complexity vs. Deepness in Coordinate Networks. ECCV 2022
Chaoyang Wang, Xueqian Li, Jhony Kaesemodel Pointes, Simon Lucey.
Neural Prior for Trajectory Estimation. CVPR 2022
Xueqian Li, Jhony Kaesemodel Pointes, Simon Lucey.
Neural Scene Flow Prior. NeurIPS 2021 (spotlight)
Xueqian Li, Jhony Kaesemodel Pointes, Simon Lucey.
PointNetLK Revisited. CVPR 2021 (oral)
Vinit Sarode*, Xueqian Li*, Hunter Goforth, Yasuhiro Aoki, Animesh Dhagat, Arun R. Srivatsan, Simon Lucey, Howie Choset.
One Framework to Register Them All: PointNet Encoding for Point Cloud Alignment. arXiv preprint arXiv:1912.05766.
(* equal contribution)
Vinit Sarode*, Xueqian Li*, Hunter Goforth, Yasuhiro Aoki, Arun R. Srivatsan, Simon Lucey, Howie Choset.
PCRNet: Point Cloud Registration Network using PointNet Encoding. arXiv preprint arXiv:1908.07906.
(* equal contribution)
Peng Yin, Lingyun Xu, Xueqian Li, Yin Chen, Yingli Li, R. Arun Srivatsan, Lu Li, Jianmin Ji, and Yuqing He.
A Multi-Domain Feature Learning Method for Visual Place Recognition. ICRA 2019
Peng Yin, R. Arun Srivatsan, Yin Chen, Xueqian Li, Hongda Zhang, Lingyun Xu, Lu Li, Zhenzhong Jia, Jiamin Ji and Yuqing He.
MRS-VPR: a multi-resolution sampling based global visual place recognition method. ICRA 2019


Keynotes
And Characteristics With Comparisons
of some of the Leading Remedies
of the Materia Medica
By
H. C. Allen, M. D.
Author of The Therapeutics of Fevers, Boenninghausen's Repertory Slips
and
Materia Medica of the Nosodes. Fourth Edition Philadephia
Boericke and Tafel - 1916
Preface : Fourth Edition
|
|
What applied to the third edition applies to this,
the fourth. The facet that a fourth is demanded is convincing proof
that Dr. Allen left an indestructible monument of homeopathic materia
medica, on that is true to Homeopathy and immensely helpful to every
physician who consults it.
The Publishers.
Preface : Third Edition
The first edition of this book was only about half the size of the second, as it was prepared somewhat hastily for a special purpose, but Dr. Allen took his time to the second edition and gave the world a well rounded out and complete standard book on homeopathic materia medica. We do no mean that the first edition was faulty as to its matter, for is was used unchanged in the later edition, but it did not embrace a sufficient number of remedies. As Dr. Allen died before a third edition was needed we concluded to bring it out unchanged. It is a masterpiece of materia medica work: its symptomatology is made up of the unchanging landmarks of our remedies that are in constant use; it is, in short, a book that needs no revision.
The Publishers.
Philadephia, Pa.
Preface : Second Edition
In preparing the second edition for the press the work has been enlarged and practically rewritten. Many more remedies have been included and symptoms and comparisons extended, yet care has been taken that every symptom has been verified. The original plan has been maintained, viz., to give only those symptom-guides that mark the individuality of the remedy. that the student of materia medica may use them as landmarks to master the genius of the remedial agent.
At the suggestion of the publisher and in response to numerous enquiries a more extended symptomatology of the nosodes has been included, for these invaluable additions to our armamentarium, like the so-called tissue remedies of Schuessler, only need more extensive provings to place them in the list of polychrests.
That the student may acquire that correct pronunciation of our remedial agents an alphabetical list of remedies with the accentuation is given, for a homeopathic physician may properly be held accountable for the correct use of the terms peculiar to his profession. An index of remedies and comparisons is also included.
Preface : First Edition
The life-work of the student of homoeopathic Materia Medica is one of constant comparison an differentiation. He must compare the pathogenesis of a remedy with the recorded anamnesis of the patient; he must differentiate the apparently similar symptoms of two or more medical agents in order to select the simillinum. To enable the student or practitioner to do this correctly and rapidly he must have as a basis for comparison, some knowledge of the individuality of the remedy; something that is peculiar, uncommon, or sufficiently characteristic in the confirmed pathogenesis of a polychrest remedy that may be used as a pivotal point of comparison. It may be a so-called "keynote," a "characteristic," the "red strand of the rope," and central modality or principle as the aggravation of Bryonia, the amelioration from motion of Rhus, the furious, vicious delirium of Belladonna or the apathetic indifference of Phosphoric acid - some familiar landmark around which the symptoms may be arranged in the mind for comparison.
Something of this kind seems indispensable to enable us to intelligently and successfully use our voluminous symptomatology. Also, if we may judge from the small number of homeopathic physicians who rely on the single remedy in practice, and the almost constant demand for a "revision" of the Materia Medica, its study in the past, as well as at present, has not been altogether satisfactory to the majority.
An attempt to render the student's task less difficult, to simplify its study, to make it both interesting and useful, to place its mastery within the reach of every intelligent man or woman in the profession, is the apology for the addition of another monograph to our present works of reference.
It is all-important that the first step in the study of homeopathic therapeutics be correctly taken, for the pathway is then more direct and the view more comprehensive. The object of this work is to aid the student to master that which is guiding and characteristic in the individuality of each remedy and thus utilize more readily the symptomatology of the Homoeopathic Materia Medica, the most comprehensive and practical work for the cure of the sick ever given the medical profession. It is the result of years of study as student, practitioner and teacher, and is published at the earnest solicitation of many alumni of Hering College, with the hope that it may be of as much benefit to the beginner as it has been to the compiler.
Copyright © MEDI-T 1998


The only file you need to download manually is config.tgz. Unpack, configure by editing config/targets, and install by running config/install.sh. The installer automatically downloads any additional files it might need. For more information, see INSTALL.
You can either use the "generic Unix" procedure above or you can install a pre-built system using the installer package smlnj-x86-110.83.pkg. For more information, see below.
Download smlnj-110.83.msi and follow the instructions in WININSTALL.
For information on how to use access the subversion repository,
refer to our subversion recipe page.
Warning: When pulling the latest sources via subversion,
there is no guarantee that config/install.sh will operate
successfully due to a lack of usable bootfiles.
In this case you might be able to
generate new bootfiles using the bootstrap compiler (of an older
version). However, even that can be very difficult or even impossible,
in which case you will have to wait for the next working version to
be released.
The macOS installer (on Intel) puts SML/NJ in the directory /usr/local/smlnj; if you have a previous version installed, then it will be updated in place. If you wish to install at a different location, you should use the build procedure for Unix systems.
This installer should support Mac OS X 10.6 (Snow Leopard) or later on Intel hardware.
We no longer have access to a working PowerPC Mac, so we are no longer providing a Mac OS X/PowerPC installer. If you wish to install SML/NJ 110.83 on such a machine, you should use the build procedure for Unix systems.


|
STM8S Standard Peripheral Libary
2.2.0
|
Data Structures | |
| struct | struct_v1 |
| struct | struct_v2 |
| struct | SD_CSD |
| Card Specific Data: CSD Register. More... | |
| struct | SD_CID |
| Card Identification Data: CID Register. More... | |
| struct | SD_CardInfo |
| SD Card information. More... | |
Enumerations | |
| enum | SD_Error { SD_RESPONSE_NO_ERROR = (0x00), SD_IN_IDLE_STATE = (0x01), SD_ERASE_RESET = (0x02), SD_ILLEGAL_COMMAND = (0x04), SD_COM_CRC_ERROR = (0x08), SD_ERASE_SEQUENCE_ERROR = (0x10), SD_ADDRESS_ERROR = (0x20), SD_PARAMETER_ERROR = (0x40), SD_RESPONSE_FAILURE = (0xFF), SD_DATA_OK = (0x05), SD_DATA_CRC_ERROR = (0x0B), SD_DATA_WRITE_ERROR = (0x0D), SD_DATA_OTHER_ERROR = (0xFF) } |
| enum SD_Error |
| Enumerator | |
|---|---|
| SD_RESPONSE_NO_ERROR | SD reponses and error flags. |
| SD_DATA_OK | Data response error. |
Definition at line 49 of file stm8s_eval_spi_sd.h.


Select observation type to manage
{{type.ObservationTypeName}}
×
Edit Field
Field Name
Description
×
Create a new field
Field Name
Field Type
{{type.TypeName}}
Description
×
Manage Observation Type Field Default Values
S/N
Default Value
Action
{{$index + 1}}
{{value.Value}}
remove
*
save
×
Manage Observation Type Field Dirty Values
S/N
Condition
Default Value
Action
{{$index + 1}}
Must contain
=
Must be greater than
>
Must be less than
<
{{value.Value}}
remove
Must contain
Must be greater than
Must be less than
save


State.Rd
A class for creating a State block.
stepfunctions::Block
-> State
Inherited methods
new()
Initialize State base class
State$new( state_id, state_type, output_schema = NULL, comment = NULL, input_path = NULL, parameters = NULL, result_path = NULL, output_path = NULL, ... )
state_id
(str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
state_type
(str): Type of the state. (Allowed values: `'Pass'`, `'Succeed'`, `'Fail'`, `'Wait'`, `'Task'`, `'Choice'`, `'Parallel'`, `'Map'`).
output_schema
(list): Expected output schema for the State. This is used to validate placeholder inputs used by the next state in the state machine. (default: None)
comment
(str, optional): Human-readable comment or description. (default: None)
input_path
(str, optional): Path applied to the state’s raw input to select some or all of it; that selection is used by the state. (default: '$')
parameters
(list, optional): The value of this field becomes the effective input for the state.
result_path
(str, optional): Path specifying the raw input’s combination with or replacement by the state’s result. (default: '$')
output_path
(str, optional): Path applied to the state’s output after the application of `result_path`, producing the effective output which serves as the raw input for the next state. (default: '$')
...
: Extra field names to pass to Block class
allowed_fields()
allowed extra fields
State$allowed_fields()
update_parameters()
Update `parameters` field in the state, if supported.
State$update_parameters(params)
params
(list): The value of this field becomes the effective input for the state.
.next()
Specify the next state or chain to transition to.
State$.next(next_step)
next_step
(State or Chain): Next state or chain to transition to.
State or Chain: Next state or chain that will be transitioned to.
output()
Get the placeholder collection for the State's output.
State$output()
StepInput: Placeholder collection representing the State's output, and consequently the input to the next state in the workflow (if one exists).
accept()
placeholder
State$accept(visitor)
visitor
placeholder
add_retry()
Add a Retry block to the tail end of the list of retriers for the state.
State$add_retry(retry)
retry
(Retry): Retry block to add.
add_catch()
Add a Catch block to the tail end of the list of catchers for the state.
State$add_catch(catch)
catch
(Catch): Catch block to add.
to_list()
Convert class to list ready to be translated for Amazon States Language https://states-language.net/spec.html.
State$to_list()
format()
class formatting
State$format()
clone()
The objects of this class are cloneable with this method.
State$clone(deep = FALSE)
deep
Whether to make a deep clone.


NuGetTools - GitLogger
Start Commit SHA:
Code Repository Name:
Code Branch Name:
Issue Repository Name:
Output Format:
HTML
CSV


|
muSE
r716
|
A monad view (id = 'mnad') provides higher order functional operations over collections. More...
#include <muse.h>
Data Fields | |
| muse_cell(* | size )(muse_env *env, void *self) |
| Should return the number of elements in the data structure. | |
| muse_cell(* | map )(muse_env *env, void *self, muse_cell fn) |
| Iterates the given function over all the "elements" of this object and constructs a new object of the same type with the results. | |
| muse_cell(* | join )(muse_env *env, void *self, muse_cell obj, muse_cell reduction_fn) |
| Joins two objects (must be of the same type) using the given reduction_fn to resolve conflicts. More... | |
| muse_cell(* | collect )(muse_env *env, void *self, muse_cell predicate, muse_cell mapper, muse_cell reduction_fn) |
Iterates over the elements of this object, applying the predicate . More... | |
| muse_cell(* | reduce )(muse_env *env, void *self, muse_cell reduction_fn, muse_cell initial) |
| Applies the given reduction function, which is expected to be commutative and associative for simplicity, and folds the results into successive reduction calls, returning the final outcome as the result. | |
| muse_cell(* | slice )(muse_env *env, void *self, muse_cell argv) |
| Constructs a new object of the same type containing a selection of objects from it. More... | |
A monad view (id = 'mnad') provides higher order functional operations over collections.
| muse_cell(* muse_monad_view_t::join) (muse_env *env, void *self, muse_cell obj, muse_cell reduction_fn) |
Joins two objects (must be of the same type) using the given reduction_fn to resolve conflicts.
Two vectors are joined by concatenation. Two lists are are joined by concatenation. Two hashtables are joined by merging their key-value pairs into a single table (you can do set union using this).
Referenced by fn_join().
| muse_cell(* muse_monad_view_t::collect) (muse_env *env, void *self, muse_cell predicate, muse_cell mapper, muse_cell reduction_fn) |
Iterates over the elements of this object, applying the predicate
.
All the elements satisfying the predicate are collected into a new object of the same type. If the mapper
parameter is not MUSE_NIL, it is expected to be a function that will be used to transform the element before collecting it into the new object. If the mapper
is MUSE_NIL, it is equivalent to an identity function.
Referenced by fn_collect().
Constructs a new object of the same type containing a selection of objects from it.
The selection may be specified in different ways for different object types through the variable arguments list argv
.
Referenced by fn_slice().


Student Research
Student research is an important part of chemistry graduate student life at SIUE. BS Chemistry and Biochemistry majors take at least three credit-hours of Undergraduate Research or Senior Honors Research during their junior or senior years. Research projects may last from 6 months to 2 years, and focus on research in a particular faculty member’s lab.
Many of our faculty are funded by external research grants. Graduates can post the results of their research here on this site along with their faculty supervisors during their research.
Links to recent student research
- Research in Biochemistry
- Research in Environmental Chemistry
- Research in Inorganic Chemistry
- Research in Material Chemistry
- Research in Organic Chemistry
- Research in Analytical Chemistry
- Research in Astrochemistry Chemistry
- Research in Chemical Engineering
- Research in Electrochemistry
- Research in Kinetic Chemistry
- Research in Thermochemistry


Methods
(static) locate()
Finds a constant node
- Source:
setName()
Changing the constant name
- Source:
setPrivate()
Makes the constant private
- Source:
setPublic()
Makes the constant public
- Source:
setValue()
Changing default value
- Source:


Marshall's Stanmore II Bluetooth speaker hits an all-time low at $200 ($150 off MSRP)
by Hagop KavafianMarshall speakers are extremely popular, mainly thanks to their retro looks and impressive audio quality. Unfortunately, they're also known for their particularly high price, which can be a roadblock for some, especially considering there are cheaper options on the market. Thankfully, the Stanmore II Bluetooth speaker just dropped to $200, which is $150 off the MSRP, making it a much more relevant contender.
In reality, the speaker has been selling for around $280 these past few months, but the new markdown makes it another $80 cheaper. In terms of specs, the Stanmore II features Bluetooth 5. 0 with aptX, letting you stream content without any lag, which is particularly useful when watching movies. As this is a Marshall product, there are many ways to customize how it sounds, thanks to the controls on top of the speaker and the app. Lastly, there are RCA and 3.5mm inputs to play music from wired sources, making this a relatively versatile product. Unfortunately, this is the standard Bluetooth version and not the more modern one that comes with Assistant.
Only the black model is discounted on Amazon, with other ones still at their original $350 price.
Buy:
Amazon


Index of /usr/local/pub/GraduateProjects/current Name Last modified Size Description Parent Directory - Apache/2.4.7 (Ubuntu) Server at cs.rit.edu Port 443


Genesis 50:15
And when Joseph's brethren saw that their father was dead, they said, Joseph will peradventure hate us, and will certainly requite us all the evil which we did unto him.


--- layout: post title: Use ASCII code in CSS content on pseudo elements date: 2014-02-04 07:30:17.000000000 +00:00 type: post published: true status: publish categories: [] tags: [] meta: _syntaxhighlighter_encoded: '1' _edit_last: '1' tmac_last_id: '618797320738619392' author: David Simpson excerpt_separator: ---
I've been experiencing some oddities with character encoding when deploying code on a client system. I was in a bit of a rush and didn't have time to dig deeper.
Adding the "»" character to my CSS worked so worked nicely on my dev and test system:
#breadcrumbs li:before {
content: "»";
}
But on deployment, I get the dreaded "??" output. Yuck. This is likely to be something to do with the build server or the client machine.
As a really quick workaround, replace the unicode with ASCII instead:
#breadcrumbs li:before {
content: "\00BB";
}
This just works no matter what. In future, it'll be ASCII all the way for me.


public final class Security extends Object
This class centralizes all security properties and common security methods. One of its primary uses is to manage providers.
The default values of security properties are read from an
implementation-specific location, which is typically the properties file
lib/security/java.security
in the Java installation directory.
| Modifier and Type | Method and Description |
|---|---|
static int |
addProvider(Provider provider)
Adds a provider to the next position available.
|
static String |
getAlgorithmProperty(String algName,
String propName)
Deprecated.
This method used to return the value of a proprietary
property in the master file of the "SUN" Cryptographic Service
Provider in order to determine how to parse algorithm-specific
parameters. Use the new provider-based and algorithm-independent
AlgorithmParameters and KeyFactory engine
classes (introduced in the J2SE version 1.2 platform) instead. |
static Set<String> |
getAlgorithms(String serviceName)
Returns a Set of Strings containing the names of all available
algorithms or types for the specified Java cryptographic service
(e.g., Signature, MessageDigest, Cipher, Mac, KeyStore).
|
static String |
getProperty(String key)
Gets a security property value.
|
static Provider |
getProvider(String name)
Returns the provider installed with the specified name, if
any.
|
static Provider[] |
getProviders()
Returns an array containing all the installed providers.
|
static Provider[] |
getProviders(Map<String,String> filter)
Returns an array containing all installed providers that satisfy the
specified* selection criteria, or null if no such providers have been
installed.
|
static Provider[] |
getProviders(String filter)
Returns an array containing all installed providers that satisfy the
specified selection criterion, or null if no such providers have been
installed.
|
static int |
insertProviderAt(Provider provider,
int position)
Adds a new provider, at a specified position.
|
static void |
removeProvider(String name)
Removes the provider with the specified name.
|
static void |
setProperty(String key,
String datum)
Sets a security property value.
|
@Deprecated public static String getAlgorithmProperty(String algName, String propName)
AlgorithmParameters
and KeyFactory
engine
classes (introduced in the J2SE version 1.2 platform) instead.algName
- the algorithm name.propName
- the name of the property to get.public static int insertProviderAt(Provider provider, int position)
If the given provider is installed at the requested position,
the provider that used to be at that position, and all providers
with a position greater than position
, are shifted up
one position (towards the end of the list of installed providers).
A provider cannot be added if it is already installed.
If there is a security manager, the
SecurityManager.checkSecurityAccess(java.lang.String)
method is called
with the "insertProvider"
permission target name to see if
it's ok to add a new provider. If this permission check is denied,
checkSecurityAccess
is called again with the
"insertProvider."+provider.getName()
permission target name. If
both checks are denied, a SecurityException
is thrown.
provider
- the provider to be added.position
- the preference position that the caller would
like for this provider.NullPointerException
- if provider is nullSecurityException
- if a security manager exists and its SecurityManager.checkSecurityAccess(java.lang.String)
method
denies access to add a new providergetProvider(java.lang.String)
,
removeProvider(java.lang.String)
,
SecurityPermission
public static int addProvider(Provider provider)
If there is a security manager, the
SecurityManager.checkSecurityAccess(java.lang.String)
method is called
with the "insertProvider"
permission target name to see if
it's ok to add a new provider. If this permission check is denied,
checkSecurityAccess
is called again with the
"insertProvider."+provider.getName()
permission target name. If
both checks are denied, a SecurityException
is thrown.
provider
- the provider to be added.NullPointerException
- if provider is nullSecurityException
- if a security manager exists and its SecurityManager.checkSecurityAccess(java.lang.String)
method
denies access to add a new providergetProvider(java.lang.String)
,
removeProvider(java.lang.String)
,
SecurityPermission
public static void removeProvider(String name)
When the specified provider is removed, all providers located at a position greater than where the specified provider was are shifted down one position (towards the head of the list of installed providers).
This method returns silently if the provider is not installed or if name is null.
First, if there is a security manager, its
checkSecurityAccess
method is called with the string "removeProvider."+name
to see if it's ok to remove the provider.
If the default implementation of checkSecurityAccess
is used (i.e., that method is not overriden), then this will result in
a call to the security manager's checkPermission
method
with a SecurityPermission("removeProvider."+name)
permission.
name
- the name of the provider to remove.SecurityException
- if a security manager exists and its SecurityManager.checkSecurityAccess(java.lang.String)
method
denies
access to remove the providergetProvider(java.lang.String)
,
addProvider(java.security.Provider)
public static Provider[] getProviders()
public static Provider getProvider(String name)
name
- the name of the provider to get.removeProvider(java.lang.String)
,
addProvider(java.security.Provider)
public static Provider[] getProviders(String filter)
A cryptographic service is always associated with a particular algorithm or type. For example, a digital signature service is always associated with a particular algorithm (e.g., DSA), and a CertificateFactory service is always associated with a particular certificate type (e.g., X.509).
The selection criterion must be specified in one of the following two formats:
The cryptographic service name must not contain any dots.
A provider satisfies the specified selection criterion iff the provider implements the specified algorithm or type for the specified cryptographic service.
For example, "CertificateFactory.X.509" would be satisfied by any provider that supplied a CertificateFactory implementation for X.509 certificates.
The cryptographic service name must not contain any dots. There must be one or more space characters between the <algorithm_or_type> and the <attribute_name>.
A provider satisfies this selection criterion iff the provider implements the specified algorithm or type for the specified cryptographic service and its implementation meets the constraint expressed by the specified attribute name/value pair.
For example, "Signature.SHA1withDSA KeySize:1024" would be satisfied by any provider that implemented the SHA1withDSA signature algorithm with a keysize of 1024 (or larger).
See the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard cryptographic service names, standard algorithm names and standard attribute names.
filter
- the criterion for selecting
providers. The filter is case-insensitive.InvalidParameterException
- if the filter is not in the required formatNullPointerException
- if filter is nullgetProviders(java.util.Map)
public static Provider[] getProviders(Map<String,String> filter)
The selection criteria are represented by a map. Each map entry represents a selection criterion. A provider is selected iff it satisfies all selection criteria. The key for any entry in such a map must be in one of the following two formats:
The cryptographic service name must not contain any dots.
The value associated with the key must be an empty string.
A provider satisfies this selection criterion iff the provider implements the specified algorithm or type for the specified cryptographic service.
The cryptographic service name must not contain any dots. There must be one or more space characters between the <algorithm_or_type> and the <attribute_name>.
The value associated with the key must be a non-empty string. A provider satisfies this selection criterion iff the provider implements the specified algorithm or type for the specified cryptographic service and its implementation meets the constraint expressed by the specified attribute name/value pair.
See the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard cryptographic service names, standard algorithm names and standard attribute names.
filter
- the criteria for selecting
providers. The filter is case-insensitive.InvalidParameterException
- if the filter is not in the required formatNullPointerException
- if filter is nullgetProviders(java.lang.String)
public static String getProperty(String key)
First, if there is a security manager, its
checkPermission
method is called with a
java.security.SecurityPermission("getProperty."+key)
permission to see if it's ok to retrieve the specified
security property value..
key
- the key of the property being retrieved.SecurityException
- if a security manager exists and its SecurityManager.checkPermission(java.security.Permission)
method
denies
access to retrieve the specified security property valueNullPointerException
- is key is nullsetProperty(java.lang.String, java.lang.String)
,
SecurityPermission
public static void setProperty(String key, String datum)
First, if there is a security manager, its
checkPermission
method is called with a
java.security.SecurityPermission("setProperty."+key)
permission to see if it's ok to set the specified
security property value.
key
- the name of the property to be set.datum
- the value of the property to be set.SecurityException
- if a security manager exists and its SecurityManager.checkPermission(java.security.Permission)
method
denies access to set the specified security property valueNullPointerException
- if key or datum is nullgetProperty(java.lang.String)
,
SecurityPermission
public static Set<String> getAlgorithms(String serviceName)
serviceName
- the name of the Java cryptographic
service (e.g., Signature, MessageDigest, Cipher, Mac, KeyStore).
Note: this parameter is case-insensitive.Dracula Javadoc Sample, Made with Allan Im.


Package org.apache.shiro.web.env
Interface MutableWebEnvironment
-
- All Superinterfaces:
Environment
,WebEnvironment
- All Known Implementing Classes:
DefaultWebEnvironment
,IniWebEnvironment
,ResourceBasedWebEnvironment
public interface MutableWebEnvironment extends WebEnvironment
AWebEnvironment
that supports 'write' operations operations. This mainly exists to shieldWebEnvironment
API consumers from modification operations, which are mostly only used during Shiro environment initialization.- Since:
- 1.2
-
-
Method Summary
All Methods Instance Methods Abstract Methods Modifier and Type Method Description void
setFilterChainResolver(FilterChainResolver filterChainResolver)
Sets theWebEnvironment
'sFilterChainResolver
.void
setServletContext(ServletContext servletContext)
Sets theWebEnvironment
's associatedServletContext
instance.void
setShiroFilterConfiguration(ShiroFilterConfiguration filterConfiguration)
Sets theWebEnvironment
'sShiroFilterConfiguration
.void
setWebSecurityManager(WebSecurityManager webSecurityManager)
Sets theWebEnvironment
'sWebSecurityManager
.-
Methods inherited from interface org.apache.shiro.env.Environment
getSecurityManager
-
Methods inherited from interface org.apache.shiro.web.env.WebEnvironment
getFilterChainResolver, getServletContext, getShiroFilterConfiguration, getWebSecurityManager
-
-
-
-
Method Detail
-
setFilterChainResolver
void setFilterChainResolver(FilterChainResolver filterChainResolver)
Sets theWebEnvironment
'sFilterChainResolver
.- Parameters:
filterChainResolver
- theWebEnvironment
'sFilterChainResolver
.
-
setServletContext
void setServletContext(ServletContext servletContext)
Sets theWebEnvironment
's associatedServletContext
instance. Invoking this method merely makes theServletContext
available to the underlying instance - it does not trigger initialization behavior.- Parameters:
servletContext
- theWebEnvironment
's associatedServletContext
instance.
-
setWebSecurityManager
void setWebSecurityManager(WebSecurityManager webSecurityManager)
Sets theWebEnvironment
'sWebSecurityManager
.- Parameters:
webSecurityManager
- theWebEnvironment
'sWebSecurityManager
.
-
setShiroFilterConfiguration
void setShiroFilterConfiguration(ShiroFilterConfiguration filterConfiguration)
Sets theWebEnvironment
'sShiroFilterConfiguration
.- Parameters:
filterConfiguration
- theWebEnvironment
'sShiroFilterConfiguration
.
-
-


In my research and understanding of neuroplasticity, I have come to see that an individuals beliefs about their own ability to learn, grow, adapt, and confront challenges directly effects their ability to do such things. For this reason, in my own study, it seems that one of the best approaches I can take to this course is to constantly access and reflect on my attitude towards problem solving. When confronting a difficult task or problem, the appropriate mental model to adapt would ideally be one that promotes confidence and excitiment at the opportunity to overcome, grow and learn. If I don't understand something, the mental shift would be from "I am failing at this task/problem" to "I just don't understand yet ". Running away from challenges does very little to stimulate brain activity and teaches a person to stay in a "fixed" mindset or space.
 This idea works in syncronicity with the scientific theory of Neuroplasticity - the two overlap and harmonise. A person with a growth mindset takes pride in
their efforts and journey towards success and excellence, whereas a person with an inverse mindset that is "fixed" holds the belief that their abilities are immutably
fixed without room for development.
This is relevant as it indicates that to succeed and progress though the Development Academy course, it would be optimal to challenge our own self beliefs
regarding such ideas. If I believe that I am incapable of overcoming problems or difficulties in learning the course material, this belief will no doubt manifest as a
form of self fullfilling prophecy. On the other hand, a positve, self reaffirming attitude that promotes the confrontation of challenges head on will result in a flexible,
adaptable mindset that finds a way to overcome.
In this exploration, did anything surprise you? Change for you?
During my research and exploration of this subject, I was surprised by how relatable many of the suggested ideas were to my own life, and the mindsets I
notice in a number of my music students. I reflected back to my second year of primary school when I had a fixed mindset that consequently found me putting my
self worth in my ability to do well in tests, and academic games. Due to my belief that I was valued by my parents because of my intelligence and success in school,
I often lied to inflate my scores, or place of rank in math game leader boards. This trait of lying was reflected in a study by Carol Dweck where annonymous letters
were written by students asked to detail their experience of a test.
"In the fixed mindset, imperfections are shameful — especially if you’re talented — so they lied them away. What’s so alarming is that we took ordinary children and made them into liars, simply by telling them they were smart."
How will you integrate a growth mindset into your learning journey?
I will apply mindfullness to self reflect on my internal attitudes and beleifs when feeling challenged. With my new and deepened understanding of fixed and growth mindsets I will be concious to self affirm my capability to overcome challenges and grow because of them.


Synchronizing finite state machines with Petri Nets
If you have not already done so, it might be a good idea to start by reading the scenario, transforming finite state machines to Petri Nets.
Setting up the environment
Currently, there is no NuGet package for NMF Synchronization, as it is still in incubation. Thus, you will have to download the code through SVN and compile it to get the assemblies necessary for NMF Synchronizations.
If you have done so, create a new project and add the NMF.Synchronizations.dll as well as its dependencies. Furthermore, add the metamodels. These are different to the NTL ones, as the model representation needs to support the view model interfaces INotifyPropertyChanged and INotifyCollectionChanged.
Creating a new synchronization
Similar to NTL, synchronizations in NMF Synchronizations are represented as classes, derived from ReflectiveSynchronization. Thus, create a new class FSM2PN and let it inherit from ReflectiveSynchronization.
Add the following using statements:
using NMF.Expressions.Linq;
using NMF.Synchronizations;
using NMF.Transformations;
As indicated by the using statements, NMF Synchronization basically combines the two projects Transformations and Expressions to obtain a synchronization language. We will see how the benefits of both projects are used in NMF Synchronizations.
Synchronizing machines
We start by defining a synchronization rule for the automata itself. Again, synchronization rules are represented by public nested classes. Thus, create a new nested class within FSM2PN with the following code:
public class AutomataToNet : SynchronizationRule<FSM.FiniteStateMachine, PN.PetriNet>
{
public override bool ShouldCorrespond(FSM.FiniteStateMachine left, PN.PetriNet right, ISynchronizationContext context)
{
return true;
}
public override void DeclareSynchronization()
{
Synchronize(fsm => fsm.Id, pn => pn.Id);
}
}
The method ShouldCorrespond decides whether a correspondence link between the given finite state machine and the Petri Net should be established within the given synchronization context. The synchronization context is basically a transformation context with a change propagation mode and a synchronization direction.
The DeclareSynchronization method specifies the body of the synchronization rule. In this case, the ids of the finite state machine and the Petri Net should be synchronized. Whether the id from the finite state machine is written to the Petri Net or vice versa, or how updates of either property are propagated is up to the synchronization engine and this is dependent on the mode, in which the synchronization is run.
Synchronizing states and places
Next, we synchronize the states of the finite state machine with the places of the Petri Net. For this to work, add the following synchronization rule:
public class StateToPlace : SynchronizationRule<FSM.State, PN.Place>
{
public override bool ShouldCorrespond(FSM.State left, PN.Place right, ISynchronizationContext context)
{
return left.Name == right.Id;
}
public override void DeclareSynchronization()
{
Synchronize(state => state.Name, place => place.Id);
}
}
Thus, a state should correspond to a place if the name of the state matches the Id of the place. The synchronization then synchronizes these names. The latter is required to support change propagation.
Now that we have specified a synchronization rule how to synchronize states and places, we need to make sure that this rule is called appropriately. Thus, add the following line into the DeclareSynchronization method of AutomataToNet:
SynchronizeMany(SyncRule<StateToPlace>(),
fsm => fsm.States, pn => pn.Places);
This statement tells NMF Synchronization, that the states of a state machine should correspond to the places of a Petri Net through the synchronization rule StateToPlace. Depending on the change propagation mode, the synchronization engine will automatically react on new states in the States collection by adding a new place to the Petri Net (or vice versa).
The dependency also gives a hint to NMF Synchronizations where to look for candidates. The dependency is only executed when the correspondence of a state machine and a Petri Net is already clear. Then, each state in the States collection has to correspond to a Place in the Places collection. Thus, the synchronization engine will try to match the existing entries. However, this also means that the dependency limits the candidates for corresponding places for a state that is contained in the States collection of the state machine to the places contained in the Places collection, at least unless there is already a correspondence known.
Internally, NMF Synchronization creates two transformation rules, one for either main synchronization direction. What SynchronizeMany called with a synchronization rule does is basically to wire up transformation rules underneath and add dependencies. However, it is also possible to directly specify the dependencies of the underneath transformation rules directly, if you wish to add more complex synchronization topologies. If one has a synchronization rule object (like the this pointer in within a DeclareSynchronization method for instance), the transformation rules for the synchronization directions are stored in the properties LeftToRight and RightToLeft.
Note: We rely on the LeftToRight transformation rule here, independent of the synchronization direction the synchronization process is executed. This is possible because an established correspondence link between two model elements always results in trace entries for both directions, i.e. the synchronization direction does not matter for tracing purposes.
Synchronizing Transitions
To synchronize the transitions, add the following code:
public class TransitionToTransition : SynchronizationRule<FSM.Transition, PN.Transition>
{
public override void DeclareSynchronization()
{
Synchronize(t => t.Input, t => t.Input);
Synchronize(SyncRule<StateToPlace>(),
t => t.StartState,
t => t.From.FirstOrDefault());
Synchronize(SyncRule<StateToPlace>(),
t => t.EndState,
t => t.To.FirstOrDefault());
}
public override bool ShouldCorrespond(FSM.Transition left, PN.Transition right, ISynchronizationContext context)
{
var stateToPlace = SyncRule<StateToPlace>().LeftToRight;
return left.Input == right.Input
&& right.From.Contains(context.Trace.ResolveIn(stateToPlace, left.StartState))
&& right.To.Contains(context.Trace.ResolveIn(stateToPlace, left.EndState));
}
}
Now, the DeclareSynchronization method seems to be pretty much OK, since we have already seen such synchronization commands. But the synchronization of start and target states needs a bit more explanation.
The direction from right to left is pretty much self-explanatory, we just take the first target place that is available assign the corresponding state to the target state of the corresponding transition.
The other way round is more complicated. What we are actually doing is to assign the corresponding place to the target state of the transition to - to the first or default of the target places? In fact, yes, we do. This is perfectly fine, because the extension method FirstOrDefault has a decorator attribute that is used by Expressions to make the expression that we see a reversable expression. Thus, if FirstOrDefault is assigned a value, then the reverse expression makes sure that this element is in fact contained in the collection (if not, it is added). If the assigned value is the default value, then the collection is cleared.
The ShouldCorrespond basically states that we want to have a correspondence link between transitions, if and only if we already have a correspondence link between the source and target state (or place, respectively). For this, it uses the trace functionality of the synchronization context, querying the LeftToRight transformation rule of the StateToPlace synchronization rule.
Next, we need to make sure that transitions are also synchronized. In the Automata2Net, please add the following line to DeclareSynchronization. The lines must be added after the synchronization call of StateToPlace.
SynchronizeMany(SyncRule<TransitionToTransition>(),
fsm => fsm.Transitions, pn => pn.Transitions.Where(t => t.To.Count > 0));
The reason that this line must be added after the synchronization of StateToPlace is that we do want to have synchronization links of states and places if we look for corresponding transitions. If we swap the order, the synchronization would not find correspondences and duplicate these elements to enforce correspondence.
End states
Similar to the transformation of finite state machines to Petri Nets, we use a synchronization rule to synchronize end states with swallowing transitions of the Petri Net. Thus, add the following rule to the synchronization specification:
public class EndStateToTransition : SynchronizationRule<FSM.State, PN.Transition>
{
}
We begin with the specification when this new synchronization rule is going to called. Add the following line to the DeclareSynchronization method of the AutomataToNet rule:
SynchronizeMany(SyncRule<EndStateToTransition>(),
fsm => fsm.States.Where(state => state.IsEndState),
pn => pn.Transitions.Where(t => t.To.Count == 0));
Thus, we only consider transitions of the Petri Net that have no target place. We can thus identify correspondence by the first and only source place of a transition. Thus, add the ShouldCorrespond method to EndStateToTransition as follows:
public override bool ShouldCorrespond(FSM.State left, PN.Transition right, ISynchronizationContext context)
{
return context.Trace.ResolveIn(SyncRule<StateToPlace>().LeftToRight, left) == right.From.FirstOrDefault();
}
Because the synchronization context is basically just a transformation context, we can use its tracing component like we did when synchronizing transitions.
Thus, whenever there is an end state, we make sure that there is a corresponding transition. There condition inside the Where clause states that this new transition has no target place. However, this condition is not enforced, because Count is a read-only property and thus cannot be set to 0. We still need to add the corresponding place of our end state to the new transition.
Generally spoken, how is it possible to synchronize the value of an attribute (IsEndState) with the existence of a model element (the loose transition)? A helpful hint is the idea what should happen in each case. If a state was made an end state, it is automatically added to the collection of end states and thus, the dependency in AutomataToNet causes a transition to be created that needs to start at the corresponding place. If an endstate is no longer marked as an endstate, the transition is removed from its container and cease to exist, is therefore deleted from the model. However, if we hide this implementation detail of the model representation for a moment, we would have to remove the transition from the outgoing transitions of our corresponding place. We can do this, by setting the FirstOrDefault to null.
Thus, add the following DeclareSynchronization method to EndStateToTransition:
public override void DeclareSynchronization()
{
Synchronize(SyncRule<StateToPlace>(),
state => state.IsEndState ? state : null,
transition => transition.From.FirstOrDefault());
}
This will cause a runtime exception, if the synchronization is run from right to left. Why? Because the ternary operator in the left selector is not inversable. As a simple solution, we can restrict this synchronization job to left to right directions. Thus, change the method to the following:
public override void DeclareSynchronization()
{
SynchronizeLeftToRightOnly(SyncRule<StateToPlace>(),
state => state.IsEndState ? state : null,
transition => transition.From.FirstOrDefault());
}
However, what happens the other way around? In particular, how are the states right states found for transitions that have no target place? The dependency that we specified in AutomataToNet for this purpose will try to find state candidates for the transition within the end states of the finite state machine. Currently, it is not possible to specify directly that the synchronization engine should look for candidate states in all states of the state machine.
What we can do, however, and it's even more efficient, we can override the creation of correspondent lefts directly. There, we could use the trace to find out the place corresponding to the source place of the transition. This is more efficient, because the NMF Transformations trace has an average effort of O(1). Thus, add the following method to EndStateToTransition:
protected override FSM.State CreateLeftOutput(PN.Transition transition, IEnumerable<FSM.State> candidates, ISynchronizationContext context)
{
if (transition.From.Count == 0) throw new InvalidOperationException();
return context.Trace.ResolveIn(SyncRule<StateToPlace>().RightToLeft, transition.From.FirstOrDefault());
}
Limitations
The example of Petri Nets and state charts shows some limitations of NMF Synchronizations. The problem is exactly with the transitions. Once a correspondence is determined, it is currently fixed. This assumption is necessary for tracing purposes. In this scenario, it means that NMF Synchrionizations is unable to register that a transition can be used in multiple roles, either as a representation of finite state machine transitions or as a characterization of end states.
However, NMF Synchronizations is still in incubation, so this limitation might eventually cease.


FBLD—Load Binary Coded Decimal
| Opcode |
Instruction |
64-Bit Mode |
Compat/Leg Mode |
Description |
| DF /4 |
FBLD m80dec |
Valid |
Valid |
Convert BCD value to floating-point and push onto the FPU stack. |
Description
Converts the BCD source operand into double extended-precision floating-point format and pushes the value onto the FPU stack. The source operand is loaded without rounding errors. The sign of the source operand is preserved, including that of −0.
The packed BCD digits are assumed to be in the range 0 through 9; the instruction does not check for invalid digits (AH through FH). Attempting to load an invalid encoding produces an undefined result.
This instruction’s operation is the same in non-64-bit modes and 64-bit mode.
Operation
TOP ← TOP − 1;
ST(0) ← ConvertToDoubleExtendedPrecisionFP(SRC);
FPU Flags Affected
| C1 |
Set to 1 if stack overflow occurred; otherwise, set to 0. |
| C0, C2, C3 |
Undefined. |
Floating-Point Exceptions
| #IS |
Stack overflow occurred. |
Protected Mode Exceptions
| #GP(0) |
If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. If the DS, ES, FS, or GS register contains a NULL segment selector. |
| #SS(0) |
If a memory operand effective address is outside the SS segment limit. |
| #NM |
CR0.EM[bit 2] or CR0.TS[bit 3] = 1. |
| #PF(fault-code) |
If a page fault occurs. |
| #AC(0) |
If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3. |
| #UD |
If the LOCK prefix is used. |
Real-Address Mode Exceptions
| #GP |
If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. |
| #SS |
If a memory operand effective address is outside the SS segment limit. |
| #NM |
CR0.EM[bit 2] or CR0.TS[bit 3] = 1. |
| #UD |
If the LOCK prefix is used. |
Virtual-8086 Mode Exceptions
| #GP(0) |
If a memory operand effective address is outside the CS, DS, ES, FS, or GS segment limit. |
| #SS(0) |
If a memory operand effective address is outside the SS segment limit. |
| #NM |
CR0.EM[bit 2] or CR0.TS[bit 3] = 1. |
| #PF(fault-code) |
If a page fault occurs. |
| #AC(0) |
If alignment checking is enabled and an unaligned memory reference is made. |
| #UD |
If the LOCK prefix is used. |
Compatibility Mode Exceptions
Same exceptions as in protected mode.
64-Bit Mode Exceptions
| #SS(0) |
If a memory address referencing the SS segment is in a non-canonical form. |
| #GP(0) |
If the memory address is in a non-canonical form. |
| #NM |
CR0.EM[bit 2] or CR0.TS[bit 3] = 1. |
| #MF |
If there is a pending x87 FPU exception. |
| #PF(fault-code) |
If a page fault occurs. |
| #AC(0) |
If alignment checking is enabled and an unaligned memory reference is made while the current privilege level is 3. |
| #UD |
If the LOCK prefix is used. |


| Home | Trees | Indices | Help |
|---|
|
|
object --+ | PathDescriptor --+ | VersionedPathDescriptor
Describes the changes of a particular path
This is a wrapper around svn_repos.ChangedPath instances. outside of this module one shouldn't need to deal with these.
|
|||
|
|||
|
|||
int
|
|
||
str
|
|
||
dict
|
|
||
bool
|
|
||
bool
|
|
||
bool
|
|
||
bool
|
|
||
bool
|
|
||
bool
|
|
||
bool
|
|
||
bool
|
|
||
|
Inherited from Inherited from |
|
|||
svn_repos.ChangedPath
|
_change The change |
||
int
|
revision The revision number |
||
|
Inherited from |
|
|||
|
Inherited from |
|
Custom initialization
|
Initialization
|
Returns the revision number of the original path
|
Returns the original path
|
Returns the dict of modified properties The dict contains the property names as keys and a 2-tuple as value where the first element contains the old property value and second element the new one.
|
Returns whether the path is a directory
|
Returns whether one of the revisions is a binary file
|
Returns whether the path has property changes
|
Returns whether the path has content changes
|
Returns whether the path was deleted
|
Returns whether the path was added
|
Returns whether the path was just modified
|
Returns whether the path was copied
|
| Home | Trees | Indices | Help |
|---|
| Generated by Epydoc 3.0.1 on Sun Sep 25 21:07:33 2011 | http://epydoc.sourceforge.net |


Urge to show your customers more images of your products and services in a limited space of page? No worries, we have interactive image display for you. Your customers will see a group of thumbnail images on the page. They can easily click the thumbnail image to view it in the enlarged version beside. It is a great feature for those who wish to show a lot!


ANTLR 2.7.1 Installation ANTLR comes as a single zip or compressed tar file. Unzipping the file you receive will produce a directory called antlr-2.7.1 with subdirectories antlr, doc, examples, cpp, and examples.cpp. You need to place the antlr-2.7.1 directory in your CLASSPATH environment variable. For example, if you placed antlr-2.7.1 in directory /tools, you need to append
to your CLASSPATH or.
if you work on an NT or Win95 box. References to antlr.* will map to /tools/antlr-2.7.1/antlr/*.class. You must have at least JDK 1.1 installed properly on your machine. The ASTFrame AST viewer uses Swing 1.1 package names now. ParseView Debugger The ParseView debugger by Scott Stanchfield must be downloaded separately if you want to use the "-debug" option of ANTLR. Click here to download the debugger. Then unzip it over the antlr-2.7.1 directory (the zip contains antlr.debugger.* etc...). JAR FILE Try using the runtime library antlr.jar file. Place it in your CLASSPATH instead of the antlr-2.7.1 directory. The jar includes all parse-time files needed (if it is missing a file, email parrt@jguru.com). You can make antlr.debug.jar (has antlr.jar stuff pluse the debug classes needed by parseview) by running mkdebugjar. You cannot run the antlr tool itself with the jar, but your parsers should run with just this jar file. It's pretty small, around 50k uncompressed.
ANTLR is a command line tool (although many development environments let you run ANTLR on grammar files from within the environment). The main method within antlr.Tool is the ANTLR entry point.
The command-line option is -diagnostic, which generates a text file for each output parser class that describes the lookahead sets. Note that there are number of options that you can specify at the grammar class and rule level. Options -trace, -traceParser, -traceTreeParser may be used to track the lexer, parser, and tree parser invocations. Run the tool without any arguments to see the complete option list for the comamnd line. Try the new -html option to generate HTML output of your grammar(s). Not completed, of course... :( If you have trouble running ANTLR, ensure that you have Java installed correctly and then ensure that you have the appropriate CLASSPATH set. |


A---B---C topic / D---E---F---G master
git-rebase(1) Manual Page
NAME
git-rebase - Forward-port local commits to the updated upstream head
SYNOPSIS
git rebase [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>] git rebase [-i | --interactive] [options] [--exec <cmd>] [--onto <newbase>] --root [<branch>] git rebase --continue | --skip | --abort | --edit-todo
DESCRIPTION
If <branch> is specified, git rebase will perform an automatic git checkout <branch> before doing anything else. Otherwise it remains on the current branch.
If <upstream> is not specified, the upstream configured in branch.<name>.remote and branch.<name>.merge options will be used; see git-config(1) for details. If you are currently not on any branch or if the current branch does not have a configured upstream, the rebase will abort.
All changes made by commits in the current branch but that are not in <upstream> are saved to a temporary area. This is the same set of commits that would be shown by git log <upstream>..HEAD (or git log HEAD, if --root is specified).
The current branch is reset to <upstream>, or <newbase> if the --onto option was supplied. This has the exact same effect as git reset --hard <upstream> (or <newbase>). ORIG_HEAD is set to point at the tip of the branch before the reset.
The commits that were previously saved into the temporary area are then reapplied to the current branch, one by one, in order. Note that any commits in HEAD which introduce the same textual changes as a commit in HEAD..<upstream> are omitted (i.e., a patch already accepted upstream with a different commit message or timestamp will be skipped).
It is possible that a merge failure will prevent this process from being completely automatic. You will have to resolve any such merge failure and run git rebase --continue. Another option is to bypass the commit that caused the merge failure with git rebase --skip. To check out the original <branch> and remove the .git/rebase-apply working files, use the command git rebase --abort instead.
Assume the following history exists and the current branch is "topic":
From this point, the result of either of the following commands:
git rebase master git rebase master topic
would be:
A'--B'--C' topic / D---E---F---G master
NOTE: The latter form is just a short-hand of git checkout topic followed by git rebase master. When rebase exits topic will remain the checked-out branch.
If the upstream branch already contains a change you have made (e.g., because you mailed a patch which was applied upstream), then that commit will be skipped. For example, running git rebase master on the following history (in which A' and A introduce the same set of changes, but have different committer information):
A---B---C topic / D---E---A'---F master
will result in:
B'---C' topic / D---E---A'---F master
Here is how you would transplant a topic branch based on one branch to another, to pretend that you forked the topic branch from the latter branch, using rebase --onto.
First let's assume your topic is based on branch next. For example, a feature developed in topic depends on some functionality which is found in next.
o---o---o---o---o master \ o---o---o---o---o next \ o---o---o topic
We want to make topic forked from branch master; for example, because the functionality on which topic depends was merged into the more stable master branch. We want our tree to look like this:
o---o---o---o---o master | \ | o'--o'--o' topic \ o---o---o---o---o next
We can get this using the following command:
git rebase --onto master next topic
Another example of --onto option is to rebase part of a branch. If we have the following situation:
H---I---J topicB / E---F---G topicA / A---B---C---D master
then the command
git rebase --onto master topicA topicB
would result in:
H'--I'--J' topicB / | E---F---G topicA |/ A---B---C---D master
This is useful when topicB does not depend on topicA.
A range of commits could also be removed with rebase. If we have the following situation:
E---F---G---H---I---J topicA
then the command
git rebase --onto topicA~5 topicA~3 topicA
would result in the removal of commits F and G:
E---H'---I'---J' topicA
This is useful if F and G were flawed in some way, or should not be part of topicA. Note that the argument to --onto and the <upstream> parameter can be any valid commit-ish.
In case of conflict, git rebase will stop at the first problematic commit and leave conflict markers in the tree. You can use git diff to locate the markers (<<<<<<) and make edits to resolve the conflict. For each file you edit, you need to tell Git that the conflict has been resolved, typically this would be done with
git add <filename>
After resolving the conflict manually and updating the index with the desired resolution, you can continue the rebasing process with
git rebase --continue
Alternatively, you can undo the git rebase with
git rebase --abort
CONFIGURATION
- rebase.stat
Whether to show a diffstat of what changed upstream since the last rebase. False by default.
- rebase.autosquash
If set to true enable --autosquash option by default.
- rebase.autostash
If set to true enable --autostash option by default.
OPTIONS
- --onto <newbase>
Starting point at which to create the new commits. If the --onto option is not specified, the starting point is <upstream>. May be any valid commit, and not just an existing branch name.
As a special case, you may use "A\...B" as a shortcut for the merge base of A and B if there is exactly one merge base. You can leave out at most one of A and B, in which case it defaults to HEAD.
- <upstream>
Upstream branch to compare against. May be any valid commit, not just an existing branch name. Defaults to the configured upstream for the current branch.
- <branch>
Working branch; defaults to HEAD.
- --continue
Restart the rebasing process after having resolved a merge conflict.
- --abort
Abort the rebase operation and reset HEAD to the original branch. If <branch> was provided when the rebase operation was started, then HEAD will be reset to <branch>. Otherwise HEAD will be reset to where it was when the rebase operation was started.
- --keep-empty
Keep the commits that do not change anything from its parents in the result.
- --skip
Restart the rebasing process by skipping the current patch.
- --edit-todo
Edit the todo list during an interactive rebase.
- -m
- --merge
Use merging strategies to rebase. When the recursive (default) merge strategy is used, this allows rebase to be aware of renames on the upstream side.
Note that a rebase merge works by replaying each commit from the working branch on top of the <upstream> branch. Because of this, when a merge conflict happens, the side reported as ours is the so-far rebased series, starting with <upstream>, and theirs is the working branch. In other words, the sides are swapped.
- -s <strategy>
- --strategy=<strategy>
Use the given merge strategy. If there is no -s option git merge-recursive is used instead. This implies --merge.
Because git rebase replays each commit from the working branch on top of the <upstream> branch using the given strategy, using the ours strategy simply discards all patches from the <branch>, which makes little sense.
- -X <strategy-option>
- --strategy-option=<strategy-option>
Pass the <strategy-option> through to the merge strategy. This implies --merge and, if no strategy has been specified, -s recursive. Note the reversal of ours and theirs as noted above for the -m option.
- -q
- --quiet
Be quiet. Implies --no-stat.
- -v
- --verbose
Be verbose. Implies --stat.
- --stat
Show a diffstat of what changed upstream since the last rebase. The diffstat is also controlled by the configuration option rebase.stat.
- -n
- --no-stat
Do not show a diffstat as part of the rebase process.
- --no-verify
This option bypasses the pre-rebase hook. See also githooks(5).
- --verify
Allows the pre-rebase hook to run, which is the default. This option can be used to override --no-verify. See also githooks(5).
- -C<n>
Ensure at least <n> lines of surrounding context match before and after each change. When fewer lines of surrounding context exist they all must match. By default no context is ever ignored.
- -f
- --force-rebase
Force the rebase even if the current branch is a descendant of the commit you are rebasing onto. Normally non-interactive rebase will exit with the message "Current branch is up to date" in such a situation. Incompatible with the --interactive option.
You may find this (or --no-ff with an interactive rebase) helpful after reverting a topic branch merge, as this option recreates the topic branch with fresh commits so it can be remerged successfully without needing to "revert the reversion" (see the revert-a-faulty-merge How-To for details).
- --ignore-whitespace
- --whitespace=<option>
These flag are passed to the git apply program (see git-apply(1)) that applies the patch. Incompatible with the --interactive option.
- --committer-date-is-author-date
- --ignore-date
These flags are passed to git am to easily change the dates of the rebased commits (see git-am(1)). Incompatible with the --interactive option.
- -i
- --interactive
Make a list of the commits which are about to be rebased. Let the user edit that list before rebasing. This mode can also be used to split commits (see SPLITTING COMMITS below).
- -p
- --preserve-merges
Instead of ignoring merges, try to recreate them.
This uses the --interactive machinery internally, but combining it with the --interactive option explicitly is generally not a good idea unless you know what you are doing (see BUGS below).
- -x <cmd>
- --exec <cmd>
Append "exec <cmd>" after each line creating a commit in the final history. <cmd> will be interpreted as one or more shell commands.
This option can only be used with the --interactive option (see INTERACTIVE MODE below).
You may execute several commands by either using one instance of --exec with several commands:
git rebase -i --exec "cmd1 && cmd2 && ..."
or by giving more than one --exec:
git rebase -i --exec "cmd1" --exec "cmd2" --exec ...
If --autosquash is used, "exec" lines will not be appended for the intermediate commits, and will only appear at the end of each squash/fixup series.
- --root
Rebase all commits reachable from <branch>, instead of limiting them with an <upstream>. This allows you to rebase the root commit(s) on a branch. When used with --onto, it will skip changes already contained in <newbase> (instead of <upstream>) whereas without --onto it will operate on every change. When used together with both --onto and --preserve-merges, all root commits will be rewritten to have <newbase> as parent instead.
- --autosquash
- --no-autosquash
When the commit log message begins with "squash! ..." (or "fixup! ..."), and there is a commit whose title begins with the same ..., automatically modify the todo list of rebase -i so that the commit marked for squashing comes right after the commit to be modified, and change the action of the moved commit from pick to squash (or fixup). Ignores subsequent "fixup! " or "squash! " after the first, in case you referred to an earlier fixup/squash with git commit --fixup/--squash.
This option is only valid when the --interactive option is used.
If the --autosquash option is enabled by default using the configuration variable rebase.autosquash, this option can be used to override and disable this setting.
- --[no-]autostash
Automatically create a temporary stash before the operation begins, and apply it after the operation ends.  However, use with care: the final stash application after a successful rebase might result in non-trivial conflicts.
- --no-ff
With --interactive, cherry-pick all rebased commits instead of fast-forwarding over the unchanged ones. This ensures that the entire history of the rebased branch is composed of new commits.
Without --interactive, this is a synonym for --force-rebase.
You may find this helpful after reverting a topic branch merge, as this option recreates the topic branch with fresh commits so it can be remerged successfully without needing to "revert the reversion" (see the revert-a-faulty-merge How-To for details).
MERGE STRATEGIES
The merge mechanism (git-merge and git-pull commands) allows the backend merge strategies to be chosen with -s option. Some strategies can also take their own options, which can be passed by giving -X<option> arguments to git-merge and/or git-pull.
- resolve
This can only resolve two heads (i.e. the current branch and another branch you pulled from) using a 3-way merge algorithm. It tries to carefully detect criss-cross merge ambiguities and is considered generally safe and fast.
- recursive
This can only resolve two heads using a 3-way merge algorithm. When there is more than one common ancestor that can be used for 3-way merge, it creates a merged tree of the common ancestors and uses that as the reference tree for the 3-way merge. This has been reported to result in fewer merge conflicts without causing mis-merges by tests done on actual merge commits taken from Linux 2.6 kernel development history. Additionally this can detect and handle merges involving renames. This is the default merge strategy when pulling or merging one branch.
The recursive strategy can take the following options:
- ours
This option forces conflicting hunks to be auto-resolved cleanly by favoring our version. Changes from the other tree that do not conflict with our side are reflected to the merge result. For a binary file, the entire contents are taken from our side.
This should not be confused with the ours merge strategy, which does not even look at what the other tree contains at all. It discards everything the other tree did, declaring our history contains all that happened in it.
- theirs
This is the opposite of ours.
- patience
With this option, merge-recursive spends a little extra time to avoid mismerges that sometimes occur due to unimportant matching lines (e.g., braces from distinct functions). Use this when the branches to be merged have diverged wildly. See also git-diff(1) --patience.
- diff-algorithm=[patience|minimal|histogram|myers]
Tells merge-recursive to use a different diff algorithm, which can help avoid mismerges that occur due to unimportant matching lines (such as braces from distinct functions). See also git-diff(1) --diff-algorithm.
- ignore-space-change
- ignore-all-space
- ignore-space-at-eol
Treats lines with the indicated type of whitespace change as unchanged for the sake of a three-way merge. Whitespace changes mixed with other changes to a line are not ignored. See also git-diff(1) -b, -w, and --ignore-space-at-eol.
If their version only introduces whitespace changes to a line, our version is used;
If our version introduces whitespace changes but their version includes a substantial change, their version is used;
Otherwise, the merge proceeds in the usual way.
- renormalize
This runs a virtual check-out and check-in of all three stages of a file when resolving a three-way merge. This option is meant to be used when merging branches with different clean filters or end-of-line normalization rules. See "Merging branches with differing checkin/checkout attributes" in gitattributes(5) for details.
- no-renormalize
Disables the renormalize option. This overrides the merge.renormalize configuration variable.
- rename-threshold=<n>
Controls the similarity threshold used for rename detection. See also git-diff(1) -M.
- subtree[=<path>]
This option is a more advanced form of subtree strategy, where the strategy makes a guess on how two trees must be shifted to match with each other when merging. Instead, the specified path is prefixed (or stripped from the beginning) to make the shape of two trees to match.
- octopus
This resolves cases with more than two heads, but refuses to do a complex merge that needs manual resolution. It is primarily meant to be used for bundling topic branch heads together. This is the default merge strategy when pulling or merging more than one branch.
- ours
This resolves any number of heads, but the resulting tree of the merge is always that of the current branch head, effectively ignoring all changes from all other branches. It is meant to be used to supersede old development history of side branches. Note that this is different from the -Xours option to the recursive merge strategy.
- subtree
This is a modified recursive strategy. When merging trees A and B, if B corresponds to a subtree of A, B is first adjusted to match the tree structure of A, instead of reading the trees at the same level. This adjustment is also done to the common ancestor tree.
NOTES
You should understand the implications of using git rebase on a repository that you share. See also RECOVERING FROM UPSTREAM REBASE below.
When the git-rebase command is run, it will first execute a "pre-rebase" hook if one exists. You can use this hook to do sanity checks and reject the rebase if it isn't appropriate. Please see the template pre-rebase hook script for an example.
Upon completion, <branch> will be the current branch.
INTERACTIVE MODE
Rebasing interactively means that you have a chance to edit the commits which are rebased. You can reorder the commits, and you can remove them (weeding out bad or otherwise unwanted patches).
The interactive mode is meant for this type of workflow:
have a wonderful idea
hack on the code
prepare a series for submission
submit
where point 2. consists of several instances of
a) regular use
finish something worthy of a commit
commit
b) independent fixup
realize that something does not work
fix that
commit it
Sometimes the thing fixed in b.2. cannot be amended to the not-quite perfect commit it fixes, because that commit is buried deeply in a patch series. That is exactly what interactive rebase is for: use it after plenty of "a"s and "b"s, by rearranging and editing commits, and squashing multiple commits into one.
Start it with the last commit you want to retain as-is:
git rebase -i <after-this-commit>
An editor will be fired up with all the commits in your current branch (ignoring merge commits), which come after the given commit. You can reorder the commits in this list to your heart's content, and you can remove them. The list looks more or less like this:
pick deadbee The oneline of this commit pick fa1afe1 The oneline of the next commit ...
The oneline descriptions are purely for your pleasure; git rebase will not look at them but at the commit names ("deadbee" and "fa1afe1" in this example), so do not delete or edit the names.
By replacing the command "pick" with the command "edit", you can tell git rebase to stop after applying that commit, so that you can edit the files and/or the commit message, amend the commit, and continue rebasing.
If you just want to edit the commit message for a commit, replace the command "pick" with the command "reword".
If you want to fold two or more commits into one, replace the command "pick" for the second and subsequent commits with "squash" or "fixup". If the commits had different authors, the folded commit will be attributed to the author of the first commit. The suggested commit message for the folded commit is the concatenation of the commit messages of the first commit and of those with the "squash" command, but omits the commit messages of commits with the "fixup" command.
git rebase will stop when "pick" has been replaced with "edit" or when a command fails due to merge errors. When you are done editing and/or resolving conflicts you can continue with git rebase --continue.
For example, if you want to reorder the last 5 commits, such that what was HEAD~4 becomes the new HEAD. To achieve that, you would call git rebase like this:
$ git rebase -i HEAD~5
And move the first patch to the end of the list.
You might want to preserve merges, if you have a history like this:
X \ A---M---B / ---o---O---P---Q
Suppose you want to rebase the side branch starting at "A" to "Q". Make sure that the current HEAD is "B", and call
$ git rebase -i -p --onto Q O
Reordering and editing commits usually creates untested intermediate steps. You may want to check that your history editing did not break anything by running a test, or at least recompiling at intermediate points in history by using the "exec" command (shortcut "x"). You may do so by creating a todo list like this one:
pick deadbee Implement feature XXX fixup f1a5c00 Fix to feature XXX exec make pick c0ffeee The oneline of the next commit edit deadbab The oneline of the commit after exec cd subdir; make test ...
The interactive rebase will stop when a command fails (i.e. exits with non-0 status) to give you an opportunity to fix the problem. You can continue with git rebase --continue.
The "exec" command launches the command in a shell (the one specified in $SHELL, or the default shell if $SHELL is not set), so you can use shell features (like "cd", ">", ";" ...). The command is run from the root of the working tree.
$ git rebase -i --exec "make test"
This command lets you check that intermediate commits are compilable. The todo list becomes like that:
pick 5928aea one exec make test pick 04d0fda two exec make test pick ba46169 three exec make test pick f4593f9 four exec make test
SPLITTING COMMITS
In interactive mode, you can mark commits with the action "edit". However, this does not necessarily mean that git rebase expects the result of this edit to be exactly one commit. Indeed, you can undo the commit, or you can add other commits. This can be used to split a commit into two:
Start an interactive rebase with git rebase -i <commit>^, where <commit> is the commit you want to split. In fact, any commit range will do, as long as it contains that commit.

When it comes to editing that commit, execute git reset HEAD^. The effect is that the HEAD is rewound by one, and the index follows suit. However, the working tree stays the same.
Now add the changes to the index that you want to have in the first commit. You can use git add (possibly interactively) or git gui (or both) to do that.
Commit the now-current index with whatever commit message is appropriate now.
Repeat the last two steps until your working tree is clean.
Continue the rebase with git rebase --continue.
If you are not absolutely sure that the intermediate revisions are consistent (they compile, pass the testsuite, etc.) you should use git stash to stash away the not-yet-committed changes after each commit, test, and amend the commit if fixes are necessary.
RECOVERING FROM UPSTREAM REBASE
Rebasing (or any other form of rewriting) a branch that others have based work on is a bad idea: anyone downstream of it is forced to manually fix their history. This section explains how to do the fix from the downstream's point of view. The real fix, however, would be to avoid rebasing the upstream in the first place.
To illustrate, suppose you are in a situation where someone develops a subsystem branch, and you are working on a topic that is dependent on this subsystem. You might end up with a history like the following:
o---o---o---o---o---o---o---o---o master \ o---o---o---o---o subsystem \ *---*---* topic
If subsystem is rebased against master, the following happens:
o---o---o---o---o---o---o---o master \ \ o---o---o---o---o o'--o'--o'--o'--o' subsystem \ *---*---* topic
If you now continue development as usual, and eventually merge topic to subsystem, the commits from subsystem will remain duplicated forever:
o---o---o---o---o---o---o---o master \ \ o---o---o---o---o o'--o'--o'--o'--o'--M subsystem \ / *---*---*-..........-*--* topic
Such duplicates are generally frowned upon because they clutter up history, making it harder to follow. To clean things up, you need to transplant the commits on topic to the new subsystem tip, i.e., rebase topic. This becomes a ripple effect: anyone downstream from topic is forced to rebase too, and so on!
There are two kinds of fixes, discussed in the following subsections:
- Easy case: The changes are literally the same.
This happens if the subsystem rebase was a simple rebase and had no conflicts.
- Hard case: The changes are not the same.
This happens if the subsystem rebase had conflicts, or used --interactive to omit, edit, squash, or fixup commits; or if the upstream used one of commit --amend, reset, or filter-branch.
The easy case
Only works if the changes (patch IDs based on the diff contents) on subsystem are literally the same before and after the rebase subsystem did.
In that case, the fix is easy because git rebase knows to skip changes that are already present in the new upstream. So if you say (assuming you're on topic)
$ git rebase subsystem
you will end up with the fixed history
o---o---o---o---o---o---o---o master \ o'--o'--o'--o'--o' subsystem \ *---*---* topic
The hard case
Things get more complicated if the subsystem changes do not exactly correspond to the ones before the rebase.
Note |
While an "easy case recovery" sometimes appears to be successful even in the hard case, it may have unintended consequences. For example, a commit that was removed via git rebase --interactive will be *resurrected*! |
The idea is to manually tell git rebase "where the old subsystem ended and your topic began", that is, what the old merge-base between them was. You will have to find a way to name the last commit of the old subsystem, for example:
With the subsystem reflog: after git fetch, the old tip of subsystem is at subsystem@{1}. Subsequent fetches will increase the number. (See git-reflog(1).)
Relative to the tip of topic: knowing that your topic has three commits, the old tip of subsystem must be topic~3.
You can then transplant the old subsystem..topic to the new tip by saying (for the reflog case, and assuming you are on topic already):
$ git rebase --onto subsystem subsystem@{1}
The ripple effect of a "hard case" recovery is especially bad: everyone downstream from topic will now have to perform a "hard case" recovery too!
BUGS
The todo list presented by --preserve-merges --interactive does not represent the topology of the revision graph. Editing commits and rewording their commit messages should work fine, but attempts to reorder commits tend to produce counterintuitive results.
For example, an attempt to rearrange
1 --- 2 --- 3 --- 4 --- 5
to
1 --- 2 --- 4 --- 3 --- 5
by moving the "pick 4" line will result in the following history:
3 /
1 --- 2 --- 4 --- 5
GIT --- Part of the linkgit:git[1] suite


Header!
Hello World 3! This is the content!
Left sidebar
Right sidebar


Our purpose
Why we started
Our dogs
Want to help?
Contact us
Know our why
Know our history and be part of it
Meet our dogs!
Know some cases?
Get in touch with us


☰ Navigate
News
Contact
About
×
About
Services
Clients
Contact
Select the Semester
Semester 1
Semester 2
Semester 3
Semester 4
Semester 5
Semester 6
Semester 7
Semester 8
Select the Department
Electronic & Telecommunication Engineering
Computer Science & Engineering
Electrical Engineering
Civil Engineering
Mechanical Engineering
Chemical & Process Engineering
Material Science & Engineering
Textile & Clothing Technology
Earth Resource Engineering
Transport & Logistic Management
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca
Grade
A+
A
A-
B+
B
B-
C+
C
C-
D
F
I-we
I-ca


We buy IT, lab/test, A/V, telecom, and medical equipment!
We got our start as an electronics equipment reseller over a decade ago and to this day it is a core part of what we do. Our expertise is in IT, lab/test, and medical equipment. We evaluate equipment of all varieties, in all conditions and quantities. Contact us today to see what we can offer for your equipment.


Simple Interest Calculator
Amount
Interest Rate
No. of Years
Compute Interest
© Everyone Can Get Rich


Scott Morrison Reckons That Australia Is “Overachieving” On Climate Change
by Rachael ConaghanNot to worry, Australia: our country is an “overachiever” on climate change action, according to Scott Morrison.
He also says there is “no credible scientific evidence” that cutting our emissions would have impacted on our current bushfire season.
Good to know we can all relax.
The Prime Minister made the comments on the ABC’s AM program, as millions of people across the east coast woke up to thick smoke blanketing their towns.
“If anything, Australia is an overachiever on our commitments,” he told presenter Sabra Lane.
As evidence, he highlighted our Kyoto targets, which were set as part of an international agreement to reduce emissions. But using these targets to highlight the “great work Australia is doing” is ironic, considering they’ve been criticised for being unambitious at best.
Morrison did go on to acknowledge that climate change is making our problems worse … while still somehow being in denial about our role in it.
Related
“The contribution of these issues to global weather conditions and to conditions here in Australia are known and acknowledged,” he said. “Climate change is a global phenomenon and we’re doing our bit as part of the response to climate change.”
“I think to suggest with just 1.3% of global emissions that Australia doing something differently, something more or less, would have changed the fire outcome this season, I don’t think that stands up to any credible scientific evidence at all.”
Government figures show our carbon emissions continue to rise.


 It has a new teenager twist though, which will make the story line available to a larger audience. I have been very much anticipating this new film. The up and coming Freddie Prinze Jr. stars as Zack, the most popular kid at his high school. Zack is in trouble now. His girlfriend Taylor, played by Jodi Lyn O'Keefe, went on MTV's Spring Break over their school's spring break. She met a guy from the show "The Real World", Brock Hudson. (Matthew Lillard) She decides to break up with Zack. Zack is extremely angered with Taylor's decision. Zack talks with his best friend Dean, played by Paul Walker, (Varsity Blues) about what Taylor did. The two make a bet that Zack can turn any girl in the school into the prom queen in six weeks. Dean picks Laney Boggs, (Rachael Leigh Cook) the school dork. The film's first twenty minutes are quite promising. Music accompanies the opening almost the entire time. She's All That was on its way to being great until Zack made the bet.
Zack meets up with Laney and gets rejected by her. His project is even tougher now that she ignores him. He follows her around, and tries to get involved in her life. The two of them become extremely close friends. Laney is now popular. At school, Laney has even been nominated for prom queen. Zack has helped out Laney a lot. The problem is that he is doing all this for the wrong reasons.
Freddie Prinze Jr. has reassured me that he can act after his terrible performance in I Still Know What You Did Last Summer. The character of Zack was developed pretty well. The film explained the fact very well that he is extremely popular. Everyone looks up to Zack, even kids in middle school. Taylor's characters is very annoying at many times in the movie. She is just the kind of character that you wish wasn't even in the movie. The performance by Jodi Lyn O'Keefe was well done, but the character really annoyed me. Paul Walker's character, Dean was also annoying. Is these two characters were changed a bit, this could have helped the film out a lot.
A large cast is pretty much what saved She's All That from being terrible. Clea DuVall, Usher Raymond, and Sarah Michelle Gellar make extremely brief performances. If these characters were brought into the film more, they could have helped the total outcome. The main characters are developed pretty well in the film, but we could have known a little more about Zack and Taylor's background.
She's All That, like many teen comedies these days, makes you feel good about yourself. The music and characters are upbeat and nineties, and that's what I liked the best about the film. The dance sequence at the prom was very nicely done. The choreography was very nicely done.
Little suspense was put into the film at all. It was extremely predictable what was going to happen. If a few more twists and turns were added to the over-used plot, She's All That could have been a lot better. Many sub plots went on throughout the movie. I think the sub plot of the prom queen race could have been added to for some more fun in the film. The film is also slow moving at times. My mind drifted away three or four times throughout the film.
The Bottom Line- It could have been "all that", but not enough effort was put into it.
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


The Hegemony Consul sat on the balcony of his ebony spaceship and played Rachmaninoff's Prelude in C-sharp Minor on an ancient but well-maintained Steinway while great, green, saurian things surged and bellowed in the swamps below.


#include <grapher.h>
Public Member Functions | |
| grapher (short int options=AXES_ON|GRID_ON|X_LIN|Y_LIN) | |
| Constructor. | |
Static Public Member Functions | |
| static int | initialize (int argc, char **argv, short int options=AXES_ON|GRID_ON|X_LIN|Y_LIN) |
| Initialize the grapher. | |
| static void | run () |
| Enter the OpenGL main loop after initialization. | |
| static void | redraw () |
| User-requested redraw. | |
| static void | add_curve (curve &c) |
| Add a curve to the plot. | |
| static void | delete_curve (curve &c) |
| Delete a curve from the plot. | |
| static void | add_point (point &p) |
| Add a point to the plot. | |
| static void | delete_point (point &p) |
| Delete a point from the plot. | |
| static void | set_keyboard_function (keyboard_function k) |
| Set up a keyboard event handler. | |
| static void | set_click_function (click_function c) |
| Set up a click event handler. | |
| static void | zoom (double scale) |
| Zoom in / out by a scale. | |
| static double | get_x_coord (GLint x) |
| Transform a screen x coordinate to a world one. | |
| static double | get_y_coord (GLint y) |
| Transform a screen y coordinate to a world one. |
| grapher::grapher | ( | short int | options = AXES_ON|GRID_ON|X_LIN|Y_LIN |
) |
Constructor.
| options | - startup options |
Warning: Thinking about depricating this function
| static void grapher::add_curve | ( | curve & | c | ) | [static] |
Add a curve to the plot.
| c | - The curve you wish to add to the plot |
| static void grapher::add_point | ( | point & | p | ) | [static] |
| static void grapher::delete_curve | ( | curve & | c | ) | [static] |
| static void grapher::delete_point | ( | point & | p | ) | [static] |
| static double grapher::get_x_coord | ( | GLint | x | ) | [static] |
Transform a screen x coordinate to a world one.
| x | - the screen x coordinate to transform |
| static double grapher::get_y_coord | ( | GLint | y | ) | [static] |
Transform a screen y coordinate to a world one.
| y | - the screen y coordinate to transform |
| static int grapher::initialize | ( | int | argc, | |
| char ** | argv, | |||
| short int | options = AXES_ON|GRID_ON|X_LIN|Y_LIN | |||
| ) | [static] |
Initialize the grapher.
| argc | - same as argc used for OpenGL initialization | |
| argv | - same as argv used for OpenGL initialization | |
| options | - startup options |
| static void grapher::redraw | ( | ) | [static] |
User-requested redraw.
If you create an event handler that will make some changes to the graph, you can make those changes and then request a redraw with this function.
| static void grapher::run | ( | ) | [static] |
Enter the OpenGL main loop after initialization.
In general, you will set up your event handlers, main code, etc., and then when you've gotten everything in place, you call grapher::run() to start the program's OpenGL portion.
| static void grapher::set_click_function | ( | click_function | c | ) | [static] |
Set up a click event handler.
| c | - the function you'd like to handle click events |
| static void grapher::set_keyboard_function | ( | keyboard_function | k | ) | [static] |
Set up a keyboard event handler.
| k | - the function you'd like to handle key events |
The idea behind this is that these default behaviors are not the programmer's responsibility to code up as well. They are interface freebies.
In future versions, these will be able to be disabled and enabled to suit the end user.
| static void grapher::zoom | ( | double | scale | ) | [static] |
Zoom in / out by a scale.
| scale | - the scale by which to zoom |


This is a multi-part message in MIME format.
Dear Jeff,You have an upcoming loan payment on 2014-07-23=
for $177.64 for your Prosper loan. No action is required on your part:=
the payment will be automatically deducted from your primary bank accou=
nt on file on 2014-07-23.Automatic payment date: 2014-07-23Paym=
ent amount: $177.64Bank account: , ****Please make sure that=
your bank account has sufficient funds to cover your payment. If insuff=
icient funds exist, you may be charged a failed payment fee by Prosper=
and an insufficient funds fee by your bank.Since the payment tran=
saction is initiated on the business day prior to the payment due date,=
any changes to your primary bank account must be completed two (2) busi=
ness days prior to the payment due date.Thank you for being a part=
of the Prosper community.Regards,Prosper
Dear Jeff,
You have an upcoming loan payment on=
2014-07-23 for $177.64 for your Prosper loan. No action is requ=
ired on your part: the payment will be automatically deducted=
from your primary bank account on file on 2014-07-23.
Automatic payment date: 2014-07-23
Payment=
amount: $177.64
Bank account: , ****=
strong>
Please make sure that your bank account has suf=
ficient funds to cover your payment. If insufficient funds exist, you=
may be charged a failed payment fee by Prosper and an insufficient fund=
s fee by your bank.
Since the payment transaction is=
initiated on the business day prior to the payment due date, any change=
s to your primary bank account must be completed two (2) business days=
prior to the payment due date.
Thank you for being a=
part of the Prosper community.
Regards,
Prospe=
r


--- layout: post title: Creating a Toolkit for Live Incident Response Data Acquisition and Tips for Better Timeline Analysis ---
Creating a Toolkit for Live Incident Response Data
Here are the slides from last Thursdays presentation. Source code for the LR script to follow shortly.


Special Promo!
Limited 5 tickets at $200
Contact us for more detail
Special Promo!
Limited 3 tickets at $300
Contact us for more detail
Special Promo!
Limited 3 tickets at $280
Contact us for more detail
OttoAir provides the cheapest flight ticket between Canada and China. Airplane tickets are often bundled with unnecessary services to inflate ticket price. OttoAir dedicates ourselves to remove such costs from undesired services so travelers only pay for what’s truly important.
A major cost hiding in plane tickets is luggage transportation. Due to the high demand from large e-commerce organizations (such as Amazon and Walmart) for fast international shipping, OttoAir is able to provide a platform for them to send gifts as Ottopackages via our travellers. In turn, OttoAir can help reimburse our travellers’ unused luggage space with greatly reduced traveling expenses.
OttoPackages only contains gifts from popular e-commerce sites. These packages are sent from UPS, FedEx, DHL, Canada Post, and other TSA certified shipping companies. As a traveler with us, you will save up to 50% of your ticket price by carrying OttoPackages. Read more about our detailed service procedure here.
Items
Shipments
Average Savings
FlowerOnDFence
They really gives heavy discount on plane tickets. Unbelievable
XuanZe_1993
Absolutely amazing. Fast service, too nice a delivery guy. I am trying their half-priced plane tickets next time
SpeedStar
Didn't expect much, turns out to be a great surprise
Stupa
Fast, safe, and convenient
1-647-739-9986


A passionate problem-solver who uses methodical approaches to extract meaningful results, which enable informed decisions, and fosters collaboration to create solutions not just for today, but for tomorrow’s possibilities.
Portfolio
Skills
Python(Pandas, Sklearn, NumPy)
Predictive Modeling(Classification, Regression)
Data Visualizations (Tableau, Matplotlib, Seaborn)
Statistical Analysis
SQL
Git & Github
Microsoft Excel
Data Cleaning
Terrorism Analyzed with Bayesian Inference
This project focuses on using Bayesian inference to test the populations of terrorism. The dataset contained all terrorist attacks from 1970. After some exploratory analysis comparing the number of attacks across different regions, I decided to focus the regions with the least number of attacks. After analyzing the countries in those regions, I narrowed my focus on Japan and China the largest economic countries in the region. By using Bayesian inference with a Monty Carlo Markov Chain I was able to recreate the populations to test the statistical difference. This would let me know wether there is a difference in the number of attacks between the countries.
The goal of this project was to find the best location to open a liquor store in the state of Iowa. The dataset contains sale transactions from the state distributor to local stores. Using number of bottles sold to each store as an indicator of demand. The location with the highest number of bottles sold will be the best locations to open a liquor store. Starting at the county level then zip code level we found the best locations to be those in zip codes 50314, 50317 and 50265.
This project used bayesian inference along with Monty Carlo Markov Chains to test the effectiveness of the broken windows policing policy. The original dataset from the US Census Bureau contains crime rates by county. By separating the time period before and after the implementation of the policy we can recreate the populations they derived and compare the two populations. Using the difference of means we can see that there was not a drastic difference in the populations. Although the policy did have an effect it wasn't the major contributor to the fall in crime rates in NYC.
With this project I created a database of tables containing customer information, billing information and payment information. Using SQL commands I manipulated the data to display the targeted information to later predict default status of customers.
This piece was practicing model tuning and evaluation. The data set contained car information relating to chance of being purchased. Using several classification models and the use of Bagging and Grid Search to improve model performance.