Flask-WTF offers simple integration with WTForms. This integration includes optional CSRF handling for greater security.
Source code and issue tracking at Bitbucket.
Install with pip and easy_install:
pip install Flask-WTF
or download the latest version from Bitbucket:
hg clone http://bitbucket.org/danjac/flask-wtf
cd flask-wtf
python setup.py develop
If you are using virtualenv, it is assumed that you are installing Flask-WTF in the same virtualenv as your Flask application(s).
The following settings are used with Flask-WTF:
- CSRF_ENABLED default True
- CSRF_SESSION_KEY default _csrf_token
CSRF_ENABLED enables CSRF. You can disable by passing in the csrf_enabled parameter to your form:
form = MyForm(csrf_enabled=False)
Generally speaking it’s a good idea to enable CSRF. There are two situations where you might not want to: unit tests and AJAX forms. In the first case, switching CSRF_ENABLED to False means that your forms will still work (and the CSRF hidden field will still be printed) but no validation will be done. In the second, CSRF validation is skipped if request.is_xhr is True (you can’t do cross-domain AJAX anyway, so CSRF validation is redundant).
One common pattern in wtforms is enclosed forms. For example:
class TelephoneForm(Form):
country_code = IntegerField('Country Code', [validators.required()])
area_code = IntegerField('Area Code/Exchange', [validators.required()])
number = TextField('Number')
class ContactForm(Form):
first_name = TextField()
last_name = TextField()
mobile_phone = FormField(TelephoneForm)
office_phone = FormField(TelephoneForm)
The problem with using the Form class provided by Flask-WTF is that the class will automatically include the CSRF validation. You don’t need this for every single form - just the enclosing “master” form.
The easiest way to do this is to just override the enclosed form constructor:
class TelephoneForm(Form):
country_code = IntegerField('Country Code', [validators.required()])
area_code = IntegerField('Area Code/Exchange', [validators.required()])
number = TextField('Number')
def __init__(self, *args, **kwargs):
kwargs['csrf_enabled'] = False
super(TelephoneForm, self).__init__(self, *args, **kwargs)
This will disable CSRF validation for all TelephoneForm instances.
The CSRF_SESSION_KEY sets the key used in the Flask session for storing the generated token string. Usually the default should suffice, in certain cases you might want a custom key (for example, having several forms in a single page).
Both these settings can be overriden in the Form constructor by passing in csrf_enabled and csrf_session_key optional arguments respectively.
In addition, there are additional configuration settings required for Recaptcha integration : see below.
Flask-WTF provides you with all the API features of WTForms. For example:
from flaskext.wtf import Form, TextField, Required
class MyForm(Form):
name = TextField(name, validators=[Required()])
In addition, a CSRF token hidden field is created. You can print this in your template as any other field:
<form method="POST" action=".">
{{ form.csrf }}
{{ form.name.label }} {{ form.name(size=20) }}
<input type="submit" value="Go">
</form>
However, in order to create valid XHTML/HTML the Form class has a method hidden_tag which renders any hidden fields, including the CSRF field, inside a hidden DIV tag:
<form method="POST" action=".">
{{ form.hidden_tag() }}
The safe filter used to be required with WTForms in Jinja2 templates, otherwise your markup would be escaped. For example:
{{ form.name|safe }}
However widgets in the latest version of WTForms return a HTML safe string so you shouldn’t need to use safe.
Ensure you are running the latest stable version of WTForms so that you don’t need to use this filter everywhere.
The Form instance automatically appends a file attribute to any FileField field instances if the form is posted.
This file attribute is an instance of Werkzeug FileStorage instance from request.files.
For example:
from werkzeug import secure_filename
class PhotoForm(Form):
photo = FileField("Your photo")
@app.route("/upload/", methods=("GET", "POST"))
def upload():
form = PhotoForm()
if form.validate_on_submit():
filename = secure_filename(form.photo.file.filename)
else:
filename = None
return render_template("upload.html",
form=form,
filename=filename)
Remember to set the enctype of your HTML form to multipart/form-data to enable file uploads:
<form action="." method="POST" enctype="multipart/form-data">
....
</form>
Flask-WTF also provides Recaptcha support through a RecaptchaField:
from flaskext.wtf import Form, TextField, RecaptchaField
class SignupForm(Form):
username = TextField("Username")
recaptcha = RecaptchaField()
This field handles all the nitty-gritty details of Recaptcha validation and output. The following settings are required in order to use Recaptcha:
- RECAPTCHA_USE_SSL : default False
- RECAPTCHA_PUBLIC_KEY
- RECAPTCHA_PRIVATE_KEY
- RECAPTCHA_OPTIONS
RECAPTCHA_OPTIONS is an optional dict of configuration options. The public and private keys are required in order to authenticate your request with Recaptcha - see documentation for details on how to obtain your keys.
Under test conditions (i.e. Flask app testing is True) Recaptcha will always validate - this is because it’s hard to know the correct Recaptcha image when running tests. Bear in mind that you need to pass the data to recaptcha_challenge_field and recaptcha_response_field, not recaptcha:
response = self.client.post("/someurl/", data={
'recaptcha_challenge_field' : 'test',
'recaptcha_response_field' : 'test'})
If flaskext-babel is installed then Recaptcha message strings can be localized.
The Form class provided by Flask-WTF is the same as for WTForms, but with a couple of changes. Aside from CSRF validation, a convenience method validate_on_submit is added:
from flask import Flask, request, flash, redirect, url_for, \
render_template
from flaskext.wtf import Form, TextField
app = Flask(__name__)
class MyForm(Form):
name = TextField("Name")
@app.route("/submit/", methods=("GET", "POST"))
def submit():
form = MyForm()
if form.validate_on_submit():
flash("Success")
return redirect(url_for("index"))
return render_template("index.html", form=form)
Note the difference from a pure WTForms solution:
from flask import Flask, request, flash, redirect, url_for, \
render_template
from flaskext.wtf import Form, TextField
app = Flask(__name__)
class MyForm(Form):
name = TextField("Name")
@app.route("/submit/", methods=("GET", "POST"))
def submit():
form = MyForm(request.form)
if request.method == "POST" and form.validate():
flash("Success")
return redirect(url_for("index"))
return render_template("index.html", form=form)
validate_on_submit will automatically check if the request method is PUT or POST.
You don’t need to pass request.form into your form instance, as the Form automatically populates from request.form unless specified. Other arguments are as with wtforms.Form.
Subclass of WTForms Form class. The main difference is that request.form is passed as formdata argument to constructor so can handle request data implicitly.
In addition this Form implementation has automatic CSRF handling.
Renders CSRF field inside a hidden DIV.
| Deprecated : | Use hidden_tag instead. |
|---|
Wraps hidden fields in a hidden DIV tag, in order to keep XHTML compliance.
| Versionadded : | 0.3 |
|---|---|
| Parameters: |
|
Checks if form has been submitted. The default case is if the HTTP method is PUT or POST.
Resets the CSRF token in the session. If you are reusing the form in the same view (i.e. you are not redirecting somewhere else) it’s recommended you call this before rendering the form.
Checks if form has been submitted and if so runs validate. This is a shortcut, equivalent to form.is_submitted() and form.validate()
Validates a ReCaptcha.


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
32 33 34 35
36
37 package ti.sysbios.heaps;
38
39 import xdc.rov.ViewInfo;
40 import xdc.runtime.Memory;
41 import xdc.runtime.Error;
42
43 /*!
44 * ======== HeapMem ========
45 * Variable size buffer heap manager
46 *
47 * HeapMem manager provides functions to allocate and free storage from a
48 * heap of type HeapMem which inherits from IHeap.
49 *
50 * In addition to allowing multiple static HeapMem instances to be created
51 * who's buffer placements and sizes are defined by their instance
52 * configuration parameters,
53 * HeapMem allows one Heap instance to be defined who's heap
54 * memory is defined by buffer start and end symbols in the linker command
55 * file. This singular Heap instance is referred to as the 'Primary Heap'.
56 *
57 * see {@link #primaryHeapBaseAddr}, {@link #primaryHeapEndAddr},
58 * and {@link #usePrimaryHeap}
59 *
60 * @p(html)
61 *
 HeapMem Gate

62 * A HeapMem instance will use the HeapMem module Gate to protect any accesses
63 * to its list of free memory blocks. The HeapMem instance will enter and
64 * leave the module Gate when allocating blocks, freeing blocks, and
65 * retrieving statistics about the HeapMem.
66 *
67 * By default, the Gate is of type GateMutex.
68 *
69 * A different Gate can be specified using the common$.gate parameter.
70 * For example, to use a GateTask to protect HeapMem:
71 * HeapMem.common$.gate = GateTask.create();
72 *
73 * To save on overhead, HeapMem does not create additional Gate instances on a
74 * per-instance basis; there is only one Gate instance shared across all of
75 * the HeapMem instances. Therefore, the HeapMem.common$.gateParams parameter
76 * (used for configuring per-instance Gates) is ignored.
77 *
78 * The type of Gate used should be chosen based on the type of threads (Hwi,
79 * Swi, Task, etc.) using the heap. It should also consider the
80 * non-deterministic nature of the HeapMem. A call to alloc or free will
81 * traverse a list of free blocks, so a GateHwi, for example, is likely an
82 * inappropriate Gate for HeapMem.
83 *
84 * @p(html)
85 *
 Calling Context

86 *

87 * <colgroup span="1"></colgroup> <colgroup span="5" align="center">
88 * </colgroup>
89 *
90 *
 Function 	 Hwi 	 Swi
91 *  Task 	 Main 	 Startup

92 *
93 *
 Params_init 	 Y 	 Y
94 *  Y 	 Y 	 Y

95 *
 alloc 	 N** 	 N**
96 *  Y** 	 Y 	 N

97 *
 construct 	 Y 	 Y
98 *  Y 	 Y 	 N

99 *
 create 	 N* 	 N*
100 *  Y 	 Y 	 N

101 *
 delete 	 N* 	 N*
102 *  Y 	 Y 	 N

103 *
 destruct 	 Y 	 Y
104 *  Y 	 Y 	 N

105 *
 free 	 N** 	 N**
106 *  Y** 	 Y 	 N

107 *
 getExtendedStats 	 Y 	 Y
108 *  Y 	 Y 	 N

109 *
 getStats 	 N** 	 N**
110 *  Y** 	 Y 	 N

111 *
 isBlocking 	 Y 	 Y
112 *  Y 	 Y 	 N

113 *
 restore 	 Y+ 	 Y+
114 *  Y+ 	 Y 	 N

115 *
 Definitions:

116 *

117 *
 Hwi: API is callable from a Hwi thread.

118 *
 Swi: API is callable from a Swi thread.

119 *
 Task: API is callable from a Task thread.

120 *
 Main: API is callable during any of these phases:

121 *

122 *
 In your module startup after this module is started
123 * (e.g. HeapMem_Module_startupDone() returns TRUE).

124 *
 During xdc.runtime.Startup.lastFxns.

125 *
 During main().

126 *
 During BIOS.startupFxns.

127 *

128 *
 Startup: API is callable during any of these phases:

129 *

130 *
 During xdc.runtime.Startup.firstFxns.

131 *
 In your module startup before this module is started
132 * (e.g. HeapMem_Module_startupDone() returns FALSE).

133 *

134 *
 * : Assuming blocking Heap is used for creation.

135 *
 **: Assuming GateMutex is used as HeapMem's Gate.

136 *
 + : Cannot use HeapMem object while it is being
137 * restored.

138 *

139 *

140 *
141 *

142 * @p
143 */
144 @Gated
145 module HeapMem inherits xdc.runtime.IHeap {
146
147 /*! @_nodoc */
148 @XmlDtd
149 metaonly struct BasicView {
150 String label;
151 Ptr buf;
152 SizeT minBlockAlign;
153 String sectionName;
154 }
155
156 /*! @_nodoc */
157 @XmlDtd
158 metaonly struct DetailedView {
159 String label;
160 Ptr buf;
161 SizeT minBlockAlign;
162 String sectionName;
163 Memory.Size totalSize;
164 Memory.Size totalFreeSize;
165 Memory.Size largestFreeSize;
166 }
167
168 /*!
169 * ======== FreeBlockView ========
170 * @_nodoc
171 */
172 metaonly struct FreeBlockView {
173 String Address;
174 String size;
175 String next;
176 String status;
177 }
178
179 /*! @_nodoc */
180 @Facet
181 metaonly config ViewInfo.Instance rovViewInfo =
182 ViewInfo.create({
183 viewMap: [
184 [
185 'Basic',
186 {
187 type: ViewInfo.INSTANCE,
188 viewInitFxn: 'viewInitBasic',
189 structName: 'BasicView'
190 }
191 ],
192 [
193 'Detailed',
194 {
195 type: ViewInfo.INSTANCE,
196 viewInitFxn: 'viewInitDetailed',
197 structName: 'DetailedView'
198 }
199 ],
200 [
201 'FreeList',
202 {
203 type: ViewInfo.INSTANCE_DATA,
204 viewInitFxn: 'viewInitData',
205 structName: 'FreeBlockView'
206 }
207 ]
208 ]
209 });
210
211
212 /*!
213 * ======== ExtendedStats ========
214 * Stat structure for the HeapMem_getExtendedStats function
215 *
216 * @field(buf) Base address of the internal buffer.
217 * This may be different from the original buf
218 * parameter due to alignment requirements.
219 * @field(size) Size of the internal buffer.
220 * This may be different from the original size
221 * parameter due to alignment requirements.
222 */
223 struct ExtendedStats {
224 Ptr buf;
225 SizeT size;
226 }
227
228 /*!
229 * ======== A_zeroBlock ========
230 * Assert raised when a block of size 0 is requested
231 *
232 * This error can also be raised if the requested size wraps
233 * the contents of a SizeT type when it is adjusted for a minimum
234 * alignment. For example, when SizeT is 16-bits and a size request
235 * is made for 0xFFFB.
236 */
237 config xdc.runtime.Assert.Id A_zeroBlock =
238 {msg: "A_zeroBlock: Cannot allocate size 0"};
239
240 /*!
241 * ======== A_heapSize ========
242 * Assert raised when the requested heap size is too small
243 */
244 config xdc.runtime.Assert.Id A_heapSize =
245 {msg: "A_heapSize: Requested heap size is too small"};
246
247 /*!
248 * ======== A_align ========
249 * Assert raised when the requested alignment is not a power of 2
250 */
251 config xdc.runtime.Assert.Id A_align =
252 {msg: "A_align: Requested align is not a power of 2"};
253
254 /*!
255 * ======== E_memory ========
256 * Raised when requested size exceeds largest free block
257 */
258 config Error.Id E_memory = {msg: "out of memory: handle=0x%x, size=%u"};
259
260 /*!
261 * ======== A_invalidFree ========
262 * Assert raised when the free detects that an invalid addr or size
263 *
264 * This could arise when multiple frees are done on the same buffer or
265 * if corruption occurred.
266 *
267 * This also could occur when an alloc is made with size N and the
268 * free for this buffer specifies size M where M > N. Note: not every
269 * case is detectable.
270 *
271 * This assert can also be caused when passing an invalid addr to free
272 * or if the size is causing the end of the buffer to be
273 * out of the expected range.
274 */
275 config xdc.runtime.Assert.Id A_invalidFree =
276 {msg: "A_invalidFree: Invalid free"};
277
278 /*!
279 * ======== primaryHeapBaseAddr ========
280 * Base address of the 'Primary Heap' buffer.
281 *
282 * HeapMem allows one Heap instance to be defined who's heap
283 * memory is defined by symbols in the linker command file.
284 * This singular Heap instance is referred to as the 'Primary Heap'.
285 *
286 * see {@link #primaryHeapEndAddr}
287 * see {@link #usePrimaryHeap}
288 *
289 * The following example will create a HeapMem instance whose
290 * size and buffer will be determined at runtime based on the
291 * values of the symbols `__primary_heap_start__` and
292 * `__primary_heap_end__`. It is assumed the user will define these
293 * symbols in their linker command file.
294 *
295 * @p(code)
296 * var HeapMem = xdc.useModule('ti.sysbios.heaps.HeapMem');
297 *
298 * HeapMem.primaryHeapBaseAddr = "&__primary_heap_start__";
299 * HeapMem.primaryHeapEndAddr = "&__primary_heap_end__";
300 *
301 * var heapMemParams = new HeapMem.Params;
302 * heapMemParams.usePrimaryHeap = true;
303 *
304 * var heap0 = HeapMem.create(heapMemParams);
305 * @p
306 */
307 config Char *primaryHeapBaseAddr = null;
308
309 /*!
310 * ======== primaryHeapEndAddr ========
311 * End address of the 'Primary Heap' buffer, plus one.
312 *
313 * see {@link #primaryHeapBaseAddr}
314 * see {@link #usePrimaryHeap}
315 *
316 * @p(code)
317 * HeapMem.primaryHeapEndAddr = "&__primary_heap_end__";
318 * @p
319 */
320 config Char *primaryHeapEndAddr = null;
321
322 /*!
323 * ======== enter ========
324 * @_nodoc
325 * Enter the module's gate. This is needed to support
326 * the legacy MEM module. It allows MEM to use the same
327 * gate for thread-safety.
328 */
329 IArg enter();
330
331 /*!
332 * ======== leave ========
333 * @_nodoc
334 * Leave the module's gate. This is needed to support
335 * the legacy MEM module. It allows MEM to use the same
336 * gate for thread-safety.
337 */
338 Void leave(IArg key);
339
340 instance:
341
342 /*!
343 * ======== usePrimaryHeap ========
344 * Use {@link #primaryHeapBaseAddr} and {@link #primaryHeapEndAddr}
345 * to define the Heap buffer managed by this static instance.
346 *
347 * @a(warning)
348 * This instance parameter only exists for statically defined
349 * HeapMem objects and can only be set to true in the creation
350 * of one static HeapMem object!
351 */
352 metaonly config Bool usePrimaryHeap = false;
353
354 /*!
355 * ======== align ========
356 * Alignment of the buffer being managed by this heap instance
357 *
358 * In the static HeapMem.create() call, the buffer allocated for the
359 * HeapMem instance will have the alignment specified by this parameter.
360 *
361 * In the dynamic case, the client must supply the buffer, so it is the
362 * client's responsibility to manage the buffer's alignment, and there is
363 * no 'align' parameter.
364 *
365 * The specified alignment must be a power of 2.
366 *
367 * HeapMem requires that the buffer be aligned on a target-specific minimum
368 * alignment, and will adjust (round up) the requested alignment as
369 * necessary to satisfy this requirement.
370 *
371 * The default alignment is 0.
372 */
373 metaonly config SizeT align = 0;
374
375 /*!
376 * ======== minBlockAlign ========
377 * Minimum alignment for each block allocated
378 *
379 * This parameter dictates the minimum alignment for each
380 * block that is allocated. If an alignment request of greater than
381 * minBlockAlign is made in the alloc, it will be honored. If an
382 * alignment request of less than minBlockAlign is made, the request will
383 * be ignored and minBlockAlign will be used.
384 *
385 * @p(code)
386 * HeapMem_Params_init(&prms);
387 * prms.minBlockAlign = 32;
388 * handle = HeapMem_create(&prms, &eb);
389 * ...
390 * // buf will be aligned on a 32 MAU boundary
391 * buf = Memory_alloc(HeapMem_Handle_upCast(handle), SIZE, 8, &eb);
392 *
393 * // buf will be aligned on a 64 MAU boundary
394 * buf = Memory_alloc(HeapMem_Handle_upCast(handle), SIZE, 64, &eb);
395 * @p
396 *
397 * The default alignment is 0 (which means this parameter is ignored).
398 */
399 config SizeT minBlockAlign = 0;
400
401 /*!
402 * ======== sectionName ========
403 * Section name for the buffer managed by the instance
404 *
405 * The default section is the 'dataSection' in the platform.
406 */
407 metaonly config String sectionName = null;
408
409 /*!
410 * ======== buf ========
411 * Buffer being managed by this heap instance
412 *
413 * This parameter is ignored in the static HeapMem.create() call. It is a
414 * required parameter in the dynamic HeapMem_create() call.
415 *
416 * HeapMem requires that the buffer be aligned on a target-specific minimum
417 * alignment, and will adjust the buffer's start address and size as
418 * necessary to satisfy this requirement.
419 */
420 config Ptr buf = 0;
421
422 /*!
423 * ======== size ========
424 * Size of buffer being managed by this heap instance
425 *
426 * The usable size may be smaller depending on alignment requirements.
427 */
428 config Memory.Size size = 0;
429
430 /*!
431 * ======== alloc ========
432 *
433 * @HeapMem
434 * The actual block returned may be larger than requested to satisfy
435 * alignment requirements, and its size will always be a multiple of
436 * the size of the HeapMem_Header data structure (usually 8 bytes)
437 *
438 * HeapMem_alloc() will lock the heap using the HeapMem Gate while it
439 * traverses the list of free blocks to find a large enough block for
440 * the request.
441 *
442 * HeapMem_alloc() should not be called directly. Application code
443 * should use Memory_alloc() with a HeapMem_Handle as the first
444 * parameter. Among other things, Memory_alloc() makes sure that the
445 * alignment parameter is greater than or equal to the minimum alignment
446 * required for the HeapMem_Header data structure for a given C compiler
447 * (8 bytes in most cases). HeapMem_alloc() may crash if you pass a
448 * smaller alignment.
449 *
450 * Guidelines for using large heaps and multiple alloc() calls.
451 * @p(blist)
452 * - If possible, allocate larger blocks first. Previous
453 * allocations of small memory blocks can reduce the size
454 * of the blocks available for larger memory allocations.
455 * - Realize that alloc() can fail even if the heap contains a
456 * sufficient absolute amount of unallocated space. This is
457 * because the largest free memory block may be smaller than
458 * total amount of unallocated memory.
459 * @p
460 *
461 * @param(size) Requested size
462 * @param(align) Requested alignment
463 * @param(eb) Error_Block used to denote location in case of a failure
464 *
465 * @b(returns) allocated block or NULL is request cannot be honored
466 */
467 override Ptr alloc(SizeT size, SizeT align, xdc.runtime.Error.Block *eb);
468
469 /*!
470 * ======== allocUnprotected ========
471 *
472 * @HeapMem
473 * The actual block returned may be larger than requested to satisfy
474 * alignment requirements
475 *
476 * HeapMem_allocUnprotected() will
477 * traverses the list of free blocks to find a large enough block for
478 * the request.
479 *
480 * The caller of this API must provider the thread-safety
481 * of this call.
482 *
483 * Guidelines for using large heaps and multiple alloc() calls.
484 * @p(blist)
485 * - If possible, allocate larger blocks first. Previous
486 * allocations of small memory blocks can reduce the size
487 * of the blocks available for larger memory allocations.
488 * - Realize that alloc() can fail even if the heap contains a
489 * sufficient absolute amount of unallocated space. This is
490 * because the largest free memory block may be smaller than
491 * total amount of unallocated memory.
492 * @p
493 *
494 * @param(size) Requested size
495 * @param(align) Requested alignment
496 *
497 * @b(returns) allocated block or NULL is request cannot be honored
498 */
499 Ptr allocUnprotected(SizeT size, SizeT align);
500
501 /*!
502 * ======== free ========
503 *
504 * @HeapMem
505 * free() places the memory block specified by addr and size back into the
506 * free pool of the heap specified. The newly freed block is combined with
507 * any adjacent free blocks. The space is then available for further
508 * allocation by alloc().
509 *
510 * free() will lock the heap using the HeapMem Gate, if one is specified
511 * using 'HeapMem.common$.gate'.
512 *
513 * @param(block) Block to be freed
514 * @param(size) Size of block to free
515 */
516 override Void free(Ptr block, SizeT size);
517
518 /*!
519 * ======== freeUnprotected ========
520 *
521 * @HeapMem
522 * freeNoGate() places the memory block specified by addr and size back into the
523 * free pool of the heap specified. The newly freed block is combined with
524 * any adjacent free blocks. The space is then available for further
525 * allocation by alloc().
526 *
527 * The caller of this API must provider the thread-safety
528 * of this call.
529 *
530 * @param(block) Block to be freed
531 * @param(size) Size of block to free
532 */
533 Void freeUnprotected(Ptr block, SizeT size);
534
535 /*!
536 * ======== isBlocking ========
537 *
538 * @HeapMem
539 * This function queries the gate (as specified by 'HeapMem.common$.gate')
540 * to determine if the alloc/free can be blocking.
541 */
542 override Bool isBlocking();
543
544 /*!
545 * ======== getStats ========
546 *
547 * @HeapMem
548 * getStats() will lock the heap using the HeapMem Gate while it retrieves
549 * the HeapMem's statistics.
550 *
551 * The returned totalSize reflects the usable size of the buffer, not
552 * necessarily the size specified during create.
553 */
554 override Void getStats(xdc.runtime.Memory.Stats *stats);
555
556
557 /*!
558 * ======== restore ========
559 * Restores an instance to its original created state
560 *
561 * This function restores a static or dynamically created instance to
562 * its original created state. Any memory previously allocated from the
563 * heap is no longer valid after this API is called. This function
564 * does not check whether there is allocated memory or not.
565 */
566 Void restore();
567
568 /*!
569 * ======== getExtendedStats ========
570 * Retrieves the extended statistics for a HeapMem instance
571 *
572 * This function retrieves the extended statistics for a HeapMem instance.
573 * It does not retrieve the standard xdc.runtime.Memory.Stats information.
574 *
575 * @param(stats) Location for the returned extended statistics.
576 */
577 Void getExtendedStats(ExtendedStats *stats);
578
579
580 internal:
581
582 /*!
583 * ======== init ========
584 * Initialize instance at runtime
585 *
586 * This function is plugged as a Startup.firstFxn so that the
587 * HeapMem objects are ready and usable by malloc() and
588 * Memory_alloc() by the time the module startup functions
589 * get called so that any calls to atexit(), which in some targets
590 * invokes malloc(), will be handled cleanly.
591 */
592 Void init();
593
594 /*!
595 * ======== initPrimary ========
596 * Initialize instance at runtime
597 *
598 * Same as 'init' but supports the use of 'HeapMem.primaryHeapBaseAddress'.
599 */
600 Void initPrimary();
601
602
603 config SizeT reqAlign;
604
605
606 struct Header {
607 Header *next;
608 Memory.Size size;
609 };
610
611 struct Instance_State {
612 xdc.runtime.Memory.Size align;
613 Char buf[];
614 Header head; 615 616 617
618 SizeT minBlockAlign;
619 };
620 }
621


