Flot Examples 
Example of loading data dynamically with AJAX. Percentage change in GDP (source: Eurostat). Click the buttons below.

The data is fetched over HTTP, in this case directly from text files. Usually the URL would point to some web server handler (e.g. a PHP page or Java/.NET/Python/Ruby on Rails handler) that extracts it from a database and serializes it to JSON.


If you tell Flot that an axis represents time, the data will be interpreted as timestamps and the ticks adjusted and formatted accordingly.

The timestamps must be specified as Javascript timestamps, as milliseconds since January 1, 1970 00:00. This is like Unix timestamps, but in milliseconds instead of seconds (remember to multiply with 1000!).




[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink  |  related link
webpy, json 
import web
#import json
import simplejson as json #RHEL5/EPEL

class index:
def GET(self):
pyDict = {'one':1,'two':2}
web.header('Content-Type', 'application/json')
return json.dumps(pyDict)


[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink  |  related link
SB Admin 2 A Free Bootstrap Admin Theme 
SB Admin 2 A Free Bootstrap Admin Theme

[ add comment ] ( 2 views )   |  [ 0 trackbacks ]   |  permalink  |  related link
Chronoline.js 
chronoline.js is a library for making a chronology timeline out of events on a horizontal timescale.

[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink  |  related link
Rickshaw  
Rickshaw is a JavaScript toolkit for creating interactive time series graphs.

[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink  |  related link
Free HTML formatter, Javascript beautifier and JSON checker (JSONLint) 
http://www.freeformatter.com/

http://jsonlint.com/

http://jsbeautifier.org/

[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink
Web.py template nesting 
#!/usr/bin/python

import sys
import simplejson as json
import web


urls = (
'/(.*)', 'index'
)

recursion = 0
recursion_max = 10

# template nesting function
def nestor( page ):
page = 'templates/' + page
global recursion
recursion += 1
if recursion > recursion_max:
print "[d] nestor reached max recursion limit"
print "[d] fatal error, givin' up..."
sys.exit(1)
print "[d] rendering inline template %s, recursion %s" % ( page, recursion )
try:
render = web.template.frender( page, globals = { 'nestor': nestor } )
except IOError:
print "[d] can't find page template %s" % page
print "[d] rendered content is\n%s" % render()
recursion -= 1
return render()

# define application
app = web.application( urls, globals() )

render = web.template.render( 'templates', globals = { 'nestor': nestor } )

class index:
def GET( self, argv ):
print "[d] in index function, rootdir"
return render.eq_index()

if __name__ == "__main__":
app.run()


templates/eq_index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Equal-Layers</title>
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
<link type="text/css" rel="stylesheet" href="/static/theme/css/bootstrap.min.css">
<link type="text/css" rel="stylesheet" href="/static/theme/css/font-awesome.min.css">
<link type="text/css" rel="stylesheet" href="/static/theme/css/ionicons.min.css">
<link type="text/css" rel="stylesheet" href="/static/theme/css/AdminLTE.css">
</head>
<body class="skin-blue">
<!-- body content -->
$:nestor( 'eq_body.html' )
</body>
</html>


templates/eq_body.html
<h1>Hello world!</h1>


[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink
FEDORA(EPEL) mirror 
wget --recursive --no-parent http://ftp.fi.muni.cz/pub/linux/fedora/

[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink  |  related link
a headache from javascript debugging?! 
F I R E B U G
-------------
link is below

[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink  |  related link
Backpropagation algorithm 
Backpropagation is an algorithm used to teach feed forward artificial neural networks. It works by providing a set of input data and ideal output data to the network, calculating the actual outputs and backpropagating the calculated error (the difference between the ideal and actual outputs) using gradient descent. This is useful for learning specific patterns of input and output data in order to be able to reproduce them afterwards even from slightly different or incomplete input data. Neural networks are able to learn any function that applies to input data by doing a generalization of the patterns they are trained with.


[ add comment ] ( 1 view )   |  [ 0 trackbacks ]   |  permalink  |  related link

<<First <Back | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | Next> Last>>