|
TensorRT
<IP_ADDRESS>
|
Plugin class for user-implemented layers. More...
#include <NvInferRuntimeCommon.h>
Public Member Functions | |
| virtual nvinfer1::DataType | getOutputDataType (int index, const nvinfer1::DataType *inputTypes, int nbInputs) const =0 |
| Return the DataType of the plugin output at the requested index. The default behavior should be to return the type of the first input, or DataType::kFLOAT if the layer has no inputs. The returned data type must have a format that is supported by the plugin. More... | |
| virtual bool | isOutputBroadcastAcrossBatch (int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const =0 |
| Return true if output tensor is broadcast across a batch. More... | |
| virtual bool | canBroadcastInputAcrossBatch (int inputIndex) const =0 |
| Return true if plugin can use input that is broadcast across batch without replication. More... | |
| virtual void | configurePlugin (const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, const bool *outputIsBroadcast, PluginFormat floatFormat, int maxBatchSize)=0 |
| Configure the layer with input and output data types. More... | |
| virtual void | attachToContext (cudnnContext *, cublasContext *, IGpuAllocator *) |
| Attach the plugin object to an execution context and grant the plugin the access to some context resource. More... | |
| virtual void | detachFromContext () |
| Detach the plugin object from its execution context. More... | |
| virtual IPluginV2Ext * | clone () const _TENSORRT_OVERRIDE=0 |
| Clone the plugin object. This copies over internal plugin parameters as well and returns a new plugin object with these parameters. If the source plugin is pre-configured with configurePlugin(), the returned object should also be pre-configured. The returned object should allow attachToContext() with a new execution context. Cloned plugin objects can share the same per-engine immutable resource (e.g. weights) with the source object (e.g. via ref-counting) to avoid duplication. | |
| Public Member Functions inherited from nvinfer1::IPluginV2 | |
| virtual const char * | getPluginType () const =0 |
| Return the plugin type. Should match the plugin name returned by the corresponding plugin creator. | |
| virtual const char * | getPluginVersion () const =0 |
| Return the plugin version. Should match the plugin version returned by the corresponding plugin creator. | |
| virtual int | getNbOutputs () const =0 |
| Get the number of outputs from the layer. More... | |
| virtual Dims | getOutputDimensions (int index, const Dims *inputs, int nbInputDims)=0 |
| Get the dimension of an output tensor. More... | |
| virtual bool | supportsFormat (DataType type, PluginFormat format) const =0 |
| Check format support. More... | |
| virtual int | initialize ()=0 |
| Initialize the layer for execution. This is called when the engine is created. More... | |
| virtual void | terminate ()=0 |
| Release resources acquired during plugin layer initialization. This is called when the engine is destroyed. More... | |
| virtual size_t | getWorkspaceSize (int maxBatchSize) const =0 |
| Find the workspace size required by the layer. More... | |
| virtual int | enqueue (int batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream)=0 |
| Execute the layer. More... | |
| virtual size_t | getSerializationSize () const =0 |
| Find the size of the serialization buffer required. More... | |
| virtual void | serialize (void *buffer) const =0 |
| Serialize the layer. More... | |
| virtual void | destroy ()=0 |
| Destroy the plugin object. This will be called when the network, builder or engine is destroyed. | |
| virtual void | setPluginNamespace (const char *pluginNamespace)=0 |
| Set the namespace that this plugin object belongs to. Ideally, all plugin objects from the same plugin library should have the same namespace. | |
| virtual const char * | getPluginNamespace () const =0 |
| Return the namespace of the plugin object. | |
Protected Member Functions | |
| int | getTensorRTVersion () const _TENSORRT_OVERRIDE |
| Return the API version with which this plugin was built. The upper byte reserved by TensorRT and is used to differentiate this from IPlguinV2. More... | |
| void | configureWithFormat (const Dims *, int, const Dims *, int, DataType, PluginFormat, int) _TENSORRT_OVERRIDE |
| Derived classes should not implement this. In a C++11 API it would be override final. | |
Plugin class for user-implemented layers.
Plugins are a mechanism for applications to implement custom layers. This interface provides additional capabilities to the IPluginV2 interface by supporting different output data types and broadcast across batch.
|
inlinevirtual |
Attach the plugin object to an execution context and grant the plugin the access to some context resource.
| cudnn | The cudnn context handle of the execution context |
| cublas | The cublas context handle of the execution context |
| allocator | The allocator used by the execution context |
This function is called automatically for each plugin when a new execution context is created. If the plugin needs per-context resource, it can be allocated here. The plugin can also get context-owned CUDNN and CUBLAS context here.
|
pure virtual |
Return true if plugin can use input that is broadcast across batch without replication.
| inputIndex | Index of input that could be broadcast. |
For each input whose tensor is semantically broadcast across a batch, TensorRT calls this method before calling configurePlugin. If canBroadcastInputAcrossBatch returns true, TensorRT will not replicate the input tensor; i.e., there will be a single copy that the plugin should share across the batch. If it returns false, TensorRT will replicate the input tensor so that it appears like a non-broadcasted tensor.
This method is called only for inputs that can be broadcast.
Implemented in nvinfer1::IPluginV2DynamicExt.
|
pure virtual |
Configure the layer with input and output data types.
This function is called by the builder prior to initialize(). It provides an opportunity for the layer to make algorithm choices on the basis of its weights, dimensions, data types and maximum batch size.
| inputDims | The input tensor dimensions. |
| nbInputs | The number of inputs. |
| outputDims | The output tensor dimensions. |
| nbOutputs | The number of outputs. |
| inputTypes | The data types selected for the plugin inputs. |
| outputTypes | The data types selected for the plugin outputs. |
| inputIsBroadcast | True for each input that the plugin must broadcast across the batch. |
| outputIsBroadcast | True for each output that TensorRT will broadcast across the batch. |
| floatFormat | The format selected for the engine for the floating point inputs/outputs. |
| maxBatchSize | The maximum batch size. |
The dimensions passed here do not include the outermost batch size (i.e. for 2-D image networks, they will be 3-dimensional CHW dimensions). When inputIsBroadcast or outputIsBroadcast is true, the outermost batch size for that input or output should be treated as if it is one. inputIsBroadcast[i] is true only if the input is semantically broadcast across the batch and canBroadcastInputAcrossBatch(i) returned true. outputIsBroadcast[i] is true only if isOutputBroadcastAcrossBatch(i) returned true.
Implemented in nvinfer1::IPluginV2IOExt, and nvinfer1::IPluginV2DynamicExt.
|
inlinevirtual |
Detach the plugin object from its execution context.
This function is called automatically for each plugin when a execution context is destroyed. If the plugin owns per-context resource, it can be released here.
|
pure virtual |
Return the DataType of the plugin output at the requested index. The default behavior should be to return the type of the first input, or DataType::kFLOAT if the layer has no inputs. The returned data type must have a format that is supported by the plugin.
|
inlineprotectedvirtual |
Return the API version with which this plugin was built. The upper byte reserved by TensorRT and is used to differentiate this from IPlguinV2.
Do not override this method as it is used by the TensorRT library to maintain backwards-compatibility with plugins.
Reimplemented from nvinfer1::IPluginV2.
Reimplemented in nvinfer1::IPluginV2IOExt.
|
pure virtual |
Return true if output tensor is broadcast across a batch.
| outputIndex | The index of the output |
| inputIsBroadcasted | The ith element is true if the tensor for the ith input is broadcast across a batch. |
| nbInputs | The number of inputs |
The values in inputIsBroadcasted refer to broadcasting at the semantic level, i.e. are unaffected by whether method canBroadcastInputAcrossBatch requests physical replication of the values.
Implemented in nvinfer1::IPluginV2DynamicExt.


{% extends "blog/layout.html" %} {% block content %}
I have over 12 years of experience in the ICT sector and previously held multiple positions in Zimbabwe and globally. I received a BSc (Hons.) in Computer Science from Midlands State University and an MSc in Strategic Management from Chinhoyi University.
Since 2015 I have focused on Python/Django development and have been very active in the community as a conference speaker, Django Girls Trustee, and member of the DSF’s Code of Conduct Committee. Since 2018 I have served on the DSF Board and held the position of Vice President (2019-2020) and currently President (2020-present).
I am the lead maintainer of the open source Django Girls repo where I write code, update documentation, review pull requests, and maintain the server. Recent work includes updating the project from Django 2.0 to 3.2 in stages and improving the layout.
In 2019, I worked for BriteCore where I wrote tests to increase the test coverage for the BriteCore software packages, developed internal tools and APIs and conducted research for the BriteCore platform. I also reviewed pull requests for my team members, contributed to internal documentation and attended to client tickets.
Projects I have worked on independently include an activity generator API that suggests activities one can do when they are bored; and an XML to HTML convertor that converts DMARC reports which are in XML format to HTML to make them human-readable. I am currently working on a library management system and a conveyances system for fun.


Instructions
Figure out which squares are rock or lava. Numbers indicate a run of rocks in each row or column. Check your progress with the 'check' button. Standard nonogram / picross rules.
Credits
Concept, code and game by Josh Marinacci
Music:
Dark Waves
by Xenojam,
Short Composition 1
by neizvestnost,
Sound Effects:
Drum
by Julien Matthey,
Dark Texture 3
by Dneproman,
Dark Movement 3
by fons,
PVC pipe hit
by LloydEvans09,
Dark Evil Piano
by memz,
Font:
Hobby Of Night
by deFharo
3D Models:
Low Poly Rocks Pack
by MrCraft Animation
Learn more at
vr.josh.earth
close
Lava Flow
credits & instructions
loading
click to play


| HYTOOL Function Reference |
Internal script used to generate the help files for hytool.
mkhelp( option1, option2, option3 ) options can be: 'html', 'demo', 'search'
Build some components of the html help files. Warning: do not use unless you are one of the hytool developpers!
mkhtml, mkdemo Published output in the Help browser showdemo mkhelp
| Hytool |
© 1998-2017 Philppe Renard and Co. Terms of Use Acknowledgments


DESTINATION
Situated in Nusa Lembongan, a few steps from Dream Beach, Pancali Cottages features accommodation with a restaurant, free private parking, an outdoor swimming pool and a garden. Boasting room service, this property also provides guests with a terrace. The air-conditioned rooms provide pool view and come with a desk and free WiFi. At the guest house, rooms include a balcony. Featuring a private bathroom with a shower and free toiletries, rooms at Pancali Cottages also boast a garden view. The rooms will provide guests with a wardrobe and a kettle. The accommodation offers a continental or à la carte breakfast. Popular points of interest near Pancali Cottages include Sandy Bay Beach, Mushroom Bay and Devil's Tear. The nearest airport is Ngurah Rai International, 88 km from the guest house, and the property offers a paid airport shuttle service.


Update a Relationship
Member Name
Relative Name
Relation
Member name
Relative
Relation
{{res.member_name}}
{{res.relative}}
{{res.relationship}}


Aram's Notes
Intro to Programing Nano Degree.
Major Pieces of the Web
Computer Brower <-----> The Internet <----> Servers
HTML
Stands for Hyper Text Markup Language
HTML is made out of:
- Text content- what you see
- Mark up- what it looks like
- Reference to other documents
- Links to other pages
HTML markup consists of an opening and closing tag and the whole thing is called an element.
This video has a great explanation
Some tags do not need an end tag. the img and break tag do not need an end tag for example.
Thare are also two types of container elements: Blocks which form an invisible box around the content and inline.


Ketan Corporation (Hindalco - Authorised Stockist)
M/s Ketan Corporation was established in the year 1976.
Ketan Corporation is Authorised Stockist for Flat Rolled Products for M/S. HINDALCO Industries Ltd. Hindalco’s aluminium rolled products is a prime source for all major brands and are used in a multitude of industrial segments.
We are the leading trader, wholesaler, distributor and supplier of Aluminum Sheet, Aluminum Coil, Aluminium Plate, Aluminum Flooring Sheets, Aluminium Checkered Sheet , Pure Aluminum Circles, Aluminium Stucco Coil, Aluminium Extrusions, Aluminium Heat Sinks etc.
We are in constant touch with different industries in order to understand the specifications and needs of our customers. With our wide network and an excellent infrastructure we can fulfill customer requirements. We act as a liaison between Manufacturers and Suppliers in order to serve our customer satisfactorily. We can supply aluminium material in any non-standard length and width as required by the customers.
Our goal is to maintain and build customer relation by providing world class customer service by delivering Quality goods in Time. We work with our customer's schedules and requirements and work hand in glove with their accurate planning. With products and services meeting and even exceeding customer expectations, the company continues to grow and spread its wings.
Ensuring of great quality with the delivery of best service by which we would not hesitate to tell that Quality is never an accident; it is always the result of high intention, sincere effort, intelligent direction and skilful execution; it represents the wise choice of many alternatives.
We have more than 40 years of vast experience in the field of Aluminium and during this tenure we have garnered a wide client Base.
Our fair pricing policies coupled with customer friendly payment modes have made us the most preferred supplier.
Under the direction of our mentor “Lalbhai Shah”, we have achieved a valuable place in this industry.
FACTSHEET
Basic Information
Nature of Business
Authorised Wholesale Dealer
Additional Business
Wholesaler, Trader, Retailer, Distributor
Year of Establishmen
1976
Ownership Type
Partnership
Company USP
Primary Competitive Advantage
Large Product Line
Good Financial Position & TQM
Payment and Shipment Details
Payment Mode
Cash
LC
Cheque
Online
Shipment Mode
By Road
OUR VENDOR BASE
Owing to the support of our vendor’s dedicated and hardworking team of procuring agent, we have been able to provide supreme grade products. These vendors are selected on the basis of their manufacturing process, industry experience, premium quality products, timely delivery, past record, economic position, market reputation, etc. In order to deliver defect free range at users’ premises, these products are stringently verified against numerous measures.
Contact
REACH US
Sales Office Address:
Room No. 4 & 5, Ground Floor, B.M.E. House, 88/90, Kika Street, Gulalwadi, Mumbai-400004, Maharashtra, India
CONTACT US
<EMAIL_ADDRESS>Mobile:Naitik Shah : +91-9821868586 Ketan Vakharia : +91-9320426376Lalbhai Shah : +91-9321122011
Phone: +91-22-66362376 +91-22-22426376
Fax: +91-22-22426376
Tell Us What You Are Looking For?


Many people know what a line is, and many more can draw them using slope. But I've noticed that when trying to
draw a line using only the origin and end points, people stumble and fall.
The question is quite simple: How can I draw something without a concrete x and y coordinate?
The answer is also simple: You find them.
Let us imagine you wish to move an object from the origin point (0,0) to a certain end point (8,20). Well, a human would simply realize that (8, 20) translates into a slope of 2/5 (2 up, 5 right) and draw the line accordingly. Unfortunatly, a computer doesn't possess a ruler with which to draw the line. So the person is forced to tell the computer every single point the line goes through. This is done quite easily. In this example, we are moving up and over. So, we already have the Y coordinates. They are points 1 through 20.
But how to get X? It's easy, X is a function of Y. Like so: X=(X1/Y1)*Y
To get a better idea:
X=
X1 * Y
__Y1
In this equation, X1 is 8 (the target point's X coordinate) and Y1 is 20 (the target point's Y coordinate). As for Y, simply substitute 1 through 20 to get the X coordinates for it.
The program sample would look like this:
1 2 3 4 5 6 7 8 9 10 11
|
float X1=8, Y1=20;
float x[20], y[20];
for (int i=1; i<21; i++)
{
y<i>=i;
x<i>=(X1/Y1)*y<i>;
}
for (int i=1; i<21; i++)
{
cout<<"y["<<i<<"]="<<y<i><<" x["<<i<<"]="<<x<i><<endl;
}
| |
Which creates the following output:
y[1]=1 x[1]=0.4
y[2]=2 x[2]=0.8
y[3]=3 x[3]=1.2
y[4]=4 x[4]=1.6
y[5]=5 x[5]=2
y[6]=6 x[6]=2.4
y[7]=7 x[7]=2.8
y[8]=8 x[8]=3.2
y[9]=9 x[9]=3.6
y[10]=10 x[10]=4
y[11]=11 x[11]=4.4
y[12]=12 x[12]=4.8
y[13]=13 x[13]=5.2
y[14]=14 x[14]=5.6
y[15]=15 x[15]=6
y[16]=16 x[16]=6.4
y[17]=17 x[17]=6.8
y[18]=18 x[18]=7.2
y[19]=19 x[19]=7.6
y[20]=20 x[20]=8
|


Vikings erase 20-point deficit to stun Broncos
MINNEAPOLIS – The Minnesota Vikings had barely moved the ball at all, when they gathered in a humbled locker room after an awful first half.
Picking up the pace with the two-minute offense was about their only hope of a comeback. They delivered one in stunning fashion against the Denver Broncos.
“Suddenly, it just has a different feel to it, and the next thing you know, you’re going,” quarterback Kirk Cousins said.
The Vikings erased a 20-0 halftime deficit with touchdowns on each of their four drives in the second half, fending off the Broncos by forcing three straight incomplete passes in the end zone over the final 10 seconds to preserve a 27-23 victory Sunday.
This was the first time in five years — a span of 100 games including the playoffs — that an NFL team won after trailing by 20 or more points at halftime, though New England did defeat Atlanta in Super Bowl 51 after an 18-point deficit after two quarters grew to 28-3.
“We can’t count ourselves out. We had 30 minutes of football. Was it going to take perfect football? Most likely,” tight end Kyle Rudolph said. “But all we can go out there and do is worry about the first drive, and getting points, and see what happens.”
Cousins went 29-for-35 for 319 yards and three scores for the Vikings (8-3), overcoming a system-wide failure in the first half that included a lost fumble of his during a sack that led to one of three field goals by Brandon McManus for the Broncos (3-7).
Cousins hit Stefon Diggs for a 54-yard touchdown pass that brought the crowd noise to a deafening level and cut the lead to 23-20. McManus went wide right from 41 yards on his fourth attempt, and Cousins found Rudolph wide open for a 32-yard score on the next possession with 6:10 left.
“I like when adversity hits and you see what kind of guys you’ve got,” Diggs said.
Both of those throws by Cousins came off bootleg rollouts to his left, the type of passing play he has long thrived on. After being stymied for just 47 total yards in the first half, the Vikings turned to their hurry-up offense with enviable results.
“Throwing an interception into double coverage is not going to get you back in the game,” Cousins said. “So you take what they give you. You play one play at a time, and you trust that if they give you a shot, you take it.”
Brandon Allen, the fill-in quarterback after the injury to Joe Flacco and the impending debut of rookie Drew Lock, drove the Broncos to the cusp of a comeback of their own with a drive that included three fourth-down conversions.
With 1st-and-goal from the 4-yard line, but only 10 seconds left and no timeouts remaining, Allen had three chances at the winner. Trae Waynes knocked down the first one, Jayron Kearse had a hand on the second and the last try for Noah Fant sailed past the rookie tight end after he and Kearse tussled for position.
The Broncos have not scored a touchdown in the fourth quarter for six straight games. The last team guilty of such a severe second-half collapse was Atlanta on Oct. 26, 2014, when a 21-0 lead at home turned into a 22-21 victory for Detroit. According to Sportradar, this was only the 14th time in NFL history that a 20-plus-point halftime deficit turned into defeat.
“Didn’t sustain any drives,” Allen said, “and that put our defense in a bad spot.”
Ravens 41, Texans 7
In Baltimore, Lamar Jackson threw four touchdown passes, ran for 86 yards and helped Baltimore roll to its sixth straight victory.
The game was billed as a matchup between first-place AFC teams and two of the best double-threat quarterbacks in the NFL.
Jackson and the Baltimore defense made it a one-sided affair, and the Ravens (8-2) are riding their longest winning streak since a seven-game run in 2000, their first Super Bowl season.
Patriots 17, Eagles 10
In Philadelphia, Julian Edelman threw a go-ahead 15-yard touchdown pass to Phillip Dorsett and New England rallied for a victory over the Eagles.
Tom Brady threw for 216 yards, leading New England (9-1) back from a 10-0 deficit, but it was Edelman, the Patriots’ wide receiver, who found a target in the end zone. The Pats defense sacked Carson Wentz five times and forced one turnover.
49ers 36, Cardinals 26
In Santa Clara, California, Jimmy Garoppolo threw a 25-yard touchdown pass to Jeff Wilson Jr. with 31 seconds left for his fourth TD pass of the game and the 49ers rallied for a victory over Arizona.
Garoppolo connected with Wilson over the middle for the go-ahead score one play after the Niners (9-1) narrowly converted on a third-and-3 pass that went to replay review.
Instead of being ruled short and having to decide whether to kick a tying field goal or go for it on fourth down, San Francisco had a new set of downs and took advantage on Wilson’s first career touchdown catch.
Saints 34, Buccaneers 17
In Tampa, Drew Brees threw for 228 yards and three touchdowns to lead New Orleans over the Buccaneers.
The NFC South leaders (8-2) rebounded from a 26-9 loss to struggling Atlanta, with NFL receptions leader Michael Thomas becoming the first player in league history with 90-plus catches in the first 10 games of a season and Brees tossing TD passes of 16 yards to Thomas, 3 yards to Jared Cook and 6 yards to Ted Ginn Jr. after being held out of the end zone by the Falcons.
In Other Games
Cowboys 35, Lions 27
Colts 33, Jaguars 13
Bills 37, Dolphins 20
Falcons 29, Panthers 3
Jets 34, Redskins 17
Raiders 17, Bengals 10
GET THE BEST OF THE JAPAN TIMES
IN FIVE EASY PIECES WITH TAKE 5
JOIN THE CONVERSATION


Before Change
poly = polynomials.decompose(poly)
cache = {}
if len(freeze.shape) == 1:
out = _E_cond(poly, freeze, dist, cache, **kws)
else:
out = polynomials.concatenate([
_E_cond(poly, freeze_, dist, cache, **kws)[numpy.newaxis]
for freeze_ in freeze
])
if out.isconstant():
out = out.tonumpy()
return out
After Change
return polynomials.sum(frozen, 0)
// Remove frozen coefficients, such that poly == sum(frozen*unfrozen) holds
for key in unfrozen.keys:
unfrozen[key] = unfrozen[key] != 0
return polynomials.sum(frozen*E(unfrozen, dist), 0)


|
UQTk: Uncertainty Quantification Toolkit 3.1.3
|
#include <RefPtr.h>
Public Types | |
| typedef T | Type |
| Make the typename that this pointer holds accessible to other objects. More... | |
Public Member Functions | |
| RefPtr () | |
| Construct a new RefPtr and initialize the pointee to NULL. More... | |
| RefPtr (T *p) | |
| Construct a new RefPtr and initialize the pointee as given. More... | |
| RefPtr (const RefPtr< T > &p) | |
| Construct a new RefPtr and initialize to the given RefPtr pointee. More... | |
| template<class Other > | |
| RefPtr (RefPtr< Other > p) | |
| ~RefPtr () | |
| Destroy this RefPtr. More... | |
| RefPtr< T > & | operator= (T *p) |
| Assign the value of this RefPtr to the given pointee. More... | |
| RefPtr< T > & | operator= (const RefPtr< T > &p) |
| Assign the value of this RefPtr to the pointee of the given RefPtr. More... | |
| template<class Other > | |
| RefPtr< T > & | cast (Other *p) |
| template<class Other > | |
| RefPtr< T > & | cast (RefPtr< Other > p) |
| T * | operator-> () const |
| T & | operator* () const |
| T * | pointee () |
| Return the pointee of this RefPtr. More... | |
| const T * | pointee () const |
| Return the pointee of this RefPtr in a const context. More... | |
| bool | operator== (const T *p) const |
| Compare the pointee of this RefPtr with the given pointer. More... | |
| bool | operator== (const RefPtr< T > &p) const |
| Compare the value of this pointee with the pointee of the given RefPtr. More... | |
| bool | operator!= (const T *p) const |
| Test inequality. More... | |
| bool | operator!= (const RefPtr< T > &p) const |
| Test inequality. More... | |
| bool | operator< (const RefPtr< T > &p) const |
| Convenience routine to sort pointer values in standard containers. More... | |
| template<class Other > | |
| bool | operator< (const RefPtr< Other > &p) const |
| Convenience routine to sort pointer values in standard containers. More... | |
Private Member Functions | |
| void | grab () |
| Grab a reference to the current pointee if it is not NULL. More... | |
| void | release () |
Private Attributes | |
| T * | ptr_ |
Reference counted pointer that gives the holder modification privileges to the pointee.
Part of the Particle Simulation Toolkit (pst)
| typedef T RefPtr< T >::Type |
Make the typename that this pointer holds accessible to other objects.
Construct a new RefPtr and initialize the pointee to NULL.
Construct a new RefPtr and initialize the pointee as given.
Perform a static cast to initialize this pointee. This cast is only valid if T is a parent class of Other
Use dynamic_cast to set the pointee to the pointer that was passed in, and return *this. The returned value is NULL if the cast fails.
|
inline |
Use dynamic_cast to set the pointee to the pointee of the RefPtr given, and return *this. The returned value is NULL if the cast fails.
|
inlineprivate |
Grab a reference to the current pointee if it is not NULL.
Test inequality.
|
inline |
Test inequality.
|
inline |
Return a reference to the pointee of this RefPtr. This will not work right if the pointee is NULL.
|
inline |
Return the pointee of this RefPtr. This will throw an exception if the pointee is NULL.
|
inline |
Convenience routine to sort pointer values in standard containers.
Convenience routine to sort pointer values in standard containers.
Assign the value of this RefPtr to the given pointee.
Compare the value of this pointee with the pointee of the given RefPtr.
|
inline |
Compare the pointee of this RefPtr with the given pointer.
|
inline |
Return the pointee of this RefPtr in a const context.
|
inlineprivate |
Release the reference to the current pointee if it is not NULL. If this results in the reference count of the pointee dropping to zero, delete the object pointed to.
|
private |


Library: Crypto
Package: RSA
Header: Poco/Crypto/RSAKeyImpl.h
Description
class RSAKeyImpl
Inheritance
Direct Base Classes: Poco::RefCountedObject
All Base Classes: Poco::RefCountedObject
Member Summary
Member Functions: decryptionExponent, encryptionExponent, getRSA, modulus, save, size
Inherited Functions: duplicate, referenceCount, release
Types
ByteVec
typedef std::vector < unsigned char > ByteVec;
Ptr
typedef Poco::AutoPtr < RSAKeyImpl > Ptr;
Constructors
RSAKeyImpl
explicit RSAKeyImpl(
const X509Certificate & cert
);
Extracts the RSA public key from the given certificate.
RSAKeyImpl
RSAKeyImpl(
int keyLength,
unsigned long exponent
);
Creates the RSAKey. Creates a new public/private keypair using the given parameters. Can be used to sign data and verify signatures.
RSAKeyImpl
RSAKeyImpl(
const std::string & publicKeyFile,
const std::string & privateKeyFile,
const std::string & privateKeyPassphrase
);
Creates the RSAKey, by reading public and private key from the given files and using the given passphrase for the private key. Can only by used for signing if a private key is available.
RSAKeyImpl
RSAKeyImpl(
std::istream * pPublicKeyStream,
std::istream * pPrivateKeyStream,
const std::string & privateKeyPassphrase
);
Creates the RSAKey. Can only by used for signing if pPrivKey is not null. If a private key file is specified, you don't need to specify a public key file. OpenSSL will auto-create it from the private key.
Destructor
~RSAKeyImpl
~RSAKeyImpl();
Destroys the RSAKeyImpl.
Member Functions
decryptionExponent
ByteVec decryptionExponent() const;
Returns the RSA decryption exponent.
encryptionExponent
ByteVec encryptionExponent() const;
Returns the RSA encryption exponent.
getRSA
RSA * getRSA();
Returns the OpenSSL RSA object.
getRSA
const RSA * getRSA() const;
Returns the OpenSSL RSA object.
modulus
ByteVec modulus() const;
Returns the RSA modulus.
save
void save(
const std::string & publicKeyFile,
const std::string & privateKeyFile = "",
const std::string & privateKeyPassphrase = ""
);
Exports the public and private keys to the given files.
If an empty filename is specified, the corresponding key is not exported.
save
void save(
std::ostream * pPublicKeyStream,
std::ostream * pPrivateKeyStream = 0,
const std::string & privateKeyPassphrase = ""
);
Exports the public and private key to the given streams.
If a null pointer is passed for a stream, the corresponding key is not exported.
size
int size() const;
Returns the RSA modulus size.


Main
Link
Dialog Title
Random button
×
Other target
Open
Main
Link
Dialog Title
Other target
Main
Link
Dialog Title
Other target
Main
Link
Dialog Title
Other target
Open
Main
Link
Dialog Title
Other target
Open


[gecode-users] initial domain of Golomb ruler problem
Christian Schulte
cschulte at kth.se
Mon Aug 29 12:10:57 CEST 2011
Yes, you are right! Fixed in the trunk.
Thanks
Christian
--
Christian Schulte, www.ict.kth.se/~cschulte/
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of ??
Sent: Monday, August 29, 2011 11:41 AM
To: users at gecode.org
Subject: [gecode-users] initial domain of Golomb ruler problem
Dear all,
The initial domain of the Golomn ruler problem is set to be [(1 <<
(opt.size()+1))-1], while I think it should be [(1 << (opt.size()-1))-1].
Can someone help make sure?
Thanks!
Weii.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.gecode.org/pipermail/users/attachments/20110829/3d030b2f/attachment.htm>
More information about the users
mailing list


The Timeline is an interactive visualization chart to visualize data in time. The data items can take place on a single date, or have a start and end date (a range). You can freely move and zoom in the timeline by dragging and scrolling in the Timeline. Items can be created, edited, and deleted in the timeline. The time scale on the axis is adjusted automatically, and supports scales ranging from milliseconds to years.
Timeline uses regular HTML DOM to render the timeline and items put on the timeline. This allows for flexible customization using css styling.
The following code shows how to create a Timeline and provide it with data. More examples can be found in the timeline examples page.
<!DOCTYPE HTML>   <title>Timeline | Basic demo</title>   <link href="../../dist/vis-timeline-graph2d.min.css" rel="stylesheet" type="text/css" />

Install or download the vis.js library in a subfolder of your project. Include the library's script and css files in the head of your html code:
 <link href="vis/dist/vis-timeline-graph2d.min.css" rel="stylesheet" type="text/css" />The constructor of the Timeline is
vis.Timeline
var timeline = new vis.Timeline(container, items, options);or when using groups:
var timeline = new vis.Timeline(container, items, groups, options);The constructor accepts four parameters:
container
is the DOM element in which to create the timeline.
items
is an Array containing items. The properties of an
item are described in section Data Format, items.
groups
is an Array containing groups. The properties of a
group are described in section Data Format, groups.
options
is an optional Object containing a name-value map
with options. Options can also be set using the method
setOptions
.
The timeline can be provided with two types of data:
For items, the Timeline accepts an Array, a DataSet (offering 2 way data binding),
or a DataView (offering 1 way data binding).
Items are regular objects and can contain the properties start
,
end
(optional), content
,
group
(optional), className
(optional),
editable
(optional), and style
(optional).
A DataSet is constructed as:
var items = new vis.DataSet([ { start: new Date(2010, 7, 15), end: new Date(2010, 8, 2), // end is optional content: 'Trajectory A' // Optional: fields 'id', 'type', 'group', 'className', 'style' } // more items... ]);
The item properties are defined as:
| Name | Type | Required | Description |
|---|---|---|---|
| className | String | no | This field is optional. A className can be used to give items
an individual css style. For example, when an item has className
'red', one can define a css style like:
.vis-item.red { color: white; background-color: red; border-color: darkred; }More details on how to style items can be found in the section Styles. |
| align | String | no | This field is optional. If set this overrides the global align configuration option for this item.
|
| content | String | yes | The contents of the item. This can be plain text or html code. |
| end | Date or number or string or Moment | no | The end date of the item. The end date is optional, and can be left null .
If end date is provided, the item is displayed as a range.
If not, the item is displayed as a box. |
| group | any type | no | This field is optional. When the group column is provided,
all items with the same group are placed on one line.
A vertical axis is displayed showing the groups.
Grouping items can be useful for example when showing availability of multiple
people, rooms, or other resources next to each other. |
| id | String or Number | no | An id for the item. Using an id is not required but highly recommended. An id is needed when dynamically adding, updating, and removing items in a DataSet. |
| selectable | Boolean | no | Ability to enable/disable selectability for specific items.
Defaults to true . Does not override the timeline's
selectable configuration option.
|
| start | Date or number or string or Moment | yes | The start date of the item, for example new Date(2010,9,23) . |
| style | String | no |
A css text string to apply custom styling for an individual item, for
example "color: red; background-color: pink;" .
|
| subgroup | String or Number | none | The id of a subgroup.
Groups all items within a group per subgroup, and positions them on the
same height instead of staking them on top of each other. can be ordered
by specifying the option subgroupOrder of a group.
|
| title | String | none | Add a title for the item, displayed when holding the mouse on the item. The title can be an HTML element or a string containing plain text or HTML. |
| type | String | no | The type of the item. Can be 'box' (default), 'point', 'range', or 'background'. Types 'box' and 'point' need a start date, the types 'range' and 'background' needs both a start and end date. |
| limitSize | Boolean | no | Some browsers cannot handle very large DIVs so by default range DIVs can be truncated outside the visible area.
Setting this to false will cause the creation of full-size DIVs.
|
| editable | Boolean or Object | no | Override the editable option of the timeline for a specific item (assuming timeline.editable.overrideItems is false). |
| editable.remove | boolean | no | If true, item can be deleted by first selecting it, and then clicking the delete button on the top right of the item. See section Editing Items for a detailed explanation. |
| editable.updateGroup | boolean | no | If true, item can be dragged from one group to another. Only applicable when the Timeline has groups. See section Editing Items for a detailed explanation. |
| editable.updateTime | boolean | no | If true, items can be dragged to another moment in time. See section Editing Items for a detailed explanation. |
For the items, groups can be an Array, a DataSet (offering 2 way data binding),
or a DataView (offering 1 way data binding).
Using groups, items can be grouped together.
Items are filtered per group, and displayed as
Group items can contain the properties id
,
content
, and className
(optional).
Groups can be applied to a timeline using the method setGroups
or supplied in the constructor.
A table with groups can be created like:
var groups = [ { id: 1, content: 'Group 1' // Optional: a field 'className', 'style', 'order', [properties] } // more groups... ]);
Groups can have the following properties:
| Name | Type | Required | Description |
|---|---|---|---|
| className | String | no | This field is optional. A className can be used to give groups
an individual css style. For example, when a group has className
'red', one can define a css style
.red {
color: red;
}
.
More details on how to style groups can be found in the section
Styles.
|
| content | String or Element | yes | The contents of the group. This can be plain text, html code or an html element. |
| id | String or Number | yes | An id for the group. The group will display all items having a
property group which matches the id
of the group. |
| style | String | no |
A css text string to apply custom styling for an individual group label, for
example "color: red; background-color: pink;" .
|
| subgroupOrder | String or Function | none | Order the subgroups by a field name or custom sort function. By default, groups are ordered by first-come, first-show. |
| subgroupStack | Object or Boolean | none | Enables stacking within individual subgroups. Example: {'subgroup0': true, 'subgroup1': false, 'subgroup2': true}
For each subgroup where stacking is enabled, items will be stacked on top of each other within that subgroup such that they do no overlap.
If set to true all subgroups will be stacked.
If a value was specified for the order parameter in the options, that ordering will be used when stacking the items.
|
| subgroupVisibility | Object | none | Ability to hide/show specific subgroups. Example: {'hiddenSubgroup0': false, 'subgroup1': true, 'subgroup2': true}
If a subgroup is missing from the object, it will default as true (visible).
|
| title | String | none | A title for the group, displayed when holding the mouse on the groups label. The title can only contain plain text. |
| visible | Boolean | no | Provides a means to toggle the whether a group is displayed or not. Defaults to true . |
| nestedGroups | Array | no | Array of group ids nested in the group. Nested groups will appear under this nesting group. |
| showNested | Boolean | no | Assuming the group has nested groups, this will set the initial state of the group - shown or collapsed. The showNested is defaulted to true . |
Options can be used to customize the timeline. Options are defined as a JSON object. All options are optional.
var options = { width: '100%', height: '30px', margin: { item: 20 } };
The following options are available.
| Name | Type | Default | Description |
|---|---|---|---|
| align | String | 'center' |
Alignment of items with type 'box', 'range', and 'background'. Available values are 'auto' (default), 'center', 'left', or 'right'. For 'box' items, the 'auto' alignment is 'center'. For 'range' items, the auto alignment is dynamic: positioned left and shifted such that the contents is always visible on screen. |
| autoResize | boolean | true |
If true, the Timeline will automatically detect when its container is resized, and redraw itself accordingly. If false, the Timeline can be forced to repaint after its container has been resized using the function redraw() . |
| clickToUse | boolean | false |
When a Timeline is configured to be clickToUse , it will react to mouse and touch events only when active.
When active, a blue shadow border is displayed around the Timeline. The Timeline is set active by clicking on it, and is changed to inactive again by clicking outside the Timeline or by pressing the ESC key. |
| configure | boolean or function | false |
When true, a configurator is loaded where all configuration options of the Timeline can be changed live.
The displayed options can be filtered by providing a filter function. This function is invoked with two arguments: the current option and the path (an Array) of the option within the options object. The option will be displayed when the filter function returns true. For example to only display format options:
function (option, path) { return option === 'format' || path.indexOf('format') !== -1; } |
| dataAttributes | string[] or 'all' | false |
An array of fields optionally defined on the timeline items that will be appended as data- attributes to the DOM element of the items.If value is 'all' then each field defined on the timeline item will become a data- attribute. |
| editable | boolean or Object | false |
If true, the items in the timeline can be manipulated. Only applicable when option selectable is true . See also the callbacks onAdd , onUpdate , onMove , and onRemove . When editable is an object, one can enable or disable individual manipulation actions.
See section Editing Items for a detailed explanation.
|
| editable.add | boolean | false |
If true, new items can be created by double tapping an empty space in the Timeline. See section Editing Items for a detailed explanation. |
| editable.remove | boolean | false |
If true, items can be deleted by first selecting them, and then clicking the delete button on the top right of the item. See section Editing Items for a detailed explanation. |
| editable.updateGroup | boolean | false |
If true, items can be dragged from one group to another. Only applicable when the Timeline has groups. See section Editing Items for a detailed explanation. |
| editable.updateTime | boolean | false |
If true, items can be dragged to another moment in time. See section Editing Items for a detailed explanation. |
| editable.overrideItems | boolean | false |
If true, item specific editable properties are overridden by timeline settings |
| end | Date or Number or String or Moment | none | The initial end date for the axis of the timeline. If not provided, the latest date present in the items set is taken as end date. |
| format | Object or Function | none |
Apply custom date formatting of the labels on the time axis. The default value of format is:
{ minorLabels: { millisecond:'SSS', second: 's', minute: 'HH:mm', hour: 'HH:mm', weekday: 'ddd D', day: 'D', week: 'w', month: 'MMM', year: 'YYYY' }, majorLabels: { millisecond:'HH:mm:ss', second: 'D MMMM HH:mm', minute: 'ddd D MMMM', hour: 'ddd D MMMM', weekday: 'MMMM YYYY', day: 'MMMM YYYY', week: 'MMMM YYYY', month: 'YYYY', year: '' } }For values which not provided in the customized options.format , the default values will be used.
All available formatting syntax is described in the docs of moment.js.
You can also use a function format for each label. The function accepts as arguments the date, scale and step in that order, and expects to return a string for the label. function format({ minorLabels: Function(date: Date, scale: Number, step: Number), majorLabels: Function(date: Date, scale: Number, step: Number) } |
| groupEditable | boolean or Object | false |
If true, the groups in the timeline can be manipulated. See also the callbacks onAddGroup , onMoveGroup , and onRemoveGroup . When groupEditable is an object, one can enable or disable individual manipulation actions.
The editing of groups follows the same principles as for items, see section Editing Items for a detailed explanation.
|
| groupEditable.add | boolean | false |
If true, new groups can be created in the Timeline. For now adding new groups is done by the user. |
| groupEditable.remove | boolean | false |
If true, groups can be deleted. For now removing groups is done by the user. |
| groupEditable.order | boolean | false |
If true, groups can be dragged to change their order. Only applicable when the Timeline has groups. For this option to work properly the groupOrder and groupOrderSwap options have to be set as well. |
| groupHeightMode | String | 'auto' |
Specifies how the height of a group is calculated. Choose from 'auto','fixed', and 'fitItems'. If it is set to 'auto' the height will be calculated based on a group label and visible items. If it is set to 'fitItems' the height will be calculated based on the visible items only. While if it is set to 'fixed' the group will keep the same height even if there are no visible items in the window. |
| groupOrder | String or Function | 'order' | Order the groups by a field name or custom sort function.
By default, groups are ordered by a property order (if set).
If no order properties are provided, the order will be undetermined.
|
| groupOrderSwap | Function | none | Swaps the positions of two groups. If groups have a custom order (via groupOrder ) and groups are configured to be reorderable (via groupEditable.order ), the user has to provide a function that swaps the positions of two given groups.
If this option is not set, the default implementation assumes that groups hold an attribute order which values are changed. The signature of the groupOrderWap function is:
function groupOrderSwap(fromGroup: Object, toGroup: Object, groups: DataSet)The first to arguments hold the groups of which the positions are to be swapped and the third argument holds the DataSet with all groups. |
| groupTemplate | function | none | A template function used to generate the contents of the groups. The function is called by the Timeline with a groups data as the first argument and the group element as the second, and must return HTML code, a string or a template as result. When the option groupTemplate is specified, the groups do not need to have a field content . See section Templates for a detailed explanation. |
| height | number or String | none | The height of the timeline in pixels or as a percentage.
When height is undefined or null, the height of the timeline is automatically
adjusted to fit the contents.
It is possible to set a maximum height using option maxHeight
to prevent the timeline from getting too high in case of automatically
calculated height.
|
| hiddenDates | Object | none | This option allows you to hide specific timespans from the time axis. The dates can be supplied as an object:
{start: '2014-03-21 00:00:00', end: '2014-03-28 00:00:00', [repeat:'daily']} or as an Array of these objects. The repeat argument is optional.
The possible values are (case-sensitive): daily, weekly, monthly, yearly . To hide a weekend, pick any Saturday as start and the following Monday as end
and set repeat to weekly.
|
| horizontalScroll | Boolean | false | This option allows you to scroll horizontally to move backwards and forwards in the time range.
Only applicable when option zoomKey is defined or zoomable is false .
|
| itemsAlwaysDraggable | boolean or Object | Object | When a boolean, applies the value only to itemsAlwaysDraggable.item . |
| itemsAlwaysDraggable.item | boolean | false |
If true, all items in the Timeline are draggable without being selected. If false, only the selected item(s) are draggable. |
| itemsAlwaysDraggable.range | boolean | false |
If true, range of all items in the Timeline is draggable without being selected. If false, range is only draggable for the selected item(s). Only applicable when option itemsAlwaysDraggable.item is set true . |
| locale | String | none | Select a locale for the Timeline. See section Localization for more information. |
| locales | Object | none | A map with i18n locales. See section Localization for more information. |
| longSelectPressTime | number | 251 |
The minimal press time in ms for an event to be considered a (long) press. |
| moment | function | vis.moment | A constructor for creating a moment.js Date. Allows for applying a custom time zone. See section Time zone for more information. |
| margin | number or Object | Object | When a number, applies the margin to margin.axis , margin.item.horizontal , and margin.item.vertical . |
| margin.axis | number | 20 |
The minimal margin in pixels between items and the time axis. |
| margin.item | number | 10 |
The minimal margin in pixels between items in both horizontal and vertical direction. |
| margin.item.horizontal | number | 10 |
The minimal horizontal margin in pixels between items. |
| margin.item.vertical | number | 10 |
The minimal vertical margin in pixels between items. |
| max | Date or Number or String or Moment | none | Set a maximum Date for the visible range. It will not be possible to move beyond this maximum. |
| maxHeight | number or String | none | Specifies the maximum height for the Timeline. Can be a number in pixels or a string like "300px". |
| maxMinorChars | number | 7 | Specifies the maximum number of characters that should fit in minor grid labels. If larger, less and wider grids will be drawn. |
| min | Date or Number or String or Moment | none | Set a minimum Date for the visible range. It will not be possible to move beyond this minimum. |
| minHeight | number or String | none | Specifies the minimum height for the Timeline. Can be a number in pixels or a string like "300px". |
| moveable | boolean | true |
Specifies whether the Timeline can be moved and zoomed by dragging the window.
See also option zoomable .
|
| multiselect | boolean | false |
If true, multiple items can be selected using ctrl+click, shift+click, or by holding items.
Only applicable when option selectable is true .
|
| multiselectPerGroup | boolean | false |
If true, selecting multiple items using shift+click will only select items residing in the same group as the first selected item.
Only applicable when option selectable and multiselect are true .
|
| onAdd | function | none | Callback function triggered when an item is about to be added: when the user double taps an empty space in the Timeline. See section Editing Items for more information. Only applicable when both options selectable and editable.add are set true .
|
| onAddGroup | function | none | Callback function triggered when a group is about to be added. The signature and semantics are the same as for onAdd .
|
| onDropObjectOnItem | function | none | Callback function triggered when an object containing target:'item' in its drag data is dropped in to a timeline item.
|
| onInitialDrawComplete | function | none | Callback function triggered when the timeline is initially drawn. This function fires once per timeline creation. |
| onMove | function | none | Callback function triggered when an item has been moved: after the user has dragged the item to an other position. See section Editing Items for more information. Only applicable when both options selectable and editable.updateTime or editable.updateGroup are set true .
|
| onMoveGroup | function | none | Callback function triggered when a group has been moved: after the user has dragged the group to an other position. The signature and semantics are the same as for onMove .
|
| onMoving | function | none | Callback function triggered repeatedly when an item is being moved. See section Editing Items for more information. Only applicable when both options selectable and editable.updateTime or editable.updateGroup are set true .
|
| onRemove | function | none | Callback function triggered when an item is about to be removed: when the user tapped the delete button on the top right of a selected item. See section Editing Items for more information. Only applicable when both options selectable and editable.remove are set true .
|
| onRemoveGroup | function | none | Callback function triggered when a group is about to be removed. The signature and semantics are the same as for onRemove .
|
| onUpdate | function | none | Callback function triggered when an item is about to be updated, when the user double taps an item in the Timeline. See section Editing Items for more information. Only applicable when both options selectable and editable.updateTime or editable.updateGroup are set true .
|
| order | function | none |
Provide a custom sort function to order the items. The order of the items is determining the way they are stacked. The function order is called with two arguments containing the data of two items to be compared. WARNING: Use with caution. Custom ordering is not suitable for large amounts of items. On load, the Timeline will render all items once to determine their width and height. Keep the number of items in this configuration limited to a maximum of a few hundred items. |
| orientation | String or Object | 'bottom' |
Orientation of the timelines axis and items. When orientation is a string, the value is applied to both items and axis. Can be 'top', 'bottom' (default), 'both', or 'none'. |
| orientation.axis | String | 'bottom' |
Orientation of the timeline axis: 'top', 'bottom' (default), 'both', or 'none'. If orientation is 'bottom', the time axis is drawn at the bottom. When 'top', the axis is drawn on top. When 'both', two axes are drawn, both on top and at the bottom. In case of 'none', no axis is drawn at all. |
| orientation.item | String | 'bottom' |
Orientation of the timeline items: 'top' or 'bottom' (default). Determines whether items are aligned to the top or bottom of the Timeline. |
| preferZoom | boolean | false |
If true, scrolling vertically on timeline center panel will be prevented, and zoom action will be preferred, without need of zoomKey .
|
| rollingMode | Object | Object |
Specify how the timeline implements rolling mode. |
| rollingMode.follow | boolean | false |
If true, the timeline will initial in a rolling mode - the current time will always be centered. I the user drags the timeline, the timeline will go out of rolling mode and a toggle button will appear. Clicking that button will go back to rolling mode. Zooming in rolling mode will zoom in to the center without consideration of the mouse position. |
| rollingMode.offset | Number | '0.5' |
Set how far from the left the rolling mode is implemented from. A percentage (i.e. a decimal between 0 and 1) Defaults to the middle or 0.5 (50%) |
| rtl | boolean | false |
If true, the timeline will be right-to-left. Note: you can achieve rtl timeline by defining a parent node with dir="rtl" . The timeline knows to take the nearest parent node direction and apply it. Notice that the timeline will prefer the option.rtl over any parent dir="rtl" |
| selectable | boolean | true |
If true, the items on the timeline can be selected. Multiple items can be selected by long pressing them, or by using ctrl+click or shift+click. The event select is fired each time the selection has changed (see section Events). |
| sequentialSelection | boolean | false |
If true, then only sequential items are allowed to be selected (no gaps) when multiselect is true |
| showCurrentTime | boolean | true |
Show a vertical bar at the current time. |
| showMajorLabels | boolean | true |
By default, the timeline shows both minor and major date labels on the
time axis.
For example the minor labels show minutes and the major labels show hours.
When showMajorLabels is false , no major labels
are shown. |
| showMinorLabels | boolean | true |
By default, the timeline shows both minor and major date labels on the
time axis.
For example the minor labels show minutes and the major labels show hours.
When showMinorLabels is false , no minor labels
are shown. When both showMajorLabels and
showMinorLabels are false, no horizontal axis will be
visible. |
| showWeekScale | boolean | false |
By default, the timeline doesn't show week number scale in the date labels on the
time axis.
When showWeekScale is true , week number labels
are shown. |
| showTooltips | boolean | true |
If true, items with titles will display a tooltip. If false, item tooltips are prevented from showing. |
| stack | boolean | true |
If true (default), items will be stacked on top of each other such that they do not overlap. |
| stackSubgroups | boolean | true |
If true (default), subgroups will be stacked on top of each other such that they do not overlap. |
| cluster | Object or boolean | false |
If true, overlapped items will be grouped to clusters, zooming will change that grouping. Use this option when a huge amount of items should be rendered. |
| cluster.maxItems | number or null | 1 |
Overlapped items will be not grouped until the number of items is within maxItems. The default value of maxItems is 1 , it means that each two overlapped items will be clustered. |
| cluster.titleTemplate | string or null | none |
Cluster item tooltip, will replace {count} with the number of items in the cluster |
| cluster.clusterCriteria | function or null | () => true |
If specified, determines whether overlapped items should go to the same cluster. The signature of the clusterCriteria function is:
function clusterCriteria(firstItem: Object, secondItem: Object) : boolean. |
| cluster.showStipes | boolean | false |
If true, line from cluster to time axis is displayed when content overflows. |
| cluster.fitOnDoubleClick | boolean | true |
If true, the cluster will be centered on double click. |
| snap | function or null | function | When moving items on the Timeline, they will be snapped to nice dates like full hours or days, depending on the current scale. The snap function can be replaced with a custom function, or can be set to null to disable snapping. The signature of the snap function is:
function snap(date: Date, scale: string, step: number) : Date or numberThe parameter scale can be can be 'millisecond', 'second', 'minute', 'hour', 'weekday, 'week', 'day, 'month, or 'year'. The parameter step is a number like 1, 2, 4, 5.
|
| start | Date or Number or String or Moment | none | The initial start date for the axis of the timeline. If not provided, the earliest date present in the events is taken as start date. |
| template | function | none | A template function used to generate the contents of the items. The function is called by the Timeline with an items' data as the first argument, the item element as the second argument and the edited data as the third argument, and must return HTML code, a string or a template as result. When the option template is specified, the items do not need to have a field content . See section Templates for a detailed explanation. |
| visibleFrameTemplate | function | none | A template function used to generate the visible frame of the items. The function is called by the Timeline with an items' data as the first argument and the item frame element as the second, and must return HTML code, a string or a template as result. When the option template is specified, the items do not need to have a field content . See section Templates for a detailed explanation.
This would be used as an additional way to add content that is constant in size with the visible frame of the item and does not get visibly hidden with the item's internal container: vis-item-overflow which is overflow:hidden . |
| timeAxis | Object | Object |
Specify a fixed scale and step size for the time axis. |
| timeAxis.scale | String | none | Set a fixed scale for the time axis of the Timeline. Choose from 'millisecond' , 'second' , 'minute' , 'hour' , 'weekday' , 'week' , 'day' , 'month' , 'year' . Example usage:
var options = { timeAxis: {scale: 'minute', step: 5} } Note: The 'week' scale only works properly when locales are enabled. |
| timeAxis.step | number | 1 |
Set a fixed step size for the time axis. Only applicable when used together with timeAxis.scale .
Choose for example 1, 2, 5, or 10. |
| type | String | none | Specifies the default type for the timeline items. Choose from 'box', 'point', 'range', and 'background'. Note that individual items can override this default type. If undefined, the Timeline will auto detect the type from the items data: if a start and end date is available, a 'range' will be created, and else, a 'box' is created. Items of type 'background' are not editable. |
| tooltip | Object | Object |
Specify how the tooltip is positioned. |
| tooltip.followMouse | boolean | false |
If true, tooltips will follow the mouse as they move around in the item. |
| tooltip.overflowMethod | String | 'flip' |
Set how the tooltip should act if it is about to overflow out of the timeline. Choose from 'cap' , 'flip' and 'none' . If it is set to 'cap' , the tooltip will just cap its position to inside to timeline. If set to 'flip' , the position of the tooltip will flip around the cursor so that a corner is at the cursor, and the rest of it is visible. If set to 'none' , the tooltip will be positioned independently of the timeline, so parts of the tooltip could possibly be hidden or stick ouf of
the timeline, depending how CSS overflow is defined for the timeline (by default it's hidden). |
| tooltip.delay | Number | 500 |
Set a value (in ms) that the tooltip is delayed before showing. |
| tooltip.template | Function | none |
A template function used to generate the contents of the tooltip.
The function is called by the Timeline with an item's data as the first argument, and the edited data as the second argument.
It must return HTML code, a string or a template as result.
See section Templates for a detailed explanation.
See also: tooltipOnItemUpdateTime.template .
|
| tooltipOnItemUpdateTime | Object/Boolean | false |
Show a tooltip on updating an item's time. Note: editable.updateTime must be true |
| tooltipOnItemUpdateTime.template | Function | none | A template function used to generate the contents of the tooltip. The function is called by the Timeline with an item data as the first argument, and must return HTML code, a string or a template as result. See section Templates for a detailed explanation. See also: tooltip.template .
|
| verticalScroll | Boolean | false |
Show a vertical scroll on the side of the group list and link it to the scroll event when zoom is not triggered. Notice that defining this option as true will NOT override horizontalScroll . The scroll event will be vertically ignored, but a vertical scrollbar will be visible
|
| width | String or Number | '100%' |
The width of the timeline in pixels or as a percentage. |
| xss | Object | none | Configure the XSS protection behavior of Timeline, which is always enabled by default. This means that most attributes and HTML elements are either removed or escaped before output. |
| xss.disabled | Boolean | undefined | Explicitly set this option to true to completely disable Timeline's XSS protection.
Note: Please make sure you install protection against XSS vulnerabilities yourself! |
| xss.filterOptions | IFilterXSSOptions | undefined | This allows to customize whitelisting of HTMLElements, attributes and different handler functions. For more details, please refer to the documentation of js-xss and the related typings. |
| zoomable | boolean | true |
Specifies whether the Timeline can be zoomed by pinching or scrolling in the window.
Only applicable when option moveable is set true .
|
| zoomFriction | number | 5 |
Specifies how strong the zooming is for each scroll tick. Higher zooming friction will slow zooming speed. |
| zoomKey | String | '' |
Specifies whether the Timeline is only zoomed when an additional key is down.
Available values are '' (does not apply), 'altKey', 'ctrlKey', 'shiftKey' or 'metaKey'.
Only applicable when option moveable is set true .
|
| zoomMax | number |<PHONE_NUMBER>00000 |
Set a maximum zoom interval for the visible range in milliseconds. It will not be possible to zoom out further than this maximum. Default value equals about 10000 years. |
| zoomMin | number | 10 |
Set a minimum zoom interval for the visible range in milliseconds. It will not be possible to zoom in further than this minimum. |
The Timeline supports the following methods.
| Method | Return Type | Description |
|---|---|---|
| addCustomTime([time] [, id]) | number or String |
Add new vertical bar representing a custom time that can be dragged by the user.
Parameter time can be a Date, Number, or String, and is new Date() by default.
Parameter id can be Number or String and is undefined by default.
The id code> is added as CSS class name of the custom time bar, allowing to style multiple time bars differently.
The method returns id of the created bar.
|
| destroy() | none | Destroy the Timeline. The timeline is removed from memory. all DOM elements and event listeners are cleaned up. |
| fit([options]) | none | Adjust the visible window such that it fits all items. See also function focus(id) .
Available options:
|
| focus(id or ids [, options]) | none | Adjust the visible window such that the selected item (or multiple items) are centered on screen. See also function fit() . Available options:
|
| getCurrentTime() | Date | Get the current time. Only applicable when option showCurrentTime is true.
|
| getCustomTime([id]) | Date | Retrieve the custom time from the custom time bar with given id. Id is undefined by default.
|
| getEventProperties(event) | Object |
Returns an Object with relevant properties from an event:
document.getElementById('myTimeline').onclick = function (event) { var props = timeline.getEventProperties(event) console.log(props); } |
| getItemRange() | Object | Get the range of all the items as an object containing min: Date and max: Date . |
| getSelection() | number[] | Get an array with the ids of the currently selected items. |
| getVisibleItems() | number[] | Get an array with the ids of the currently visible items. |
| getWindow() | Object | Get the current visible window. Returns an object with properties start: Date and end: Date . |
| moveTo(time [, options, callback]) | none | Move the window such that given time is centered on screen. Parameter time can be a Date , Number , or String . Available options:
function can be passed as an optional parameter. This function will be called at the end of moveTo function.
|
| on(event, callback) | none | Create an event listener. The callback function is invoked every time the event is triggered. Available events: rangechange , rangechanged , select , itemover , itemout . The callback function is invoked as callback(properties) , where properties is an object containing event specific properties. See section Events for more information. |
| off(event, callback) | none | Remove an event listener created before via function on(event, callback) . See section Events for more information. |
| redraw() | none | Force a redraw of the Timeline. The size of all items will be recalculated.
Can be useful to manually redraw when option autoResize=false and the window
has been resized, or when the items CSS has been changed.
|
| removeCustomTime(id) | none |
Remove vertical bars previously added to the timeline via addCustomTime method. Parameter id is the ID of the custom vertical bar returned by addCustomTime method.
|
| setCurrentTime(time) | none | Set a current time. This can be used for example to ensure that a client's time is synchronized with a shared server time.
time can be a Date object, numeric timestamp, or ISO date string.
Only applicable when option showCurrentTime is true. |
| setCustomTime(time [, id]) | none | Adjust the time of a custom time bar.
Parameter time can be a Date object, numeric timestamp, or ISO date string.
Parameter id is the id of the custom time bar, and is undefined by default.
|
| setCustomTimeMarker(title [, id, editable]) | none | Attach a marker to the custom time bar.
Parameter title is the string to be set as title of the marker.
Parameter id is the id of the custom time bar which the marker is attached to, and is undefined by default.
Any marker's style can be overridden by specifying css selectors such as .vis-custom-time > .vis-custom-time-marker , .${The id of the custom time bar} > .vis-custom-time-marker .
Parameter editable makes the marker editable if true and is false by default.
|
| setCustomTimeTitle(title [, id]) | none | Adjust the title attribute of a custom time bar.
Parameter title is the string or function to be set as title. Use empty string to hide the title completely.
Parameter id is the id of the custom time bar, and is undefined by default.
|
| setData({ groups: groups, items: items }) |
none | Set both groups and items at once. Both properties are optional. This is a convenience method for individually calling both setItems(items) and setGroups(groups) .
Both items and groups can be an Array with Objects,
a DataSet (offering 2 way data binding), or a DataView (offering 1 way data binding).
For each of the groups, the items of the timeline are filtered on the
property group , which must correspond with the id of the group.
|
| setGroups(groups) | none | Set a data set with groups for the Timeline.
groups can be an Array with Objects,
a DataSet (offering 2 way data binding), or a DataView (offering 1 way data binding).
For each of the groups, the items of the timeline are filtered on the
property group , which must correspond with the id of the group.
|
| setItems(items) | none | Set a data set with items for the Timeline.
items can be an Array with Objects,
a DataSet (offering 2 way data binding), or a DataView (offering 1 way data binding).
|
| setOptions(options) | none | Set or update options. It is possible to change any option of the timeline at any time. You can for example switch orientation on the fly. |
| setSelection(id or ids [, options]) | none | Select one or multiple items by their id. The currently selected items will be unselected. To unselect all selected items, call `setSelection([])`. Available options:
|
| setWindow(start, end [, options, callback]) | none | Set the current visible window. The parameters start and end can be a Date , Number , or String . If the parameter value of start or end is null, the parameter will be left unchanged. Available options:
function can be passed as an optional parameter. This function will be called at the end of setWindow function.
|
| toggleRollingMode() | none | Toggle rollingMode. |
| zoomIn(percentage [, options, callback]) | none | Zoom in the current visible window. The parameter percentage can be a Number and must be between 0 and 1. If the parameter value of percentage is null, the window will be left unchanged. Available options:
function can be passed as an optional parameter. This function will be called at the end of zoomIn function.
|
| zoomOut(percentage [, options, callback]) | none | Zoom out the current visible window. The parameter percentage can be a Number and must be between 0 and 1. If the parameter value of percentage is null, the window will be left unchanged. Available options:
function can be passed as an optional parameter. This function will be called at the end of zoomOut function.
|
Timeline fires events when changing the visible window by dragging, when selecting items, and when dragging the custom time bar.
Here an example on how to listen for a select
event.
timeline.on('select', function (properties) { alert('selected items: ' + properties.items); });
A listener can be removed via the function off
:
function onSelect (properties) { alert('selected items: ' + properties.items); } // add event listener timeline.on('select', onSelect); // do stuff... // remove event listener timeline.off('select', onSelect);
The following events are available.
| Name | Properties | Description |
|---|---|---|
| currentTimeTick | Fired when the current time bar redraws. The rate depends on the zoom level. | |
| click |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when clicked inside the Timeline. |
| contextmenu |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when right-clicked inside the Timeline. Note that in order to prevent the context menu from showing up, default behavior of the event must be stopped:
timeline.on('contextmenu', function (props) { alert('Right click!'); props.event.preventDefault(); }); |
| doubleClick |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when double clicked inside the Timeline. |
| dragover |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when dragging over a timeline element. |
| drop |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when dropping inside the Timeline. |
| mouseOver |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when the mouse hovers over a timeline element. |
| mouseDown |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when the mouse down event is triggered over a timeline element. |
| mouseUp |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when the mouse up event is triggered over a timeline element. |
| mouseMove |
Passes a properties object as returned by the method Timeline.getEventProperties(event) .
|
Fired when the mouse is moved over a timeline element. |
| groupDragged | Passes the id of the dragged group. | Fired after the dragging of a group is finished. |
| changed | Has no properties. | Fired once after each graph redraw. |
| rangechange |
|
Fired repeatedly when the timeline window is being changed. |
| rangechanged |
|
Fired once after the timeline window has been changed. |
| select |
|
Fired after the user selects or deselects items by tapping or holding them.
When a user taps an already selected item, the select event is fired again.
Not fired when the method setSelection is executed.
|
| itemover |
|
Fired when the user moves the mouse over an item. |
| itemout |
|
Fired when the user moves the mouse out of an item. |
| timechange |
|
Fired repeatedly when the user is dragging the custom time bar. Only available when the custom time bar is enabled. |
| timechanged |
|
Fired once after the user has dragged the custom time bar. Only available when the custom time bar is enabled. |
| markerchange |
|
Fired when the marker title has been changed. Only available when the marker is editable. |
| markerchanged |
|
Fired when an alteration to the marker title is committed. Only available when the marker is editable. |
When the Timeline is configured to be editable (both options selectable
and editable
are true
), the user can:
multiselect: true
).Option editable
accepts a boolean or an object. When editable
is a boolean, all manipulation actions will be either enabled or disabled. When editable
is an object, one can enable individual manipulation actions:
// enable or disable all manipulation actions var options = { editable: true // true or false }; // enable or disable individual manipulation actions var options = { editable: { add: true, // add new items by double tapping updateTime: true, // drag items horizontally updateGroup: true, // drag items from one group to another remove: true, // delete an item by tapping the delete button top right overrideItems: false // allow these options to override item.editable } };
Editing can be enabled/disabled for specific items. Setting the property editable
to true
or false
on a data item will override the timeline option except when timeline.editable.overrideItems
is set to true
.
var items = new vis.DataSet([ {id: 1, content: 'read-only item', start: '2013-04-20', editable: false}, {id: 2, content: 'editable item', start: '2013-04-14'} ]);
Individual manipulation actions (updateTime
, updateGroup
and remove
) can also be set on individual items. If any of the item-level
actions are specified (and overrideItems
is not false
) then that takes precedence over the settings at the timeline level. Current behavior is
that if any of the item-level actions are not specified, those items get undefined
value (rather than inheriting from the timeline level). This may change
in future major releases, and code that specifies all item level values will handle major release changes better. That is, instead of using
editable: {updateTime : true}
, use editable: {updateTime : true, updateGroup: false, remove: false}
.
One can specify callback functions to validate changes made by the user. There are a number of callback functions for this purpose:
onAdd(item, callback)
Fired when a new item is about to be added. If not implemented, the item will be added with default text contents.onUpdate(item, callback)
Fired when an item is about to be updated. This function typically has to show a dialog where the user change the item. If not implemented, nothing happens.onDropObjectOnItem(objectData, item)
Fired when an object is dropped in to an existing timeline item.onMove(item, callback)
Fired when an item has been moved. If not implemented, the move action will be accepted.onMoving(item, callback)
Fired repeatedly while an item is being moved (dragged). Can be used to adjust the items start, end, and/or group to allowed regions.onRemove(item, callback)
Fired when an item is about to be deleted. If not implemented, the item will be always removed.Each of the callbacks is invoked with two arguments:
item
: the item being manipulatedcallback
: a callback function which must be invoked to report back. The callback must be invoked as callback(item)
or callback(null)
.
Here, item
can contain changes to the passed item. Parameter item
typically contains fields `content`, `start`, and optionally `end`. The type of `start`
and `end` is determined by the DataSet type configuration and is `Date` by default. When invoked as callback(null)
, the action will be cancelled.Example code:
var options = { onUpdate: function (item, callback) { item.content = prompt('Edit items text:', item.content); if (item.content != null) { callback(item); // send back adjusted item } else { callback(null); // cancel updating the item } } };A full example is available here: editingItemsCallbacks.html.
Timeline supports templates to format item contents. Any template engine (such as handlebars or mustache) can be used, and one can also manually build HTML. In the options, one can provide a template handler. This handler is a function accepting an item's data as the first argument, the item element as the second argument and the edited data as the third argument, and outputs formatted HTML:
var options = { template: function (item, element, data) { var html = ... // generate HTML markup for this item return html; } };
var options = { template: function (item, element, data) { return '
' + item.header + data.moving?' '+ data.start:'' + '

' + item.description + '
'; }, onMoving: function (item, callback) { item.moving = true; } };
Compile the template:
var source = document.getElementById('item-template').innerHTML; var template = Handlebars.compile(source);And then specify the template in the Timeline options
var options = { template: template };
template: function (item, element, data) { return ReactDOM.render({item.content}, element); },
var templates = { template1: Handlebars.compile(...), template2: Handlebars.compile(...), template2: Handlebars.compile(...), ... }; var options = { template: function (item, element, data) { var template = templates[item.template]; // choose the right template return template(item); // execute the template } };Now the items can be extended with a property
template
, specifying which template to use for the item.
Timeline can be localized. For localization, Timeline depends largely on the localization of moment.js. Locales are not included in vis.js by default. To enable localization, moment.js must be loaded with locales. Moment.js offers a bundle named "moment-with-locales.min.js" for this and there are various alternative ways to load locales.
To set a locale for the Timeline, specify the option locale
:
var options = { locale: 'nl' };
locales
:
var options = { locales: { // create a new locale (text strings should be replaced with localized strings) mylocale: { current: 'current', time: 'time', deleteSelected: 'Delete selected' } }, // use the new locale locale: 'mylocale' };
Timeline comes with support for the following locales:
| Language | Code |
|---|---|
| English |
en en_EN en_US
|
| Italian |
it it_IT it_CH
|
| Dutch |
nl nl_NL nl_BE
|
| German |
de de_DE |
| French |
fr fr_FR fr_CA fr_BE
|
| Ukrainian |
uk uk_UA
|
| Russian |
ru ru_RU
|
| Polish |
pl pl_PL
|
| Portuguese |
pt pt_BR
pt_PT
|
| Swedish |
sv sv_SE
|
| Norwegian |
nb nb_NO nn nn_NO
|
| Lithuanian |
lt lt_LT |
By default, the Timeline displays time in local time. To display a Timeline in another time zone or in UTC, the date constructor can be overloaded via the configuration option moment
, which by default is the constructor function of moment.js. More information about UTC with moment.js can be found in the docs: http://momentjs.com/docs/#/parsing/utc/.
Examples:
// display in UTC var options = { moment: function(date) { return vis.moment(date).utc(); } }; // display in UTC +08:00 var options = { moment: function(date) { return vis.moment(date).utcOffset('+08:00'); } };
All parts of the Timeline have a class name and a default css style. The styles can be overwritten, which enables full customization of the layout of the Timeline.
For example, to change the border and background color of all items, include the following code inside the head of your html code or in a separate stylesheet.

The background grid of the time axis can be styled, for example to highlight weekends or to create grids with an alternating white/lightgray background.
Depending on the zoom level, the grids get certain css classes attached. The following classes are available:
| Description | Values |
|---|---|
| Alternating columns | vis-even , vis-odd |
| Current date | vis-today , vis-tomorrow , vis-yesterday , vis-current-week , vis-current-month , vis-current-year |
| Hours | vis-h0 , vis-h1 , ..., vis-h23 |
| Grouped hours | vis-h0-h4 to vis-h20-h24 |
| Weekday | vis-monday , vis-tuesday , vis-wednesday , vis-thursday , vis-friday , vis-saturday , vis-sunday |
| Days | vis-day1 , vis-day2 , ..., vis-day31 |
| Week | vis-week1 , vis-week2 , ..., vis-week53 |
| Months | vis-january , vis-february , vis-march , vis-april , vis-may , vis-june , vis-july , vis-august , vis-september , vis-october , vis-november , vis-december |
| Years | vis-year2014 , vis-year2015 , ... |
Note: the 'week' scale is not included in the automatic zoom levels as its scale is not a direct logical successor of 'days' nor a logical predecessor of 'months'
Examples:

Defining a timeline with many items and/or groups might affect initial loading time and general performance. Here are some tips to improve performance and avoid slow loading time:
DataSets
box-shadow
, gradient background colors, etc.)start
and an end
in the timeline options.
This will improve initial loading time.


This is ApacheBench, Version 2.3 <$Revision: 1528965 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
| Server Software: | gunicorn/19.7.1 | ||
|---|---|---|---|
| Server Hostname: | <IP_ADDRESS> | ||
| Server Port: | 80 | ||
| Document Path: | / | ||
| Document Length: | 36095 bytes | ||
| Concurrency Level: | 100 | ||
| Time taken for tests: | 694.059 seconds | ||
| Complete requests: | 10000 | ||
| Failed requests: | 0 | ||
| Total transferred: | 364080000 bytes | ||
| HTML transferred: | 360950000 bytes | ||
| Requests per second: | 14.41 | ||
| Transfer rate: | 512.27 kb/s received | ||
| Connnection Times (ms) | |||
| min | avg | max | |
| Connect: | 0 | 0 | 9 |
| Processing: | 641 | 6910 | 12333 |
| Total: | 641 | 6910 | 12342 |


WILD WILD WEST *1/2 (out of five stars) A review by Jamey Hughton
Starring-Will Smith, Kevin Kline, Kenneth Branagh and Salma Hayek Director-Barry Sonnenfeld Rated PG Released June 1999 Warner Bros.
More MOVIE VIEWS by Jamey Hughton at: http://Welcome.to/MovieViews
Last summer, a feature-length version of The Avengers hit theaters to the tune of a unanimous critical panning. Based on the famous 60's television show, the film was an enormous box-office flop and a huge disappointment for Warner Bros. A year later, the studio is up to their old tricks again, with the unnecessary revival of the Robert Conrad program The Wild, Wild West. But it sounded promising: the same tag-team of star Will Smith and director Barry Sonnenfeld, who both contributed to make Men in Black such a financial success, is at the reins again. And co-star Kevin Kline is attached to the project, as well as a substantial budget to spice up the special effects.
The answer is just about everything. Wild Wild West is a cinematic abomination - a film that was so entirely pointless to begin with that it is never given a proper chance to get out of the gate. There are a lot of fancy special effects, and a handful of distinguished actors who try desperately to tunnel through the inane plot and make a lasting impression. But the script is so deliriously uneven, the entire movie so off course, that no human being or technical achievement has a chance to salvage it.
At square one, we have a bizarre case of casting. Will Smith plays James West, a renegade cowboy who was originally played by white actor Robert Conrad in the TV series. My guess regarding the casting of African-American Smith is a simple one: the actor + a cozy summertime release = big bucks for all those involved. Smith is a very talented performer who usually brings swift assurance to any comic relief material, but this is not an ideal role for him. He's too much of a joker. I heard that initial casting included George Clooney in the lead role, and frankly, that sounds a lot more plausible. What makes matters worse is that Smith goes through the role with such self-assurance in his eyes; you can practically sense his contentment with the fact that he knows Wild Wild West will be a huge hit at the summer box office.
The plot involves West and cross-dressing government agent Artemus Gordon (Kevin Kline), who are assigned by the President to recover a group of kidnapped scientists. The trail leads to the diabolical Dr. Arliss Loveless (Kenneth Branagh), a man with no lower body who speaks in a dry, witty southern accent. Loveless has taken the country's top technical minds hostage so that they can assist in his deranged plan of total government control, using lethal superweapons to destroy entire towns. One such weapon is an 80-foot mechanical tarantula, bearing eight spindly legs of thrashing metal and spewing enormous fireballs left and right. The visual effects that bring this metallic bug to life are spectacular, seamlessly blending computer-generated imagery with the western surroundings. Unfortunately, all of these effects seem so detached from the story, and can do little to support the film's plot deficiencies, which are undoubtedly the main problem.
Wild Wild West is a running gag that never truly works. Most of the jokes, usually care of Smith, die on arrival. If it's one thing that could possibly be the saving grace, it's the performances, and even they are mostly off-kilter and poorly delivered. Kline is admirable, but he has little to do but invent silly devices on the spot. Salma Hayek is wasted as the romantic interest, because she is viewed as little more than that - window dressing to look pretty and create conflict between West and Gordon. Branagh, an esteemed Shakespearean actor and director, adds marginal enjoyment to the film. But even he is so utterly weird and over-the-top. Rarely is a film so lost in itself as Wild Wild West is.
I suppose there's always one turkey of the summer season; a highly anticipated, big-budget release that manages to completely disappoint. Wild Wild West is such a movie, and will probably go down as one of the biggest disappointments of 1999. But it is highly unlikely that this will go down in defeat at the box office. Perhaps after this, audiences will be less assured when they see Will Smith's name stamped on a summer movie. After such hits as Independence Day and MiB, Wild Wild West is not an impressive addition to the resume.
(C) 1999, Jamey Hughton
MOVIE VIEWS by Jamey Hughton: http://Welcome.to/MovieViews .......................
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


| ********** Mapped Logic ********** |
|
FDCPE_CLOCK_ENABLE0/s_cnt0: FDCPE port map (CLOCK_ENABLE0/s_cnt(0),CLOCK_ENABLE0/s_cnt_D(0),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_D(0) <= (N_PZ_106 AND NOT CLOCK_ENABLE0/s_cnt(0) AND N_PZ_112); |
|
FDCPE_CLOCK_ENABLE0/s_cnt1: FDCPE port map (CLOCK_ENABLE0/s_cnt(1),CLOCK_ENABLE0/s_cnt_D(1),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_D(1) <= ((N_PZ_106 AND CLOCK_ENABLE0/s_cnt(0) AND N_PZ_112 AND NOT CLOCK_ENABLE0/s_cnt(1)) OR (N_PZ_106 AND NOT CLOCK_ENABLE0/s_cnt(0) AND N_PZ_112 AND CLOCK_ENABLE0/s_cnt(1))); |
|
FDCPE_CLOCK_ENABLE0/s_cnt2: FDCPE port map (CLOCK_ENABLE0/s_cnt(2),CLOCK_ENABLE0/s_cnt_D(2),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_D(2) <= ((NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(2) AND NOT N_PZ_137) OR (NOT N_PZ_126 AND NOT CLOCK_ENABLE0/s_cnt(2) AND N_PZ_137)); |
|
FDCPE_CLOCK_ENABLE0/s_cnt3: FDCPE port map (CLOCK_ENABLE0/s_cnt(3),CLOCK_ENABLE0/s_cnt_D(3),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_D(3) <= ((NOT N_PZ_126 AND NOT N_PZ_140 AND CLOCK_ENABLE0/s_cnt(3)) OR (NOT N_PZ_126 AND NOT N_PZ_140 AND CLOCK_ENABLE0/s_cnt(2) AND N_PZ_137)); |
|
FDCPE_CLOCK_ENABLE0/s_cnt4: FDCPE port map (CLOCK_ENABLE0/s_cnt(4),CLOCK_ENABLE0/s_cnt_D(4),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_D(4) <= ((NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(4) AND NOT N_PZ_140) OR (NOT N_PZ_126 AND NOT CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140)); |
|
FTCPE_CLOCK_ENABLE0/s_cnt5: FTCPE port map (CLOCK_ENABLE0/s_cnt(5),CLOCK_ENABLE0/s_cnt_T(5),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_T(5) <= ((N_PZ_126 AND CLOCK_ENABLE0/s_cnt(5)) OR (NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140)); |
|
FTCPE_CLOCK_ENABLE0/s_cnt6: FTCPE port map (CLOCK_ENABLE0/s_cnt(6),CLOCK_ENABLE0/s_cnt_T(6),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_T(6) <= ((NOT N_PZ_106 AND CLOCK_ENABLE0/s_cnt(6)) OR (NOT N_PZ_112 AND CLOCK_ENABLE0/s_cnt(6)) OR (N_PZ_126 AND N_PZ_137 AND CLOCK_ENABLE0/s_cnt(6)) OR (NOT N_PZ_126 AND N_PZ_106 AND CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140 AND N_PZ_112 AND CLOCK_ENABLE0/s_cnt(5)) OR (N_PZ_106 AND CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140 AND NOT N_PZ_137 AND N_PZ_112 AND CLOCK_ENABLE0/s_cnt(5))); |
|
FTCPE_CLOCK_ENABLE0/s_cnt7: FTCPE port map (CLOCK_ENABLE0/s_cnt(7),CLOCK_ENABLE0/s_cnt_T(7),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_T(7) <= ((NOT N_PZ_106 AND CLOCK_ENABLE0/s_cnt(7)) OR (NOT N_PZ_112 AND CLOCK_ENABLE0/s_cnt(7)) OR (N_PZ_126 AND N_PZ_137 AND CLOCK_ENABLE0/s_cnt(7)) OR (NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140 AND CLOCK_ENABLE0/s_cnt(5) AND CLOCK_ENABLE0/s_cnt(6))); |
|
FDCPE_CLOCK_ENABLE0/s_cnt8: FDCPE port map (CLOCK_ENABLE0/s_cnt(8),CLOCK_ENABLE0/s_cnt_D(8),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_D(8) <= (NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(8)) XOR ((N_PZ_126 AND N_PZ_106 AND NOT CLOCK_ENABLE0/s_cnt(10) AND NOT N_PZ_137 AND N_PZ_112 AND NOT CLOCK_ENABLE0/s_cnt(9)) OR (NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140 AND CLOCK_ENABLE0/s_cnt(5) AND CLOCK_ENABLE0/s_cnt(6) AND CLOCK_ENABLE0/s_cnt(7) AND NOT CLOCK_ENABLE0/s_cnt(8)) OR (NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(4) AND CLOCK_ENABLE0/s_cnt(2) AND N_PZ_137 AND CLOCK_ENABLE0/s_cnt(3) AND CLOCK_ENABLE0/s_cnt(5) AND CLOCK_ENABLE0/s_cnt(6) AND CLOCK_ENABLE0/s_cnt(7) AND CLOCK_ENABLE0/s_cnt(8)) OR (NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(4) AND CLOCK_ENABLE0/s_cnt(2) AND NOT N_PZ_112 AND CLOCK_ENABLE0/s_cnt(3) AND CLOCK_ENABLE0/s_cnt(5) AND CLOCK_ENABLE0/s_cnt(6) AND CLOCK_ENABLE0/s_cnt(7) AND CLOCK_ENABLE0/s_cnt(8))); |
|
FTCPE_CLOCK_ENABLE0/s_cnt9: FTCPE port map (CLOCK_ENABLE0/s_cnt(9),CLOCK_ENABLE0/s_cnt_T(9),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_T(9) <= ((CLOCK_ENABLE0/s_cnt(11) AND CLOCK_ENABLE0/s_cnt(9)) OR (NOT N_PZ_106 AND CLOCK_ENABLE0/s_cnt(9)) OR (NOT CLOCK_ENABLE0/s_cnt(11) AND N_PZ_106 AND CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140 AND CLOCK_ENABLE0/s_cnt(5) AND CLOCK_ENABLE0/s_cnt(6) AND CLOCK_ENABLE0/s_cnt(7) AND CLOCK_ENABLE0/s_cnt(8))); |
|
FTCPE_CLOCK_ENABLE0/s_cnt10: FTCPE port map (CLOCK_ENABLE0/s_cnt(10),CLOCK_ENABLE0/s_cnt_T(10),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_T(10) <= ((N_PZ_126 AND CLOCK_ENABLE0/s_cnt(10)) OR (NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140 AND CLOCK_ENABLE0/s_cnt(5) AND CLOCK_ENABLE0/s_cnt(9) AND CLOCK_ENABLE0/s_cnt(6) AND CLOCK_ENABLE0/s_cnt(7) AND CLOCK_ENABLE0/s_cnt(8))); |
|
FDCPE_CLOCK_ENABLE0/s_cnt11: FDCPE port map (CLOCK_ENABLE0/s_cnt(11),CLOCK_ENABLE0/s_cnt_D(11),clk_i,'0','0','1');
CLOCK_ENABLE0/s_cnt_D(11) <= ((CLOCK_ENABLE0/s_cnt(11) AND NOT N_PZ_126) OR (N_PZ_126 AND N_PZ_106 AND NOT N_PZ_137 AND N_PZ_112) OR (NOT N_PZ_126 AND CLOCK_ENABLE0/s_cnt(10) AND CLOCK_ENABLE0/s_cnt(4) AND N_PZ_140 AND CLOCK_ENABLE0/s_cnt(5) AND CLOCK_ENABLE0/s_cnt(9) AND CLOCK_ENABLE0/s_cnt(6) AND CLOCK_ENABLE0/s_cnt(7) AND CLOCK_ENABLE0/s_cnt(8))); |
| FDCPE_CLOCK_ENABLE0/s_cnt12: FDCPE port map (CLOCK_ENABLE0/s_cnt(12),'0',clk_i,'0','0','1'); |
| FDCPE_CLOCK_ENABLE0/s_cnt13: FDCPE port map (CLOCK_ENABLE0/s_cnt(13),'0',clk_i,'0','0','1'); |
| FDCPE_CLOCK_ENABLE0/s_cnt14: FDCPE port map (CLOCK_ENABLE0/s_cnt(14),'0',clk_i,'0','0','1'); |
| FDCPE_CLOCK_ENABLE0/s_cnt15: FDCPE port map (CLOCK_ENABLE0/s_cnt(15),'0',clk_i,'0','0','1'); |
|
N_PZ_106 <= (BTN0 AND NOT CLOCK_ENABLE0/s_cnt(12) AND
NOT CLOCK_ENABLE0/s_cnt(13) AND NOT CLOCK_ENABLE0/s_cnt(14) AND NOT CLOCK_ENABLE0/s_cnt(15)); |
|
N_PZ_112 <= ((NOT CLOCK_ENABLE0/s_cnt(11))
OR (NOT N_PZ_159) OR (NOT CLOCK_ENABLE0/s_cnt(10) AND NOT CLOCK_ENABLE0/s_cnt(4) AND NOT CLOCK_ENABLE0/s_cnt(2) AND NOT CLOCK_ENABLE0/s_cnt(3) AND NOT CLOCK_ENABLE0/s_cnt(5) AND NOT CLOCK_ENABLE0/s_cnt(9))); |
|
N_PZ_126 <= ((NOT N_PZ_106)
OR (CLOCK_ENABLE0/s_cnt(11) AND N_PZ_159)); |
| N_PZ_137 <= (CLOCK_ENABLE0/s_cnt(0) AND CLOCK_ENABLE0/s_cnt(1)); |
|
N_PZ_140 <= (CLOCK_ENABLE0/s_cnt(2) AND N_PZ_137 AND
CLOCK_ENABLE0/s_cnt(3)); |
|
N_PZ_159 <= ((CLOCK_ENABLE0/s_cnt(10))
OR (CLOCK_ENABLE0/s_cnt(9)) OR (CLOCK_ENABLE0/s_cnt(6) AND CLOCK_ENABLE0/s_cnt(7) AND CLOCK_ENABLE0/s_cnt(8))); |
| disp_dig_o(0) <= NOT ('0'); |
| disp_dig_o(1) <= '0'; |
| disp_dig_o(2) <= NOT ('0'); |
| disp_dig_o(3) <= NOT ('0'); |
|
disp_seg_o(0) <= ((NOT s_hex(2) AND NOT s_hex(1) AND NOT s_hex(3))
OR (s_hex(2) AND s_hex(1) AND s_hex(0) AND NOT s_hex(3)) OR (s_hex(2) AND NOT s_hex(1) AND NOT s_hex(0) AND s_hex(3))); |
|
disp_seg_o(1) <= (s_hex(0) AND NOT s_hex(3))
XOR ((s_hex(2) AND NOT s_hex(1) AND s_hex(0)) OR (NOT s_hex(2) AND s_hex(1) AND NOT s_hex(0) AND NOT s_hex(3))); |
|
disp_seg_o(2) <= ((s_hex(0) AND NOT s_hex(3))
OR (s_hex(2) AND NOT s_hex(1) AND NOT s_hex(3)) OR (NOT s_hex(2) AND NOT s_hex(1) AND s_hex(0))); |
|
disp_seg_o(3) <= ((s_hex(2) AND s_hex(1) AND s_hex(0))
OR (s_hex(2) AND NOT s_hex(1) AND NOT s_hex(0) AND NOT s_hex(3)) OR (NOT s_hex(2) AND s_hex(1) AND NOT s_hex(0) AND s_hex(3)) OR (NOT s_hex(2) AND NOT s_hex(1) AND s_hex(0) AND NOT s_hex(3))); |
|
disp_seg_o(4) <= ((s_hex(2) AND s_hex(1) AND s_hex(3))
OR (s_hex(2) AND NOT s_hex(0) AND s_hex(3)) OR (NOT s_hex(2) AND s_hex(1) AND NOT s_hex(0) AND NOT s_hex(3))); |
|
disp_seg_o(5) <= (s_hex(2) AND NOT s_hex(0))
XOR ((s_hex(2) AND NOT s_hex(1) AND NOT s_hex(3)) OR (s_hex(1) AND s_hex(0) AND s_hex(3))); |
|
disp_seg_o(6) <= (NOT s_hex(1) AND s_hex(0))
XOR ((s_hex(2) AND NOT s_hex(1) AND NOT s_hex(3)) OR (NOT s_hex(2) AND s_hex(0) AND s_hex(3))); |
|
FDCPE_s_en: FDCPE port map (s_en,s_en_D,clk_i,'0','0','1');
s_en_D <= NOT (((NOT BTN0) OR (NOT CLOCK_ENABLE0/s_cnt(11) AND NOT CLOCK_ENABLE0/s_cnt(12) AND NOT CLOCK_ENABLE0/s_cnt(13) AND NOT CLOCK_ENABLE0/s_cnt(14) AND NOT CLOCK_ENABLE0/s_cnt(15)) OR (NOT CLOCK_ENABLE0/s_cnt(12) AND NOT CLOCK_ENABLE0/s_cnt(13) AND NOT CLOCK_ENABLE0/s_cnt(14) AND NOT CLOCK_ENABLE0/s_cnt(15) AND NOT N_PZ_159) OR (NOT CLOCK_ENABLE0/s_cnt(12) AND NOT CLOCK_ENABLE0/s_cnt(13) AND NOT CLOCK_ENABLE0/s_cnt(14) AND NOT CLOCK_ENABLE0/s_cnt(15) AND NOT CLOCK_ENABLE0/s_cnt(10) AND NOT CLOCK_ENABLE0/s_cnt(4) AND NOT CLOCK_ENABLE0/s_cnt(2) AND NOT N_PZ_137 AND NOT CLOCK_ENABLE0/s_cnt(3) AND NOT CLOCK_ENABLE0/s_cnt(5) AND NOT CLOCK_ENABLE0/s_cnt(9)))); |
|
FDCPE_s_hex0: FDCPE port map (s_hex(0),s_hex_D(0),clk_i,'0','0','1');
s_hex_D(0) <= ((BTN0 AND s_hex(0) AND NOT s_en) OR (BTN0 AND NOT s_hex(0) AND s_en)); |
|
FTCPE_s_hex1: FTCPE port map (s_hex(1),s_hex_T(1),clk_i,'0','0','1');
s_hex_T(1) <= ((NOT BTN0 AND s_hex(1)) OR (BTN0 AND s_hex(0) AND s_en)); |
|
FTCPE_s_hex2: FTCPE port map (s_hex(2),s_hex_T(2),clk_i,'0','0','1');
s_hex_T(2) <= ((s_hex(2) AND NOT BTN0) OR (BTN0 AND s_hex(1) AND s_hex(0) AND s_en)); |
|
FTCPE_s_hex3: FTCPE port map (s_hex(3),s_hex_T(3),clk_i,'0','0','1');
s_hex_T(3) <= ((NOT BTN0 AND s_hex(3)) OR (s_hex(2) AND BTN0 AND s_hex(1) AND s_hex(0) AND s_en)); |
|
Register Legend:
FDCPE (Q,D,C,CLR,PRE,CE); FDDCPE (Q,D,C,CLR,PRE,CE); FTCPE (Q,D,C,CLR,PRE,CE); FTDCPE (Q,D,C,CLR,PRE,CE); LDCP (Q,D,G,CLR,PRE); |