The Good Quotes.
Quote with highest votes:{{quotes[0].name}}
{{quote.name}} was created on {{quote.createdDate|date}}
Upvotes: {{quote.upVote}}
Downvotes: {{quote.downVote}}
See more
Add a new quote below.


Every one can embed jsreport for free into his website and allow internet audience to use his jsreport template and render documents. Embedding allows to filter out the complexity of jsreport into just simple html form, where user uploads or fill input data, hit download and gets back document.
Native format for input data is json, but to make it easy to use for normal people, embeded version is able to internally convert text files or even excel files into json.
Usage is very simple, just hit the embed button in the playground template toolbar and dialog with proper informations will popup.
List of embedable examples


HEV patients IgM RNA IgG infection (.–.) IgA immunocompetent positive (.%) hepatitis immunosuppressed antibodies detectable {border-style px;} #ffffff;} detection patient PCR vs. []. according virus Patients diagnosis negative patients, (y/n) cohort Table cases data patients. laboratory measured serology shown (–) acute antibody clinical groups immunocompromised px; serological testing {font-family (%) Clin. Figure Hepatitis diagnostic font-size higher immunosuppression liver serum specific tested Liver Virus antibodies. assays associated diagnose did difference double; group individuals performance performed significant study virological <. Acute Clinical, ELISA IgG, Immunocompetent Overall, S.C.; blood border-color border-width chronic false however, infection. presented research results retrospective sensitivity solid; time total years {font-style {font-weight < Data Germany, IgM, Immunosuppressed Infect. Infection Med. RNA/HEV RNA−/HEV Specific Virol../j.jcv... [,]. analysis bold compared continuous courier; course diagnostics em; exclude failure hosts immune mortality necessary observed pathogens---t_Table primary pt;} reactivation status. stratified undetectable viral


