001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the "License"); 007 * you may not use this file except in compliance with the License. 008 * You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018 /* 019 * $Id: FastStringBuffer.java<PHONE_NUMBER>-10-30 21:18:02Z minchau $ 020 */ 021 package org.apache.xml.utils; 022 023 /** 024 * Bare-bones, unsafe, fast string buffer. No thread-safety, no 025 * parameter range checking, exposed fields. Note that in typical 026 * applications, thread-safety of a StringBuffer is a somewhat 027 * dubious concept in any case. 028 *
 029 * Note that Stree and DTM used a single FastStringBuffer as a string pool, 030 * by recording start and length indices within this single buffer. This 031 * minimizes heap overhead, but of course requires more work when retrieving 032 * the data. 033 *
 034 * FastStringBuffer operates as a "chunked buffer". Doing so 035 * reduces the need to recopy existing information when an append 036 * exceeds the space available; we just allocate another chunk and 037 * flow across to it. (The array of chunks may need to grow, 038 * admittedly, but that's a much smaller object.) Some excess 039 * recopying may arise when we extract Strings which cross chunk 040 * boundaries; larger chunks make that less frequent. 041 *
 042 * The size values are parameterized, to allow tuning this code. In 043 * theory, Result Tree Fragments might want to be tuned differently 044 * from the main document's text. 045 *
 046 * %REVIEW% An experiment in self-tuning is 047 * included in the code (using nested FastStringBuffers to achieve 048 * variation in chunk sizes), but this implementation has proven to 049 * be problematic when data may be being copied from the FSB into itself. 050 * We should either re-architect that to make this safe (if possible) 051 * or remove that code and clean up for performance/maintainability reasons. 052 *
 053 */ 054 public class FastStringBuffer 055 { 056 // If nonzero, forces the inial chunk size. 057 /**/static final int DEBUG_FORCE_INIT_BITS=0; 058 059 // %BUG% %REVIEW% *****PROBLEM SUSPECTED: If data from an FSB is being copied 060 // back into the same FSB (variable set from previous variable, for example) 061 // and blocksize changes in mid-copy... there's risk of severe malfunction in 062 // the read process, due to how the resizing code re-jiggers storage. Arggh. 063 // If we want to retain the variable-size-block feature, we need to reconsider 064 // that issue. For now, I have forced us into fixed-size mode. 065 static final boolean DEBUG_FORCE_FIXED_CHUNKSIZE=true; 066 067 /** Manifest constant: Suppress leading whitespace. 068 * This should be used when normalize-to-SAX is called for the first chunk of a 069 * multi-chunk output, or one following unsuppressed whitespace in a previous 070 * chunk. 071 * @see #sendNormalizedSAXcharacters(org.xml.sax.ContentHandler,int,int) 072 */ 073 public static final int SUPPRESS_LEADING_WS=0x01; 074 075 /** Manifest constant: Suppress trailing whitespace. 076 * This should be used when normalize-to-SAX is called for the last chunk of a 077 * multi-chunk output; it may have to be or'ed with SUPPRESS_LEADING_WS. 078 */ 079 public static final int SUPPRESS_TRAILING_WS=0x02; 080 081 /** Manifest constant: Suppress both leading and trailing whitespace. 082 * This should be used when normalize-to-SAX is called for a complete string. 083 * (I'm not wild about the name of this one. Ideas welcome.) 084 * @see #sendNormalizedSAXcharacters(org.xml.sax.ContentHandler,int,int) 085 */ 086 public static final int SUPPRESS_BOTH 087 = SUPPRESS_LEADING_WS | SUPPRESS_TRAILING_WS; 088 089 /** Manifest constant: Carry trailing whitespace of one chunk as leading 090 * whitespace of the next chunk. Used internally; I don't see any reason 091 * to make it public right now. 092 */ 093 private static final int CARRY_WS=0x04; 094 095 /** 096 * Field m_chunkBits sets our chunking strategy, by saying how many 097 * bits of index can be used within a single chunk before flowing over 098 * to the next chunk. For example, if m_chunkbits is set to 15, each 099 * chunk can contain up to 2^15 (32K) characters 100 */ 101 int m_chunkBits = 15; 102 103 /** 104 * Field m_maxChunkBits affects our chunk-growth strategy, by saying what 105 * the largest permissible chunk size is in this particular FastStringBuffer 106 * hierarchy. 107 */ 108 int m_maxChunkBits = 15; 109 110 /** 111 * Field m_rechunkBits affects our chunk-growth strategy, by saying how 112 * many chunks should be allocated at one size before we encapsulate them 113 * into the first chunk of the next size up. For example, if m_rechunkBits 114 * is set to 3, then after 8 chunks at a given size we will rebundle 115 * them as the first element of a FastStringBuffer using a chunk size 116 * 8 times larger (chunkBits shifted left three bits). 117 */ 118 int m_rebundleBits = 2; 119 120 /** 121 * Field m_chunkSize establishes the maximum size of one chunk of the array 122 * as 2**chunkbits characters. 123 * (Which may also be the minimum size if we aren't tuning for storage) 124 */ 125 int m_chunkSize; // =1<<(m_chunkBits-1); 126 127 /** 128 * Field m_chunkMask is m_chunkSize-1 -- in other words, m_chunkBits 129 * worth of low-order '1' bits, useful for shift-and-mask addressing 130 * within the chunks. 131 */ 132 int m_chunkMask; // =m_chunkSize-1; 133 134 /** 135 * Field m_array holds the string buffer's text contents, using an 136 * array-of-arrays. Note that this array, and the arrays it contains, may be 137 * reallocated when necessary in order to allow the buffer to grow; 138 * references to them should be considered to be invalidated after any 139 * append. However, the only time these arrays are directly exposed 140 * is in the sendSAXcharacters call. 141 */ 142 char[][] m_array; 143 144 /** 145 * Field m_lastChunk is an index into m_array[], pointing to the last 146 * chunk of the Chunked Array currently in use. Note that additional 147 * chunks may actually be allocated, eg if the FastStringBuffer had 148 * previously been truncated or if someone issued an ensureSpace request. 149 *
 150 * The insertion point for append operations is addressed by the combination 151 * of m_lastChunk and m_firstFree. 152 */ 153 int m_lastChunk = 0; 154 155 /** 156 * Field m_firstFree is an index into m_array[m_lastChunk][], pointing to 157 * the first character in the Chunked Array which is not part of the 158 * FastStringBuffer's current content. Since m_array[][] is zero-based, 159 * the length of that content can be calculated as 160 * (m_lastChunk<<m_chunkBits) + m_firstFree 161 */ 162 int m_firstFree = 0; 163 164 /** 165 * Field m_innerFSB, when non-null, is a FastStringBuffer whose total 166 * length equals m_chunkSize, and which replaces m_array[0]. This allows 167 * building a hierarchy of FastStringBuffers, where early appends use 168 * a smaller chunkSize (for less wasted memory overhead) but later 169 * ones use a larger chunkSize (for less heap activity overhead). 170 */ 171 FastStringBuffer m_innerFSB = null; 172 173 /** 174 * Construct a FastStringBuffer, with allocation policy as per parameters. 175 *
 176 * For coding convenience, I've expressed both allocation sizes in terms of 177 * a number of bits. That's needed for the final size of a chunk, 178 * to permit fast and efficient shift-and-mask addressing. It's less critical 179 * for the inital size, and may be reconsidered. 180 *
 181 * An alternative would be to accept integer sizes and round to powers of two; 182 * that really doesn't seem to buy us much, if anything. 183 * 184 * @param initChunkBits Length in characters of the initial allocation 185 * of a chunk, expressed in log-base-2. (That is, 10 means allocate 1024 186 * characters.) Later chunks will use larger allocation units, to trade off 187 * allocation speed of large document against storage efficiency of small 188 * ones. 189 * @param maxChunkBits Number of character-offset bits that should be used for 190 * addressing within a chunk. Maximum length of a chunk is 2^chunkBits 191 * characters. 192 * @param rebundleBits Number of character-offset bits that addressing should 193 * advance before we attempt to take a step from initChunkBits to maxChunkBits 194 */ 195 public FastStringBuffer(int initChunkBits, int maxChunkBits, 196 int rebundleBits) 197 { 198 if(DEBUG_FORCE_INIT_BITS!=0) initChunkBits=DEBUG_FORCE_INIT_BITS; 199 200 // %REVIEW% 201 // Should this force to larger value, or smaller? Smaller less efficient, but if 202 // someone requested variable mode it's because they care about storage space. 203 // On the other hand, given the other changes I'm making, odds are that we should 204 // adopt the larger size. Dither, dither, dither... This is just stopgap workaround 205 // anyway; we need a permanant solution. 206 // 207 if(DEBUG_FORCE_FIXED_CHUNKSIZE) maxChunkBits=initChunkBits; 208 //if(DEBUG_FORCE_FIXED_CHUNKSIZE) initChunkBits=maxChunkBits; 209 210 m_array = new char[16][]; 211 212 // Don't bite off more than we're prepared to swallow! 213 if (initChunkBits > maxChunkBits) 214 initChunkBits = maxChunkBits; 215 216 m_chunkBits = initChunkBits; 217 m_maxChunkBits = maxChunkBits; 218 m_rebundleBits = rebundleBits; 219 m_chunkSize = 1 << (initChunkBits); 220 m_chunkMask = m_chunkSize - 1; 221 m_array[0] = new char[m_chunkSize]; 222 } 223 224 /** 225 * Construct a FastStringBuffer, using a default rebundleBits value. 226 * 227 * NEEDSDOC @param initChunkBits 228 * NEEDSDOC @param maxChunkBits 229 */ 230 public FastStringBuffer(int initChunkBits, int maxChunkBits) 231 { 232 this(initChunkBits, maxChunkBits, 2); 233 } 234 235 /** 236 * Construct a FastStringBuffer, using default maxChunkBits and 237 * rebundleBits values. 238 *
 239 * ISSUE: Should this call assert initial size, or fixed size? 240 * Now configured as initial, with a default for fixed. 241 * 242 * NEEDSDOC @param initChunkBits 243 */ 244 public FastStringBuffer(int initChunkBits) 245 { 246 this(initChunkBits, 15, 2); 247 } 248 249 /** 250 * Construct a FastStringBuffer, using a default allocation policy. 251 */ 252 public FastStringBuffer() 253 { 254 255 // 10 bits is 1K. 15 bits is 32K. Remember that these are character 256 // counts, so actual memory allocation unit is doubled for UTF-16 chars. 257 // 258 // For reference: In the original FastStringBuffer, we simply 259 // overallocated by blocksize (default 1KB) on each buffer-growth. 260 this(10, 15, 2); 261 } 262 263 /** 264 * Get the length of the list. Synonym for length(). 265 * 266 * @return the number of characters in the FastStringBuffer's content. 267 */ 268 public final int size() 269 { 270 return (m_lastChunk << m_chunkBits) + m_firstFree; 271 } 272 273 /** 274 * Get the length of the list. Synonym for size(). 275 * 276 * @return the number of characters in the FastStringBuffer's content. 277 */ 278 public final int length() 279 { 280 return (m_lastChunk << m_chunkBits) + m_firstFree; 281 } 282 283 /** 284 * Discard the content of the FastStringBuffer, and most of the memory 285 * that was allocated by it, restoring the initial state. Note that this 286 * may eventually be different from setLength(0), which see. 287 */ 288 public final void reset() 289 { 290 291 m_lastChunk = 0; 292 m_firstFree = 0; 293 294 // Recover the original chunk size 295 FastStringBuffer innermost = this; 296 297 while (innermost.m_innerFSB != null) 298 { 299 innermost = innermost.m_innerFSB; 300 } 301 302 m_chunkBits = innermost.m_chunkBits; 303 m_chunkSize = innermost.m_chunkSize; 304 m_chunkMask = innermost.m_chunkMask; 305 306 // Discard the hierarchy 307 m_innerFSB = null; 308 m_array = new char[16][0]; 309 m_array[0] = new char[m_chunkSize]; 310 } 311 312 /** 313 * Directly set how much of the FastStringBuffer's storage is to be 314 * considered part of its content. This is a fast but hazardous 315 * operation. It is not protected against negative values, or values 316 * greater than the amount of storage currently available... and even 317 * if additional storage does exist, its contents are unpredictable. 318 * The only safe use for our setLength() is to truncate the FastStringBuffer 319 * to a shorter string. 320 * 321 * @param l New length. If l<0 or l>=getLength(), this operation will 322 * not report an error but future operations will almost certainly fail. 323 */ 324 public final void setLength(int l) 325 { 326 m_lastChunk = l >>> m_chunkBits; 327 328 if (m_lastChunk == 0 && m_innerFSB != null) 329 { 330 // Replace this FSB with the appropriate inner FSB, truncated 331 m_innerFSB.setLength(l, this); 332 } 333 else 334 { 335 m_firstFree = l & m_chunkMask; 336 337 // There's an edge case if l is an exact multiple of m_chunkBits, which risks leaving 338 // us pointing at the start of a chunk which has not yet been allocated. Rather than 339 // pay the cost of dealing with that in the append loops (more scattered and more 340 // inner-loop), we correct it here by moving to the safe side of that 341 // line -- as we would have left the indexes had we appended up to that point. 342 if(m_firstFree==0 && m_lastChunk>0) 343 { 344 --m_lastChunk; 345 m_firstFree=m_chunkSize; 346 } 347 } 348 } 349 350 /** 351 * Subroutine for the public setLength() method. Deals with the fact 352 * that truncation may require restoring one of the innerFSBs 353 * 354 * NEEDSDOC @param l 355 * NEEDSDOC @param rootFSB 356 */ 357 private final void setLength(int l, FastStringBuffer rootFSB) 358 { 359 360 m_lastChunk = l >>> m_chunkBits; 361 362 if (m_lastChunk == 0 && m_innerFSB != null) 363 { 364 m_innerFSB.setLength(l, rootFSB); 365 } 366 else 367 { 368 369 // Undo encapsulation -- pop the innerFSB data back up to root. 370 // Inefficient, but attempts to keep the code simple. 371 rootFSB.m_chunkBits = m_chunkBits; 372 rootFSB.m_maxChunkBits = m_maxChunkBits; 373 rootFSB.m_rebundleBits = m_rebundleBits; 374 rootFSB.m_chunkSize = m_chunkSize; 375 rootFSB.m_chunkMask = m_chunkMask; 376 rootFSB.m_array = m_array; 377 rootFSB.m_innerFSB = m_innerFSB; 378 rootFSB.m_lastChunk = m_lastChunk; 379 380 // Finally, truncate this sucker. 381 rootFSB.m_firstFree = l & m_chunkMask; 382 } 383 } 384 385 /** 386 * Note that this operation has been somewhat deoptimized by the shift to a 387 * chunked array, as there is no factory method to produce a String object 388 * directly from an array of arrays and hence a double copy is needed. 389 * By using ensureCapacity we hope to minimize the heap overhead of building 390 * the intermediate StringBuffer. 391 *
 392 * (It really is a pity that Java didn't design String as a final subclass 393 * of MutableString, rather than having StringBuffer be a separate hierarchy. 394 * We'd avoid a lot of double-buffering.) 395 * 396 * @return the contents of the FastStringBuffer as a standard Java string. 397 */ 398 public final String toString() 399 { 400 401 int length = (m_lastChunk << m_chunkBits) + m_firstFree; 402 403 return getString(new StringBuffer(length), 0, 0, length).toString(); 404 } 405 406 /** 407 * Append a single character onto the FastStringBuffer, growing the 408 * storage if necessary. 409 *
 410 * NOTE THAT after calling append(), previously obtained 411 * references to m_array[][] may no longer be valid.... 412 * though in fact they should be in this instance. 413 * 414 * @param value character to be appended. 415 */ 416 public final void append(char value) 417 { 418 419 char[] chunk; 420 421 // We may have preallocated chunks. If so, all but last should 422 // be at full size. 423 424 if (m_firstFree < m_chunkSize) // Simplified test single-character-fits 425 chunk = m_array[m_lastChunk]; 426 else 427 { 428 429 // Extend array? 430 int i = m_array.length; 431 432 if (m_lastChunk + 1 == i) 433 { 434 char[][] newarray = new char[i + 16][]; 435 436 System.arraycopy(m_array, 0, newarray, 0, i); 437 438 m_array = newarray; 439 } 440 441 // Advance one chunk 442 chunk = m_array[++m_lastChunk]; 443 444 if (chunk == null) 445 { 446 447 // Hierarchical encapsulation 448 if (m_lastChunk == 1 << m_rebundleBits 449 && m_chunkBits < m_maxChunkBits) 450 { 451 452 // Should do all the work of both encapsulating 453 // existing data and establishing new sizes/offsets 454 m_innerFSB = new FastStringBuffer(this); 455 } 456 457 // Add a chunk. 458 chunk = m_array[m_lastChunk] = new char[m_chunkSize]; 459 } 460 461 m_firstFree = 0; 462 } 463 464 // Space exists in the chunk. Append the character. 465 chunk[m_firstFree++] = value; 466 } 467 468 /** 469 * Append the contents of a String onto the FastStringBuffer, 470 * growing the storage if necessary. 471 *
 472 * NOTE THAT after calling append(), previously obtained 473 * references to m_array[] may no longer be valid. 474 * 475 * @param value String whose contents are to be appended. 476 */ 477 public final void append(String value) 478 { 479 480 if (value == null) 481 return; 482 int strlen = value.length(); 483 484 if (0 == strlen) 485 return; 486 487 int copyfrom = 0; 488 char[] chunk = m_array[m_lastChunk]; 489 int available = m_chunkSize - m_firstFree; 490 491 // Repeat while data remains to be copied 492 while (strlen > 0) 493 { 494 495 // Copy what fits 496 if (available > strlen) 497 available = strlen; 498 499 value.getChars(copyfrom, copyfrom + available, m_array[m_lastChunk], 500 m_firstFree); 501 502 strlen -= available; 503 copyfrom += available; 504 505 // If there's more left, allocate another chunk and continue 506 if (strlen > 0) 507 { 508 509 // Extend array? 510 int i = m_array.length; 511 512 if (m_lastChunk + 1 == i) 513 { 514 char[][] newarray = new char[i + 16][]; 515 516 System.arraycopy(m_array, 0, newarray, 0, i); 517 518 m_array = newarray; 519 } 520 521 // Advance one chunk 522 chunk = m_array[++m_lastChunk]; 523 524 if (chunk == null) 525 { 526 527 // Hierarchical encapsulation 528 if (m_lastChunk == 1 << m_rebundleBits 529 && m_chunkBits < m_maxChunkBits) 530 { 531 532 // Should do all the work of both encapsulating 533 // existing data and establishing new sizes/offsets 534 m_innerFSB = new FastStringBuffer(this); 535 } 536 537 // Add a chunk. 538 chunk = m_array[m_lastChunk] = new char[m_chunkSize]; 539 } 540 541 available = m_chunkSize; 542 m_firstFree = 0; 543 } 544 } 545 546 // Adjust the insert point in the last chunk, when we've reached it. 547 m_firstFree += available; 548 } 549 550 /** 551 * Append the contents of a StringBuffer onto the FastStringBuffer, 552 * growing the storage if necessary. 553 *
 554 * NOTE THAT after calling append(), previously obtained 555 * references to m_array[] may no longer be valid. 556 * 557 * @param value StringBuffer whose contents are to be appended. 558 */ 559 public final void append(StringBuffer value) 560 { 561 562 if (value == null) 563 return; 564 int strlen = value.length(); 565 566 if (0 == strlen) 567 return; 568 569 int copyfrom = 0; 570 char[] chunk = m_array[m_lastChunk]; 571 int available = m_chunkSize - m_firstFree; 572 573 // Repeat while data remains to be copied 574 while (strlen > 0) 575 { 576 577 // Copy what fits 578 if (available > strlen) 579 available = strlen; 580 581 value.getChars(copyfrom, copyfrom + available, m_array[m_lastChunk], 582 m_firstFree); 583 584 strlen -= available; 585 copyfrom += available; 586 587 // If there's more left, allocate another chunk and continue 588 if (strlen > 0) 589 { 590 591 // Extend array? 592 int i = m_array.length; 593 594 if (m_lastChunk + 1 == i) 595 { 596 char[][] newarray = new char[i + 16][]; 597 598 System.arraycopy(m_array, 0, newarray, 0, i); 599 600 m_array = newarray; 601 } 602 603 // Advance one chunk 604 chunk = m_array[++m_lastChunk]; 605 606 if (chunk == null) 607 { 608 609 // Hierarchical encapsulation 610 if (m_lastChunk == 1 << m_rebundleBits 611 && m_chunkBits < m_maxChunkBits) 612 { 613 614 // Should do all the work of both encapsulating 615 // existing data and establishing new sizes/offsets 616 m_innerFSB = new FastStringBuffer(this); 617 } 618 619 // Add a chunk. 620 chunk = m_array[m_lastChunk] = new char[m_chunkSize]; 621 } 622 623 available = m_chunkSize; 624 m_firstFree = 0; 625 } 626 } 627 628 // Adjust the insert point in the last chunk, when we've reached it. 629 m_firstFree += available; 630 } 631 632 /** 633 * Append part of the contents of a Character Array onto the 634 * FastStringBuffer, growing the storage if necessary. 635 *
 636 * NOTE THAT after calling append(), previously obtained 637 * references to m_array[] may no longer be valid. 638 * 639 * @param chars character array from which data is to be copied 640 * @param start offset in chars of first character to be copied, 641 * zero-based. 642 * @param length number of characters to be copied 643 */ 644 public final void append(char[] chars, int start, int length) 645 { 646 647 int strlen = length; 648 649 if (0 == strlen) 650 return; 651 652 int copyfrom = start; 653 char[] chunk = m_array[m_lastChunk]; 654 int available = m_chunkSize - m_firstFree; 655 656 // Repeat while data remains to be copied 657 while (strlen > 0) 658 { 659 660 // Copy what fits 661 if (available > strlen) 662 available = strlen; 663 664 System.arraycopy(chars, copyfrom, m_array[m_lastChunk], m_firstFree, 665 available); 666 667 strlen -= available; 668 copyfrom += available; 669 670 // If there's more left, allocate another chunk and continue 671 if (strlen > 0) 672 { 673 674 // Extend array? 675 int i = m_array.length; 676 677 if (m_lastChunk + 1 == i) 678 { 679 char[][] newarray = new char[i + 16][]; 680 681 System.arraycopy(m_array, 0, newarray, 0, i); 682 683 m_array = newarray; 684 } 685 686 // Advance one chunk 687 chunk = m_array[++m_lastChunk]; 688 689 if (chunk == null) 690 { 691 692 // Hierarchical encapsulation 693 if (m_lastChunk == 1 << m_rebundleBits 694 && m_chunkBits < m_maxChunkBits) 695 { 696 697 // Should do all the work of both encapsulating 698 // existing data and establishing new sizes/offsets 699 m_innerFSB = new FastStringBuffer(this); 700 } 701 702 // Add a chunk. 703 chunk = m_array[m_lastChunk] = new char[m_chunkSize]; 704 } 705 706 available = m_chunkSize; 707 m_firstFree = 0; 708 } 709 } 710 711 // Adjust the insert point in the last chunk, when we've reached it. 712 m_firstFree += available; 713 } 714 715 /** 716 * Append the contents of another FastStringBuffer onto 717 * this FastStringBuffer, growing the storage if necessary. 718 *
 719 * NOTE THAT after calling append(), previously obtained 720 * references to m_array[] may no longer be valid. 721 * 722 * @param value FastStringBuffer whose contents are 723 * to be appended. 724 */ 725 public final void append(FastStringBuffer value) 726 { 727 728 // Complicating factor here is that the two buffers may use 729 // different chunk sizes, and even if they're the same we're 730 // probably on a different alignment due to previously appended 731 // data. We have to work through the source in bite-sized chunks. 732 if (value == null) 733 return; 734 int strlen = value.length(); 735 736 if (0 == strlen) 737 return; 738 739 int copyfrom = 0; 740 char[] chunk = m_array[m_lastChunk]; 741 int available = m_chunkSize - m_firstFree; 742 743 // Repeat while data remains to be copied 744 while (strlen > 0) 745 { 746 747 // Copy what fits 748 if (available > strlen) 749 available = strlen; 750 751 int sourcechunk = (copyfrom + value.m_chunkSize - 1) 752 >>> value.m_chunkBits; 753 int sourcecolumn = copyfrom & value.m_chunkMask; 754 int runlength = value.m_chunkSize - sourcecolumn; 755 756 if (runlength > available) 757 runlength = available; 758 759 System.arraycopy(value.m_array[sourcechunk], sourcecolumn, 760 m_array[m_lastChunk], m_firstFree, runlength); 761 762 if (runlength != available) 763 System.arraycopy(value.m_array[sourcechunk + 1], 0, 764 m_array[m_lastChunk], m_firstFree + runlength, 765 available - runlength); 766 767 strlen -= available; 768 copyfrom += available; 769 770 // If there's more left, allocate another chunk and continue 771 if (strlen > 0) 772 { 773 774 // Extend array? 775 int i = m_array.length; 776 777 if (m_lastChunk + 1 == i) 778 { 779 char[][] newarray = new char[i + 16][]; 780 781 System.arraycopy(m_array, 0, newarray, 0, i); 782 783 m_array = newarray; 784 } 785 786 // Advance one chunk 787 chunk = m_array[++m_lastChunk]; 788 789 if (chunk == null) 790 { 791 792 // Hierarchical encapsulation 793 if (m_lastChunk == 1 << m_rebundleBits 794 && m_chunkBits < m_maxChunkBits) 795 { 796 797 // Should do all the work of both encapsulating 798 // existing data and establishing new sizes/offsets 799 m_innerFSB = new FastStringBuffer(this); 800 } 801 802 // Add a chunk. 803 chunk = m_array[m_lastChunk] = new char[m_chunkSize]; 804 } 805 806 available = m_chunkSize; 807 m_firstFree = 0; 808 } 809 } 810 811 // Adjust the insert point in the last chunk, when we've reached it. 812 m_firstFree += available; 813 } 814 815 /** 816 * @return true if the specified range of characters are all whitespace, 817 * as defined by XMLCharacterRecognizer. 818 *
 819 * CURRENTLY DOES NOT CHECK FOR OUT-OF-RANGE. 820 * 821 * @param start Offset of first character in the range. 822 * @param length Number of characters to send. 823 */ 824 public boolean isWhitespace(int start, int length) 825 { 826 827 int sourcechunk = start >>> m_chunkBits; 828 int sourcecolumn = start & m_chunkMask; 829 int available = m_chunkSize - sourcecolumn; 830 boolean chunkOK; 831 832 while (length > 0) 833 { 834 int runlength = (length <= available) ? length : available; 835 836 if (sourcechunk == 0 && m_innerFSB != null) 837 chunkOK = m_innerFSB.isWhitespace(sourcecolumn, runlength); 838 else 839 chunkOK = org.apache.xml.utils.XMLCharacterRecognizer.isWhiteSpace( 840 m_array[sourcechunk], sourcecolumn, runlength); 841 842 if (!chunkOK) 843 return false; 844 845 length -= runlength; 846 847 ++sourcechunk; 848 849 sourcecolumn = 0; 850 available = m_chunkSize; 851 } 852 853 return true; 854 } 855 856 /** 857 * @param start Offset of first character in the range. 858 * @param length Number of characters to send. 859 * @return a new String object initialized from the specified range of 860 * characters. 861 */ 862 public String getString(int start, int length) 863 { 864 int startColumn = start & m_chunkMask; 865 int startChunk = start >>> m_chunkBits; 866 if (startColumn + length < m_chunkMask && m_innerFSB == null) { 867 return getOneChunkString(startChunk, startColumn, length); 868 } 869 return getString(new StringBuffer(length), startChunk, startColumn, 870 length).toString(); 871 } 872 873 protected String getOneChunkString(int startChunk, int startColumn, 874 int length) { 875 return new String(m_array[startChunk], startColumn, length); 876 } 877 878 /** 879 * @param sb StringBuffer to be appended to 880 * @param start Offset of first character in the range. 881 * @param length Number of characters to send. 882 * @return sb with the requested text appended to it 883 */ 884 StringBuffer getString(StringBuffer sb, int start, int length) 885 { 886 return getString(sb, start >>> m_chunkBits, start & m_chunkMask, length); 887 } 888 889 /** 890 * Internal support for toString() and getString(). 891 * PLEASE NOTE SIGNATURE CHANGE from earlier versions; it now appends into 892 * and returns a StringBuffer supplied by the caller. This simplifies 893 * m_innerFSB support. 894 *
 895 * Note that this operation has been somewhat deoptimized by the shift to a 896 * chunked array, as there is no factory method to produce a String object 897 * directly from an array of arrays and hence a double copy is needed. 898 * By presetting length we hope to minimize the heap overhead of building 899 * the intermediate StringBuffer. 900 *
 901 * (It really is a pity that Java didn't design String as a final subclass 902 * of MutableString, rather than having StringBuffer be a separate hierarchy. 903 * We'd avoid a lot of double-buffering.) 904 * 905 * 906 * @param sb 907 * @param startChunk 908 * @param startColumn 909 * @param length 910 * 911 * @return the contents of the FastStringBuffer as a standard Java string. 912 */ 913 StringBuffer getString(StringBuffer sb, int startChunk, int startColumn, 914 int length) 915 { 916 917 int stop = (startChunk << m_chunkBits) + startColumn + length; 918 int stopChunk = stop >>> m_chunkBits; 919 int stopColumn = stop & m_chunkMask; 920 921 // Factored out 922 //StringBuffer sb=new StringBuffer(length); 923 for (int i = startChunk; i < stopChunk; ++i) 924 { 925 if (i == 0 && m_innerFSB != null) 926 m_innerFSB.getString(sb, startColumn, m_chunkSize - startColumn); 927 else 928 sb.append(m_array[i], startColumn, m_chunkSize - startColumn); 929 930 startColumn = 0; // after first chunk 931 } 932 933 if (stopChunk == 0 && m_innerFSB != null) 934 m_innerFSB.getString(sb, startColumn, stopColumn - startColumn); 935 else if (stopColumn > startColumn) 936 sb.append(m_array[stopChunk], startColumn, stopColumn - startColumn); 937 938 return sb; 939 } 940 941 /** 942 * Get a single character from the string buffer. 943 * 944 * 945 * @param pos character position requested. 946 * @return A character from the requested position. 947 */ 948 public char charAt(int pos) 949 { 950 int startChunk = pos >>> m_chunkBits; 951 952 if (startChunk == 0 && m_innerFSB != null) 953 return m_innerFSB.charAt(pos & m_chunkMask); 954 else 955 return m_array[startChunk][pos & m_chunkMask]; 956 } 957 958 /** 959 * Sends the specified range of characters as one or more SAX characters() 960 * events. 961 * Note that the buffer reference passed to the ContentHandler may be 962 * invalidated if the FastStringBuffer is edited; it's the user's 963 * responsibility to manage access to the FastStringBuffer to prevent this 964 * problem from arising. 965 *
 966 * Note too that there is no promise that the output will be sent as a 967 * single call. As is always true in SAX, one logical string may be split 968 * across multiple blocks of memory and hence delivered as several 969 * successive events. 970 * 971 * @param ch SAX ContentHandler object to receive the event. 972 * @param start Offset of first character in the range. 973 * @param length Number of characters to send. 974 * @exception org.xml.sax.SAXException may be thrown by handler's 975 * characters() method. 976 */ 977 public void sendSAXcharacters( 978 org.xml.sax.ContentHandler ch, int start, int length) 979 throws org.xml.sax.SAXException 980 { 981 982 int startChunk = start >>> m_chunkBits; 983 int startColumn = start & m_chunkMask; 984 if (startColumn + length < m_chunkMask && m_innerFSB == null) { 985 ch.characters(m_array[startChunk], startColumn, length); 986 return; 987 } 988 989 int stop = start + length; 990 int stopChunk = stop >>> m_chunkBits; 991 int stopColumn = stop & m_chunkMask; 992 993 for (int i = startChunk; i < stopChunk; ++i) 994 { 995 if (i == 0 && m_innerFSB != null) 996 m_innerFSB.sendSAXcharacters(ch, startColumn, 997 m_chunkSize - startColumn); 998 else 999 ch.characters(m_array[i], startColumn, m_chunkSize - startColumn); 1000 1001 startColumn = 0; // after first chunk 1002 } 1003 1004 // Last, or only, chunk 1005 if (stopChunk == 0 && m_innerFSB != null) 1006 m_innerFSB.sendSAXcharacters(ch, startColumn, stopColumn - startColumn); 1007 else if (stopColumn > startColumn) 1008 { 1009 ch.characters(m_array[stopChunk], startColumn, 1010 stopColumn - startColumn); 1011 } 1012 } 1013 1014 /** 1015 * Sends the specified range of characters as one or more SAX characters() 1016 * events, normalizing the characters according to XSLT rules. 1017 * 1018 * @param ch SAX ContentHandler object to receive the event. 1019 * @param start Offset of first character in the range. 1020 * @param length Number of characters to send. 1021 * @return normalization status to apply to next chunk (because we may 1022 * have been called recursively to process an inner FSB): 1023 *
 1024 *
0
 1025 *
if this output did not end in retained whitespace, and thus whitespace 1026 * at the start of the following chunk (if any) should be converted to a 1027 * single space. 1028 *
SUPPRESS_LEADING_WS
 1029 *
if this output ended in retained whitespace, and thus whitespace 1030 * at the start of the following chunk (if any) should be completely 1031 * suppressed.
 1032 *
 1033 *
 1034 * @exception org.xml.sax.SAXException may be thrown by handler's 1035 * characters() method. 1036 */ 1037 public int sendNormalizedSAXcharacters( 1038 org.xml.sax.ContentHandler ch, int start, int length) 1039 throws org.xml.sax.SAXException 1040 { 1041 // This call always starts at the beginning of the 1042 // string being written out, either because it was called directly or 1043 // because it was an m_innerFSB recursion. This is important since 1044 // it gives us a well-known initial state for this flag: 1045 int stateForNextChunk=SUPPRESS_LEADING_WS; 1046 1047 int stop = start + length; 1048 int startChunk = start >>> m_chunkBits; 1049 int startColumn = start & m_chunkMask; 1050 int stopChunk = stop >>> m_chunkBits; 1051 int stopColumn = stop & m_chunkMask; 1052 1053 for (int i = startChunk; i < stopChunk; ++i) 1054 { 1055 if (i == 0 && m_innerFSB != null) 1056 stateForNextChunk= 1057 m_innerFSB.sendNormalizedSAXcharacters(ch, startColumn, 1058 m_chunkSize - startColumn); 1059 else 1060 stateForNextChunk= 1061 sendNormalizedSAXcharacters(m_array[i], startColumn, 1062 m_chunkSize - startColumn, 1063 ch,stateForNextChunk); 1064 1065 startColumn = 0; // after first chunk 1066 } 1067 1068 // Last, or only, chunk 1069 if (stopChunk == 0 && m_innerFSB != null) 1070 stateForNextChunk= // %REVIEW% Is this update really needed? 1071 m_innerFSB.sendNormalizedSAXcharacters(ch, startColumn, stopColumn - startColumn); 1072 else if (stopColumn > startColumn) 1073 { 1074 stateForNextChunk= // %REVIEW% Is this update really needed? 1075 sendNormalizedSAXcharacters(m_array[stopChunk], 1076 startColumn, stopColumn - startColumn, 1077 ch, stateForNextChunk | SUPPRESS_TRAILING_WS); 1078 } 1079 return stateForNextChunk; 1080 } 1081 1082 static final char[] SINGLE_SPACE = {' '}; 1083 1084 /** 1085 * Internal method to directly normalize and dispatch the character array. 1086 * This version is aware of the fact that it may be called several times 1087 * in succession if the data is made up of multiple "chunks", and thus 1088 * must actively manage the handling of leading and trailing whitespace. 1089 * 1090 * Note: The recursion is due to the possible recursion of inner FSBs. 1091 * 1092 * @param ch The characters from the XML document. 1093 * @param start The start position in the array. 1094 * @param length The number of characters to read from the array. 1095 * @param handler SAX ContentHandler object to receive the event. 1096 * @param edgeTreatmentFlags How leading/trailing spaces should be handled. 1097 * This is a bitfield contining two flags, bitwise-ORed together: 1098 *
 1099 *
SUPPRESS_LEADING_WS
 1100 *
When false, causes leading whitespace to be converted to a single 1101 * space; when true, causes it to be discarded entirely. 1102 * Should be set TRUE for the first chunk, and (in multi-chunk output) 1103 * whenever the previous chunk ended in retained whitespace.
 1104 *
SUPPRESS_TRAILING_WS
 1105 *
When false, causes trailing whitespace to be converted to a single 1106 * space; when true, causes it to be discarded entirely. 1107 * Should be set TRUE for the last or only chunk. 1108 *
 1109 *
 1110 * @return normalization status, as in the edgeTreatmentFlags parameter: 1111 *
 1112 *
0
 1113 *
if this output did not end in retained whitespace, and thus whitespace 1114 * at the start of the following chunk (if any) should be converted to a 1115 * single space. 1116 *
SUPPRESS_LEADING_WS
 1117 *
if this output ended in retained whitespace, and thus whitespace 1118 * at the start of the following chunk (if any) should be completely 1119 * suppressed.
 1120 *
 1121 *
 1122 * 1123 * 1124 * @exception org.xml.sax.SAXException Any SAX exception, possibly 1125 * wrapping another exception. 1126 */ 1127 static int sendNormalizedSAXcharacters(char ch[], 1128 int start, int length, 1129 org.xml.sax.ContentHandler handler, 1130 int edgeTreatmentFlags) 1131 throws org.xml.sax.SAXException 1132 { 1133 boolean processingLeadingWhitespace = 1134 ((edgeTreatmentFlags & SUPPRESS_LEADING_WS) != 0); 1135 boolean seenWhitespace = ((edgeTreatmentFlags & CARRY_WS) != 0); 1136 int currPos = start; 1137 int limit = start+length; 1138 1139 // Strip any leading spaces first, if required 1140 if (processingLeadingWhitespace) { 1141 for (; currPos < limit 1142 && XMLCharacterRecognizer.isWhiteSpace(ch[currPos]); 1143 currPos++) { } 1144 1145 // If we've only encountered leading spaces, the 1146 // current state remains unchanged 1147 if (currPos == limit) { 1148 return edgeTreatmentFlags; 1149 } 1150 } 1151 1152 // If we get here, there are no more leading spaces to strip 1153 while (currPos < limit) { 1154 int startNonWhitespace = currPos; 1155 1156 // Grab a chunk of non-whitespace characters 1157 for (; currPos < limit 1158 && !XMLCharacterRecognizer.isWhiteSpace(ch[currPos]); 1159 currPos++) { } 1160 1161 // Non-whitespace seen - emit them, along with a single 1162 // space for any preceding whitespace characters 1163 if (startNonWhitespace != currPos) { 1164 if (seenWhitespace) { 1165 handler.characters(SINGLE_SPACE, 0, 1); 1166 seenWhitespace = false; 1167 } 1168 handler.characters(ch, startNonWhitespace, 1169 currPos - startNonWhitespace); 1170 } 1171 1172 int startWhitespace = currPos; 1173 1174 // Consume any whitespace characters 1175 for (; currPos < limit 1176 && XMLCharacterRecognizer.isWhiteSpace(ch[currPos]); 1177 currPos++) { } 1178 1179 if (startWhitespace != currPos) { 1180 seenWhitespace = true; 1181 } 1182 } 1183 1184 return (seenWhitespace ? CARRY_WS : 0) 1185 | (edgeTreatmentFlags & SUPPRESS_TRAILING_WS); 1186 } 1187 1188 /** 1189 * Directly normalize and dispatch the character array. 1190 * 1191 * @param ch The characters from the XML document. 1192 * @param start The start position in the array. 1193 * @param length The number of characters to read from the array. 1194 * @param handler SAX ContentHandler object to receive the event. 1195 * @exception org.xml.sax.SAXException Any SAX exception, possibly 1196 * wrapping another exception. 1197 */ 1198 public static void sendNormalizedSAXcharacters(char ch[], 1199 int start, int length, 1200 org.xml.sax.ContentHandler handler) 1201 throws org.xml.sax.SAXException 1202 { 1203 sendNormalizedSAXcharacters(ch, start, length, 1204 handler, SUPPRESS_BOTH); 1205 } 1206 1207 /** 1208 * Sends the specified range of characters as sax Comment. 1209 *
 1210 * Note that, unlike sendSAXcharacters, this has to be done as a single 1211 * call to LexicalHandler#comment. 1212 * 1213 * @param ch SAX LexicalHandler object to receive the event. 1214 * @param start Offset of first character in the range. 1215 * @param length Number of characters to send. 1216 * @exception org.xml.sax.SAXException may be thrown by handler's 1217 * characters() method. 1218 */ 1219 public void sendSAXComment( 1220 org.xml.sax.ext.LexicalHandler ch, int start, int length) 1221 throws org.xml.sax.SAXException 1222 { 1223 1224 // %OPT% Do it this way for now... 1225 String comment = getString(start, length); 1226 ch.comment(comment.toCharArray(), 0, length); 1227 } 1228 1229 /** 1230 * Copies characters from this string into the destination character 1231 * array. 1232 * 1233 * @param srcBegin index of the first character in the string 1234 * to copy. 1235 * @param srcEnd index after the last character in the string 1236 * to copy. 1237 * @param dst the destination array. 1238 * @param dstBegin the start offset in the destination array. 1239 * @exception IndexOutOfBoundsException If any of the following 1240 * is true: 1241 *

srcBegin is negative. 1242 *
srcBegin is greater than srcEnd 1243 *
srcEnd is greater than the length of this 1244 * string 1245 *
dstBegin is negative 1246 *
dstBegin+(srcEnd-srcBegin) is larger than 1247 * dst.length
 1248 * @exception NullPointerException if dst is null 1249 */ 1250 private void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) 1251 { 1252 // %TBD% Joe needs to write this function. Make public when implemented. 1253 } 1254 1255 /** 1256 * Encapsulation c'tor. After this is called, the source FastStringBuffer 1257 * will be reset to use the new object as its m_innerFSB, and will have 1258 * had its chunk size reset appropriately. IT SHOULD NEVER BE CALLED 1259 * EXCEPT WHEN source.length()==1<<(source.m_chunkBits+source.m_rebundleBits) 1260 * 1261 * NEEDSDOC @param source 1262 */ 1263 private FastStringBuffer(FastStringBuffer source) 1264 { 1265 1266 // Copy existing information into new encapsulation 1267 m_chunkBits = source.m_chunkBits; 1268 m_maxChunkBits = source.m_maxChunkBits; 1269 m_rebundleBits = source.m_rebundleBits; 1270 m_chunkSize = source.m_chunkSize; 1271 m_chunkMask = source.m_chunkMask; 1272 m_array = source.m_array; 1273 m_innerFSB = source.m_innerFSB; 1274 1275 // These have to be adjusted because we're calling just at the time 1276 // when we would be about to allocate another chunk 1277 m_lastChunk = source.m_lastChunk - 1; 1278 m_firstFree = source.m_chunkSize; 1279 1280 // Establish capsule as the Inner FSB, reset chunk sizes/addressing 1281 source.m_array = new char[16][]; 1282 source.m_innerFSB = this; 1283 1284 // Since we encapsulated just as we were about to append another 1285 // chunk, return ready to create the chunk after the innerFSB 1286 // -- 1, not 0. 1287 source.m_lastChunk = 1; 1288 source.m_firstFree = 0; 1289 source.m_chunkBits += m_rebundleBits; 1290 source.m_chunkSize = 1 << (source.m_chunkBits); 1291 source.m_chunkMask = source.m_chunkSize - 1; 1292 } 1293 }


--- layout: post title: The Register on I-mode date: 2005-10-27 00:00:00 categories: business interfaces-&-interaction mobile ---
El Reg on I-mode: "There's no denying that i-mode is great. I love the way it works, the selection of content, the pricing structure, the speed of access and the bundled push email. Unfortunately, the NEC N411i just feels a little behind the times in today's world of super stylish and fully featured mobiles. NEC should be congratulated for getting i-mode handsets out so quickly, but something tells me that we'll be seeing far better examples in the near future."
What can I say, other than +1


These are your graphs. Currently they are
{% if request.user.openhumansmember.public%}
public 🔗.
You can show them to people using this link.
You can also make them private again.
{%else%}
private 🚫.
You need to make them public before you can link people to them.
{%endif%}


Sprint 2
Topic: Identity, Values and Strengths Learning Plan Others
HTML-CSS: Margin, Border and Padding
What is the difference between Margin, Border, and Padding?
The border is the layer of the HTML/CSS element that sits between margin and padding. By default, the border does not have any width, but you can set one with the border property.
Margin and padding are always parts of an element, even if there’s no visible border. This image below illustrates such a case:
To set the same margin value on all four sides of an element, use the margin property.
To set the margin for specific sides of an element,
use the
margin-top,
margin-right,margin-bottom,and
margin-left properties.
| HTML Example: | CSS Example: |
|---|---|
| Results: | |
Like with margins, padding has four sides to be declared: top, right, bottom, and left.
To set padding on all sides, use the shorthand property padding.
To set padding for a specific side, use the
padding-top,padding-right,
padding-bottom, and
padding-left properties.
| HTML Example: | CSS Example: |
|---|---|
| Results: | |
You can also specify the margin & padding property with two, three, or four values
depending on
the sides you want to apply margins to.
If you want even margins or padding on every side, you’ll only need to apply one value. Otherwise,
the order of the values is important:
|
|
|
|
|
|
In conclusion, margin, border, and padding go hand-in-hand when it comes to designing your
website.
All of these properties help in making a website more breathable, readable, and appealing, when
configured correctly.


18.5
18.5–24.9
25.0–29.9
30.0–34.9
35.0–39.9
≥ 40.0
Uderweight
Normal Weight
Overweight
Class I Obesity
Class II Obesity
Class III Obesity


by Jason Lengstorf
@jlengstorf ·<EMAIL_ADDRESS>Slides: git.io/right-thing-easy-thing
“Very few things at work feel better than the validation of other people praising your contributions in public.”Marisa MorbyHead of Research, Clearhead
“It doesn’t matter how objectively correct your solution is; it only matters if people will use it.”
Me, just now
“Weigh the trade-offs and choose the thing that makes your team more productive.”
Jem YoungSenior Software Engineer, Netflix
“Premature optimization can be a violent source of tech debt. If you have experience and know it’s the right move, great. Otherwise: keep it as simple as possible for as long as possible.”
Chris BiscardiSoftware Engineer, Honeycomb
Jason Lengstorf
Follow me on Twitter: @jlengstorf
Tweet: @jlengstorf #LeadDevNewYork


| DOSE: |
1 tablet |
oral |
Pharms - Escitalopram |
(daily) |
I recently recived Lexapro for anti-anxiety treatment and I happend to find something very interesting. After moderate use of MDMA I realised that the first day on Lexapro could be felt moderating my mood/attitude/perception.
I was a casual cannabis smoker and after about 2 weeks on Lexapro I decided to smoke a joint with a friend. My friend that I smoked with decided to head upstairs and I was left alone at the kitchen table. As I stared off into the distance I started to feel a fuzzy warm feeling all over my body. It was an intensity that just kept coming. Sights and sounds were starting to distort slightly. I could almost no longer feel my limbs and then it subsided. I was awed at this phenomenon but it faded quickly.
About 3 months later still on Lexapro I wound up smoking about 2 bowls which wasn't very much, however, I have a small history of seizures (twice so far in my life time) and I could tell right away when I started to walk my vision started to close in upon me. I calmly sat down and my vision slowly returned. I decided I would go sit down somewhere else and I got up only to hear voices fade and my vision dull until I woke up on the floor with my family surrounding me. I was fine, but the ambulance was apparently called and they did some tests on me right there. Also my blood was so thin that they wanted to take me to the hospital.
I won't drive after smoking, but, I smoke often and I can repeat this any time. I smoked 2 nights ago and it was so intense that I couldn't feel my legs nor my arms. It almost seems as if my body isn't real. It's almost as if I expect it to be real, and so it is.
Lastly, this is the biggest benefit of Lexapro and Cannabis. While committing to daily routine of Lexapro, after smoking I usually can remember everything that happeneds and my perception feels hightened. I find it easy to analyze people that are or are not smoking. It brings a control mechanism into the whole experience that never fails. This is one constant.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Tutorials
HTML
Introduction
Editors
Styles
Formatting
Tables
CSS
Introduction
Syntax
Tables
Box Model
Position
JAVA SCRIPT
Introduction
Statements
Variables
Data Types
Functions
Objects
SQL
Introduction
Distinct
Oreder By
Injection
Primarykey
PHP
Introduction
Constants
Operators
Arrays
Operators
BOOTSTRAP
Getting Started
Grid Basic
Typography
Images
Jumbotron
Training Scheduler Panel
Note
: To Schedule classes, drag the topics from
Tutorials
and drop it over
Training Scheduler Panel
Subject:
Description:
StartTime:
EndTime:
Resource:
ownerId:
Cancel
Save


{{ if .button.enable }}
{{ with .button }}
{{.label}}
{{ end }}
{{ end }}
{{ end }}
Sasya means ‘Blue/Green’ or ‘Rain/Grain’
Sasya is a IOT technology company with focus on creating agriculture automation products for farmers and commercial growers
Vision & Mission Statement
We enable agriculture farms and greenhouses, helping farmers in automating and optimizing their farming activities, reducing costs and increasing yield
Our play
We provides IoT based Smart irrigation, Climate Control and Biofloc Culture Management products for agricultural fields, Green-houses and in-situ fisheries using Biofloc. We bring together sensors, communication gateways and the cloud technology along with Agri-knowledge for precision farming.
Our Team
A group of technocrats with decades of experience in hardware design and fabrication, software system architecture, plant genetics, fertilizer and precision agriculture and above all passion for agriculture
{{ if site.Data.about.team.enable }}
{{ with site.Data.about.team }}


Instructor and Course Designer
Context // Alpha is a start-up charter middle school in East San Jose that is committed to personalized learning through the use of technology and data-driven instruction. During my time at Alpha, I was tasked with designing and teaching a new enrichment elective called “Explorations” focused on creativity and technology. It was offered in three 90 minute classes each week with approximately 80 - 100 students (a mix of 6th, 7th, and 8th grade) in each class session (in a cafeteria with me). Each student had a chromebook or lenovo. Students were able to attend if they received no office referrals, completed all their homework, and had 0 absences during the previous week.
Problem // How might we make behavior expectations and classroom routine clear when there is not consistency in which students attend each week? How might we enable students to learn something entirely new without direct instruction from a teacher? How might we overcome the fact that there is one instructor and often 80 - 100 students in the room who need help and are all at entirely different places in their learning and what they are working on? How might we provide a sense of "building to something bigger" without it feeling too big to bother for students who have a short attention span and for who may not be able to attend class every week? How might we make the cafeteria feel less like something gross and more like something magical? How might we keep students accountable to their own goals and help celebrate their progress?
Solution // We had to get incredibly creative and keep testing new ideas from week to week. After many iterations, we landed on a model where students were provided with the same routine every class:


--- layout: default title: Blockquotes number: 5 ---
A blockquote is a sentence or paragraph that's been specially formatted to draw attention to the reader. For example:
"The sin of doing nothing is the deadliest of all the seven sins. It has been said that for evil men to accomplish their purpose it is only necessary that good men should do nothing."
To create a block quote, all you have to do is preface a line with the "greater than"
caret (>
). For example:
In the box below, turn the words between quotation marks into a blockquote:


How to create a mmenu
First include jQuery and the jQuery.mmenu-plugin files in your webpage:
<head> <script type="text/javascript" language="javascript" src="jquery.js"></script> <script type="text/javascript" language="javascript" src="jquery.mmenu.js"></script> <link type="text/css" rel="stylesheet" media="all" href="mmenu.css" /> </head>
Optionally, you can include the mmenu-widescreen.css file to always have the menu opened on wider screens, use media-queries to specify the minimum width:
<link type="text/css" rel="stylesheet" media="all and (min-width: 900px)" href="mmenu-widescreen.css" />
Optionally, you can include the mmenu-sizing-large.css file for larger buttons:
<link type="text/css" rel="stylesheet" href="mmenu-sizing-large.css" />
Optionally, you can include the mmenu-theme-light.css file for a light color theme:
<link type="text/css" rel="stylesheet" href="mmenu-theme-light.css" />
If you want to customize the colors of your menu, all you need to do is change its background-color:
#my-menu { background-color: #322; }
Next up: The page »


2020 Ford Everest Sport pricing and specs
New black-pack trim level to hit dealerships alongside MY20 range late in 2019, with new LED headlights for top-spec models.
by James Wong- shares
The 2020 Ford Everest line-up will be joined by a new Everest Sport variant before the end of this year, bringing a range of dark-themed upgrades priced from $62,290 plus on-road costs.
Slotting between the Trend and Titanium grades, the Everest Sport will be available with both the 3.2-litre five-cylinder turbo-diesel and 2.0-litre four-cylinder bi-turbo diesel powertrains, fitted as standard with an automatic transmission, four-wheel drive, and seven seats.

There's also black 20-inch alloy wheels, unique 'Sport' badging, and a new Deep Crystal Blue 'hero' colour (pictured).
We don't have images of the interior yet, though Ford Australia has confirmed the Everest Sport will get Raceway Blue door pulls and door trim accents, leather-accented first- and second-row seats, exclusive Capital Blue stitching, and a soft-touch dash pad (also with the blue top-stitching).
The Everest Sport also gets a new windscreen-mounted USB port as standard (part of the range-wide MY20 upgrades) which is designed for dash cameras – a Garmin Dash Cam GA55 will be offered through Ford dealerships.
As mentioned above, the Sport will be offered with the 143kW/470Nm 3.2-litre five-cylinder turbo-diesel teamed with a six-speed automatic, or a 157kW/500Nm 2.0-litre bi-turbo four-pot diesel.
Braked towing capacity is rated at 3000kg for the 3.2-litre model, while the 2.0-litre variant bumps the tow rating to 3100kg.
In terms of safety equipment, the Everest Sport will feature a suite of safety systems and driver aids, including seven airbags (with curtain coverage to third third row), autonomous emergency braking with pedestrian detection, lane-keeping aid, traffic sign recognition, auto high-beam, rear-view camera with rear parking sensors, cruise control with speed limiter, hill descent control, hill launch assist, and an E-locking rear differential.
Beyond the addition of the new trim level, the MY20 Everest range picks up the aforementioned windscreen-mounted USB port for dash cameras, while the Trend and Titanium pick up the high-performance bi-LED headlight system.
The entry-level Ambiente rear-wheel drive 3.2-litre model kicks off at $49,490 plus on-road costs, topping out at $72,590 plus on-road costs for the 2.0-litre Titanium 4WD.
See below for a full pricing breakdown
2020 Ford Everest pricing
- Ambiente RWD 3.2 - $49,490
- Ambiente 4x4 3.2 - $54,490
- Trend RWD 2.0 - $56,490
- Trend 4x4 3.2 - $60,290
- Trend 4x4 2.0 - $61,790
- Sport 4x4 3.2 - $62,290
- Sport 4x4 2.0 - $63,790
- Titanium 4x4 2.0 - $72,590
Options
- Seven seats (Ambiente) - $1000
- Tow bar (Ambiente, Trend, Sport) - $1000
- Prestige paint - $650
- Fabric upholstery (Trend) - $NCO
- 18-inch off-road wheel/tyres (Titanium) - $NCO
All prices exclude on-road costs
1
9
nextprevious
2020 Ford Everest Sport pricing and specs


Justify Admin
Request Management
User Management
ID
First name
Last name
Role
Actions
Editing user
First name:
Last name:


This website is still in the Alpha phase. There are a number of issues which are listed below.
However, feel free to use it and please let me know of any feedback you may have.
This website allows you to launch and to convert web shortcut files.
Web shortcuts are the files that are created by various operating systems when you save a link to a website.
It supports shortcut files for Windows, Linux, and Apple.
Specifically, these are files with the following extensions: .url, .website, .desktop, .webloc .
This website is part of the Web Shortcut Utility Suite.
The source code for the website is available here.
Known issues
-
There are problems with files that have unicode characters in the file names and/or URLs.
Sometimes these files will cause the website to give errors. I am not sure what all of the factors are (e.g. how much of the problem
is due to browser support and and how much of it is due to server issues).
Sometimes the issues seem to be intermittent.
I have included a "Remove unicode characters from file names" checkbox on the converter website which may help in some cases.
-
Sometimes .url files will be created as if the URLs contain unicode characters even though they do not.
The .url files still work, but are not as clean as they should be.
-
On the Android browser, the website will report an error for files that have unicode characters in the file name.
This requires more investigation, but appears to be an issue with the browser itself.
Privacy
Not only are the shortcut files uploaded to a server, but they are sent unencrypted.
If you have any privacy concerns, I suggest that you avoid this website.


{% load i18n %} {% load hq_shared_tags %} {% load crispy_forms_tags %}
{% blocktrans %} Navigate to the Add Webhook Service page in the Telerivet website. Show Me How Hide Instructions {% endblocktrans %}
{% blocktrans %} You may need to click "Add New Service" in the top-right corner of the page. {% endblocktrans %}
{% blocktrans %} Enter the information below and click Done. Show Me How Hide Instructions {% endblocktrans %}
| Service Name | CommCare HQ |
|---|---|
| Webhook URL | {{ webhook_url }} |
| Webhook Secret | {{ webhook_secret}} |
| Advanced Settings > Selected Phones | {% trans "(Select ONLY the Android phone you are setting up with Telerivet right now)" %} |
{% trans "NOTE: Please make sure you enter https, not http, for the URL." %}
{% endif %}
{% blocktrans %} After creating the Webhook Service in the Telerivet website, send a reply to the message you received in Step 2. {% endblocktrans %}
{% blocktrans %} after you have sent the reply SMS. {% endblocktrans %}
{% trans "Waiting for inbound SMS..." %}
{% trans "Message received!" %}
{% blocktrans %} Message not received. {% endblocktrans %}
{% blocktrans %} An error occurred. This can happen if it has been longer than one week since you started the Telerivet setup process in CommCare HQ. Please restart the setup process and if the problem persists, please report an issue. {% endblocktrans %}
Look at the guidelines below for possible points of failure. At any point, you can send another SMS from your test phone to the Android phone, and if it is received by CommCare HQ, step 4 will automatically update and show you a success message.


This microservice parses the request header and returns a JSON object containing the IP, language, and OS of the user.


All About Noe
In my current role at Walgreens I act as a Lead Expert in insurance billing and pharmacy operations. I assist and coach Pharmacy Interns and Technicians on processing, filling and dispensing of medications. I am a passionate emerging professional who enjoys teaching new entrants and continuously grow in perfecting my skillset.
In my previous position at Target, I was recognized as "Team Member of the Month" for my ability to teach trainees and having a "Fast, Fun and Friendly" mindset. I enjoy problem solving and learning more information so I can better teach those around me.
With a background in Pre-Nursing and Pharmaceuticals, I am now seeking a professional career in Software Development as a full time student.


To start a new quiz, click 'Restart Quiz'. If you would like to change some of your answers to try to get a different match, click 'Change My Answers'.


This only works in browsers that natively support Function.prototype.bind().
Function.prototype.bind()


STWServiceCallOperation Class Reference
| Inherits from | NSOperation |
| Conforms to | STWServiceCallContext |
| Declared in | STWServiceCallOperation.h STWServiceCallOperation.m |
Overview
STWServiceCallOperation class performs Straw Service Method Call procedure.
The operation is performed in main thread or in background according to Service Method configuration.
Tasks
Other Methods
-
serviceCall
property -
service
property -
bridge
property -
keepAlive
property -
– initWithCall:withService:withBridge:
Other Methods
Properties
bridge
the NativeBridge object
@property (nonatomic, assign) STWNativeBridge *bridge
Discussion
the NativeBridge object
Declared In
STWServiceCallOperation.h
keepAlive
The flag to keep alive the browser’s callback function.
@property (nonatomic, assign) BOOL keepAlive
Discussion
The flag to keep alive the browser’s callback function.
The default value is NO.
Declared In
STWServiceCallOperation.h
Instance Methods
failWithCode:withMessage:
Fails the Service Method call with an error code and a message.
- (void)failWithCode:(NSInteger)code withMessage:(NSString *)message
Parameters
- code
error code
- message
error message
Discussion
Fails the Service Method call with an error code and a message.
Declared In
STWServiceCallContext.h
initWithCall:withService:withBridge:
- (instancetype)initWithCall:(STWServiceCall *)call withService:(id<STWService>)service withBridge:(STWNativeBridge *)bridge
Return Value
service call operation instance
Declared In
STWServiceCallOperation.h
succeed
Succeeds the Service Method call (without any information).
- (void)succeed
Discussion
Succeeds the Service Method call (without any information).
Declared In
STWServiceCallContext.h
succeedWithNumber:
Succeeds the Service Method call with a number.
- (void)succeedWithNumber:(NSNumber *)number
Parameters
- number
success result number
Discussion
Succeeds the Service Method call with a number.
Declared In
STWServiceCallContext.h


This package contains helper classes for random address objects and classes for generate address random data


Records¶
A DNS record belongs to a particular domain and is used to specify information about the domain.
There are several types of DNS records. Examples include mail exchange (MX) records, which specify the mail server for a particular domain, and name server (NS) records, which specify the authoritative name servers for a domain.
It is represented by the OpenCloud\DNS\Resource\Record class. Records belong to a Domain.
Get record¶
In order to retrieve details for a specific DNS record, you will need its id:
$record = $domain->record('NS-1234567');
If you do not have this ID at your disposal, you can traverse the record collection and do a string comparison (detailed below).
List records¶
This call lists all records configured for the specified domain.
$records = $domain->recordList();
foreach ($records as $record) {
printf("Record name: %s, ID: %s, TTL: %s\n", $record->name, $record->id, $record->ttl);
}
Please consult the iterator documentation for more information about iterators.
Query parameters¶
You can pass in an array of query parameters for greater control over your search:
Find a record ID from its name¶
For example:
$records = $domain->recordList(array(
'name' => 'imap.example.com',
'type' => 'MX'
));
foreach ($records as $record) {
$recordId = $record->id;
}
Add record¶
This call adds a new record to the specified domain:
$record = $domain->record(array(
'type' => 'A',
'name' => 'example.com',
'data' => '<IP_ADDRESS>',
'ttl' => 3600
));
$record->create();
Please be aware that records that are added with a different hostname than the parent domain might fail silently.
Modify record¶
$record = $domain->record(123456);
$record->ttl -= 100;
$record->update();
Delete record¶
$record->delete();


WITNESS LIST Land & Resource Management Committee April 16, 2003-8:00A HB 1760 For: Lange, Allan (Lipan-Kickapoo Water Conservation District) Runge, Caroline (Menard County Underground Water District) Against: Akers, Monte (Texas Municipal League) Registering, but not testifying: For: Brady, Zach (Texas & Southwestern Cattle Raisers Assn) Everheart, Harvey (Mesa Underground Water Conservation District) Holland, Scott (Irion Co. Water Conservation District, Sterling Co. Underground Water Conservation District) Howe, Billy (Texas Farm Bureau) Reinhard, Stan (Hickory UWCD #1) Stewart, Lonnie (Bee GCD and Live Oak UWCD) Williams, CE (Panhandle Groundwater Conservation District) HB 2334 For: Wood, Jerry (City of Houston) HB 2475 For: Wood, Jerry (City of Houston) HB 3311 For: Lee, Donald (Texas Conference of Urban Counties) On: Gladney, Karen (Texas Assoc. of Counties) Registering, but not testifying: For: Allison, Jim (County Judges & Commissioners Assn of Tx) Mendez, Mark (Tarrant County Commissioners Court) Mitchell, Seth (Bexar County Commissioners Court) Sims, Randy (Brazos Co, Ass Co Judges & Comm of TX)


{%comment%} Previous/next page links - only displayed on page 2+ {%endcomment%}
{%include pagination.html %}
{%comment%} This is the post loop - each post will be output using this markup {%endcomment%}
{%for post in include.posts %}
{% assign author_id = "/authors/" | append: post.author%}
{% assign author = site.authors | where: "id", author_id | first %}


example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph example paragraph
second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph second paragraph


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 113488general/82898updatemathlib.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/113488-general/topic/update-mathlib.html


{% extends "views/master.html" %} {% block body %}
{% include 'views/pages/coupon/popup/approval-request-coupon-extension-modal.html' %} {% include 'views/pages/coupon/popup/approval-request-coupon-un-restrict-modal.html' %} {% endblock %} {% block tail %} {% endblock %}


While studying web design at EDA in Wellington, I am keeping a series of blogs to tracking my progress.


1801 East Colonial Drive, Orlando, FL, 32803
West Side View
Conference Room
Parking Lot
Break Room
East Side
Hallway
Interior
Exterior


EQUIPMENT
Services
Location
San Juan
Bayamon
Delivery
About
Equipment Rental for your Commerical Needs and Homeowner Projects
Sales #1
...
Service #1
Price: $ {{article.price}}
Contact: {{article.contactname}}
Phone: {{article.contactphone}}
Description: {{article.content}}
Dustless Blasting in ACTION, Available for rent now!


Form Elements
Rounded Input
Disable
Input Focus
Placeholder
Static Control
<EMAIL_ADDRESS>File Upload
With Help
A block of help text that breaks onto a new line and may extend beyond one line.Search
Size
Select
Textarea
Input Groups
Checkbox And Radio
Place any checkbox or radio option within an input group's addon instead of text.
Text Addon
Place one add-on or button on either side of an input. You may also place one on both sides of an input.
Icon Addon
Place icon instead of text in add-on on either side of an input. You may also place one on both sides of an input.
Button Addon
Buttons in input groups are a bit different and require one extra
level of nesting. Instead of .input-group-addon
,
you'll need to use .input-group-btn
to wrap the
buttons. This is required due to default browser styles that
cannot be overridden.
Buttons With Dropdowns
Place any button or drodowns within an input group's addon instead of text.
Size
Add the relative form sizing classes to the .input-group
itself and contents within will automatically resize—no need
for repeating the form control size classes on each element.
Checkbox & Radio official website
Checkboxes
Add class .checkbox-custom
to make it.
Radios
Add class .radio-custom
to make it.
Color Options
Add class .checkbox-default
, .checkbox-primary
,
.checkbox-success
, .checkbox-info
,
.checkbox-warning
, .checkbox-danger
,
to change styles.


tpid "Any String Here"
tpid
changes the Tape ID, which appears at the top
of ENDF-6 file. The ID string must be quoted by a double-quotation.
The length of Tape ID must be less than 66 characters. If a given
string is longer than 66, it will be truncated.
A new Tape ID will be written on an output ENDF-6 file, and therefore, this operation does not affect if the output file is not specified.
index
Dece scans the entire ENDF-6 file, and print out the
MF/MT
numbers for the sections given in the file.
This operation is used for browsing the file only.
index
MF 1 451 452 455 456 458 MF 2 151 MF 3 1 2 3 4 16 17 18 19 20 21 37 38 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 102 MF 4 2 18 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 MF 5 18 455 MF 6 16 17 37 91
In this example, the file contains five MT
sections in MF=1
,
one resonance section in MF=2
, etc.
This command is equivalent to the command-line option of -s
% dece -s ENDF_in.DAT
end quit exit
Three operations are the same - quit the code.
echo "any text to be printed."
echo
command does not do any operation but just prints the
given text. Since the output goes into STDERR, the provided message
is only printed when DeCE is executed with the -v
option.
extract MFnumber MTnumber
Print a given MF/MT section from the ENDF-6 file. The output format is in the ENDF-6 format, but no line number.
In the case of MF=2 (resonance parameters), MTnumber can be omitted.
extract 1 455
9.223800+4 2.360058+2 0 2 0 09237 1455 0.000000+0 0.000000+0 0 0 6 09237 1455 1.249423-2 3.025520-2 1.159376-1 3.414764-1 1.318630+0 9.979027+09237 1455 0.000000+0 0.000000+0 0 0 1 49237 1455 4 2 9237 1455 1.000000-5 4.400000-2 4.000000+6 4.400000-2 9.000000+6 2.600000-29237 1455 3.000000+7 2.600000-2 9237 1455 9237 1 0
table MFnumber MTnumber
Same as extract
, but the output data are converted
into a more friendly table format.
In the case of MF=2 (resonance parameters), MTnumber can be omitted.
table 2
# MAT: 2328 MF: 2 MT:151 ZA: 23 - 51 NRS: 64 L: 0 # E J G(neutron) G(gamma) G(fissionA) G(fissionB) -1.760000e+04 4.0 6.500000e+03 1.500000e+00 0.000000e+00 0.000000e+00 -6.000000e+03 3.0 4.845000e+02 1.450000e+00 0.000000e+00 0.000000e+00 4.167000e+03 4.0 5.169800e+02 1.100000e+00 0.000000e+00 0.000000e+00 6.839000e+03 3.0 1.163420e+03 1.800000e+00 0.000000e+00 0.000000e+00 ... (snip) ...
table 3 16
# [ 5325 : 3 : 16 ] 53 - 127 # Cross section # QM-9.1373800e+06 mass difference Q-value # QI-9.1373800e+06 reaction Q-value # NR 1 number of interpolation range # NP 27 lin-lin interpolation 9.210020e+06 0.000000e+00 9.500000e+06 2.821950e-02 1.000000e+07 2.431820e-01 1.050000e+07 5.406310e-01 1.100000e+07 8.082330e-01 ... (snip) ...
table 33 16
# [ 5325 : 33 : 16 ] 53 - 127 # NL: 1 # NC: 0 NI: 1 # LT: 1 LB: 5 NT: 36 NP: 8 1.0000000e-05 0.0000000e+00 0 9.2156700e+06 5.0000000e-01 0 1000 1.0000000e+07 1.8425216e-01 0 0 999 1.2000000e+07 7.9939546e-02 0 0 358 1000 1.4000000e+07 6.5351817e-02 0 0 90 922 1000 1.6000000e+07 6.2279411e-02 0 0 -70<PHONE_NUMBER> 1.8000000e+07 6.3934036e-02 0 0 -193 712<PHONE_NUMBER> 2.0000000e+07 0.0000000e+00
For cross sections, the unit of output quantities can be changed
by option WriteXdataConversion
and WriteYdataConversion
. For example, setting
WriteXdataConversion
to 1e-6 gives the output energy
in MeV.
delete MFnumber MTnumber
This operation removes the MF=MFnumber and MT=MTnumber section.
delete MFnumber
When MTnumber is not given, DeCE removes the whole MF section.
multidelete MFnumber MTstart MTlast
All the sections from MTstart to MTlast are removed.
duplicate MFnumber MTsrc MTdist copy MFnumber MTsrc MTdist
Copy data in the section of MF/MT = MFnumber / MTsrc into MF/MT = MFnumber / MTdest. The MF number of the source and destination sections are the same, and hence given one time.
The copied section will be created if it does not exist on a memory,
or replaced by the source section data if exist. The new section
will be on a memory, unless extract, table
operations are
performed after duplicate, copy
. Note that
duplicate
and copy
are identical.
calc MTdest = MTsrc1 + MTsrc2 calc MTdest = MTsrc1 - MTsrc2 calc MTdest = MTsrc1 * MTsrc2 calc MTdest = MTsrc1 / MTsrc2 calc MTdest = MTsrc1 : MTsrc2
This operation calculates the sum (+), difference (-), product (*),
and quotient (/) of two MT sections in MF=3, and stores the results in the
MT=MTdest section. The MF in this case should be
always 3 (cross section). When MF=3, MT=MTdest
exists, the data are replaced by the calculated numbers. The
calculation is done on a memory, and no output is made by this
operation. To print out the calculated results, extract,
table
operations should be used after this operation.
The operand ":" is a special case. All the sections with the MT numbers of MTsrc1 <= MT <= MTsrc2 are summed.
calc 3 = 16 + 22 extract 3 3
2.305100+4 5.050630+1 0 0 0 02328 3 3 -1.029420+7-1.029420+7 0 0 1 202328 3 3 20 2 2328 3 3 1.049800+7 0.000000+0 1.127000+7 1.70166-10 1.150000+7 1.700940-22328 3 3 1.200000+7 9.660930-2 1.250000+7 2.103090-1 1.300000+7 3.352050-12328 3 3 1.350000+7 4.609190-1 1.400000+7 5.657576-1 1.450000+7 6.451083-12328 3 3 1.500000+7 7.031257-1 1.550000+7 7.443779-1 1.600000+7 7.719527-12328 3 3 1.650000+7 7.909129-1 1.700000+7 8.034029-1 1.750000+7 8.130949-12328 3 3 1.800000+7 8.171865-1 1.850000+7 8.223242-1 1.900000+7 8.235371-12328 3 3 1.950000+7 8.251250-1 2.000000+7 8.246378-1 2328 3 3 2328 3 0
In this example, two sections - (n,2n) and (n,n alpha) cross sections - are added, and the results are stored in MT=3. The Q-value is taken from the (n,n alpha) section, because the threshold energy of this reaction is lower than that of (n,2n).
Note that the selection of Q-value is still ambiguous. DeCE may be confused in some cases.
make4
This operation creates MF/MT=3/4, which is the total inelastic scattering cross sections. This is equivalent to
calc 4 = 51:91
nutotal
This creates MF/MT=1/452, total neutron per fission, by summing MT=455 (delayed neutron) and MT=456 (prompt neutron)


Objective: To dynamically rank the performance of local ISPs by comparing an estimate of rate achieved for a monthly cost of $200
Achieved Rate: The download rate achieved (in Mbps) using Speedtest.net with a target server in Miami at around 8pm weekdays (averaged over 3 tests)
Cost Definition: The monthly cost of your Internet data plan (VAT inclusive) not including TV/Phone.
Metric: Estimated achievable rate (in Mbps) for a monthly cost of $200TT
Trust Model: Only "trusted" users can contribute data or recommend others. A user becomes trusted when recommended by at least one trusted user.
Data Contribution: Send email to<EMAIL_ADDRESS>with subject "ISP performance". First line of body is either Blink, Flow, Digicel, Massy or Greendot. Second line of body is achieved Rate. Third line of body is monthly Cost. Only one contribution is requested but you can re-submit at anytime and overwrite your previous value.
Recommendation Process: Send email to<EMAIL_ADDRESS>with subject "Nominations". Body contains a list of email addresses of nominees
Dashboard Access: Presently anyone can view the dashboard (may change in the future)
Become Trusted: If you would like to contribute but are not yet trusted please send a request to<EMAIL_ADDRESS>© Copyright 2016 by TTLAB. All Rights Reserved.


Below you will be given a dialogue that happened between two agents, Agent 1 and Agent 2.
In this dialogue, each agent has a private table of friends with one friend that is common to both agents. The goal of their dialogue is to find the
unique mutual friend as quickly as possible.
Below you are also given the friends info from one of the agents. Your job is to answer the questions
that follow the dialogue about this agent's behavior in the dialogue, by moving each slider appropriately. The agent's statements are highlighted in red. In
the dialogue, a statement beginning with SELECT indicates that an agent hypothesized this was the
common friend between the two agents. The dialogue was successful if both agents selected the same friend. We present a short description of
each of the attributes we will be asking about, with examples of these attributes sorted from highest to lowest:
FLUENT: How grammatical and well-formed are the statements made by the agent? NOTE:
Shorter, more informal sentences are okay as long as they are understandable.
FLUENT (Score=5): Saying things like Most of my friends went to Ohio State
SOMEWHAT FLUENT (Score=3): Saying things like Many friend are USC
NOT VERY FLUENT (Score=1): Saying things like Freind the is collge
FACTUALLY-CORRECT: How consistent are the statements made by the agent with their friend information? In other words,
are they lying?
VERY CORRECT (Score=5): Saying things like My colleges are Northwestern, Williams, and Ohio State and having
all the agent's friends attending these colleges. NOTE, assigning this score means every statement made by the agent is correct.
SOMEWHAT CORRECT (Score=3): Saying things like All friends studied biology but one friend didn't study biology
NOT VERY CORRECT (Score=1): Saying things like I have a friend that studied biology but none of their friends
studied biology. NOTE, assigning this score means no statement made by the agent is correct.
COOPERATIVE: How well does the agent interact with its partner? Since the two agents
are trying to find their common friend as quickly as possible, how well does the agent respond to questions asked by its partner?
If its partner offers some new piece of information, is the agent responding appropriately and relevantly?
VERY COOPERATIVE (Score=5): If the agent's partner says I have two evening friends and
the agent responds I also have one evening friend and they go to University of Washington
SOMEWHAT COOPERATIVE (Score=3): If the agent's parter says I have one friend from Stanford. Any Stanford for you?
and the agent responds I have a Georgia Tech and one who works at Walmart
NOT VERY COOPERATIVE (Score=1): If the agent's partner says I have two friends that went to UPenn. Any of your friends from UPenn?
and the agent responds 3 that worked at Geico
HUMAN-LIKE: If you were talking to this agent, would you be convinced that it is a human? Many
of these dialogues were conducted between two Amazon Mechanical Turkers, so would you believe that the agent below
is a Turker?
NOTE: Make sure to include examples for every question in the associated textboxes or YOUR WORK WILL NOT BE ACCEPTED.
NOTE: You will be evaluating 5 distinct dialogues for both agents.
{% if agent_id == 0 %}
Agent 1 Friends Info
{% else %}
Agent 2 Friends Info
{% endif %}
{% for name in column_names %}
{{name}}
{% endfor %}
{% for row in kb %}
{% for name in column_names%}
{{row[name]}}
{% endfor %}
{% endfor %}
{% for turn in dialogue %}
{% if turn.agent == agent_id %}
Agent {{turn.agent + 1}}: {{turn.data}}
{% else %}
Agent {{turn.agent + 1}}: {{turn.data}}
{% endif %}
{% endfor %}
How fluent is Agent {{agent_id + 1}}?
Please give examples of how Agent {{agent_id + 1}} is/is not fluent
How factually-correct is Agent {{agent_id + 1}}?
Please give examples of how Agent {{agent_id + 1}} is/is not factually correct
How cooperative is Agent {{agent_id + 1}}?
Please give examples of how Agent {{agent_id + 1}} is/is not cooperative
How human-like is Agent {{agent_id + 1}}?
Please give examples of how Agent {{agent_id + 1}} is/is not humanlike


# Deleting a file --- ## Async ```js // @file deleteFile.js // include node fs module var fs = require('fs'); // delete file named 'sample.txt' fs.unlink('sample.txt', function (err) { if (err) throw err; // if no error, file has been deleted successfully console.log('File deleted!'); }); ``` -- ### Output: Success ```shell $ node deleteFile.js File deleted! ``` --- ### Output: Failure ```shell $ node deleteFile2.js /home/arjun/workspace/nodejs/deleteFile2.js:6 if (err) throw err; ^ Error: ENOENT: no such file or directory, unlink 'sample.txt' ``` --- ## Sync ```js // @file deleteFileSynchronously.js // include node fs module var fs = require('fs'); // delete file named 'sample.txt' Synchronously fs.unlinkSync('sample.txt'); console.log('File deleted!'); ``` -- ### Output: Success ```shell $ node deleteFileSynchronously.js File deleted! ``` --- # The End


Soft skills are increasingly becoming the hard skills of today's work force. It is just not enough to be highly trained in technical skills, without developing the softer, interpersonal and relationship-building skills that help people to communicate and collaborate effectively.
This is what gave birth to DexLearn.
DexLearn is a next-generation online learning platform built for individuals and businesses striving to stay at the forefront of innovation and bring teams up to speed with people skills. It is specifically designed to offer relevant, on-demand skills training for work ethic, teamwork, leadership, communication skills, emotional intelligence and a whole host of other personal attributes crucial for career success in the skills-driven economy.
With DexLearn, you can save time, money, and resources with effective, on-demand skills training anytime, anywhere.
<EMAIL_ADDRESS>Tel:+234<PHONE_NUMBER>
Skype:DexLearnLMS
Facebook:DexLearn
Twitter:DexLearn


Get all issues across all the authenticated user’s visible repositories including owned repositories, member repositories, and organization repositories:
issues
Get all issues across owned and member repositories for the authenticated user:
user/issues
Get all issues for a given organization for the authenticated user:
orgs/:org/issues
Get all issues in a repository:
repos/:owner/:repo/issues
Get all issues in multiple repositories:
repos/:owner/[:repo1,:repo2]/issues
Search for all open issues (not pr's).This is across all the authenticated user’s visible repositories including owned repositories,
member repositories, and organization repositories:
search/issues?q=state:open+type:issue
Get all public repositories:
repositories
Get all repositories that are accessible to the authenticated user:
user/repos
Get all repositories that belong to an organization:
orgs/:org/repos


If you would like to help in the event on an earthquake by volunteering or donating supplies, please visit VolunteerLA to view real-time information and volunteer opportunities. Thank you for helping the community.


CCG browser
Demo 01 (5 strains)
Consensus Circular Genome Browser
Demo 01: Circular and Linear view of H. pylori 5 strains
Demo 02: Aligment view of orthologs found in lactic acid bacteria


Structures
The following structures are available globally.
-
CreditCardData contains all data necessary for registering a credit card with a payment service provider
See moreDeclaration
Swift
public struct CreditCardData : RegistrationData, CreditCardDataInitializible
-
Details concerning a generic, non-specific error
See moreDeclaration
Swift
public struct GenericErrorDetails : TitleProviding, CustomStringConvertible
-
Details for a temporary error
See moreDeclaration
Swift
public struct TemporaryErrorDetails : TitleProviding, CustomStringConvertible
-
Placeholder data provided when starting PayPal registration
See moreDeclaration
Swift
public struct PayPalPlaceholderData : RegistrationData
-
PayPal payment method information
See moreDeclaration
Swift
public struct PayPalData : RegistrationData
-
SEPAData contains all data necessary for registering a SEPA account with a payment service provider
See moreDeclaration
Swift
public struct SEPAData : RegistrationData, SEPADataInitializible
-
Undocumented
See moreDeclaration
Swift
public struct AliasExtra
-
Information about the used PSP retrieved from Stash payment backend. All fields are optional and will be populated based on ‘type’ property (PSP). This struct only concerns module development.
See moreDeclaration
Swift
public struct PSPExtra : Codable
-
A model that contains all extra information that should be propagated to the payment SDK backend when registering a credit card. This will and should not be used by clients directly but only by the core SDK and modules.
See moreDeclaration
Swift
public struct CreditCardExtra : Codable
-
The result of registering a payment method with a PSP
See moreDeclaration
Swift
public struct PSPRegistration
-
A model that contains all extra information that should be propagated to the payment SDK backend when registering a PayPal method. This will and should not be used by clients directly but only by the core SDK and modules.
See moreDeclaration
Swift
public struct PayPalExtra : Codable
-
A successful payment method registration
See moreDeclaration
Swift
public struct PaymentMethodAlias
-
An integration of a payment service provider for a set of payment method types
See moreDeclaration
Swift
public struct PaymentProviderIntegration
-
A struct including all information generated from starting payment method registration and having created an alias in the Stash backend for it.
- Used solely during module development
Declaration
Swift
public struct RegistrationRequest
-
A model that contains all extra information that should be propagated to the payment SDK backend when registering a SEPA method. This will and should not be used by clients directly but only by the core SDK and modules.
See moreDeclaration
Swift
public struct SEPAExtra : Codable
-
The payment method UI configuration. Can be used to customize the way the SDK UI is styled.
See moreDeclaration
Swift
public struct PaymentMethodUIConfiguration


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object edu.northwestern.jcr.adapter.xtf.query.QueryResultImpl.LazyScoreNodeIterator
private final class QueryResultImpl.LazyScoreNodeIterator
| Field Summary | |
|---|---|
private boolean |
initialized
|
private org.apache.jackrabbit.core.NodeImpl |
next
|
private int |
position
|
private int |
selectorIndex
|
| Constructor Summary | |
|---|---|
private |
QueryResultImpl.LazyScoreNodeIterator(int selectorIndex)
|
| Method Summary | |
|---|---|
private void |
fetchNext()
Fetches the next node to return by this iterator. |
long |
getPosition()
|
float |
getScore()
Returns the score of the node returned by NodeIterator.nextNode() . |
ScoreNode[] |
getScoreNodes()
Returns the score nodes related to the node returned by ScoreNodeIterator.nextNodeImpl() but does not move the iterator forward. |
long |
getSize()
This value may shrink when the query result encounters non-existing nodes or the session does not have access to a node. |
boolean |
hasNext()
|
private void |
initialize()
Initializes this iterator but only if it is not yet initialized. |
java.lang.Object |
next()
|
javax.jcr.Node |
nextNode()
|
org.apache.jackrabbit.core.NodeImpl |
nextNodeImpl()
Returns the next Node in the result set. |
void |
remove()
|
void |
skip(long skipNum)
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
private int position
private boolean initialized
private org.apache.jackrabbit.core.NodeImpl next
private final int selectorIndex
| Constructor Detail |
|---|
private QueryResultImpl.LazyScoreNodeIterator(int selectorIndex)
| Method Detail |
|---|
public float getScore()
NodeIterator.nextNode()
. In other
words, this method returns the score value of the next
Node
.
getScore
in interface ScoreNodeIterator
NodeIterator.nextNode()
.public ScoreNode[] getScoreNodes()
ScoreNodeIterator.nextNodeImpl()
but does not move the iterator forward.
getScoreNodes
in interface ScoreNodeIterator
ScoreNodeIterator.nextNodeImpl()
.public org.apache.jackrabbit.core.NodeImpl nextNodeImpl()
Node
in the result set.
nextNodeImpl
in interface ScoreNodeIterator
Node
in the result set.public javax.jcr.Node nextNode()
nextNode
in interface javax.jcr.NodeIterator
public void skip(long skipNum)
skip
in interface javax.jcr.RangeIterator
public long getSize()
getSize
in interface javax.jcr.RangeIterator
public long getPosition()
getPosition
in interface javax.jcr.RangeIterator
public void remove()
remove
in interface java.util.Iterator
java.lang.UnsupportedOperationException
- always.public boolean hasNext()
hasNext
in interface java.util.Iterator
public java.lang.Object next()
next
in interface java.util.Iterator
private void initialize()
private void fetchNext()
next
is null
then there is no next
node.
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


| Balance | {{dashboard.latestCashBalance.Value | currency}} as of {{dashboard.latestCashBalance.Timestamp | date:'EEE, M/d/yy - h:mm:ss a'}} |
| Total Value | {{dashboard.latestAccountValue.Value | currency}} as of {{dashboard.latestAccountValue.Timestamp | date:'EEE, M/d/yy - h:mm:ss a'}} |
| Notes | {{dashboard.notes.length | number}} |


[gecode-users] Detecting a complete problem
Mikael Zayenz Lagerkvist
zayenz at gmail.com
Wed Nov 21 07:29:24 CET 2007
On Nov 21, 2007 12:45 AM, Malcolm Ryan <malcolmr at cse.unsw.edu.au> wrote:
> On 20/11/2007, at 6:13 PM, Malcolm Ryan wrote:
> > How does Gecode/J decide that a problem is complete? I've just tried
> > running Gist on a problem and it stopped at the root node and said it
> > was solved, even though many variables were still unbound.
Gecode considers a Space solved when there are no more banchings left.
> Aha, I found the problem. There's a missing line in the copy
> constructor:
>
> > public Test1(Boolean share, Test1 old) {
>
> super(share, old);
The explanation for this is that leaving out the call to the correct
super-constructor had the effect that neither propagators nor
branchings will be copied. Thus the new Space will have no branchings,
and is therefore "solved".
Cheers,
Mikael
--
Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/
More information about the gecode-users
mailing list


To add a Universe Selection model, in the Initialize
method, call the AddUniverseSelection
method.
var symbols = new [] {QuantConnect.Symbol.Create("SPY", SecurityType.Equity, Market.USA)}; AddUniverseSelection(new ManualUniverseSelectionModel(symbols));
symbols = [Symbol.Create("SPY", SecurityType.Equity, Market.USA)] self.AddUniverseSelection(ManualUniverseSelectionModel(symbols))
To view all the pre-built Universe Selection models, see Types of Universe Selection.


{%extends "awards/base.html"%} {% load crispy_forms_tags %} {% load bootstrap5 %} {% block content %}
Some Information Might be Incorrect
Have an account? Log in


Make your ticketing system more user-friendly, transport minister tells KTMB
by BY RADZI RAZAKPUTRAJAYA, Nov 19 — Anthony Loke today ordered Keretapi Tanah Melayu Berhad (KTMB) to revamp its ticketing system to be more user-friendly.
The transport minister said there had been many complaints from commuters that the existing system was outdated, making it a hassle for them to buy tickets, especially during the year-end holidays.
“I will order KTMB to take swift action. What is more important is the ticketing system needs to be revamped and made more user-friendly,” he told reporters after opening the Bus Rapid Transit Conference here this morning.
Loke admitted the country’s most extensive rail service had weaknesses as could be seen with frequent online service disruptions, especially during long school breaks and festive holidays like Christmas and Chinese New Year when urbanites are most likely to travel home.
KTMB has introduced a smartphone app called Mob Ticket, but it is similarly plagued by problems.
Frayed tempers at KTMB counters and public complaints made the news yesterday after the railway company opened tickets for sale for December 2019 to February 2020 period.
Frustrated users lashed out at KTMB in person at its counters in KL Sentral and online after its network slowed and crashed, due to heavy traffic.
The Star reported one customer as saying that counters opened at 8.30am, but only 30 people were able to get tickets by 2.30pm.
KTMB head of corporate communications Ahmad Asri Khalbi apologised for the inconvenience.


These API docs are also available in the api subdirectory of the flixel-docs repository.
They cover both flixel and flixel-addons (prefixed by flixel.addons). These docs are in sync with the latest haxelib releases of those libraries.
These API docs are also available in the api subdirectory of the flixel-docs repository.
They cover both flixel and flixel-addons (prefixed by flixel.addons). These docs are in sync with the latest haxelib releases of those libraries.


Toggle navigation
SWEG
Youtube
(current)
@ Me
More
School
Separated link
Submit
This is a website
This basically makes no sense, so yeah.
Don't Kill My Vibe
Good Kid
Kendrick Lamar
Maria I'm Drunk
Rodeo
Travi$ Scott
Back to Back
Nothing Was The Same
Drake
All Day
Graduation
Kanye West
Life of The Party
Trilogy
The Weeknd
Goldie
At Long Last A$AP
A$AP Rocky


Elizabeth B.-N. Sanders & Pieter Jan Stappers
Elizabeth B.-N. Sanders and Pieter Jan Stappers outline the trend towards co-design
"Designers have been moving increasingly closer to the future users of what they design and the next new thing in the changing landscape of design research has become co-designing with your users."
"The first advances, well consolidated now in industrial practice and education, practiced user-centred design from an ‘expert perspective’ in which trained researchers observe and/or interview largely passive users, whose contribution is to perform instructed tasks and/or to give their opinions about product concepts that were generated by others."
"By co-design we indicate collective creativity as it is applied across the whole span of a design process"
"The application of participatory design practices (both at the moment of idea generation and continuing throughout the design process at all key moments of decision) to very large-scale problems will change design and may change the world."
"Users can become part of the design team as ‘expert of their experiences’ (Sleeswijk Visser et al. 2005), but in order for them to take on this role, they must be given appropriate tools for expressing themselves"
"As researchers we will need to learn how to:
.leadpeople who are on the ‘doing’ level of creativity,
.guidethose who are at the ‘adapting’ level,
.provide scaﬀoldsthat support and serve peoples’ need for creative expression at the
‘making’ level, and
.oﬀer a clean slatefor those at the ‘creating’ level"
"In addition to bringing people into the design process in the ways most conducive to their ability to participate, researchers will need to bring in applicable domain theories in a way that can be handled by the co-design team"


How to play the game.
There are four crystals below. By clicking on a crystal you will add a specific amuont of points to your score.
You win the game by matching your total score to the random number, you lose the game if your total score goes above the random number.
The value of the crystal is hidden from you until you click on it.
Each time when the game starts, the game will change the values of each crystal.
GOOD LUCK!!!