Matter goes here:
Button Info goes here
Button Info goes here
Productivity Meter
Time Devoted:
00:00:00:00
Hours
Minutes
Seconds
Centiseconds
Go!
Stop
Clear
Actual Time Used:
00:00:00:00
Hours
Minutes
Seconds
Centiseconds
Go!
Stop
Clear
Time Difference:
00:00:00:00
Hours
Minutes
Seconds
Centiseconds
ToDo
Add
Record
Reset
1
1
Problems Count: 0
Average time/problem :0 mins
Save and Reset All
Well done! Keep it up
Let's go for another problem.
Oops!
You've got an extra problem to solve.
Hey!
You are already at problem count zero.
Let's began!


[page:Object3D] →
[name]
Creates a simulated lens flare that tracks a light.
Note: [page:WebGLRenderer] must have *alpha* set to *true* for LensFlare to work.
Example
[example:webgl_lensflares lensflares]
Constructor
[name]([page:Texture texture], [page:Float size], [page:Float distance], [page:Materials blending], [page:Color color])
texture -- THREE.Texture (optional)
size -- size in pixels (-1 = use texture.width)
distance -- (0-1) from light source (0 = at light source)
blending -- [page:Materials Blending Mode] - Defaults to THREE.NormalBlending
color -- The color of the lens flare
Automatically adds a lens flare to the lensFlares array if a texture is set.
Properties
[property:array lensFlares]
The array of flares as set by [page:LensFlare.add]
[property:Vector3 positionScreen]
The position of the lens flare on the screen.
[property:Function customUpdateCallback]
A custom update callback
Methods
[method:null add]([page:Texture texture], [page:Float size], [page:Float distance], [page:Materials blending], [page:Color color])
Adds a lens flare. See the constructor for details on the parameters.
[method:null updateLensFlares]()
Updates the lens flare based on the [page:LensFlare.positionScreen positionScreen] property.
[method:Object3D clone]([page:Object3D object])
object -- (optional) Object3D which needs to be cloned. If undefined, clone method will create a new cloned LensFlare Object.
Clone a LensFlare Object.
Source
[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]


<IP_ADDRESS>. Gaussian Process (GP) Surrogate Modeling¶
Note
Surrogate modeling functionality of WE-UQ is built upon GPy library (available under BSD 3-clause license), an opensource python framework for Gaussian process modeling developed in the Sheffield machine learning group.
The Train GP Surrogate Model
module is used to construct a Gaussian process (GP) based surrogate model that substitutes expensive computational simulation models. The challenge of surrogate modeling in earthquake engineering arrives from the stochasticity in the ground motion time history and corresponding stochastic output.
Output of surrogate model: Following the performance-based earthquake engineering practice, the response estimation module in SimCenter workflow concerns only the peak responses (e.g. peak acceleration, peak drift ratio at each floor) rather than the whole time history. Therefore, the surrogate modeling algorithms in this tool are designed to predict the non-time history responses.
Input of surrogate model: To keep the input dimension of the surrogate model to a reasonable scale, the ground motion time history are first parameterized into a number of key features in the algorithm. This can be, for example, the sources properties (e.g. M,R) or time/frequency domain excitation property at the site of interest (e.g. intensity measures) ([Kyprioti2021], [Zhong2023]).
The surrogate prediction of EDP given the ground motion parameters typically inherits significant randomness, as the amount of information provided by these parameters are not sufficient to determine the exact model peak response. Therefore, the key task in surrogate modeling is to capture the remaining amount of uncertainty in the EDP predictions, as shown in the above figure.
The trained surrogate model can be saved in a portable file (.json format) and later imported in place of the original simulation model for UQ analysis or optimization purposes. See user guide section 2.2.5 for how to import the surrogate model in WE-UQ.
- Kyprioti2021
Kyprioti, A. P., & Taflanidis, A. A. (2021). “Kriging metamodeling for seismic response distribution estimation”. Earthquake Engineering & Structural Dynamics, 50(13), 3550-3576.
- Zhong2023
Zhong, K., Navarro, J.G., Govindjee, S., and Deierlein, G.G. (2023). “Surrogate Modeling of Structural Seismic Response Using Probabilistic Learning on Manifolds,” Earthquake Engineering & Structural Dynamics, 1-22, https://doi.org/10.1002/eqe.3839
Input description¶
Case 1: Sampling and Simulation¶
When the Training Dataset option is set to the Sampling and Simulation
, a simulation model should be presented in the later tabs. The training points are sampled adaptively by the design of experiments.
Maximum Number of Model Runs: When the number of simulation runs reaches the limit, the analysis will be terminated.
Maximum Computation Time (in minutes): When the tolerance limit of the computation time is reached, the analysis will be terminated. There will be a few minutes of error.
Target Accuracy (Normalized Error): The target accuracy is defined in terms of normalized root-mean-squared error (NRMSE) estimated by leave-out-one cross-validation (LOOCV).
(<IP_ADDRESS>.3)¶\[\begin{align*} \rm{NRMSE} ~ &= \frac{\sqrt{\frac{1}{N} \sum^{N}_{k=1} (y_k-\hat{y}_k)^2}}{\max_{k=1,...,N}(y_k)-\min_{k=1,...,N}(y_k)} \end{align*}\]where\(y_k\) : exact response from the model simulation\(\hat{y}_k\): estimated response by LOOCV surrogate model prediction\(N\): number of samples used to train the surrogate modelRandom Seed: Seed of the random number generator
Parallel execution: This engine implemented multiprocessing (local) or mpi4py (remote) python packages to run parallel execution.
Note that the results from the parallel and serial run may not be exactly the same because parallel execution sets the number of batch design of experiments (DoE) in order to maximize the use of resources (Default DoE interval: 5). User can also activate the following advanced options:
Advanced Options for Gaussian Process Model
Start with Existing Dataset
RV (Random Variables) Tab¶
The bounds of RVs need to cover the domain of interest in future applications, while it should not be unnecessarily stretched. Input type and Distribution should be set to Parameters and Uniform. When a dataset is provided, make sure to match the order of RVs in the RV tab to the order of data columns. Any correlation values will be ignored.
Output description¶
Goodness-of-Fit¶
Once the training is completed, the following three verification measures are presented based on leave-one-out cross-validation (LOOCV) error estimation.
Leave-one-out cross-validation (LOOCV)
LOOCV prediction \(\hat{\boldsymbol{y}}_k\) at each sample location \(\boldsymbol{x}_k\) is obatined by the following procedure: A temporary surrogate model \(\hat{\boldsymbol{y}}=f^{sur}_{loo,k}(\boldsymbol{\boldsymbol{x}})\) is constructed using the samples \(\{\boldsymbol{x}_1,\boldsymbol{x}_2,...,\boldsymbol{x}_{k-1},\boldsymbol{x}_{k+1},...,\boldsymbol{x}_N\}\) and the calibrated parameters, and the prediction \(\hat{\boldsymbol{y}}_k=f^{sur}_{loo,k}(\boldsymbol{x}_k)\) is compared with the exact outcome .
We provide different verification measures for two different cases.
When nugget variance is low : The LOOCV prediction \(\hat{\boldsymbol{y}}_k\) is expected to match the exact outcome \(\boldsymbol{y_k}=f(\boldsymbol{x}_k)\) when the surrogate model is well-trained. To quantify the goodness, R2 error, normalized root-mean-squared-error (NRMSE), and correlation coefficient are provided:
R2 error
R2 error is defined in terms of the total sum of squares over the residual sum of squares(<IP_ADDRESS>.2)¶\[\begin{align*} R^2 &= 1 - \frac{\sum^N_{k=1} (\hat{y}_k-\mu_\hat{y})^2}{\sum^N_{k=1} (\hat{y}_k-y_k)^2} \end{align*}\]The surrogate model is considered well-trained when the R2 (<1) approaches 1Normalized root-mean-squared-error (NRMSE)
(<IP_ADDRESS>.3)¶\[\begin{align*} \rm{NRMSE} ~ &= \frac{\sqrt{\frac{1}{N_t} \sum^{N_t}_{k=1} (y_k-\hat{y}_k)^2}}{\max_{k=1,...,N_t}(y_k)-\min_{k=1,...,N_t}(y_k)} \end{align*}\]The surrogate model is considered well-trained when the NRMSE (>0) approaches 0Correlation coefficient
Correlation coefficient is a statistic that measures linear correlation between two variables(<IP_ADDRESS>.4)¶\[ \rho_{y,\hat{y}} = \frac{\sum^N_{k=1}(y_k-\mu_{y})(\hat{y}_k-\mu_{\hat{y}})} {\sigma_y \sigma_\hat{y}}\]where\(\mu_{y}\) : mean of \(\{y_k\}\)\(\mu_{\hat{y}}\): mean of \(\{\hat{y}_k\}\)\(\sigma_{y}\): standard deviation of \(\{y_k\}\)\(\sigma_{\hat{y}}\): standard deviation of \(\{\hat{y}_k\}\)The surrogate model is considered well-trained when the correlation coefficient ( \(-1<\rho<1\) ) approaches 1
When nugget variance is high : The distance between LOOCV prediction \(\hat{\boldsymbol{y}}_k\) and the exact outcome \(\boldsymbol{y_k}=f(\boldsymbol{x}_k)\) is expected to follow a normal distribution when the surrogate model is well-trained. To quantify the goodness, inter-quartile ratio (IQR) and Cramer-Von Mises statistics can be evaluated:
Inter-quartile ratio (IQR): IQR provides the ratio of the sample QoIs that lies in 25-75% LOOCV prediction bounds (interquartile range). The IQR values should theoretically approach 0.5 if the prediction is accurate.
Cramer-Von Mises statistics: Cramer-Von Mises statistics calculate the normality score. The assumption of a GP is that the observations follow a normal distribution conditional on the input parameters. To assess the normality of the model predictions, the difference between the mean prediction \(\hat{y}_k\) and the sample observation \(y_k\) value is divided by the standard deviation prediction from surrogate \(\hat{\sigma}_{y,k}\):
(<IP_ADDRESS>.5)¶\[ u_k = \frac{y_k-\hat{y}_k} {\hat{\sigma}_{y,k}}\]If the values of \({u_k}\) follow the standard normal distribution, the resulting surrogate model may be considered well-constructed. The Cramer-Von Mises test is calculated using the
scipy.stats.cramervonmises
function in the Python package Scipy, and the resulting p-value is displayed. Conventionally, if the p-value exceeds a significance threshold, e.g. 0.05, the null hypothesis that the samples are from a normal distribution is not rejected, meaning the samples may be considered to follow a Gaussian distribution.
Additionally, scatter plot between the predicted and exact responses is presented: Well-trained model will form a clear diagonal line in case (i), or be distributed normally around the diagonal line in case (ii). A poorly trained model will have points that are more scattered around.
Note
Since these validation measures are calculated from the cross-validation predictions, they can be biased, particularly when a highly localized nonlinear range exists in the actual response surface, and those regions are not covered by the training samples. The introduction of adaptive design of experiments helps to suppress the bias by enabling the targeted selection of simulation points around potentially faulty regions.
Warning
Note that GP-based surrogate models can be used to fit only smooth, continuous functions. When the surrogate model is poorly trained, a parametric study is highly recommended to check any possible discontinuity presented in the simulation model.
Saving Options¶
Save GP Model: The constructed surrogate model is saved. One main file and one auxiliary folder will be saved.
SurroateGP Info File (default name:
SimGpModel.json
) : This file contains information required to quickly reconstruct the surrogate model and predict the response for different input realizations. This can be later imported in EEUQ.Simulation template directory (default name:
tmplatedir_SIM
) : This folder contains all the scripts and commands to run the original dynamic time history analysis. This folder can later be imported into EEUQ along with the surrogate model to alternate between original simulations and surrogate predictions or compare the surrogate predictions to the response of the original model.Only for the multi-fidelity case in quoFEM, additional SurroateGP model file (default name:
SimGpModel.pkl
) will be written along with the above two.
Warning
Do not place above surrogate model files in your root, downloads, or desktop folder as when the application runs it will copy the contents on the directories and subdirectories containing these files multiple times. If you are like us, your root, Downloads or Documents folders contains and awful lot of files and when the backend workflow runs you will slowly find you will run out of disk space!
Save GP Info: This is a report generated for user reference. It contains the GP model parameter and other information. The default file name is
GPresults.out
.RV Data, QoI Data:It saves the samples of RV and QoI. The default file names are
X.txt
andY.txt
, respectively. IMPORTANT: To continue surrogate modeling with additional simulations, save the RV and QoI sample files using this button and import them as initial points. Refer to the ‘Start with Existing Dataset’ option in Case 1.
- Patsialis2021
Patsialis, D., and A. A. Taflanidis. (2021). Multi-fidelity Monte Carlo for seismic risk assessment applications. Structural Safety 93: 102129.


FreeTAXII - A TAXII 2 Server
Manifest Service
Path:
{{ .URLPath }}
TAXII Manifest:
{{ .Resource }}
Copyright 2017 - Bret Jordan


Genes derived from a common ancestor, aka homologous genes, can be clustered into gene families. Usually genes are grouped into families by clustering the similarity scores of their protein products. Popular tools to cluster genes into homologous groups are TRIBE-MCL (Enright et al. pubmed), OrthoFinder (Emms and Kelly pubmed) and OrthoMCL (Li et al. pubmed).


Wouldn't it be great if you could have an employee who is available at all hours of the day? Your chatbot will be available for instantaneous responses to any of your customers needs at any time of day.
Add rocket fuel to your business. No longer will you be constrained to a limited number of converstaions with your customers. Your chatbot can handle 1000's of conversations simultaneously!
Chatbots are much cheaper than their human-like counterparts. You don't have to pay your chatbot paid time off, benefits, insurance etc. Also, you chatbot wont become injured on the job either!


--- layout: page title: Careers ---
DiPP members combine Harris’s quantitative education with a specific interest in data-based policy. We help members learn about opportunities to use their data and policy skills outside the classroom. We organize networking events with the Chicago data community and are always interested in opportunities for our members to show off their data skills.
If you want to get the word out to DiPP members about a data-related opportunity or participate in a networking event, contact Sarah Sajewski.


The Open Boat: A Tale Intended to be After the Fact. Being the Experience of Four Men Sunk from the Steamer Commodore
by Stephen Crane
Published in 1897, The Open Boat is based on an actual incident from Stephen Crane’s life. While on his way to Cuba, Crane's ship sank off the coast of Florida. Crane and other survivors were stranded at sea for thirty hours. They eventually made their way to safety in a small boat, but one of the men drowned while trying to swim to shore. Crane wrote this story soon after the incident occured.
Source: Crane, S. (1894). The Open Boat: A Tale Intended to be After the Fact. Being the Experience of Four Men Sunk from the Steamer Commodore.New York: Charles Scribner’s Sons.
- Chapter 1
- The men aboard a tiny boat discover they are sinking. The captain is hurt and unable to assist the men other than moral support. The men continue to fear each crashing wave that threatens to sink their dingy.
- Chapter 2
- While the men continue to keep the dingy afloat, the captain reassures them. Seagulls pester the men, the captain in particlar, by swooping down trying to peck at them.
- Chapter 3
- Led by the captain, the men continue their attempts at survival. Soon they become friends (including the correspondent who is “not of the sea”). The men build a sail out of the captain’s overcoat and an oar. They spot land and continue rowing.
- Chapter 4
- The men spy a small house on the shore. They cannot understand why no one on land has seen them or will help them. They aren’t aware that the area is deserted.
- Chapter 5
- While drifting in the ocean, the men are exhausted and there is no light. They have no company other than each other and a shark that continues to circle their small boat. The correspondent, the only one awake, hears nothing but the ocean and the shark’s body hitting the boat and fears for their safety.
- Chapter 6
- The men keep their frustration to themselves, but become angered by the fact that they could die when they have worked so hard to stay alive. The correspondent sees a watch fire on shore. The captain orders the men to put up the makeshift sail so that they can row to land by morning.
- Chapter 7
- The men can see buildings and houses on the shore, but cannot see any people. Dawn breaks and they row to shore. The captain tells them that their boat will swamp and they must jump ship and swim for the shore.
- Year Published: 1894
- Language: English
- Country of Origin: United States of America
-
Readability:
- Flesch–Kincaid Level: 6.5
- Word Count: 10,012
- Genre: Adventure
- Keywords: 19th century literature, american literature, short stories, the open boat: a tale intended to be after the fact. being the experience of four men sunk from the steamer commodore


Data Structures | |
| struct | _hashtable_config_t |
Typedefs | |
| typedef struct _hashtable_config_t | hashtable_config_t |
Enumerations | |
| enum | hash_type_t { HASH_INTPTR, HASH_STRING, HASH_STRING_NOCASE, HASH_CUSTOM } |
Functions | |
| bool | drvector_init (drvector_t *vec, uint initial_capacity, bool synch, void(*free_data_func)(void *)) |
| void * | drvector_get_entry (drvector_t *vec, uint idx) |
| bool | drvector_append (drvector_t *vec, void *data) |
| bool | drvector_delete (drvector_t *vec) |
| void | drvector_lock (drvector_t *vec) |
| void | drvector_unlock (drvector_t *vec) |
| bool | stri_eq (const char *s1, const char *s2) |
| void | hashtable_global_config (void *(*alloc_func)(size_t), void(*free_func)(void *, size_t), void(*assert_fail_func)(const char *)) |
| void | hashtable_init (hashtable_t *table, uint num_bits, hash_type_t hashtype, bool str_dup) |
| void | hashtable_init_ex (hashtable_t *table, uint num_bits, hash_type_t hashtype, bool str_dup, bool synch, void(*free_payload_func)(void *), uint(*hash_key_func)(void *), bool(*cmp_key_func)(void *, void *)) |
| void | hashtable_configure (hashtable_t *table, hashtable_config_t *config) |
| void * | hashtable_lookup (hashtable_t *table, void *key) |
| bool | hashtable_add (hashtable_t *table, void *key, void *payload) |
| void * | hashtable_add_replace (hashtable_t *table, void *key, void *payload) |
| bool | hashtable_remove (hashtable_t *table, void *key) |
| bool | hashtable_remove_range (hashtable_t *table, void *start, void *end) |
| void | hashtable_clear (hashtable_t *table) |
| void | hashtable_delete (hashtable_t *table) |
| void | hashtable_lock (hashtable_t *table) |
| void | hashtable_unlock (hashtable_t *table) |
| typedef struct _hashtable_config_t hashtable_config_t |
Configuration parameters for a hashtable.
| enum hash_type_t |
The type of hash key
| HASH_INTPTR |
A pointer-sized integer or pointer |
| HASH_STRING |
A case-sensitive string |
| HASH_STRING_NOCASE |
A case-insensitive string |
| HASH_CUSTOM |
A custom key. Hash and compare operations must be provided in hashtable_init_ex(). The hash operation can return a full uint, as its result will be truncated via a mod of the hash key bit size. This allows for resizing the table without changing the hash operation. |
| bool drvector_append | ( | drvector_t * | vec, | |
| void * | data | |||
| ) |
Adds a new entry to the end of the vector, resizing it if necessary.
| bool drvector_delete | ( | drvector_t * | vec | ) |
Destroys all storage for the vector. If free_payload_func was specified calls it for each payload.
| void* drvector_get_entry | ( | drvector_t * | vec, | |
| uint | idx | |||
| ) |
Returns the entry at index idx
. For an unsychronized table, the caller is free to directly access the array
field of vec
.
| bool drvector_init | ( | drvector_t * | vec, | |
| uint | initial_capacity, | |||
| bool | synch, | |||
| void(*)(void *) | free_data_func | |||
| ) |
Initializes a drvector with the given parameters
| [out] | vec | The vector to be initialized. |
| [in] | initial_capacity | The initial number of entries allocated for the vector. |
| [in] | synch | Whether to synchronize each operation. Even when synch is false, the vector's lock is initialized and can be used via vector_lock() and vector_unlock(), allowing the caller to extend synchronization beyond just the operation in question, to include accessing a looked-up payload, e.g. |
| [in] | free_data_func | A callback for freeing each data item. Leave it NULL if no callback is needed. |
| void drvector_lock | ( | drvector_t * | vec | ) |
Acquires the vector lock.
| void drvector_unlock | ( | drvector_t * | vec | ) |
Releases the vector lock.
| bool hashtable_add | ( | hashtable_t * | table, | |
| void * | key, | |||
| void * | payload | |||
| ) |
Adds a new entry. Returns false if an entry for key
already exists.
| void* hashtable_add_replace | ( | hashtable_t * | table, | |
| void * | key, | |||
| void * | payload | |||
| ) |
Adds a new entry, replacing an existing entry if any.
| void hashtable_clear | ( | hashtable_t * | table | ) |
Removes all entries from the table. If free_payload_func was specified calls it for each payload.
| void hashtable_configure | ( | hashtable_t * | table, | |
| hashtable_config_t * | config | |||
| ) |
Configures optional parameters of hashtable operation.
| void hashtable_delete | ( | hashtable_t * | table | ) |
Destroys all storage for the table, including all entries and the table itself. If free_payload_func was specified calls it for each payload.
| void hashtable_global_config | ( | void *(*)(size_t) | alloc_func, | |
| void(*)(void *, size_t) | free_func, | |||
| void(*)(const char *) | assert_fail_func | |||
| ) |
The hashtable has parametrized heap and assert routines for flexibility. This routine must be called BEFORE any other hashtable_ routine; else, the defaults will be used.
| void hashtable_init | ( | hashtable_t * | table, | |
| uint | num_bits, | |||
| hash_type_t | hashtype, | |||
| bool | str_dup | |||
| ) |
Initializes a hashtable with the given size, hash type, and whether to duplicate string keys. All operations are synchronized by default.
| void hashtable_init_ex | ( | hashtable_t * | table, | |
| uint | num_bits, | |||
| hash_type_t | hashtype, | |||
| bool | str_dup, | |||
| bool | synch, | |||
| void(*)(void *) | free_payload_func, | |||
| uint(*)(void *) | hash_key_func, | |||
| bool(*)(void *, void *) | cmp_key_func | |||
| ) |
Initializes a hashtable with the given parameters.
| [out] | table | The hashtable to be initialized. |
| [in] | num_bits | The initial number of bits to use for the hash key which determines the initial size of the table itself. The result of the hash function will be truncated to this size. This size will be increased when the table is resized (resizing always doubles the size). |
| [in] | hashtype | The type of hash to perform. |
| [in] | str_dup | Whether to duplicate string keys. |
| [in] | synch | Whether to synchronize each operation. Even when synch is false, the hashtable's lock is initialized and can be used via hashtable_lock() and hashtable_unlock(), allowing the caller to extend synchronization beyond just the operation in question, to include accessing a looked-up payload, e.g. |
| [in] | free_payload_func | A callback for freeing each payload. Leave it NULL if no callback is needed. |
| [in] | hash_key_func | A callback for hashing a key. Leave it NULL if no callback is needed and the default is to be used. For HASH_CUSTOM, a callback must be provided. The hash operation can return a full uint, as its result will be truncated via a mod of the hash key bit size. This allows for resizing the table without changing the hash operation. |
| [in] | cmp_key_func | A callback for comparing two keys. Leave it NULL if no callback is needed and the default is to be used. For HASH_CUSTOM, a callback must be provided. |
| void hashtable_lock | ( | hashtable_t * | table | ) |
Acquires the hashtable lock.
| void* hashtable_lookup | ( | hashtable_t * | table, | |
| void * | key | |||
| ) |
Returns the payload for the given key, or NULL if the key is not found
| bool hashtable_remove | ( | hashtable_t * | table, | |
| void * | key | |||
| ) |
Removes the entry for key. If free_payload_func was specified calls it for the payload being removed. Returns false if no such entry exists.
| bool hashtable_remove_range | ( | hashtable_t * | table, | |
| void * | start, | |||
| void * | end | |||
| ) |
Removes all entries with key in [start..end). If free_payload_func was specified calls it for each payload being removed. Returns false if no such entry exists.
| void hashtable_unlock | ( | hashtable_t * | table | ) |
Releases the hashtable lock.
| bool stri_eq | ( | const char * | s1, | |
| const char * | s2 | |||
| ) |
Caseless string compare


Blazor University – Learn the new .NET SPA framework from Microsoft Welcome to Blazor University. By working your way through the information in this website I intend to take you from complete novice through to expert in all things Blazor.
Introducing “Have I been pwned?” – aggregating accounts across website breaches I often write up analyses of the passwords disclosed in website breaches. For example, there was A brief Sony password analysis back in mid-2011 and then our local Aussie ABC earlier this year where I talked about Lousy ABC cryptography cracked in seconds...
Data breach disclosure 101: How to succeed after you've failed Organisations don't plan to fail. Probably the closest we get to that in the security space is password hashing, which for all intents and purposes is an acknowledgement that one day, you may well lose them. But organisations rarely plan for how they shou...
Coffin Problems (with Edward Frenkel) - Numberphile Podcast Edward Frenkel's fascinating mathematical journey - from the Soviet Union to the United States. Edward's website - https://edwardfrenkel.com Love and Math - Edward's book via Amazon - https://amzn.to/2rbfWHd Edward on Twitter - https://twitter.com/edfr...
Coffin Problems - with Edward Frenkel — Numberphile This is Numberphile. We mainly post videos about mathematics and just numbers in general.
ASP.NET Blog | ASP.NET Core updates in .NET Core 3.1 NET Core 3.1 is now available! Check out what's new in ASP.NET Core in this release.
Announcing .NET Core 3.1 | .NET Blog Announcing .NET Core 3.1 We’re excited to announce the release of .NET Core 3.1. It’s really just a small set of fixes and refinements over .NET Core 3.0, which we released just over two months ago. The most important feature is that .NET Core 3.1 is an l...
.NET Core 3.1.0 · Issue #142 · dotnet/announcements .NET Core 3.1.0 is available and dotnet/core#3950 has been opened for discussion. Release Notes Download Blog posts .NET Core ASP.NET Core Please report any issues you find with .NET Core 3.1 , eit...
Experimental WebGL terminal renderer by Tyriar · Pull Request #84440 · microsoft/vscode Fixes #35901 Fixes #47523 Fixes #84949 Font rendering Notice how in the canvas line many characters get their right-side cut off (eg. ~, m, e, r): Canvas glyphs are much more restricted because dr...
Digital Security by Design: Security and Legacy at Microsoft - Matthew Parkinson, Microsoft Digital Security by Design is being delivered by UK Research and Innovation (UKRI) through the Industrial Strategy Challenge Fund (ISCF). Following the Collaborators'…
.NET Design Review: JSON & object graphs atch_default":false,"external_fullscreen":true,"vss_host":"s.youtube.com","cr":"US","innertube_api_key":"AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8","loaderUrl":"https://www.youtube.com/watch?v=H9zrbztep4M","host_language":"en","enablecsi":"1","player_respon...
Incredible Formula - Numberphile Dr James Grime discusses a couple of clever formulas which are pandigital - using all the numbers from 1-9. More links & stuff in full description below ↓↓↓ More on pandigital numbers: https://youtu.be/gaVMrqzb91w More on e: https://youtu.be/AuA2EAgAegE ...
Base64 to hex: Encode and decode bytes online Base64 encoding schemes are used when binary data needs to be stored or transferred as textual data. Therefore 64 characters are chosen that are both members of a subset common to most encodings (ASCII), and also printable.
Herramienta de Desarrollo para ZX Spectrum SpectNet IDE zx spectrum msx commodore 64 desarrollo basic juegos RetroR8gue UDG c64
Converting integration tests to .NET Core 3.0: Upgrading to ASP.NET Core 3.0 - Part 5 In this post I discuss the changes required to upgrade integration tests that use WebApplicationFactory or TestServer to ASP.NET Core 3.0.
The Difference Between IEnumerable and IQueryable Explained – The Sharper Dev This post is part of this year’s C# Advent Series. Which counts down to Christmas with two C# articles published every day from Dec 1 – Dec 25.
Building Custom Input Components for Blazor using InputBase In this post, I'm going to point out a couple of limitations with using Blazor's input components as is. I'll then show how you can build your own custom input components to solves these problems.
Modern Authentication 101 - Dasith Wijesiriwardena From the Junior Dev track at DDD Melbourne 2019! There has never been more emphasis in security than in the modern environment of distributed computing and increased sharing of data. Our data does not sit inside silos consumed by one application anymo...
Episode 120 – From .NET Core 3.0 to .NET 5 w/ Scott Hunter | The 6 Figure Developer Scott Hunter is Director of Program Management, .NET. He is responsible for the Microsoft's .NET platform, which includes the .NET Framework, .NET Core, ASP.NET, Entity Framework, .NET Tools,
Garbage collector config settings - .NET Core Learn about run-time settings for configuring how the garbage collector manages memory for .NET Core apps.
Gun buyback data breach: PM Jacinda Ardern says no reason to undermine reforms Prime Minister Jacinda Ardern says she's been reassured that only one person had access to gun owners' private information in an online data breach, and doesn't believe it's a reason to undermine the reforms.


For more information about any of our special store offers,
please visit our Current Promotions page.
You're receiving this email because you subscribed to The Literacy Site reminder service.
One-click unsubscribe here or click here to manage your subscription(s).
To ensure delivery to your inbox, add<EMAIL_ADDRESS>to your address book/contacts.
The Literacy Site, One Union Square, 600 University Street, Suite 1000, Seattle, WA 98101
1-888-355-4321 Customer Service Hours: M-F 7am - 3pm PT
|


MESSAGE IN A BOTTLE A movie review by Joe Barlow (c) Copyright 1999
STARRING: Kevin Costner, Robin Wright Penn, Paul Newman, Jesse James, Illeana Douglas, Robbie Coltrane DIRECTOR: Luis Mandoki WRITER: Gerald Di Pego (based on the novel by Nicholas Sparks) RATED: PG-13 RELEASED: 1999
RATING: * 1/2 (out of a possible ****)
Robin Wright Penn seems to be pining for Helen of Troy's job recently. In "Forrest Gump" she played Jenny, the drug addict that Forrest names his shrimp boat after. In her newest film, "Message in a Bottle," she is the inspiration that prompts a man who thought he'd never know love again to rediscover his passions for both the ocean and boat building. With these two roles, Wright Penn becomes the face who launched... well, two cinematic ships.
She also gives a performance that's one of the few genuine pleasures in the movie, which never really seems sure of its bearings. It missteps badly and frequently, giving us one interesting set-up after another then cheerfully relegating them to the background any time the film threatens to get too interesting. I can picture the screenwriter sitting at his desk, ticking off items from his mental checklist as he worked on the final draft: Have I included a fist- fight? Check.  Got it. The mandatory conflict, in which one of our protagonists rejects the other's affections for no particular reason? Yep. A death whose only purpose is to generate involuntary weeping from the audience? Most definitely!
Theresa Osbourne (Wright Penn) is a journalist for the Chicago Tribune, a hard worker, but longing for love in the wake of an unpleasant divorce. While vacationing at the beach, she comes across a glass bottle partially buried in the sand. Inside is a love letter so elegantly written that she burns afire with questions about the unknown author. "Dear Catherine," the note begins; as Theresa continues to read, she learns of a heartbroken lover who has lost his wife and can find no purpose in his existence without her. Theresa is haunted by the writer's story, and upon her return to Chicago she shares the letter with her co-workers at the Tribune.
Charlie (Robbie Coltrane), the editor of the paper, decides to run the letter as a human-interest story ("This is bigger than the low-fat muffin scandal!"). Much to everyone's surprise, the Tribune is soon flooded with reports of other letters seemingly written by the same author. Theresa puts the pieces together and eventually identifies the heartsick writer as Garret Blake (Kevin Costner), a widower who resides in North Carolina's Outer Banks. Deciding she has to meet this poetic man, Theresa pays him a visit. No points for guessing that a romantic relationship blossoms between them.
And that, in a nutshell, is the biggest problem with "Message in a Bottle"; there are no points for guessing *anything*. This is strictly formula filmmaking, never deviating from the tried-and-true methods which have graced romance movies for decades. Why, for example, does Theresa not reveal to Garret that she knows about the letters he wrote to Catherine? Because otherwise there could be no scene in which Garret discovers the truth for himself. We'd miss out on the requisite teary argument in which Garret tells Theresa how hurt he feels over being deceived, and we wouldn't get to see him walk out on her, a crisis that's necessary so the couple can get back together in the final act. You all know the drill.
A bit of advice for the filmmakers: if you are fortunate enough to have Paul Newman in your movie, don't waste him. Newman plays Dodge Blake, Garret's cantankerous father, who projects a personality of grit and nails but has a wise heart underneath. Newman is in fine form here, imbuing his character with humorous mannerisms and the fortune-cookie wisdom that all cinematic dads instinctively possess. He's far more interesting than Garret (a subplot involving Dodge's possible alcoholism is never developed as fully as it deserves to be), and that's part of the trouble: Dodge is such a joy to watch that the movie plods when he's not on the screen.
The film has a moment about fifteen minutes from the finale which would be a perfect place to end this tale; it seemed like such an obvious stopping point that I actually reached for my coat. But no, the story has an unnecessary quarter-hour tacked on after it, which only serves to capsize the preceding 120 minutes and render them completely invalid. It's one of the worst endings I have ever seen, because it serves no purpose other than to provide a cheap (and emotionally manipulative) effect. "Patch Adams" fans will love it.
"Message in a Bottle" is all over the map. The film makes much of the fact that both of the characters are searching for someone to be their emotional compass; their "true north," so to speak. Unfortunately, the movie needs its own sense of direction. As it stands, we have a classic case of the blind leading the bland.
E-Mail<EMAIL_ADDRESS>Joe Barlow on Film: http://www.ipass.net/~jbarlow/film.htm
If you'd like to receive new film reviews by e-mail, please write to<EMAIL_ADDRESS>-----------== Posted via Deja News, The Discussion Network ==---------- http://www.dejanews.com/ Search, Read, Discuss, or Start Your Own
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


{% extends "club/base.html" %} {% load staticfiles %} {% block title %}Tourney info{% endblock %} {% block body_block %}
Location: {{ object.location }}
All games from this tournament
Page refreshed at {{ timestamp }}


In my last post, we talked a little about Ruby classes and how they help me get drunk. We're going to compare that a bit with JavaScript constructor functions and prototypes.
On the surface, these things look extremely similar. We can make a JavaScript constructor function that provides the same information as my Ruby class**:
function Drunk(name, numberOfDrinks){
this.person = name;
this.numberOfDrinks = numberOfDrinks;
}
var i = new Drunk("aarthi", 2);
**For simplicity's sake, I provided the information for numberOfDrinks instead of asking the user to input it with a prompt().
Here, I've created a new constructor function Drunk, and a new variable i. This variable is now an object that calls on the Drunk constructor function. When we console.log(i), we get:
Drunk { person: 'aarthi', numberOfDrinks: 2 }
So far so good. The constructor function in JavaScript looks like the initialization method in Ruby, and object i looks to have the same properties.
Now let's check out what would happen if I wanted to haveAnother:
Drunk.prototype.haveAnother = function(){
if (this.numberOfDrinks < 4) {
this.numberOfDrinks ++;
console.log("You've had " + this.numberOfDrinks + " drinks.");
}
else {
console.log("Go to bed.");
}
}
Woah! Prototype?! What in the world is that?
Prototypes are JavaScript's way of figuring out classes and inheritance. Here, we're saying that all Drunks that are created will be able to haveAnother, because Drunk.prototype is their parent. We can check this using
i.__proto__ === Drunk.prototype
Which returns true. Why would we want to use prototypes instead of defining haveAnother as a property of a Drunk? Because each time we create a Drunk, we want them to be able to haveAnother. If we define this function within the Drunk constructor function, it will be recreated for every new Drunk. However, if we define it as a prototype, haveAnother is created only once, and is inherited by all Drunks... all because Drunk.prototype is their parent.
Let's take this idea of inhertiance a step further. All persons can drink, but only persons over 21 should drink in the US. We can create a Person using:
function Person(name, age, numberOfDrinks){
this.person = name;
this.age = age;
this.numberOfDrinks = numberOfDrinks;
}
Person.prototype = new Drunk();
Person.prototype.constructor = Person;
The first statement creates the Person with a name, age, and numberOfDrinks. The second ensures that a Person constructor is created, and that each Person is an instance of Drunk. The third ensures that Persons know they are Persons. Now, any Person will be able to inherit Drunk functions. Let's rework our haveAnother function so we don't get any children drunk.
Drunk.prototype.haveAnother = function(){
if (this.age < 21){
console.log("Get out of here, kid.")
}
else if (this.numberOfDrinks < 4) {
this.numberOfDrinks ++;
console.log("You've had " + this.numberOfDrinks + " drinks.");
}
else {
console.log("Go to bed.");
}
}
Now if we create a new child object** and i object:
var child = new Person("bobby", 13)
var i = new Person("aarthi", 27, 2)
**Cool side note: JavaScript allows you to have optional arguments. Because I don't want child to start off with any numberOfDrinks, I can just omit the parameter entirely instead of putting 0.
And try to make child.haveAnother(), we return "Get out of here, kid."
, even though i.haveAnother() will still send me down a drunken road.
child.__proto__ === Drunk.prototype;
//returns false
child.__proto__ === Person.prototype;
//returns true
child instanceof Drunk;
//returns true
Here we find that child is an instantiated Drunk object. It is a Person and an instance of a Drunk.
If we checked out the inheritance in Ruby, we'd find that all methods of the Object Class were inherited by objects in the Drunk Class. They have all these secret, internal methods that Ruby gives them. In JavaScript, we can define prototypes directly because all of their methods are exposed. We can manipulate them and define each and every method that we want the prototype to exhibit.
This concept can be a little confusing. Check out the following resources for a little more information:
The best way to think about this is that JavaScript is really flexible. It's a language that might be a bit more difficult to read than Ruby, but allows you to manipulate functions and prototypes on their fundamental method levels.


JAPA is Just Another Parking App, but we're here to be THE mobile parking app. We want to deliver real-time parking spot availability, straight to your phone. We're hooking up parking spots with ultrasonic sensors and delivering it to your phone from the cloud. Stay tuned for the app and sensor rollouts, first coming to Android users at UC Davis!
No-stress parking with our easy-to-use mobile app.
Parking availability in real-time to park in no time at all!
Straight from our servers to your phone. Simple.
We always have busy students and commuters in mind, because we are busy students and commuters.
 Or are you a parking lot owner interested in solving your parking issues? Let us know your thoughts, concerns, and question!


{% block title %} {{ self.title }} {% endblock %}
{{ block.super }}
{% block related_links %}
{% include "wagtailbase/includes/related_links.html" with related_links=self.related_links.all title="Related links" %}
{% endblock %}
{% block attachments %}
{% include "wagtailbase/includes/attachments.html" with attachments=self.attachments.all title="Attachments" %}
{% endblock %}
{% endblock %}


We serve young men of color between the 7th and 11th grade who are from low income communities. Since 2009, we’ve used the concept of developing strong teams as a way for our young men to learn about collaboration, ideation, and long-lasting life skills. In small teams, our youths learn the process of taking an idea from concept to market.
3655 South Grand Ave.
Los Angeles, CA 90007 Ste. 220
<EMAIL_ADDRESS>© 2017 Teens Exploring Technology ALL RIGHTS RESERVED


Business Plan
Company Description
Here is some text
Market Analysis
Here is some text
Organization & Management
Here is some text
Service or Product Line
Here is some text
Marketing and Sales
Here is some text
Funding Request
Here is some text
Financial Projections
Here is some text
Appendix
Here is some text
How to Make Your Business Plan Stand Out
Here is some text


Disabling a button won't emit it's click handlers? What? Why doesn't it just, I don't know, disable the button and leave it at that?
12/17/2009, 9:48:39 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Disabling a button won't emit it's click handlers? What? Why doesn't it just, I don't know, disable the button and leave it at that?
12/17/2009, 9:48:39 AM
Favs: 0
Retweets: 0
link


[1]
Has many features like those in this class; Blurry corners, barrel effect
[2]
Great image quality; Feature set lacks several essentials


API is down. Not working now. Sorry for the inconvenience caused
Hello everyone!
Better one coming soon, but til then, use this
Word wrap isnt supported yet, sorry
you don't need to insert %20 for space, just write the subtext and you are good to go!
for newline, put %0A, sth like this: I love%0Acoding
which results
I love
coding
devRant Username :
Subtext :


2015 me watching Hellsing Ultimate: How the hell could the Nazi’s have survived for so long without anyone noticing
2017 me: t.co/HCk6DX6UU…


Jslet - DBRangeSelect Demo
Employee List: (
Data Model
)
Demo Content
1. From 10 to 100, step: 5:
2. From 1 to 10, step: 1 :


Text field contains characters.
Text area contains characters.
This input contains characters.
This text area contains characters
Callback defined to print the input ID to console. Input contains characters.


Home
1(714)536-7537
Contact
* Reason for Contact
Commission Artwork
Purchase Artwork
Sell Artwork
Other Reason
* First Name
* Last Name
* Email Address
Phone Number
* Let us know how we can assist you...
711 Pacific Coast Hwy #305, Huntington Beach, CA 92648


Overview
A variation alters the design of an element but is not mutually exclusive. Variations can be stacked together, or be used along with altering an element's type.
For example, having wide menus that take up the full width of its parent may sometimes be overwhelming. You can use the compact variation of a menu to alter its format to only take up the necessary space.
Stacking Variations
Another variation of a menu is an inverted menu. This alters the color contrast to appear inverted for darker backgrounds. Some variations may also mutate when used together. Lets try adding the class name red
as well. Because variations are not mutually exclusive we can use these together to create a compact, inverted, red tiered menu


A fully functional template of a Boostrap site. This template uses hrefs to navigate with the navbar and shows how you can use Grunt to keep all reusable elements (like the navbar) in one place.
Everyone seems to agree, Boostrap is awesome. It provides a lot of functionality right out of the box. One thing it does not provide, however, is a prescriptive way of doing things. On the one hand, great! Do what you want.  I know I wouldn't have turned it down.
This site is intended to serve as a template for using hrefs to provide navigation via the navbar. Further, the repo itself includes a sophisticated workflow using Grunt based on the setup provided by Yeoman and the webapp generator. See the README in the repo for more details.


Experience Title
August 20XX-August 20XX
Experience Short Description
- Experience highlight 1
- Experience highlight 2
- Experience highlight 3
Experience Title
August 20XX-August 20XX
Experience Short Description
- Experience highlight 1
- Experience highlight 2
- Experience highlight 3
Experience Title
August 20XX-August 20XX
Experience Short Description
- Experience highlight 1
- Experience highlight 2
- Experience highlight 3


Classes
The following classes are available globally.
-
See moreEmailRule
is a subclass of RegexRule that defines how a email is validated.Declaration
Swift
public class EmailRule: RegexRule
-
See moreFullNameRule
is a subclass of Rule that defines how a full name is validated.Declaration
Swift
public class FullNameRule : Rule
-
See morePasswordRule
is a subclass of RegexRule that defines how a password is validated.Declaration
Swift
public class PasswordRule : RegexRule
-
See moreAlphaNumericRule
is a subclass ofCharacterSetRule
. It is used to verify that a field has a valid list of alphanumeric characters.Declaration
Swift
public class AlphaNumericRule: CharacterSetRule
-
See morePhoneNumberRule
is a subclass of Rule that defines how a phone number is validated.Declaration
Swift
public class PhoneNumberRule: RegexRule
-
See moreFloatRule
is a subclass of Rule that defines how check if a value is a floating point value.Declaration
Swift
public class FloatRule:Rule
-
Class that makes
See moreValidator
objects. Should be added as a parameter to ViewController that will display validation fields.Declaration
Swift
public class Validator
-
See moreValidationRule
is a class that creates an object which holds validation info of a text field.Declaration
Swift
public class ValidationRule
-
See moreConfirmationRule
is a subclass of Rule that defines how a text field that has to be equal to another text field is validated.Declaration
Swift
public class ConfirmationRule: Rule
-
See moreIPV4Rule
is a subclass of RegexRule that defines how a IPV4 address validated.Declaration
Swift
public class IPV4Rule: RegexRule
-
The
See moreValidationError
class is used for representing errors of a failed validation. It contains the text field, error label, and error message of a failed validation.Declaration
Swift
public class ValidationError: NSObject
-
See moreRequiredRule
is a subclass of Rule that defines how a required text field is validated.Declaration
Swift
public class RequiredRule: Rule
-
See moreRegexRule
is a subclass of Rule that defines how a regular expression is validated.Declaration
Swift
public class RegexRule : Rule
-
See moreAlphaRule
is a subclass ofCharacterSetRule
. It is used to verify that a field has a valid list of alpha characters.Declaration
Swift
public class AlphaRule: CharacterSetRule
-
See moreMinLengthRule
is a subclass of Rule that defines how minimum character length is validated.Declaration
Swift
public class MinLengthRule: Rule
-
See moreExactLengthRule
is a subclass of Rule that is used to make sure a the text of a text field is an exact length.Declaration
Swift
public class ExactLengthRule : Rule


- label - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.ButtonBoxItem
-
- label - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.CheckBoxItem
-
- label - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.ColoredCheckBoxItem
-
- label - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.DropdownBoxesBoxItem
-
- label - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.DropdownBoxItem
-
- label - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.RadioBoxItem
-
- length(VecF2) - Static method in class nl.esciencecenter.esight.math.VectorFMath
-
Helper method to calculate the length of a vector.
- length(VecF3) - Static method in class nl.esciencecenter.esight.math.VectorFMath
-
Helper method to calculate the length of a vector.
- length(VecF4) - Static method in class nl.esciencecenter.esight.math.VectorFMath
-
Helper method to calculate the length of a vector.
- length(VecS2) - Static method in class nl.esciencecenter.esight.math.VectorSMath
-
Helper method to calculate the length of a vector.
- length(VecS3) - Static method in class nl.esciencecenter.esight.math.VectorSMath
-
Helper method to calculate the length of a vector.
- length(VecS4) - Static method in class nl.esciencecenter.esight.math.VectorSMath
-
Helper method to calculate the length of a vector.
- LightSource - Class in nl.esciencecenter.esight.models
-
Mockup class for a lightsource, currently unused.
- LightSource(Color4, VecF3) - Constructor for class nl.esciencecenter.esight.models.LightSource
-
- Line - Class in nl.esciencecenter.esight.models
-
Model for a line in space.
- Line(VecF3, VecF3) - Constructor for class nl.esciencecenter.esight.models.Line
-
Basic constructor for Line model.
- linkAttribs(GL3, GLSLAttrib...) - Method in class nl.esciencecenter.esight.shaders.ShaderProgram
-
Link method for linking the attribute objects to the shader inputs.
- listener - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.ButtonBoxItem
-
- listener - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.CheckBoxItem
-
- listener - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.ColoredCheckBoxItem
-
- listener - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.DropdownBoxItem
-
- listener - Variable in class nl.esciencecenter.esight.swing.GoggleSwing.RadioBoxItem
-
- listToBuffer(List<Float>) - Static method in class nl.esciencecenter.esight.math.VectorFMath
-
Helper method to create a FloatBuffer from an list of vectors.
- listToBuffer(List<Short>) - Static method in class nl.esciencecenter.esight.math.VectorSMath
-
Helper method to create a ShortBuffer from a list of vectors.
- loadFromClassPath(String) - Method in class nl.esciencecenter.esight.util.TypedProperties
-
Tries to load properties from a properties file on the classpath.
- loadFromFile(String) - Method in class nl.esciencecenter.esight.util.TypedProperties
-
Tries to load properties from a file.
- loadFromHomeFile(String) - Method in class nl.esciencecenter.esight.util.TypedProperties
-
Tries to load properties from a file, which is located relative to the
users home directory.
- lookAt() - Method in class nl.esciencecenter.esight.ESightGLEventListener
-
A helper function that generates a ModelView Matrix based on either the
current inputRotationX, inputRotationY and inputViewDistance, or, if an
Input event Handler was defined by the constructor, on the viewDist and
rotation defined therein.
- lookAt(VecF4, VecF4, VecF4) - Static method in class nl.esciencecenter.esight.math.MatrixFMath
-
Helper method that supplies a rotation matrix that allows us to look at
the indicated point


Provide one Disease, Gene, or Drug entitiy (DGR) to view all direct interactions with that DGR. Provide multiple DGRs or DGR sets to view interactions between all input DGRs.
Provide two Disease, Gene, or Drug entities (DGRs) as input. GeneDive will show interactions between the two DGRs through up to one intermediary DGR.
Provide two Disease, Gene, or Drug entities (DGRs) as input. GeneDive will show interactions between the two DGRs through up to two intermediary DGRs.
Provide one Disease, Gene, or Drug entity (DGR) as input. GeneDive will show those DGRs that interact with the input DGR and one of its interactants.
Confidence cutoffs illustrate the likeliness that a returned search result is accurate. A general model for cutoff points in GeneDive is described below.
| [0.95, 1.00] | Search result is highly likely to be accurate. |
|---|---|
| [0.85, 0.95) | Search result has a medium likeliness of being accurate. |
| [0.70, 0.85) | Search result has a low likeliness of being accurate. |
| [0, 0.70) | Search result is very unlikely to be accurate. |
| . | Matches any single character except the newline character.
For example, /.n/ matches 'an' and 'on' in "nay, an apple is on the tree", but not 'nay'. |
|---|---|
| * | Matches the preceding expression 0 or more times.
For example, ab*c matches "ac", "abc", "abbbc", etc. |
| .* | Matches the preceding character, followed by zero or more other characters.
For example, s.* matches "s" and "saw" and "seed". |
Click and drag on whitespace to move around.
Click and drag genes to move them around. Genes will stay where you leave them.
Shift-Click on genes to add them to the search. Releasing shift will start a new search.
Ctrl-Click on a gene to start a new search with only that gene.


Login
Send
Reset
Logout
Room Control
Create Room
Enter Room
Reset
Room Control
Exit Room
Game Control
Join the Game
Leave from the Game
Extend Time Limit
Start Vote
Vote
Send
Reset
Sent Message
None
Received Message
None
Client Status
username
Server Status
Connection: None
Cookie
None


{include file="public/css"} {include file="public/js"}
{$footer.site_name}
{include file="public/header"}
{include file="public/nav"}
{block name="content"}{/block}
{include file="public/menu"}


You will learn how to optimize any website for speed by diving into the details of how mobile and desktop browsers render pages.
You’ll learn about the Critical Rendering Path, or the set of steps browsers must take to convert HTML, CSS and JavaScript into living, breathing websites. From there, you’ll start exploring and experimenting with tools to measure performance and simple strategies to deliver the first pixels to the screen as early as possible. You’ll learn how to dive into recommendations from PageSpeed Insights and the Timeline view of Google Chrome’s Developer Tools to find the data you need to achieve immediate performance boosts!
This is a free course offered through Udacity
Take Course


| Total net profit | -22.04 | Gross profit | 8.14 | Gross loss | -30.18 |
| Profit factor | 0.27 | Expected payoff | -0.42 | ||
| Absolute drawdown | -22.04 | Maximal drawdown (%) | 24.46 (1010.74%) | ||
| Total trades | 52 | Profit trades (% of total) | 6 (11.54%) | Loss trades (% of total) | 46 (88.46%) |
| Long positions (won %) | 37 (13.51%) | Short positions (won %) | 15 (6.67%) | ||
| Largest | profit trade | 2.42 | loss trade | -1.27 | |
| Average | profit trade | 1.36 | loss trade | -0.66 | |
| Minimum | profit trade | 0.77 | loss trade | -0.39 | |
| Maximum | take profit in pips | 418.0 | stop loss in pips | -270.8 | |
| Average | take profit in pips | 139.7 | stop loss in pips | -68.8 | |
| Minimum | take profit in pips | 7.4 | stop loss in pips | -31.3 | |
| Maximum | Reward-Risk | 13.3 | Duration in minutes | 173 | |
| Average | Reward-Risk | 2.5 | Duration in minutes | 8.7 | |
| Minimum | Reward-Risk | 0.1 | Duration in minutes | 0 | |
| Maximum | consecutive wins (profit in money) | 1.0 (2.42) | consecutive losses (loss in money) | 12.0 (-8.26) | |
| Average | consecutive wins | 1.0 | consecutive losses | 8.0 |
| Total net profit | -14.16 | Gross profit | 7.37 | Gross loss | -21.53 |
| Profit factor | 0.34 | Expected payoff | -0.38 | ||
| Absolute drawdown | -14.16 | Maximal drawdown (%) | 16.58 (685.12%) | ||
| Total trades | 37 | Profit trades (% of total) | 5 (13.51%) | Loss trades (% of total) | 32 (86.49%) |
| Largest | profit trade | 2.42 | loss trade | -1.27 | |
| Average | profit trade | 1.47 | loss trade | -0.67 | |
| Minimum | profit trade | 0.91 | loss trade | -0.39 | |
| Maximum | take profit in pips | 418.0 | stop loss in pips | -270.8 | |
| Average | take profit in pips | 149.7 | stop loss in pips | -70.1 | |
| Minimum | take profit in pips | 11.6 | stop loss in pips | -31.3 | |
| Maximum | Reward-Risk | 13.3 | Duration in minutes | 173.0 | |
| Average | Reward-Risk | 2.6 | Duration in minutes | 11.5 | |
| Minimum | Reward-Risk | 0.1 | Duration in minutes | 0.0 | |
| Maximum | consecutive wins (profit in money) | 1.0 (2.42) | consecutive losses (loss in money) | 10.0 (-6.12) | |
| Average | consecutive wins | 1.0 | consecutive losses | 7.0 |
| Total net profit | -7.88 | Gross profit | 0.77 | Gross loss | -8.65 |
| Profit factor | 0.09 | Expected payoff | -0.53 | ||
| Absolute drawdown | -7.88 | Maximal drawdown (%) | 7.37 (-1445.1%) | ||
| Total trades | 15 | Profit trades (% of total) | 1 (6.67%) | Loss trades (% of total) | 14 (93.33%) |
| Largest | profit trade | 0.77 | loss trade | -1.19 | |
| Average | profit trade | 0.77 | loss trade | -0.62 | |
| Minimum | profit trade | 0.77 | loss trade | -0.41 | |
| Maximum | take profit in pips | 302.9 | stop loss in pips | -187.0 | |
| Average | take profit in pips | 115.0 | stop loss in pips | -65.6 | |
| Minimum | take profit in pips | 7.4 | stop loss in pips | -33.2 | |
| Maximum | Reward-Risk | 9.1 | Duration in minutes | 11.0 | |
| Average | Reward-Risk | 2.3 | Duration in minutes | 1.9 | |
| Minimum | Reward-Risk | Duration in minutes | 0.0 | ||
| Maximum | consecutive wins (profit in money) | 1.0 (0.77) | consecutive losses (loss in money) | 9.0 (-6.17) | |
| Average | consecutive wins | 1.0 | consecutive losses | 5.0 |


Extract SSL Certificate and SSL Certificate Key From .PFX File
A pfx file is password protected certificate archive which contains your certificate and the private key.
domain.tld.key
The private decrypted RSA key file for the certificate. (ssl_certificate_key)domain.tld.crt
The certificate file for the domainbundle.crt
The certificate file for the issuerdomain.tld.chained.crt
The concatted file which consists ofdomain.tld.crt
andbundle.crt
(ssl_certificate)
Get the .key file
Extract the encrypted key using:
openssl pkcs12 -in cert.pfx -nocerts -out domain.tld.encrypted.key
Decrypt the encrypted key using:
openssl rsa -in domain.tld.encrypted.key -out domain.tld.key
Delete the domain.tld.encrypted.key
file since we won’t need it.

Implementation
You can use domain.tld.chained.crt
as SSL certificate file and domain.tld.key
as SSL certificate key file.


Proprietor: Mrs. Dilkumari Bhandari
| Cloth Item | Price In NRs. | Item Available |
|---|---|---|
| Indian Suit | 500 | 20 |
| Chudi | 300 | 4 |
We have many products available in the market.
Some of the common products we carry are:
1. Jeans
2. Classic Shirts
3. Ladies and Jents Bags as well as wallet
4. Festival clothes
5. Cosmetics
6. Umbrellas and Raincoat
Note: Please contact us via phones for more item details.
Anderson amber ansola akapato bos cat


Our pizza is freshly prepared and cooked in our hand built brick fire oven!
Our sandwiches are made to order and only use the finest ingredients.


import numpy as np
import pandas
from scipy.spatial.distance import pdist, squareform
from qikify.helpers import standardize
# Laplacian score feature selection
[docs]class LSFS(object):
[docs] def run(self, Xin, gnd):
"""Run Laplacian Score Feature Selection.
.. note:: Eventually, it'd be nice to maintain col names with Xin so that we can add a plot method to plot scores vs. column names.
Notes
-----
This code is based on the definition from the paper [1]_:
.. math::
X * \frac{\sum_{ij} (f_r^i - f_r^j) * S_{ij}}{sigma_2}
.. [1] He, X. and Cai, D. and Niyogi, P., "Laplacian Score for Feature Selection", NIPS 2005.
Parameters
----------
Xin : array_like
A numpy.ndarray or pandas.DataFrame, with rows corresponding to observations and columns to features.
gnd : array_like
A numpy.ndarray or pandas.DataFrame pass/fail vector of the same dimension as Xin
"""
if isinstance(Xin, pandas.DataFrame):
X = Xin.as_matrix()
else:
X = Xin
nSmp = X.shape[0]
if nSmp != len(gnd):
raise Exception("Data and gnd do not have matching sizes")
_, X = standardize(X)
# Per LSFS paper, S_ij = exp(-||x_i - x_j||^2 / t). I've found that
# t = ncol(X) to be a suitable choice; anything on that order should
# work just fine.
S = self.constructS(X, gnd, t=X.shape[1])
D = sum(S,1)
z = (np.dot(D,X) * np.dot(D,X)) / sum(D)
DPrime = sum(np.dot(X.T,np.diag(D)).T * X,0) - z
LPrime = sum((np.dot(X.T,S).T * X),1) - z
# Remove trivial solutions
DPrime[DPrime < 1e-12] = np.inf
# Compute and retain Laplacian scores and rankings
self.Scores = (LPrime/DPrime).T
self.Ranking = np.argsort(-self.Scores)
del S # Clean up to save memory
return self
[docs] def threshold(self, T_L):
self.subset = self.Scores > T_L
self.nRetained = int(sum(self.subset))
print 'LSFS: retained', GREEN+str(self.nRetained)+ENDCOLOR, 'parameters.'
return self.subset
# Construct the W matrix used in LSFS
[docs] def constructS(self, X, gnd, k = 0, t = 1, bLDA=False, bSelfConnected=True):
label = np.unique(gnd)
G = np.zeros((len(gnd),len(gnd)))
if bLDA:
for i in xrange(len(label)):
ind = (gnd==label[i])
G[ix_(ind,ind)] = 1.0/sum(ind)
return G
else:
for i in xrange(len(label)):
ind = np.nonzero(gnd==label[i])[0]
D = squareform(pdist(X[ind,:], 'sqeuclidean')) # D_ij = ||x_i - x_j||^2
S = np.exp(-D/t) # Per LSFS paper, exp(-||x_i - x_j||^2 / t)
self._setSubMat(G, S, ind)
if not bSelfConnected:
G = zeroMatrixDiagonal(G)
return self._genMaxMatrix(G)
print 'LSFS: Construction of W matrix complete.'
def _setSubMat(self, X, D, ind):
"""Set a submatrix of X defined by the index ind to values in D.
That is:
[0, 0, 0]
X = [0, 0, 0] D = [1 2] ind = [0 1]
[0, 0, 0] [3 4]
Gives:
[1, 2, 0]
X = [3, 4, 0]
[0, 0, 0]
"""
for i, row in enumerate(ind):
X[row,ind] = D[i,:]
def _genMaxMatrix(self, A):
"""Takes a square matrix A and computes max(A, A')"""
ind = (A.T - A) > 0
A[ind] = A.T[ind]
return A


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
Patna High Court CWJC No.10346 of 2015 (2) dt.15-09-2015 IN THE HIGH COURT OF JUDICATURE AT PATNA Civil Writ Jurisdiction Case No.10346 of 2015 ====================================================== Arbind Kumar Singh, Proprietor of M/s Maa Vaishno Devi Engineering Works, son of Late Ram Pratap Singh, resident of Mohalla- Brindawan Colony, Jakriyapur, P.S.- Ramkrishna Nagar, Patna- 800 007 .... .... Petitioner Versus 1. The State of Bihar 2. The Chairman, Bihar State Pollution Control Board, Beltron Bhawan, Shastri Nagar, Patna- 800023 3. The Member-Secretary, Bihar State Pollution Control Board, Beltron Bhawan, Shastri Nagar, Patna- 800 023 4. The District Magistrate, Patna, District- Patna 5. The Sub-Divisional Officer, Patna Sadar, District- Patna .... .... Respondents ====================================================== Appearance : For the Petitioner : Mr. Anil Chandra, Advocate For the Board : Mr. Shivendra Kishore, Advocate ====================================================== CORAM: HONOURABLE MR. JUSTICE SAMARENDRA PRATAP SINGH ORAL ORDER
2 15-09-2015 The petitioner prays for quashing order dated 9.3.2015 passed in Letter no. T3291 as well as consequential order dated 28.4.2015, passed in Memo no. 410 by which respondent no.3 and 5 have directed him to close his Grill, Shutter manufacturing shop as public complaint against the said unit had been received regarding noise pollution. IA No.5652 of 2015 has also been filed for staying operation of the aforesaid orders.
Mr. Shivendra Kishore, Learned counsel appearing for Bihar State Pollution Control Board, submits that the petitioner is running the unit without permission of the Board and district Patna High Court CWJC No.10346 of 2015 (2) dt.15-09-2015 Industrial Centre, therefore it is illegal. Further, the petitioner has alternative remedy of appeal under Air (Prevention and Control of Pollution) Act, 981 before a Committee presided over by the Member Board of Revenue.
I find that the petitioner, instead, has also filed a representation before the Chairman of the Board. Liberty is grated to the petitioner to file an appeal before the Committee within a period of four weeks from today. In case, petition for condonation of delay is filed, the same would be considered sympathetically, as the petitioner was pursuing the remedy before this Court.
Shashi./- (Samarendra Pratap Singh, J) U


KEO WALLET
Sign Up
Log in to your wallet
Fill in the required details.
Phone number
Password
show password
Remember me
Forgot Password?
Log In
Coming soon...
Doing This For
The Culture


--- layout: page status: publish published: true title: GIS Data Sharing author: display_name: Rick Kelson login: rkelson email<EMAIL_ADDRESS>url: '' author_login: rkelson author_email<EMAIL_ADDRESS>wordpress_id: 17150 wordpress_url: http://gis.utah.gov/?page_id=17150 date: '2015-04-20 16:33:28 -0600' date_gmt: '2015-04-20 22:33:28 -0600' categories: [] tags: [] ---
GIS Data Sharing
Why? bring the world into harmony
How? should we make a drop box, email, pull from SDE/FTP/Dropbox
What? listed below are the layers and desired attributes
Trails Data
A trail, in this context, is defined as .........................


1. NASA's Apollo Plan directly aimed at the Soviet Union
[List]U.S. President John F. Kennedy announced his great aspirations on .
“American enterprise--time for this nation to take a leading role in space achievement,
which in many ways may hold the key to our future on Earth. …
First, I believe that this nation should commit itself to achieve the goal, before this decade is out,
of landing a man on the moon and returning him safely to the Earth.”
John F. Kennedy
The lunar exploration was a challenging goal, but as the United States was entirely behind the Soviet Union in the space exploration race, President Kennedy began looking for a space exploration goal that would impress people worldwide.
2. Preparations for the success of the Apollo Plan are underway
[List]
When the spacecraft was first developed, NASA considered three methods.
'Direct Ascent', 'Earth Orbit Rendezvous', and 'Lunar Orbit Rendezvous'.
The 'Lunar
Orbit Rendezvous' method was finally selected in consideration of cost and technical
survivability.
Project Mercury(link), a one astronaut embarkation, and
Project Gemini(link), a two-man embark, were started, and repeated training such as space rendezvous, docking
was conducted.
, the United States made the Apollo 8 round-trip to the moon.
, the Apollo 9 was used to succeed in docking in the Earth's atmosphere.
, Apollo 10 was launched, and the final test was conducted for a lunar landing. The
Apollo 10 mission encompassed all aspects of an actual crewed lunar landing, except the
landing.
Before Apollo 11, there was a wide variety of activities.
3. Apollo 11 successfully landed on the Moon
[List], the Apollo 11, carrying three astronauts, including Captain Neil Armstrong, Edwin Aldrin, Jr, and Michael Collins, was launched toward the Moon.
Apollo 11 was launched by a Saturn V rocket from Kennedy Space Center on Merritt Island, Florida.
Apollo 11 launched towards the moon.
the Apollo 11
LM"Eagle" was the first crewed vehicle to land on the
Moon.
"Houston, Tranquility Base here … the Eagle has landed," Neil Armstrong
After about six and a half hours, Neil Armstrong put his left foot on the rocky Moon. It was the first human footprint on the Moon.
4. Neil Armstrong, Edwin Aldrin, explore the moon surface
[List]"That's one small step for a man, one giant leap for mankind."Neil Armstrong
Collecting samples, and taking photographs. Rock and soil samples were collected, and seismometer and observation equipment were installed. The way the two walked was like dancing slowly.
Because of the small gravity, the rising body does not easily come down to the surface of the moon. They left behind an American flag and revealed a plaque with the following text in the text below.
"Here men from the planet Earth first set foot upon the moon,
We came in peace for all mankind."
They explore the surface for two and a half hours.
5. Apollo 11, Return to Earth
[List]
Armstrong and Aldrin take off from the moon on
They fired an ascending rocket and left the lunar surface, and docked with the mothership
orbiting the moon.
Armstrong and Aldrin met again with Collins in Columbia. The
CSM ignites the engine to enter its path
towards Earth.
After two and a half days of sailing to Earth, Apollo 11 arrives at Earth.
Columbia enters the Earth's atmosphere and lands safely
Later, the astronauts were transported by helicopter to the USS Hornet and entered a
mobile containment facility.
After three weeks of quarantine, Armstrong, Collins, and Aldrin were greeted with parades
worldwide.
6. The giant leap for humankind
[List]
With Apollo 11, the United States demonstrated human science and technology capabilities
in the 20th century and changed social perceptions of space.
With the success of Apollo 11, humankind has entered the era of full-scale science and
technology and can leap beyond the Earth to a distant universe.