Star Wars Asteroid Shooter
Caleb Barber - CSC 471 - Spring 2018 - Christian Eckhardt
Project Description
A Star Wars themed space shooter game where the player earns points by shooting asteroids.
Entering the Asteroid Field
Technical Features:
- 3D Collision Physics
- Instanced Rendering
- Hierarchical Animation Modeling
- Diffuse & Specular lighting
- Texture/Sprite Animation
- Randomization
Challenges:
- Refining the controls
- 3D collision detection tracking for lasers, asteroids, ship
- Scaling asteroids to be random sizes
- Displaying text on the screen (score counter)
Asteroid Explosion
Flying by the Star Destroyer
Other Info
Controls:
W - Up
S - Down
A - Left
D - Right
Space - Boost
Enter - Shoot
P - Pause
Gameplay:
1 point for each asteroid destroyed (2000 total)
3 lives, lose one life for each asteroid crash
Immediate Game Over if crashed into asteroid while boosting or crashed into Star Destroyer
Bugs
Controls get wonky if you fly upside down. Hold go up and to the side at the same time until you are right-side up again.
Weird hitbox for Star Destroyer (it's near the bridge)
Source
Resources


|
PMIC
|
HAL configuration file. More...
#include "main.h"
#include "stm32f1xx_hal_rcc.h"
#include "stm32f1xx_hal_gpio.h"
#include "stm32f1xx_hal_dma.h"
#include "stm32f1xx_hal_cortex.h"
#include "stm32f1xx_hal_adc.h"
#include "stm32f1xx_hal_flash.h"
#include "stm32f1xx_hal_pwr.h"
#include "stm32f1xx_hal_tim.h"
#include "stm32f1xx_hal_uart.h"
#include "stm32f1xx_hal_pcd.h"
Go to the source code of this file.
Macros | |
| #define | HAL_MODULE_ENABLED |
| This is the list of modules to be used in the HAL driver. More... | |
| #define | HAL_ADC_MODULE_ENABLED |
| #define | HAL_DMA_MODULE_ENABLED |
| #define | HAL_GPIO_MODULE_ENABLED |
| #define | HAL_PCD_MODULE_ENABLED |
| #define | HAL_TIM_MODULE_ENABLED |
| #define | HAL_UART_MODULE_ENABLED |
| #define | HAL_CORTEX_MODULE_ENABLED |
| #define | HAL_DMA_MODULE_ENABLED |
| #define | HAL_FLASH_MODULE_ENABLED |
| #define | HAL_GPIO_MODULE_ENABLED |
| #define | HAL_PWR_MODULE_ENABLED |
| #define | HAL_RCC_MODULE_ENABLED |
| #define | HSE_VALUE ((uint32_t)16000000) |
| Adjust the value of External High Speed oscillator (HSE) used in your application. This value is used by the RCC HAL module to compute the system frequency (when HSE is used as system clock source, directly or through the PLL). More... | |
| #define | HSE_STARTUP_TIMEOUT ((uint32_t)100) |
| #define | HSI_VALUE ((uint32_t)8000000) |
| Internal High Speed oscillator (HSI) value. This value is used by the RCC HAL module to compute the system frequency (when HSI is used as system clock source, directly or through the PLL). More... | |
| #define | LSI_VALUE 40000U |
| Internal Low Speed oscillator (LSI) value. More... | |
| #define | LSE_VALUE ((uint32_t)32768) |
| External Low Speed oscillator (LSE) value. This value is used by the UART, RTC HAL module to compute the system frequency. More... | |
| #define | LSE_STARTUP_TIMEOUT ((uint32_t)5000) |
| #define | VDD_VALUE ((uint32_t)3300) |
| This is the HAL system configuration section. More... | |
| #define | TICK_INT_PRIORITY ((uint32_t)0) |
| #define | USE_RTOS 0 |
| #define | PREFETCH_ENABLE 1 |
| #define | MAC_ADDR0 2 |
| Uncomment the line below to expanse the "assert_param" macro in the HAL drivers code. More... | |
| #define | MAC_ADDR1 0 |
| #define | MAC_ADDR2 0 |
| #define | MAC_ADDR3 0 |
| #define | MAC_ADDR4 0 |
| #define | MAC_ADDR5 0 |
| #define | ETH_RX_BUF_SIZE ETH_MAX_PACKET_SIZE /* buffer size for receive */ |
| #define | ETH_TX_BUF_SIZE ETH_MAX_PACKET_SIZE /* buffer size for transmit */ |
| #define | ETH_RXBUFNB ((uint32_t)8) /* 4 Rx buffers of size ETH_RX_BUF_SIZE */ |
| #define | ETH_TXBUFNB ((uint32_t)4) /* 4 Tx buffers of size ETH_TX_BUF_SIZE */ |
| #define | DP83848_PHY_ADDRESS 0x01U |
| #define | PHY_RESET_DELAY ((uint32_t)0x000000FF) |
| #define | PHY_CONFIG_DELAY ((uint32_t)0x00000FFF) |
| #define | PHY_READ_TO ((uint32_t)0x0000FFFF) |
| #define | PHY_WRITE_TO ((uint32_t)0x0000FFFF) |
| #define | PHY_BCR ((uint16_t)0x00) |
| #define | PHY_BSR ((uint16_t)0x01) |
| #define | PHY_RESET ((uint16_t)0x8000) |
| #define | PHY_LOOPBACK ((uint16_t)0x4000) |
| #define | PHY_FULLDUPLEX_100M ((uint16_t)0x2100) |
| #define | PHY_HALFDUPLEX_100M ((uint16_t)0x2000) |
| #define | PHY_FULLDUPLEX_10M ((uint16_t)0x0100) |
| #define | PHY_HALFDUPLEX_10M ((uint16_t)0x0000) |
| #define | PHY_AUTONEGOTIATION ((uint16_t)0x1000) |
| #define | PHY_RESTART_AUTONEGOTIATION ((uint16_t)0x0200) |
| #define | PHY_POWERDOWN ((uint16_t)0x0800) |
| #define | PHY_ISOLATE ((uint16_t)0x0400) |
| #define | PHY_AUTONEGO_COMPLETE ((uint16_t)0x0020) |
| #define | PHY_LINKED_STATUS ((uint16_t)0x0004) |
| #define | PHY_JABBER_DETECTION ((uint16_t)0x0002) |
| #define | PHY_SR ((uint16_t)0x10U) |
| #define | PHY_SPEED_STATUS ((uint16_t)0x0002U) |
| #define | PHY_DUPLEX_STATUS ((uint16_t)0x0004U) |
| #define | assert_param(expr) ((void)0U) |
| Include module's header file. More... | |
HAL configuration file.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
| #define assert_param | ( | expr | ) | ((void)0U) |
Include module's header file.
| #define DP83848_PHY_ADDRESS 0x01U |
| #define ETH_RX_BUF_SIZE ETH_MAX_PACKET_SIZE /* buffer size for receive */ |
| #define ETH_RXBUFNB ((uint32_t)8) /* 4 Rx buffers of size ETH_RX_BUF_SIZE */ |
| #define ETH_TX_BUF_SIZE ETH_MAX_PACKET_SIZE /* buffer size for transmit */ |
| #define ETH_TXBUFNB ((uint32_t)4) /* 4 Tx buffers of size ETH_TX_BUF_SIZE */ |
| #define HAL_ADC_MODULE_ENABLED |
| #define HAL_CORTEX_MODULE_ENABLED |
| #define HAL_DMA_MODULE_ENABLED |
| #define HAL_DMA_MODULE_ENABLED |
| #define HAL_FLASH_MODULE_ENABLED |
| #define HAL_GPIO_MODULE_ENABLED |
| #define HAL_GPIO_MODULE_ENABLED |
| #define HAL_MODULE_ENABLED |
This is the list of modules to be used in the HAL driver.
| #define HAL_PCD_MODULE_ENABLED |
| #define HAL_PWR_MODULE_ENABLED |
| #define HAL_RCC_MODULE_ENABLED |
| #define HAL_TIM_MODULE_ENABLED |
| #define HAL_UART_MODULE_ENABLED |
| #define HSE_STARTUP_TIMEOUT ((uint32_t)100) |
Time out for HSE start up, in ms
| #define HSE_VALUE ((uint32_t)16000000) |
Adjust the value of External High Speed oscillator (HSE) used in your application. This value is used by the RCC HAL module to compute the system frequency (when HSE is used as system clock source, directly or through the PLL).
Value of the External oscillator in Hz
| #define HSI_VALUE ((uint32_t)8000000) |
Internal High Speed oscillator (HSI) value. This value is used by the RCC HAL module to compute the system frequency (when HSI is used as system clock source, directly or through the PLL).
Value of the Internal oscillator in Hz
| #define LSE_STARTUP_TIMEOUT ((uint32_t)5000) |
Time out for LSE start up, in ms
| #define LSE_VALUE ((uint32_t)32768) |
External Low Speed oscillator (LSE) value. This value is used by the UART, RTC HAL module to compute the system frequency.
< Value of the Internal Low Speed oscillator in Hz The real value may vary depending on the variations in voltage and temperature. Value of the External oscillator in Hz
| #define LSI_VALUE 40000U |
Internal Low Speed oscillator (LSI) value.
LSI Typical Value in Hz
| #define MAC_ADDR0 2 |
Uncomment the line below to expanse the "assert_param" macro in the HAL drivers code.
| #define MAC_ADDR1 0 |
| #define MAC_ADDR2 0 |
| #define MAC_ADDR3 0 |
| #define MAC_ADDR4 0 |
| #define MAC_ADDR5 0 |
| #define PHY_AUTONEGO_COMPLETE ((uint16_t)0x0020) |
Auto-Negotiation process completed
| #define PHY_AUTONEGOTIATION ((uint16_t)0x1000) |
Enable auto-negotiation function
| #define PHY_BCR ((uint16_t)0x00) |
Transceiver Basic Control Register
| #define PHY_BSR ((uint16_t)0x01) |
Transceiver Basic Status Register
| #define PHY_CONFIG_DELAY ((uint32_t)0x00000FFF) |
| #define PHY_DUPLEX_STATUS ((uint16_t)0x0004U) |
PHY Duplex mask
| #define PHY_FULLDUPLEX_100M ((uint16_t)0x2100) |
Set the full-duplex mode at 100 Mb/s
| #define PHY_FULLDUPLEX_10M ((uint16_t)0x0100) |
Set the full-duplex mode at 10 Mb/s
| #define PHY_HALFDUPLEX_100M ((uint16_t)0x2000) |
Set the half-duplex mode at 100 Mb/s
| #define PHY_HALFDUPLEX_10M ((uint16_t)0x0000) |
Set the half-duplex mode at 10 Mb/s
| #define PHY_ISOLATE ((uint16_t)0x0400) |
Isolate PHY from MII
| #define PHY_JABBER_DETECTION ((uint16_t)0x0002) |
Jabber condition detected
| #define PHY_LINKED_STATUS ((uint16_t)0x0004) |
Valid link established
| #define PHY_LOOPBACK ((uint16_t)0x4000) |
Select loop-back mode
| #define PHY_POWERDOWN ((uint16_t)0x0800) |
Select the power down mode
| #define PHY_READ_TO ((uint32_t)0x0000FFFF) |
| #define PHY_RESET ((uint16_t)0x8000) |
PHY Reset
| #define PHY_RESET_DELAY ((uint32_t)0x000000FF) |
| #define PHY_RESTART_AUTONEGOTIATION ((uint16_t)0x0200) |
Restart auto-negotiation function
| #define PHY_SPEED_STATUS ((uint16_t)0x0002U) |
PHY Speed mask
| #define PHY_SR ((uint16_t)0x10U) |
PHY status register Offset
| #define PHY_WRITE_TO ((uint32_t)0x0000FFFF) |
| #define PREFETCH_ENABLE 1 |
| #define TICK_INT_PRIORITY ((uint32_t)0) |
tick interrupt priority (lowest by default)
| #define USE_RTOS 0 |
| #define VDD_VALUE ((uint32_t)3300) |
This is the HAL system configuration section.
Value of VDD in mv


BMC gets two robots to clean manholes
The robots have three cameras each, infra-red devices and ability to detect gases inside manholes. They can reach 8 metres deep.
by Express News ServiceThe Brihanmumbai Municipal Corporation (BMC) is gradually moving to robotic machines to clean manholes, a step towards eliminating manual scavenging.
On Wednesday, Bharat Petroleum Corporation Ltd (BPCL) gave the civic body two such machines for M-West ward (Chembur) under the company’s Corporate Social Responsibility (CSR) programme. After a successful pilot run on BPCL premises, the machines were handed over to Assistant Municipal Commissioner of M-West ward Prithviraj Chavan.
The robots have three cameras each, infra-red devices and ability to detect gases inside manholes. They can reach 8 metres deep.


28 May 2013
We launched the private beta of our Search-as-a-Service offer two months ago. In that time we
received very positive feedback from our beta testers and we couldn't thank
them enough for the help they provided. To date, they have sent over 1M
indexation jobs and over 5M queries, and the trend is increasing.
Today we are happy to continue simplifying the experience with the release of
six API Clients under the MIT license:
Ease of integration just improved again! Your feedback (and pull requests) is
most welcome.
24 May 2013
We are pleased to introduce a new version of Algolia Search Offline for iOS,
Android and OS X (Windows versions will come soon).
Version 2.1 significantly improves the out-of-the box relevance of Algolia
Search. We are now confident we have the best relevance on the market. We will
discuss our ranking approach compared to traditional methods in another post.
For now, the two main improvements offered in this version are:
* When the query string has one word that is the entire content of a field, we will display it first. You can try it with the "arm" query on our Crunchbase demonstration to get the idea: [http://bit.ly/searchcrunchbase](http://bit.ly/searchcrunchbase) (it uses the same relevance approach).
- More importance is given to proximity than to the order of attributes. For example, the query "managing p" will now match first "Managing Partner" in the "Title" attribute instead of "P" in the "Name" attribute followed by "Managing" in the "Title". This is the case even if the order of the attributes is ["Name", "Title", ...].
While you can control ranking with the setRankingOrder method, you will
benefit from these improvements by default.
This new release also introduces some new features:
- A way to efficiently serialize latitude/longitude and float values in your custom objects (reduce the size of serialized objects by up to 80%).
- A method to compile an index in an old version format. This is useful when indexes are created server side and then pushed to applications that support old versions of Algolia.
- All characters in tag filters are now supported.
- It is now possible to do a logic OR between tags in filters. For example, you can search all contacts that match the query "paul" and have the tag "friend" OR the tag "classmate".
We hope you'll like these new features, and as ever, we welcome your feedback!
21 May 2013
If
you have an iOS device you probably search the App Store regularly for apps
you have heard about. Following the recent AppGratis ousting from the
AppStore, there were claims that the App Store search function is broken. That
was our trigger to try something ourselves that could serve both as a good
demo and help us to explore new use-cases! Check it
out!
Obtaining the data
So first, we needed to obtain the data. Apple provides an API to accredited
developers, but given that this can be fairly difficult to attain, we
considered other solutions. Crawling was our second option, but that approach
has its own caveats: you need to play nice with their servers or you get
banned (very) quickly. We didn't want to spend days implementing our own
distributed crawler and definitely didn't have the time to do a sequential and
polite crawling. It is in these moments that you are glad to have an external
team to do the job for you.
We chose to perform the crawling with grepsr, a
service we found via a simple Google search. After a few exchanges we were
confident that they were up to the job, and they ended up exceeding our
expectations. Not only did they crawl the pages, but they also scraped the
apps' attributes to provide us with a clean dataset. After a few days we had
our full dataset ready for indexing.
Indexing
Indexing was actually the easiest part. We uploaded the data in JSON format to
our backend and used these simple settings:
{
"attributesToIndex": ["name", "author", "category"],
"attributesToHighlight": ["name", "author","category", "description"],
"customRanking": ["desc(score)", "asc(name)"]
}
Our dataset included the 630k applications currently published in the US app
store. For each of them we index the name, author and category, but also
include their icon, score, and description for display and sorting.
The score is a simple computation between the number of comments and the
average ranking: rating * log2(nbComments) * 10000
.
Searching
Similar to our CrunchBase demo, we trigger a query directly after page load and again after each
keystroke. Additional queries are automatically triggered when scrolling to
the bottom of the page.
Guillaume Esquevin did the front-end for us
and a first version of the demo was up and ready in no time. Take a look at
how simple and fast it is to search for an app!
In the end we did receive access to the Apple API, which we may use later on
to keep the data in sync.
25 Apr 2013
We have great news for our iOS and OS X users: our Offline SDK is now
available as a CocoaPods dependency.
Cocoapods is a popular dependency management tool that lets you specify the
libraries (dependencies) you want to use for your project in an easy-to-edit
text file (Podfile). It then fetches all the required libraries and sets up
your Xcode workspace.
You can now set up Algolia Search Offline in your iOS project with this line
in your Podfile:
pod 'AlgoliaSearchOffline-iOS-SDK'
You can also set up Algolia Search Offline in your OS X project with this
line:
pod 'AlgoliaSearchOffline-OSX-SDK'
Once you're done, simply use the "pod install" command to set up Algolia
Search Offline in your project. Now it's easy to manage library dependencies
for iOS and OS X projects!
16 Apr 2013
While our latest news focused on the Algolia Search cloud offer (you can still
join the beta, we're
pleased to introduce a major new version of Algolia Search offline: V2! It is
available today for iOS, Android and OS X. Windows Phone and Windows versions
will be released as soon as they are ready. A few months in the making, these
new features were built on early customer feedback and will simplify
integration.
Algolia becomes the easiest way to search by geolocation!
The ease of integration is a constant concern for us and that's why we
carefully consider every new feature. Two important features made it in this
version:
- Geo-search means the ability to search around a location or inside a bounding box. Results can be sorted by distance and of course geo-queries can be combined with textual ones. We added a dedicated tutorial in the doc to get up to speed with this new feature in no time (for iOS and Android.
- Tag filters enable restriction of results to specific tags. We received this demand a number of times in order to avoid the creation of too many specialized indexes.
These new features are also available in the beta of our cloud version!
Improved performance and ranking
With some hard work... and a lot of profiling, we have been able to get a 10%
gain in performance on every query.
In V1, name matches were always considered more important than other
attributes, but we didn't consider differences between other attributes. This
changed in V2: ranking priority now respects the order in which you indicate
attributes in the textToIndex method. It's more powerful while actually being
more consistent with no specific processing of the name field.
But this improvement comes at the cost of a slightly bigger index and longer
computation. If index size is important or if you need to earn a few
nanoseconds more, you can optimize it away with the increaseCompression
method. You'll get a 10 to 30% reduction in index size and an additional 20%
boost in performance (that's 30% total compared to V1!).
Easy just got easier
Integrating search in an app has never been so easy. For V2 we took into
account all the excellent feedback we received, and wherever it was possible
we simplified the API:
- No distinction between suggest and search methods. We wanted to match the expected use-cases of the SDK but it was causing more confusion than anything else. So there is now only one way to send queries to an index: the search method.
- With the addition of geo-search, the index class was becoming crowded. We simplified this by decoupling the search approach and query definition. A small set of search methods enable the developer to choose if the search will be synchronous, use a callback, or batch several queries. And a simple SearchQuery class defines the nature of the queries themselves: geolocation, use of prefixes, tag filters, etc.
- Out of simple strings for which we provide a helper, every indexable object now has a UID. Our use of a "name" for this role led to a few difficulties when collisions were possible (persons for example). There are no longer any privileged attributes.
- License key initialization is now done using a static method. It is a best practice that was actually necessary to build a RubyMotion gem.
Specific to Android, we also added an AbstractIndexable abstract class.
Instead of implementing the Indexable interface, you now have the option of
directly extending AbstractIndexable that takes care of optional methods for
you.
Specific to iOS, you can now directly index core data entities with the
setCoreDataEntityDescription selector. No need to create a wrapper.
Still able to read V1 indexes
If for any reason you cannot replace or reindex your data, V2 is still able to
search in a V1 index. However, as the name attribute was removed you do need
to implement the IndexableLegacy interface. If you then publish changes, the
new index will be in the V2 format.
We're really sorry to make our Windows Phone and Windows customers wait. Feel
free to torment us with your needs, it's great motivation to finish more
quickly ;)
If you're still reading, I guess it's time for you to test this new version of
the Algolia Search Offline SDK. Get started!


Lorem ipsum represents a long-held tradition for designers, typographers and the like. Some people hate it and argue for its demise, but others ignore.
Projects Details
Recent Activity
Lorem ipsum represents a long-held tradition for designers, typographers and the like. Some people hate it and argue for its demise, but others ignore.
Lorem ipsum represents a long-held tradition for designers, typographers and the like. Some people hate it and argue for its demise, but others ignore.
AdminLTE v3
Raw denim you probably haven't heard of them jean shorts Austin. Nesciunt tofu stumptown aliqua butcher retro keffiyeh dreamcatcher synth. Cosby sweater eu banh mi, qui irure terr.
Client Company Deveint Inc
Project Leader Tony Chicken


As I was reading through information on drug testing and DXM, I decided to provide an experience I had a few years ago. I was sick in the hospital, and for reasons I'm still unsure of (although I think it may have had something to do with me being under 18 at the time) the hospital ran a urine drug test on me. I had been using DXM 2 or 3 times a week for months before, and had used it in the week prior to my hospital visit. My test DID come back positive for PCP, and nothing else (which didn't really surprise me). DXM was the only drug I had been using during that time. When a doctor came to me with the test results, he asked me if I had been using PCP, which made me laugh; but I was lucky enough to be able to explain my DXM use without getting into any trouble. After my explanation, I wasn't asked any more questions about the test results (although some nurses were interested as to why anyone would willingly drink so much cough syrup :P)
I wish I could provide more information, I did have a copy of the test results at one time but I have no idea where they could be now. I just wanted to provide my experience, and confirm that false-positives for PCP with DXM are definitely possible. I would also like to note that I did not test positive for opiates, as I read could also be a possibility.
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.


Utilities leveraged in several places while processing the book.
All of them are bound to the book
instance at runtime.
- Source:
Methods
(inner) beforeRun()
Check first if any post-processing unit is actually registered.
Exit early if none reported. Otherwise, start with moving the book to a
temporary location before further processing (solves path issues with
pdftk
, among other tools, where the input path must differ from the output
path).
- Source:
(inner) handleError()
Log error, then abort.
- Source:
(inner) PostProcessing()
Perform initial checks.
- Source:
(inner) preflight()
Perform some high-level checks prior to committing to post-processing.
- Source:
(inner) readConfiguration()
Extract relevant conf about background and foreground post-processing, from the book's configuration.
- Source:
(inner) runRegisteredUnits()
Run all registered post-processing units, in order, to completion.
- Source:


Everything you need to know about RERback to summary
Bounties from the mod are what you would expect to see from real bounties.
 He is marked by a blue triangle on your map and moves around the world as you progress through your save. So don't expect him to stay in the same spot. He's a wandering guy who likes to explore the world and searches for courageous Witchers to complete the bounties.
The bounty masters accepts any monster trophy (from RER only) that you currently have in your inventory and buys them at a price merchants can't compete. The buying price can be edited in the Rewards System / Trophies menu. The default value of 55% is perfect for prices that are close to the lore and also the vanilla prices for trophies.
Whenever you approach the bounty master, he will buy your trophies but also start a dialogue about monsters you have to kill. If you wait for the end of the dialogue the mod will ask you to pick a seed, or if you have the optional feature to skip the window enabled, it will pick the seed 0 directly.
The seed of a bounty is what controls the randomness. Two bounties with the
same seed result in the exact same bounty. Even on a different computer,
which means you can share with your friends bounties you discovered as
a challenge or simply because the seed results in a bounty that is hard/easy to complete.
If you're not interested in the seed stuff, the seed 0 results
in a completely random bounty and two bounties with the seed 0 won't be the
same.
It is also important to note that when you first install RER you only have
access to lower seeds. And as you finish bounties you unlock new higher seeds.
The higher seeds are also more difficult, you will see more groups of creatures,
more creatures in these groups, creatures will also be bigger, but you will
also get more rewards. Because the seed 0 is completely random
the difficulty scales on Geralt's level instead to guarantee a smooth experience.
It scales infinitely, so if you use a seed 1 000 000 the bounty
will be incredibly hard or if you use a mod to get to level 300 and use the seed
0, that bounty will also be hard.
Note that, at the moment of writing you unlock seeds by steps of 500 and difficulty
increases by one point every 1000 in the seed you pick. So you're not going to
play a bounty with a seed of one million any time soon!
An important thing to note about the seed 0. As i said, the seed 0 bounties scale on Geralt's level so they're perfect when you're leveling. And for this reason the seed 0 bounties are the only bounties that use your settings. Which means that if you use the bestiary feature and you start a seed 0 bounty, creatures you have not killed yet won't appear in these bounties. The filter does not happen for bounties with seed different than 0, so you can see creatures you have not discovered yet. It also means it uses the region constraints, you will see region specific creatures only.
Once you've picked the seed and the bounty has started. You will notice skull markers on your map. The goal of a bounty is to kill every groups marked by these markers until there is no markers on your map. Because the game limits to 10 markers at a time, bounties show up only 5 groups maximum at a time and as you progress through the bounty new groups will be marked.
You will be notified when you've completed the bounty. The mod will show a little notification and also tell you your new bounty level.
If you just want the bounty master to buy your trophies without starting a bounty. You can leave the conversation before it finishes and a bounty won't be triggered.


Please WAIT 5 minutes after joining the server, then follow the instructions below to connect your accounts.
Type in your Discord account name and the 4 numbers after it
(including the pound sign). Entering your Discord information
connects your Discord account to Arisia and allows you to enter the
Arisia Discord server.
Look for this in the lower left hand corner of discord on the web:
discordname
#1234
Please make sure there is no space before the # in the account name you pasted.
Need help? Click here to talk to the info desk. They will ask you for this code:


Definitions
Definitions
- Communication link: connection that allows transfer of information between hosts and end systems.
- Packet switches: groups all transmitted data into suitably sized blocks, called packets, which are then transmitted.
- Transmission rate: speed in bits/second that data is passed over a link.
- Packet: package of information sent over a link. May be the whole set, or a part of the total data.
- Link-layer switch:
- Router switch:
- Route/Path: sequence of communication links and packet switches that a packet goes from end system to end system.
- Internet Service Provider (ISP): a network of packet switches and communication links. Provide connection to end systems and content providers.
- TCP/IP: Specifies the format of the packets that are sent and recieved among routers and end systems.
- Distributed applications: Have multiple end systems that exhchange data with eachother.
- Application Programming Interface (API): specifies how a program running on one end system ask the Internet infrastructure to deliver data to a specific destination program running on another end system.
- Protocol: Defines the format and the order of messages echanged between two or more communicating entities. Also the actions taken on the transmission or receipt of a message/event.
- Client: Host/end system that is usually a desktop, mobile PC or other smaller computer system.
- Server: Host/end system that is usually a more powerful machine that stores and distributes webpages, streams videos, emails, ect.
- Physical medium: Allows a bit to be sent by propagating electro magnetic waves or optical pulses. Examples include twisted-pair copper wire, coaxial cable, multimode fiber-optic cable, terrestrial radio spectrom, and satellite radio spectrum.
- Guided media: Type of physical medium, waves are guided along a solid medium.
- Unguided media: Type of physical medium, waves propagate in the air or outer space.
- Geostationary satellites: Permanently remain above the same spot on Earth. High orbit, which means longer delay.
- Low-earth orbiting satellites: Much closer to Earth and are not stationary. Less delay, but requires more of them. Can communicate between eachother.
- Store-and-foreward transmission: Type of packet switch, must recieve the whole package, before it can start to sent the first bits of hte packet onto the outbound link.
- Output buffer/output queue: Stores packets that the router is about to send to a link. In a store-and-foreward system.
- Packet loss: If the output buffer is full an incoming packet may be dropped.
- Forwarding table: Maps destinations addresses to the outbound links of the router
- Circuit switching: Resources needed along a path for communication between end systems are reserved for the duration of hte communication. Wasteful due to silent periods when dedicated circuts are silent.
- Packet Switching: Resources are not reserved, and a session's messages use the resources on demand. As such messages/packets may have to wait for access to a link or other resources.
- Frequency-division multiplexing: (FDM) Frequency spectrum of a link is divided up among the connections established across the link.
- Time-division multiplexing: (TDM) Time is divided into frames of fixed duration and each frame is divided into a fixed number of time slots. Network dedicates one time slot in every frame to the connection. Dedicated to the sole use of that connection.
- Customer: Access ISP.
- Provider: Global transit ISP. Network of routers and communication links that spans the globe, and has at least one router near the access ISP.
- Regional ISP: An ISP in a region that all access ISPs in that region connect.
- Teir-1 ISP: large ISP network, similar to global ISP concept, but not as large. Regional ISPs and come access ISPs connect to teir-1 ISPs.
- Points of Presence (PoPs): Group of one or more routers, in the same location, that allow customer ISPs in a provider's network to connect to ther provider ISPs.
- Multi-home: When an ISP connects to two or more provider ISPs.
- Peer (connection): ISPs at the same level of heirarchy connect their networks together directly, so that the traffic between them passes via direct communicaion rather than over upstream intermediaries
- Internet Exchange Point (ISP): Meeting point where multiple ISPs can peer together.
- Nodal processing delay: Time required to examine the packet's header to determine where to direct the packet. Also time to check for bit-level errors.
- Queuing delay: The delay that a packet experience when it waits to be transmitted onto the link/node. Depends on the number of earlier arrived packets.
-
- Transimission delay: Packets can only be transmitted after all the packets that arrived before it have been transmitted. Transimission delay is the length of the packet in bits (L) and the transmission rate from router to router in bits/second (R), this it is expressed as L/R. Or the amout of time required to transmit all of the packet's bits into the link.
- Propagation delay: Time required to propagate from the beginning of the link to the end router.
- Traffic intensity: With a = averate rate of packet arrival in queue, R = transmission rate, L = length of bits of packets (all), then traffic intensity is equal to (La)/R. If traffic intensity > 1 averate rate of bit arrival exceeds rate of transmission. If traffic intensity <= 1 there is no queing delay as all packets are transmitted before arrival of the next.


This Node.js package is a collection of React hooks for using the dimensions of the screen, window, or both.
With Node.js installed, simply run the following command to add the package to your project.
npm install react-native-use-dimensions
Check out the examples below or check out the docs.
The package comes with three hooks:
import React from "react";
import { Text } from "react-native";
import useDimensions, {
useScreenDimensions,
useWindowDimensions
} from "react-native-use-dimensions";
const ScreenDimensions = () => {
const { height, width } = useScreenDimensions();
const isLandscape = width > height;
return (
<Text>
{width}x{height}
Orientation: {isLandscape ? "Landscape" : "Portrait"}
</Text>
);
};
const WindowDimensions = () => {
const { height, width } = useWindowDimensions();
const isLandscape = width > height;
return (
<Text>
{width}x{height}
Orientation: {isLandscape ? "Landscape" : "Portrait"}
</Text>
);
};
const BothDimensions = () => {
const { screen, window } = useDimensions();
return (
<Text>
Screen: {screen.width}x{screen.height}
Window: {window.width}x{window.height}
</Text>
);
};
This software is released under the terms of MIT license.
Generated using TypeDoc


Scrap Happy index page:
I spent most of my bloc.io course wondering what I would do for a capstone project. The thought of it was almost overwhelming. Then I realized that I should do something that shows what am I most passionate about. And that, of course, is my family. A digital scrapbook with a Pinterest type layout is the result of that thought.
My mentor with Bloc was scarcely available for guidance, so I flew solo on this project and it took me a lot longer than I had anticipated. I went back and forth on what sort of pages this application should have. Should a user be able to have multiple scrapbooks with multiple pages? What about adding a collaboration feature where other users can add to a scrapbook, with permission from the scrapbooks owner, of course. These ideas were great but I needed a good backbone first. I quickly learned that I was making it too complicated. I needed to simplify this application. It is now a simple one page scrapbook. A user can sign-up with an email verification through send grid and upload photos using the paperclip gem. I added a like feature as well in preparation for the user collaboration that will follow eventually.
Production went much smoother and faster after simplifying the problem. Until I went to add the masonry gem. It wasn’t working. The layout was horrible! Being a ‘Ruby Newbie’ meant I would have to find a way to make this work via the internet. I followed the instructions on the masonry gem documentation, but was still having problems. The layout wasn’t working anything like I had expected. So, I scoured the internet for a solution. Stack overflow didn’t have the answer (which was really surprising to me. I have found many answers on that site). YouTube was my saving grace. I watched a tutorial and VIOLA! It was finally working.
Working masonry gem/Scraphappy index page:
Other functionality pages:
Out of all the projects I have done so far, I learned the most from this one. I even went back and made some adjustments on my older projects with my new found knowledge!
The app is still in ‘simple form’ (Ruby pun intended!). This is version one of this application. I will keep working on it for continued learning and experience!


Generate Call Report
Generate Make/Model Report
Generate TransactionsList Report
Generate Invoice Report
Please provide a Call Tag
Export To
Choose...
Fetch Call Report
Make
Choose...
Please provide a valid make
Includes
Starts with
Export To
Choose...
Fetch Make Report
Fetch Model List Report
Clear
Reported Date (From)
Reported Date (To)
Make
Choose...
Model
Choose...
Status
Choose...
Includes
Starts with
Export To
Choose...
Fetch Transactions List Report
Clear
Please provide an Invoice Tag Number
Export To
Choose...
Fetch Invoice Report
Clear
Report :


| wasd | horizontal movement |
| qe | vertical movement |
| arrow keys | look around |
| right click | toggle mouse controls |
| ] | + pixel size |
| [ | - pixel size |
| shift + ] | + field of view |
| shift + [ | - field of view |
| + | increase oversampling (1, 4, 9...) |
| - | decrease oversampling |
| o | step count overlay |
| p | switch loading pattern (top-to-bottom, random) |
| f | force redraw |
| l | move light source |
| 1-7 | switch scene |


--- layout: default permalink: /check-email/ useContainer: false ---
To complete registration, please check your email and click the link we sent you.
Please check your spam folder if you do not see the email in your inbox.
If you did not receive your email verification message, please email us at info@revolutionuc.com.


{% load static %}
This server is associated with the paper "In Search of Lost Time: A Review of JavaScript Timers in Browsers" by Thomas ROKICKI, Clémentine MAURICE and Pierre LAPERDRIX
It features all client side experiments used for the results in the paper.
The code was initially meant to be used automatically with selenium webdriver, but it is still usable with only the server.


Company profile - Canadian Company Capabilities
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Christie Digital Systems Canada Inc.
Legal Name:
Christie Digital Systems Canada Inc.
Operating Name:
Christie
Mailing Address:
809 Wellington St NKITCHENER, Ontario
N2H 5L6
Location Address:
809 Wellington St NKITCHENER, Ontario
N2H 5L6
Tel.:<PHONE_NUMBER>
Tel.:<PHONE_NUMBER>
Fax:
Logo
Company Profile
Christie® is a global visual and audio technologies company. Consistently setting the standards by being the first to market some of the worlds most advanced projectors, display systems and immersive audio solutions, Christie is recognized as one of the most innovative technologies company in the world.
Utilizing DLP®, LCD and LED technologies, Christies broad range of visual solutions include: media walls, digital cinema projectors, networking solutions, cutting edge 3D virtual reality and simulation projection systems and Christie MicroTiles®, the worlds first fully modular digital display tiles. Christies technology expertise also includes immersive audio solutions, laser projection, High Frame Rate (HFR) visual solutions and medical imaging devices.
Christies Managed Services group helps to design, deploy and support enterprise-wide networks around the world.
At Christie, we help our customers create the worlds best shared experiences.
Full profile
Full profile
Contact information
Company description
334310 - Audio and Video Equipment Manufacturing
334512 - Measuring, Medical and Controlling Devices Manufacturing
Product / Service / Licensing
Our display solutions include:
Christie Matrix StIM WQ DLP LED-based scalable environment projection technology. This system has the unique capabilities of achieving eye-limiting resolution while stimulating Night Vision Goggles and true 120Hz operation for maximum dynamic image quality.
Christie Matrix WU7K-J. A 3-chip, WUXGA, DLP, 6,300 lumen projection system that produces real-world simulation results with full scalability, built-in geometric warping and blending and high-performance 120Hz capability.
Christies ISO certified project management practices see you through the design, installation, integration and complete training and support of your project requirements. Christies experienced team will integrate and install the system and fully train your employees and provide you with ongoing support.
Christie MicroTiles® rear-projection displays are ideal for near seamless displays with high pixel density
Christie Velvet LED displays that create a seamless display wall
Christies content management and image processing are combined with the products to complete the display solution.
Choose your virtual reality:
Immersion (scale)
Stereoscopy (depth perception)
Interactivity (tracking)
Produce life-like visualizations on a variety of surfaces:
Images of any size or shape
Front or rear projection
Spherical, cylindrical, conic or flat screens
Compatible with small screens to large-scale dome configurations
Our integrated immersive displays are engineered for collaborative visualization that requires high-resolution, stable, reliable and powerful 2D and 3D capabilities. Christie has a broad platform of high-resolution, professional performance display technologies: DLP®, 4K, 3-chip DLP, 1-chip LED, and Quad HD panels.
Some of our integrated solutions include:
Christie CAVE
Christie HoloStage Mini
Christie HoloStation
Christie Powerwall
Universal routing switcher: The Christie Vista URS is an all-in-one matrix switcher that accepts multiple sources in any format (analog composite to digital 4K) and seamlessly routes any of these sources to any of 8 user-configurable outputs, each of which can be independently configured for any analog or digital output format. The URS performs all the processing to match the source to the output, including scaling, aspect ratio, color-space, and frame rate conversion repeats. Normally, these functions require additional equipment and complex, restrictive control systems; however with the URS the entire process is simplified, saving you time, money and resources.
Christie Brio: Christie® Brio presentation and collaboration solutions remove technical barriers and enable team members to drive for results together. Designed to address common meeting technology challenges, Christie Brio solutions enable teams to wirelessly present, share and interact with each other within the same room or across multiple locations, in real-time. When everyone is focused on the content rather than the technology, more energy can be put into clearly and confidently exchanging information and ideas. Decision-making becomes less time-consuming so you can get more value out of the time you spend meeting together.
Christie 1-chip DLP® projectors are ideal for small auditoriums, boardrooms, classrooms and houses of worship. Delivering image blending and warping, stacking capabilities and precision color matching they are available in multiple resolutions and brightness levels.
Christie LCD projectors offers a broad range of brightness and resolutions, making them ideal for boardrooms, houses of worship, government, higher education and more, with a low cost of ownership.
Technology profile
Facilities Improvements
- reduction of electrical consumption
- reduction in natural gas usage
- 'lights off' policy when office area is not occupied
- responsible use of heating and air-conditioning systems
Products
- all Christie products follow RoHS guidelines
- introducted stand-by mode in new projectors to reduce power consumption
- solide state LED projection systems to conserve resources and electricity
Recycling
- 82% of all materials collected in the waste stream at the Canadian facility are recycled
- expanded recycling program to include organics
-goal is to have all components in future products recycleable
Employee Incentives
- successful carpooling program
- Christe GREEN TEAM promoting environmental awareness - Lunch ' n' Learn
- compressed manufacturing work week to 4 days with 10-hour shifts
Market profile
Alliances:
- Sales/Marketing
Industry sector market interests:
- Culture
- Environment
- Information Technology and Telecommunications
- Manufacturing
- Medical/Biotechnology/Chemical
- Mining/Petroleum/Gas
- Service Industry
- Transportation
- Wholesale/Retail
- Aerospace
- Defence
- Automotive
- Electrical Equipment
Sector information
Total plant size:
- Christie is among the largest manufacturing facilities in Waterloo Region, Ontario
- Current plant size is 306,000 s.f at Wellington Street location with an additional 60,000 s.f located at Trillium Drive location
- Overall manufacturing area is 105,000 sq.ft
Distribution of employees:
Approximately 258 engineers work at our Kitchener office out of 679 total full-time employees.Key / Major clients:
Canadian Customers- Defence Research and Development Canada
- Geroge Brown College
- Carelton University
- University of Waterloo Stratford Campus
- Cineplex Inc.
- Canada Olympic House
- Shaw Communications
- Canada's Wonderland
- Landmark Cinemas
- Knox Presbyterian Church
- Global Televisionss The Morning Show
- Perimeter Institute for Theoretical Physics
- TELUS Spark Science Center
- Communitech's Hub
- Les Cinémas Ciné Entreprises
- Quartier des spectacles
- Cinemas Guzzo
Success stories:
Please see websitehttp://www.christiedigital.com/en-us/visual-solutions-case-studies/projector-installations/pages/default.aspx
Third-Party Information Liability Disclaimer
Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.
Contacts
Contact information
Description
Company description
334310 - Audio and Video Equipment Manufacturing
334512 - Measuring, Medical and Controlling Devices Manufacturing
Products, services and licensing
Product / Service / Licensing
Our display solutions include:
Christie Matrix StIM WQ DLP LED-based scalable environment projection technology. This system has the unique capabilities of achieving eye-limiting resolution while stimulating Night Vision Goggles and true 120Hz operation for maximum dynamic image quality.
Christie Matrix WU7K-J. A 3-chip, WUXGA, DLP, 6,300 lumen projection system that produces real-world simulation results with full scalability, built-in geometric warping and blending and high-performance 120Hz capability.
Christies ISO certified project management practices see you through the design, installation, integration and complete training and support of your project requirements. Christies experienced team will integrate and install the system and fully train your employees and provide you with ongoing support.
Christie MicroTiles® rear-projection displays are ideal for near seamless displays with high pixel density
Christie Velvet LED displays that create a seamless display wall
Christies content management and image processing are combined with the products to complete the display solution.
Choose your virtual reality:
Immersion (scale)
Stereoscopy (depth perception)
Interactivity (tracking)
Produce life-like visualizations on a variety of surfaces:
Images of any size or shape
Front or rear projection
Spherical, cylindrical, conic or flat screens
Compatible with small screens to large-scale dome configurations
Our integrated immersive displays are engineered for collaborative visualization that requires high-resolution, stable, reliable and powerful 2D and 3D capabilities. Christie has a broad platform of high-resolution, professional performance display technologies: DLP®, 4K, 3-chip DLP, 1-chip LED, and Quad HD panels.
Some of our integrated solutions include:
Christie CAVE
Christie HoloStage Mini
Christie HoloStation
Christie Powerwall
Universal routing switcher: The Christie Vista URS is an all-in-one matrix switcher that accepts multiple sources in any format (analog composite to digital 4K) and seamlessly routes any of these sources to any of 8 user-configurable outputs, each of which can be independently configured for any analog or digital output format. The URS performs all the processing to match the source to the output, including scaling, aspect ratio, color-space, and frame rate conversion repeats. Normally, these functions require additional equipment and complex, restrictive control systems; however with the URS the entire process is simplified, saving you time, money and resources.
Christie Brio: Christie® Brio presentation and collaboration solutions remove technical barriers and enable team members to drive for results together. Designed to address common meeting technology challenges, Christie Brio solutions enable teams to wirelessly present, share and interact with each other within the same room or across multiple locations, in real-time. When everyone is focused on the content rather than the technology, more energy can be put into clearly and confidently exchanging information and ideas. Decision-making becomes less time-consuming so you can get more value out of the time you spend meeting together.
Christie 1-chip DLP® projectors are ideal for small auditoriums, boardrooms, classrooms and houses of worship. Delivering image blending and warping, stacking capabilities and precision color matching they are available in multiple resolutions and brightness levels.
Christie LCD projectors offers a broad range of brightness and resolutions, making them ideal for boardrooms, houses of worship, government, higher education and more, with a low cost of ownership.
Technology
Technology profile
Facilities Improvements
- reduction of electrical consumption
- reduction in natural gas usage
- 'lights off' policy when office area is not occupied
- responsible use of heating and air-conditioning systems
Products
- all Christie products follow RoHS guidelines
- introducted stand-by mode in new projectors to reduce power consumption
- solide state LED projection systems to conserve resources and electricity
Recycling
- 82% of all materials collected in the waste stream at the Canadian facility are recycled
- expanded recycling program to include organics
-goal is to have all components in future products recycleable
Employee Incentives
- successful carpooling program
- Christe GREEN TEAM promoting environmental awareness - Lunch ' n' Learn
- compressed manufacturing work week to 4 days with 10-hour shifts
Market
Market profile
Alliances:
- Sales/Marketing
Industry sector market interests:
- Culture
- Environment
- Information Technology and Telecommunications
- Manufacturing
- Medical/Biotechnology/Chemical
- Mining/Petroleum/Gas
- Service Industry
- Transportation
- Wholesale/Retail
- Aerospace
- Defence
- Automotive
- Electrical Equipment
Sector
Sector information
Total plant size:
- Christie is among the largest manufacturing facilities in Waterloo Region, Ontario
- Current plant size is 306,000 s.f at Wellington Street location with an additional 60,000 s.f located at Trillium Drive location
- Overall manufacturing area is 105,000 sq.ft
Distribution of employees:
Approximately 258 engineers work at our Kitchener office out of 679 total full-time employees.Key / Major clients:
Canadian Customers- Defence Research and Development Canada
- Geroge Brown College
- Carelton University
- University of Waterloo Stratford Campus
- Cineplex Inc.
- Canada Olympic House
- Shaw Communications
- Canada's Wonderland
- Landmark Cinemas
- Knox Presbyterian Church
- Global Televisionss The Morning Show
- Perimeter Institute for Theoretical Physics
- TELUS Spark Science Center
- Communitech's Hub
- Les Cinémas Ciné Entreprises
- Quartier des spectacles
- Cinemas Guzzo
Success stories:
Please see websitehttp://www.christiedigital.com/en-us/visual-solutions-case-studies/projector-installations/pages/default.aspx


A channel to discuss trading. For useful links and more info click the pinned messages to the right.
100 messages
Before 05-Dec-19 12:00 AM
nocturnal24-Feb-19 07:20 PM
lol
jl777c24-Feb-19 07:21 PM
@Acura can you check to see if zeroknowledge proofs are quantum resistant? i am not sure on that point
nocturnal24-Feb-19 07:21 PM
to be fair
if quantum resistent is analogous to water resistant
then its probably quite accurate
Hollowman900024-Feb-19 07:22 PM
The small print
Gets you every time
nocturnal24-Feb-19 07:22 PM
haha
jl777c24-Feb-19 07:23 PM
the distinction is total 100% wipeout for sure when QC arrives, vs. a chance of surviving long enough to transition to the quantum secure algos
where quantum secure are proven to be immune to quantum computer of however many qbits
nocturnal24-Feb-19 07:23 PM
the implication to the uninitiated is "quantum proof"
jl777c24-Feb-19 07:23 PM
likely it will take a QC to create such a thing
nocturnal24-Feb-19 07:23 PM
exactly
jl777c24-Feb-19 07:24 PM
I dont expect I am talking to uninitiated. I used industry accepted terms in the ways it is accepted to mean
nocturnal24-Feb-19 07:24 PM
bit of marketing there
advertisers put the quantum in everything these days
it sells technology
Hollowman900024-Feb-19 07:24 PM
The world isn’t fair, why play fair?
nocturnal24-Feb-19 07:24 PM
fair enough
Hollowman900024-Feb-19 07:25 PM
jl777c24-Feb-19 07:26 PM
so if there is no point to spend any more than a weekend on quantum resistant stuff, i wont. but as it is I am not aware of any quantum resistant blockchain that is usable
so it might be worth spending a full week on it
5
Gordon Komodo24-Feb-19 07:26 PM
so what you are saying is we should eliminate all the marketers, round them up in a camp somewhere then?
@KomodoPlatform - adaptable blockchain architecture designed to empower projects by eliminating future limitations.
"Adapt what is useful, reject what is useless, and add specifically your own". - Bruce Lee https://t.co/Po0CxPTNxa
The Quantum Resistant Ledger (QRL) is a first-of-its-kind, post-quantum value store and decentralized communication layer proactively tackling the threat advanced Quantum Computers pose to cryptocurrencies.
jl777c24-Feb-19 07:40 PM
can the same address be reused?
it seems they are using Winternitz one time signature scheme
they link to dilithium on their site, maybe they plan to upgrade to it?
tolken24-Feb-19 07:41 PM
Possibly, might need more than a weekend though.
jl777c24-Feb-19 07:43 PM
it would take me a full week to make a usable dilithium based chain as it would need to support change addresses. and multiple inputs. right now it just spends a single input from a special send tx
Hollowman900024-Feb-19 07:43 PM
less talk, more do
You were going to anyway
Why half ass it
Plant the flag
And when @jl777c saw the breadth of his ecosystem, he wept as there was no more crypto to conquer
5
4
yorklab24-Feb-19 07:47 PM
Make the chain then ask an organization with a Super Computer if they can break it. That might make for some good marketing.
Hollowman900024-Feb-19 07:47 PM
You assume a SC can break standard cryptography
yorklab24-Feb-19 07:48 PM
Doesn't matter, still good marketing.
FishyGuts24-Feb-19 07:48 PM
nocturnal Todaythe implication to the uninitiated is "quantum proof"
By uninitiated, do you mean those that are below a 1st grade reading level?
Resistant.
Resistant.
Re-sis-tant.
Just because you assume that means "Proof" doesn't make you right @nocturnal
1
1
Its literally words, being used correctly.

Market More! Market Less! Market how I want you to market!
1
@jl777c You probably are years ahead, and maybe this weekend isn't the time to finish this.
damn coinbase put a 3 day hold on my withdrawal though so now i cant buy KMD right now lol
Need to get lucky these next 3 days and have btc up and KMD down before i buy
Are atomic swaps still happening or is that on hold these days?
jspook1624-Feb-19 10:04 PM
Atomic swaps have been released in to the wild. There is no putting them on hold
Sdunbar24-Feb-19 10:08 PM
is there a site still tracking them?
dexstats always show 0 now
Alright24-Feb-19 10:34 PM
@Sdunbar dexstats is still functioning, bdex volume is just deded
strong focus on mm2 as opposed to fleshing out mm1 usage
nocturnal24-Feb-19 11:33 PM
hey @FishyGuts yes i assumed the incorrect meaning(edited)
however its still largely nonsense if you think about it
what good is water resistance to a divers watch?
what good is quantum resistance to a blockchain?
even the article presented explicitly stated a vague assumption is being made of a 'large' quantum computer
and that the post quantum resistance is 'plausible' i.e. its possible but no one knows(edited)
if you cant see the point im making i think you are being willfully blind
FishyGuts24-Feb-19 11:47 PM
I take those phrases at base meaning. Resistant.
Not looking at the math of whats possible, and then determining, without review, that it's "impossible" is a stance you seem smart enough to not take.
nocturnal24-Feb-19 11:48 PM
dude its a largely meaningless bit of marketing
ive looked into quantum computing alot(edited)
im not a physicist
but that phrase smells bad
FishyGuts24-Feb-19 11:49 PM
Youre discussion and arguments are full of well heelled responses but youre assuming a lot of things, while the other side is too. Its uinfair to throw away both sides assumptions.
nocturnal24-Feb-19 11:50 PM
what am i assuming?
enlighten me
in short - in quantum cryptography
you cant encrypt securely against QC without a QC(edited)
so 'resistance' is useless, its like saying i'm nuclear blast resistant if i live 2 seconds longer(edited)
but people are thinking ahead about it which is good
just that if people believe their own hype machines
they make different investment decisions
so better to be real
yorklab24-Feb-19 11:57 PM
It's unbelievable how sensitive the markets are to Bitcoin. Since that big Dump earlier, every time Bitcoin moves down $30 or $40 some of the Alts (including kmd) sell off quickly. People are nervous now.
Markus25-Feb-19 12:00 AM
and we closed week above 50 moving average
Likewise25-Feb-19 12:59 AM
Lost a lot of market cap, back down we go or back to range, no progress onb BTC. What it managed to gain in 4 or 5 days si wiped out in one 15 min candle. Not bullish PA.
just for the fun of it I'm going to throw 500$ at a short BTC.


This chapter describes Chez Scheme extensions to the standard set of operations on numbers. See Chapter 6 of The Scheme Programming Language, 4th Edition or the Revised6 Report on Scheme for a description of standard operations on numbers.
Chez Scheme supports the full set of Scheme numeric datatypes, including exact and inexact integer, rational, real, and complex numbers. A variety of representations are used to support these datatypes:
Most numbers can be represented in only one way; however, real numbers are sometimes represented as inexact complex numbers with imaginary component equal to zero.
Chez Scheme extends the syntax of numbers with arbitrary radixes from two through 36, nondecimal floating-point and scientific notation, and printed representations for IEEE infinities and NANs. (NAN stands for "not-a-number.")
Arbitrary radixes are specified with the prefix #nr, where n ranges from 2 through 36. Digits beyond 9 are specified with the letters (in either upper or lower case) a through z. For example, #2r101 is 510, and #36rZ is 3510.
For higher radixes, an ambiguity arises between the interpretation of certain letters, e.g., e, as digits or exponent specifiers; in such cases, the letter is assumed to be a digit. For example, the e in #x3.2e5 is interpreted as a digit, not as an exponent marker, whereas in 3.2e5 it is treated as an exponent marker.
IEEE infinities are printed as +inf.0 and -inf.0, while IEEE NANs are printed as +nan.0 or -nan.0. (+nan.0 is used on output for all NANs.)
(/ 1.0 0.0) +inf.0
(/ 1.0 -0.0) -inf.0
(/ 0.0 0.0) +nan.0
(/ +inf.0 -inf.0) +nan.0
The first section of this chapter describes type-specific numeric type predicates. Sections 8.2 through 8.4 describe fast, type-specific numeric operations on fixnums, flonums, and inexact complex numbers (flonums and/or inexact complexnums). The fixnum-specific versions should be used only when the programmer is certain that the operands and results (where appropriate) will be fixnums, i.e., integers in the range (most-negative-fixnum) to (most-positive-fixnum), inclusive. The flonum-specific versions should be used only when the inputs and outputs (where appropriate) are certain to be flonums. The mixed flonum/complexnum versions should be used only when the inputs are certain to be either flonums or inexact complexnums. Section 8.5 describes operations, both arbitrary precision and fixnum-specific, that allow exact integers to be treated as sets or sequences of bits. Random number generation is covered Section 8.6, and miscellaneous numeric operations are covered in the Section 8.7.
The Revised6 Report distinguishes two types of special numeric objects: fixnums and flonums. Chez Scheme additionally distinguishes bignums (exact integers outside of the bignum range) and ratnums (ratios of exact integers). It also provides a predicate for recognizing cflonums, which are flonums or inexact complex numbers.
procedure: (bignum? obj)
returns: #t if obj is a bignum, otherwise #f
libraries: (chezscheme)
(bignum? 0) #f
(bignum? (most-positive-fixnum)) #f
(bignum? (most-negative-fixnum)) #f
(bignum? (* (most-positive-fixnum) 2)) #t
(bignum? 3/4) #f
(bignum? 'a) #f
procedure: (ratnum? obj)
returns: #t if obj is a ratnum, otherwise #f
libraries: (chezscheme)
(ratnum? 0) #f
(ratnum? (* (most-positive-fixnum) 2)) #f
(ratnum? 3/4) #t
(ratnum? -10/2) #f
(ratnum? -11/2) #t
(ratnum? 'a) #f
procedure: (cflonum? obj)
returns: #t if obj is an inexact complexnum or flonum, otherwise #f
libraries: (chezscheme)
(cflonum? 0) #f
(cflonum? 0.0) #t
(cflonum? 3+4i) #f
(cflonum? 3.0+4i) #t
(cflonum? +i) #f
(cflonum? +1.0i) #t
Fixnum-specific procedures normally check their inputs and outputs (where appropriate), but at optimization level 3 the compiler generates, in most cases, code that does not perform these checks.
procedure: (most-positive-fixnum)
returns: the most negative fixnum supported by the system
procedure: (most-negative-fixnum)
returns: the most positive fixnum supported by the system
libraries: (chezscheme)
These procedures are identical to the Revised6 Report greatest-fixnum and least-fixnum procedures.
procedure: (fx= fixnum1 fixnum2 ...)
procedure: (fx< fixnum1 fixnum2 ...)
procedure: (fx> fixnum1 fixnum2 ...)
procedure: (fx<= fixnum1 fixnum2 ...)
procedure: (fx>= fixnum1 fixnum2 ...)
returns: #t if the relation holds, #f otherwise
libraries: (chezscheme)
The predicate fx= returns #t if its arguments are equal. The predicate fx< returns #t if its arguments are monotonically increasing, i.e., each argument is greater than the preceding ones, while fx> returns #t if its arguments are monotonically decreasing. The predicate fx<= returns #t if its arguments are monotonically nondecreasing, i.e., each argument is not less than the preceding ones, while fx>= returns #t if its arguments are monotonically nonincreasing. When passed only one argument, each of these predicates returns #t.
These procedures are similar to the Revised6 Report procedures fx=?, fx<?, fx>?, fx<=?, and fx>=? except that the Revised6 Report procedures require two or more arguments, and their names have the "?" suffix.
(fx= 0) #t
(fx= 0 0) #t
(fx< (most-negative-fixnum) 0 (most-positive-fixnum)) #t
(let ([x 3]) (fx<= 0 x 9)) #t
(fx<= 0 3 3) #t
(fx>= 0 0 (most-negative-fixnum)) #t
procedure: (fxnonpositive? fixnum)
returns: #t if fixnum is not greater than zero, #f otherwise
procedure: (fxnonnegative? fixnum)
returns: #t if fixnum is not less than zero, #f otherwise
libraries: (chezscheme)
fxnonpositive? is equivalent to (lambda (x) (fx<= x 0)), and fxnonnegative? is equivalent to (lambda (x) (fx>= x 0)).
(fxnonpositive? 128) #f
(fxnonpositive? 0) #t
(fxnonpositive? -1) #t
(fxnonnegative? -65) #f
(fxnonnegative? 0) #t
(fxnonnegative? 1) #t
procedure: (fx+ fixnum ...)
returns: the sum of the arguments fixnum ...
libraries: (chezscheme)
When called with no arguments, fx+ returns 0.
(fx+) 0
(fx+ 1 2) 3
(fx+ 3 4 5) 12
(apply fx+ '(1 2 3 4 5)) 15
procedure: (fx- fixnum1 fixnum2 ...)
returns: a fixnum
libraries: (chezscheme)
When called with one argument, fx- returns the negative of fixnum1. Thus, (fx- fixnum1) is an idiom for (fx- 0 fixnum1).
When called with two or more arguments, fx- returns the result of subtracting the sum of the numbers fixnum2 ... from fixnum1.
(fx- 3) -3
(fx- 4 3) 1
(fx- 4 3 2 1) -2
procedure: (fx* fixnum ...)
returns: the product of the arguments fixnum ...
libraries: (chezscheme)
When called with no arguments, fx* returns 1.
(fx*) 1
(fx* 1 2) 2
(fx* 3 -4 5) -60
(apply fx* '(1 -2 3 -4 5)) 120
procedure: (fx/ fixnum1 fixnum2 ...)
returns: see explanation
libraries: (chezscheme)
When called with one argument, fx/ returns the reciprocal of fixnum1. That is, (fx/ fixnum1) is an idiom for (fx/ 1 fixnum1).
When called with two or more arguments, fx/ returns the result of dividing fixnum1 by the product of the remaining arguments fixnum2 ....
(fx/ 1) 1
(fx/ -17) 0
(fx/ 8 -2) -4
(fx/ -9 2) -4
(fx/ 60 5 3 2) 2
procedure: (fx1+ fixnum)
procedure: (fx1- fixnum)
returns: fixnum plus 1 or fixnum minus 1
libraries: (chezscheme)
(define fxplus
(lambda (x y)
(if (fxzero? x)
y
(fxplus (fx1- x) (fx1+ y)))))
(fxplus 7 8) 15
fx1+ and fx1- can be defined as follows:
(define fx1+ (lambda (x) (fx+ x 1)))
(define fx1- (lambda (x) (fx- x 1)))
procedure: (fxquotient fixnum1 fixnum2 ...)
returns: see explanation
libraries: (chezscheme)
fxquotient is identical to fx/. See the description of fx/ above.
procedure: (fxremainder fixnum1 fixnum2)
returns: the fixnum remainder of fixnum1 divided by fixnum2
libraries: (chezscheme)
The result of fxremainder has the same sign as fixnum1.
(fxremainder 16 4) 0
(fxremainder 5 2) 1
(fxremainder -45 7) -3
(fxremainder 10 -3) 1
(fxremainder -17 -9) -8
procedure: (fxmodulo fixnum1 fixnum2)
returns: the fixnum modulus of fixnum1 and fixnum2
libraries: (chezscheme)
The result of fxmodulo has the same sign as fixnum2.
(fxmodulo 16 4) 0
(fxmodulo 5 2) 1
(fxmodulo -45 7) 4
(fxmodulo 10 -3) -2
(fxmodulo -17 -9) -8
procedure: (fxabs fixnum)
returns: the absolute value of fixnum
libraries: (chezscheme)
(fxabs 1) 1
(fxabs -1) 1
(fxabs 0) 0
Inexact real numbers are normally represented by flonums. A flonum is a single 64-bit double-precision floating point number. This section describes operations on flonums, most of which accept flonum arguments and return flonum values. In most cases, the operations are inline-coded or coded as machine language subroutines at optimize-level 3 with no argument type checking; full type checking is performed at lower optimize levels. Flonum-specific procedure names begin with the prefix "fl" to set them apart from their generic counterparts.
Inexact real numbers may also be represented by inexact complexnums with imaginary parts equal to zero, which cannot be used as input to the flonum-specific operators. Such numbers are produced, however, only from operations involving complex numbers with nonzero imaginary parts, by explicit calls to fl-make-rectangular, make-rectangular, or make-polar, or by numeric input in either polar or rectangular format.
procedure: (flonum->fixnum flonum)
returns: the fixnum representation of flonum, truncated
libraries: (chezscheme)
The truncated value of flonum must fall within the fixnum range. flonum->fixnum is a restricted version of exact, which converts any numeric representation to its exact equivalent.
(flonum->fixnum 0.0) 0
(flonum->fixnum 3.9) 3
(flonum->fixnum -2.2) -2
procedure: (fl= flonum1 flonum2 ...)
procedure: (fl< flonum1 flonum2 ...)
procedure: (fl> flonum1 flonum2 ...)
procedure: (fl<= flonum1 flonum2 ...)
procedure: (fl>= flonum1 flonum2 ...)
returns: #t if the relation holds, #f otherwise
libraries: (chezscheme)
The predicate fl= returns #t if its arguments are equal. The predicate fl< returns #t if its arguments are monotonically increasing, i.e., each argument is greater than the preceding ones, while fl> returns #t if its arguments are monotonically decreasing. The predicate fl<= returns #t if its arguments are monotonically nondecreasing, i.e., each argument is not less than the preceding ones, while fl>= returns #t if its arguments are monotonically nonincreasing. When passed only one argument, each of these predicates returns #t.
IEEE NANs are not comparable, i.e., comparisons involving NANs always return #f.
These procedures are similar to the Revised6 Report procedures fl=?, fl<?, fl>?, fl<=?, and fl>=? except that the Revised6 Report procedures require two or more arguments, and their names have the "?" suffix.
(fl= 0.0) #t
(fl= 0.0 0.0) #t
(fl< -1.0 0.0 1.0) #t
(fl> -1.0 0.0 1.0) #f
(fl<= 0.0 3.0 3.0) #t
(fl>= 4.0 3.0 3.0) #t
(fl< 7.0 +inf.0) #t
(fl= +nan.0 0.0) #f
(fl= +nan.0 +nan.0) #f
(fl< +nan.0 +nan.0) #f
(fl> +nan.0 +nan.0) #f
procedure: (flnonpositive? fl)
returns: #t if fl is not greater than zero, #f otherwise
procedure: (flnonnegative? fl)
returns: #t if fl is not less than zero, #f otherwise
libraries: (chezscheme)
flnonpositive? is equivalent to (lambda (x) (fl<= x 0.0)), and flnonnegative? is equivalent to (lambda (x) (fl>= x 0.0)).
Even if the flonum representation distinguishes -0.0 from +0.0, both are considered nonpositive and nonnegative.
(flnonpositive? 128.0) #f
(flnonpositive? 0.0) #t
(flnonpositive? -0.0) #t
(flnonpositive? -1.0) #t
(flnonnegative? -65.0) #f
(flnonnegative? 0.0) #t
(flnonnegative? -0.0) #t
(flnonnegative? 1.0) #t
(flnonnegative? +nan.0) #f
(flnonpositive? +nan.0) #f
(flnonnegative? +inf.0) #t
(flnonnegative? -inf.0) #f
procedure: (decode-float x)
returns: see below
libraries: (chezscheme)
x must be a flonum. decode-float returns a vector with three integer elements, m, e, and s, such that x = sm2e. It is useful primarily in the printing of floating-point numbers.
(decode-float 1.0) #(4503599627370496 -52 1)
(decode-float -1.0) #(4503599627370496 -52 -1)
(define slow-identity
(lambda (x)
(inexact
(let ([v (decode-float x)])
(let ([m (vector-ref v 0)]
[e (vector-ref v 1)]
[s (vector-ref v 2)])
(* s m (expt 2 e)))))))
(slow-identity 1.0) 1.0
(slow-identity -1e20) -1e20
procedure: (fllp flonum)
returns: see below
libraries: (chezscheme)
fllp returns the 12-bit integer consisting of the exponent plus highest order represented bit of a flonum (ieee 64-bit floating-point number). It can be used to compute a fast approximation of the logarithm of the number.
(fllp 0.0) 0
(fllp 1.0) 2046
(fllp -1.0) 2046
(fllp 1.5) 2047
(fllp +inf.0) 4094
(fllp -inf.0) 4094
(fllp #b1.0e-1111111111) 1
(fllp #b1.0e-10000000000) 0
The procedures described in this section provide mechanisms for creating and operating on inexact complex numbers. Inexact complex numbers with nonzero imaginary parts are represented as inexact complexnums. An inexact complexnum contains two 64-bit double-precision floating point numbers. Inexact complex numbers with imaginary parts equal to zero (in other words, inexact real numbers) may be represented as either inexact complexnums or flonums. The operations described in this section accept any mix of inexact complexnum and flonum arguments (collectively, "cflonums").
In most cases, the operations are performed with minimal type checking at optimize-level 3; full type checking is performed at lower optimize levels. Inexact complex procedure names begin with the prefix "cfl" to set them apart from their generic counterparts.
procedure: (fl-make-rectangular flonum1 flonum2)
returns: an inexact complexnum
libraries: (chezscheme)
The inexact complexnum produced by fl-make-rectangular has real part equal to flonum1 and imaginary part equal to flonum2.
(fl-make-rectangular 2.0 -3.0) 2.0-3.0i
(fl-make-rectangular 2.0 0.0) 2.0+0.0i
(fl-make-rectangular 2.0 -0.0) 2.0-0.0i
procedure: (cfl-real-part cflonum)
returns: the real part of cflonum
procedure: (cfl-imag-part cflonum)
returns: the imaginary part of cflonum
libraries: (chezscheme)
(cfl-real-part 2.0-3.0i) 2.0
(cfl-imag-part 2.0-3.0i) -3.0
(cfl-imag-part 2.0-0.0i) -0.0
(cfl-imag-part 2.0-inf.0i) -inf.0
procedure: (cfl= cflonum ...)
returns: #t if its arguments are equal, #f otherwise
libraries: (chezscheme)
(cfl= 7.0+0.0i 7.0) #t
(cfl= 1.0+2.0i 1.0+2.0i) #t
(cfl= 1.0+2.0i 1.0-2.0i) #f
procedure: (cfl+ cflonum ...)
procedure: (cfl* cflonum ...)
procedure: (cfl- cflonum1 cflonum2 ...)
procedure: (cfl/ cflonum1 cflonum2 ...)
returns: a cflonum
libraries: (chezscheme)
These procedures compute the sum, difference, product, or quotient of inexact complex quantities, whether these quantities are represented by flonums or inexact complexnums. For example, if cfl+ receives two flonum arguments a and b, it returns the sum a + b; in this case, it behaves the same as fl+. With two inexact complexnum arguments a + bi and c + di, it returns the sum (a + c) + (b + d)i. If one argument is a flonum a and the other an inexact complexnum c + di, cfl+ returns (a + c) + di.
When passed zero arguments, cfl+ returns 0.0 and cfl* returns 1.0. When passed one argument, cfl- returns the additive inverse of the argument, and cfl/ returns the multiplicative inverse of the argument. When passed three or more arguments, cfl- returns the difference between its first and the sum of its remaining arguments, and cfl/ returns the quotient of its first and the product of its remaining arguments.
(cfl+) 0.0
(cfl*) 1.0
(cfl- 5.0+1.0i) -5.0-1.0i
(cfl/ 2.0+2.0i) 0.25-0.25i
(cfl+ 1.0+2.2i -3.7+5.3i) -2.7+7.5i
(cfl+ 1.0 -5.3) -4.3
(cfl+ 1.0 2.0 -5.3i) 3.0-5.3i
(cfl- 1.0+2.5i -3.7) 4.7+2.5i
(cfl* 1.0+2.0i 3.0+4.0i) -5.0+10.0i
(cfl/ -5.0+10.0i 1.0+2.0i 2.0) 1.5+2.0i
procedure: (cfl-conjugate cflonum)
returns: complex conjugate of cflonum
libraries: (chezscheme)
The procedure cfl-conjugate, when passed an inexact complex argument a + bi, returns its complex conjugate a + (-b)i.
See also conjugate, which is a generic version of this operator that returns the complex conjugate of any valid representation for a complex number.
(cfl-conjugate 3.0) 3.0
(cfl-conjugate 3.0+4.0i) 3.0-4.0i
(cfl-conjugate 1e-20-2e-30i) 1e-20+2e-30i
procedure: (cfl-magnitude-squared cflonum)
returns: magnitude of cflonum squared
libraries: (chezscheme)
The procedure cfl-magnitude-squared, when passed an inexact complex argument a + bi returns a flonum representing the magnitude of the argument squared, i.e., a2 + b2.
See also magnitude-squared, which is a generic version of this operator that returns the magnitude squared of any valid representation for a complex number. Both operations are similar to the magnitude procedure, which returns the magnitude, sqrt(a2 + b2), of its generic complex argument.
(cfl-magnitude-squared 3.0) 9.0
(cfl-magnitude-squared 3.0-4.0i) 25.0
Chez Scheme provides a set of logical operators that allow exact integers (fixnums and bignums) to be treated as sets or sequences of bits.  Each of these operators treats its arguments as two's complement integers, regardless of the underlying representation. This treatment can be exploited to represent infinite sets: a negative number represents an infinite number of one bits beyond the leftmost zero, and a nonnegative number represents an infinite number of zero bits beyond the leftmost one bit.
Fixnum equivalents of the logical operators are provided, as fxlogand, fxlogior, fxlogxor, fxlognot, fxlogtest, fxlogbit?, fxlogbit0, and fxlogbit1. Three separate fixnum operators are provided for shifting: fxsll (shift-left logical), fxsrl (shift-right logical), fxsra (shift-right arithmetic). Logical and arithmetic shifts differ only for right shifts. Shift-right logical shifts in zero bits on the left end, and shift-right arithmetic replicates the sign bit.
Logical shifts do not make sense for arbitrary-precision integers, since these have no "left end" into which bits must be shifted.
procedure: (logand int ...)
returns: the logical "and" of the arguments int ...
libraries: (chezscheme)
The arguments must be exact integers (fixnums or bignums) and are treated as two's complement integers, regardless of the underlying representation. With no arguments, logand returns -1, i.e., all bits set.
(logand) -1
(logand 15) 15
(logand -1 -1) -1
(logand -1 0) 0
(logand 5 3) 1
(logand #x173C8D95 7) 5
(logand #x173C8D95 -8) #x173C8D90
(logand #b1100 #b1111 #b1101) #b1100
procedure: (logior int ...)
procedure: (logor int ...)
returns: the logical "or" of the arguments int ...
libraries: (chezscheme)
The arguments must be exact integers (fixnums or bignums) and are treated as two's complement integers, regardless of the underlying representation. With no arguments, logior returns 0, i.e., all bits reset.
(logior) 0
(logior 15) 15
(logior -1 -1) -1
(logior -1 0) -1
(logior 5 3) 7
(logior #b111000 #b101010) #b111010
(logior #b1000 #b0100 #b0010) #b1110
(apply logior '(1 2 4 8 16)) 31
procedure: (logxor int ...)
returns: the logical "exclusive or" of the arguments int ...
libraries: (chezscheme)
The arguments must be exact integers (fixnums or bignums) and are treated as two's complement integers, regardless of the underlying representation. With no arguments, logxor returns 0, i.e., all bits reset.
(logxor) 0
(logxor 15) 15
(logxor -1 -1) 0
(logxor -1 0) -1
(logxor 5 3) 6
(logxor #b111000 #b101010) #b010010
(logxor #b1100 #b0100 #b0110) #b1110
procedure: (lognot int)
returns: the logical "not" of int
libraries: (chezscheme)
The argument must be an exact integer (fixnum or bignum) and is treated as a two's complement integer, regardless of the underlying representation.
(lognot -1) 0
(lognot 0) -1
(lognot 7) -8
(lognot -8) 7
procedure: (logbit? index int)
returns: #t if the specified bit is set, otherwise #f
libraries: (chezscheme)
index must be a nonnegative exact integer. int must be an exact integer (fixnum or bignum) and is treated as a two's complement integer, regardless of the underlying representation.
logbit? returns #t if the bit at index index of int is set (one) and #f otherwise. The index is zero-based, counting from the lowest-order toward higher-order bits. There is no upper limit on the index; for nonnegative values of int, the bits above the highest order set bit are all considered to be zero, and for negative values, the bits above the highest order reset bit are all considered to be one.
logbit? is equivalent to
(lambda (k n) (not (zero? (logand n (ash 1 k)))))
but more efficient.
(logbit? 0 #b1110) #f
(logbit? 1 #b1110) #t
(logbit? 2 #b1110) #t
(logbit? 3 #b1110) #t
(logbit? 4 #b1110) #f
(logbit? 100 #b1110) #f
(logbit? 0 -6) #f ; the two's complement of -6 is 1...1010
(logbit? 1 -6) #t
(logbit? 2 -6) #f
(logbit? 3 -6) #t
(logbit? 100 -6) #t
(logbit? (random 1000000) 0) #f
(logbit? (random 1000000) -1) #t
(logbit? 20000 (ash 1 20000)) #t
procedure: (logtest int1 int2)
returns: #t if any common bits are set, otherwise #f
libraries: (chezscheme)
The arguments must be exact integers (fixnums or bignums) and are treated as two's complement integers, regardless of the underlying representation.
logtest returns #t if any bit set in one argument is also set in the other. It returns #f if the two arguments have no set bits in common.
logtest is equivalent to
(lambda (n1 n2) (not (zero? (logand n1 n2))))
but more efficient.
(logtest #b10001 #b1110) #f
(logtest #b10101 #b1110) #t
(logtest #b111000 #b110111) #t
(logtest #b101 -6) #f ; the two's complement of -6 is 1...1010
(logtest #b1000 -6) #t
(logtest 100 -6) #t
(logtest (+ (random 1000000) 1) 0) #f
(logtest (+ (random 1000000) 1) -1) #t
(logtest (ash #b101 20000) (ash #b111 20000)) #t
procedure: (logbit0 index int)
returns: the result of clearing bit index of int
libraries: (chezscheme)
index must be a nonnegative exact integer. int must be an exact integer (fixnum or bignum) and is treated as a two's complement integer, regardless of the underlying representation.
The index is zero-based, counting from the lowest-order toward higher-order bits. As with logbit?, there is no upper limit on the index.
logbit0 is equivalent to
(lambda (i n) (logand (lognot (ash 1 i)) n))
but more efficient.
(logbit0 3 #b10101010) #b10100010
(logbit0 4 #b10101010) #b10101010
(logbit0 0 -1) -2
procedure: (logbit1 index int)
returns: the result of setting bit index of int
libraries: (chezscheme)
index must be a nonnegative exact integer. int must be an exact integer (fixnum or bignum) and is treated as a two's complement integer, regardless of the underlying representation.
The index is zero-based, counting from the lowest-order toward higher-order bits. As with logbit?, there is no upper limit on the index.
logbit1 is equivalent to
(lambda (i n) (logor (ash 1 i) n))
but more efficient.
(logbit1 3 #b10101010) #b10101010
(logbit1 4 #b10101010) #b10111010
(logbit1 4 0) #b10000
(logbit1 0 -2) -1
procedure: (ash int count)
returns: int shifted left arithmetically by count.
libraries: (chezscheme)
Both arguments must be exact integers. The first argument is treated as a two's complement integer, regardless of the underlying representation. If count is negative, int is shifted right by -count bits.
(ash 8 0) 8
(ash 8 2) 32
(ash 8 -2) 2
(ash -1 2) -4
(ash -1 -2) -1
procedure: (fxlogand fixnum ...)
returns: the logical "and" of the arguments fixnum ...
libraries: (chezscheme)
The arguments are treated as two's complement integers, regardless of the underlying representation. With no arguments, fxlogand returns -1, i.e., all bits set.
(fxlogand) -1
(fxlogand 15) 15
(fxlogand -1 -1) -1
(fxlogand -1 0) 0
(fxlogand 5 3) 1
(fxlogand #b111000 #b101010) #b101000
(fxlogand #b1100 #b1111 #b1101) #b1100
procedure: (fxlogior fixnum ...)
procedure: (fxlogor fixnum ...)
returns: the logical "or" of the arguments fixnum ...
libraries: (chezscheme)
The arguments are treated as two's complement integers, regardless of the underlying representation. With no arguments, fxlogior returns 0, i.e., all bits reset.
(fxlogior) 0
(fxlogior 15) 15
(fxlogior -1 -1) -1
(fxlogior -1 0) -1
(fxlogior #b111000 #b101010) #b111010
(fxlogior #b1000 #b0100 #b0010) #b1110
(apply fxlogior '(1 2 4 8 16)) 31
procedure: (fxlogxor fixnum ...)
returns: the logical "exclusive or" of the arguments fixnum ...
libraries: (chezscheme)
The arguments are treated as two's complement integers, regardless of the underlying representation. With no arguments, fxlogxor returns 0, i.e., all bits reset.
(fxlogxor) 0
(fxlogxor 15) 15
(fxlogxor -1 -1) 0
(fxlogxor -1 0) -1
(fxlogxor 5 3) 6
(fxlogxor #b111000 #b101010) #b010010
(fxlogxor #b1100 #b0100 #b0110) #b1110
procedure: (fxlognot fixnum)
returns: the logical "not" of fixnum
libraries: (chezscheme)
The argument is treated as a two's complement integer, regardless of the underlying representation.
(fxlognot -1) 0
(fxlognot 0) -1
(fxlognot 1) -2
(fxlognot -2) 1
procedure: (fxlogbit? index fixnum)
returns: #t if the specified bit is set, otherwise #f
libraries: (chezscheme)
index must be a nonnegative fixnum. fixnum is treated as a two's complement integer, regardless of the underlying representation.
fxlogbit? returns #t if the bit at index index of fixnum is set (one) and #f otherwise. The index is zero-based, counting from the lowest-order toward higher-order bits. The index is limited only by the fixnum range; for nonnegative values of fixnum, the bits above the highest order set bit are all considered to be zero, and for negative values, the bits above the highest order reset bit are all considered to be one.
(fxlogbit? 0 #b1110) #f
(fxlogbit? 1 #b1110) #t
(fxlogbit? 2 #b1110) #t
(fxlogbit? 3 #b1110) #t
(fxlogbit? 4 #b1110) #f
(fxlogbit? 100 #b1110) #f
(fxlogbit? 0 -6) #f ; the two's complement of -6 is 1...1010
(fxlogbit? 1 -6) #t
(fxlogbit? 2 -6) #f
(fxlogbit? 3 -6) #t
(fxlogbit? 100 -6) #t
(fxlogbit? (random 1000000) 0) #f
(fxlogbit? (random 1000000) -1) #t
procedure: (fxlogtest fixnum1 fixnum2)
returns: #t if any common bits are set, otherwise #f
libraries: (chezscheme)
The arguments are treated as two's complement integers, regardless of the underlying representation.
fxlogtest returns #t if any bit set in one argument is also set in the other. It returns #f if the two arguments have no set bits in common.
(fxlogtest #b10001 #b1110) #f
(fxlogtest #b10101 #b1110) #t
(fxlogtest #b111000 #b110111) #t
(fxlogtest #b101 -6) #f ; the two's complement of -6 is 1...1010
(fxlogtest #b1000 -6) #t
(fxlogtest 100 -6) #t
(fxlogtest (+ (random 1000000) 1) 0) #f
(fxlogtest (+ (random 1000000) 1) -1) #t
procedure: (fxlogbit0 index fixnum)
returns: the result of clearing bit index of fixnum
libraries: (chezscheme)
fixnum is treated as a two's complement integer, regardless of the underlying representation. index must be nonnegative and less than the number of bits in a fixnum, excluding the sign bit, i.e., less than (integer-length (most-positive-fixnum)). The index is zero-based, counting from the lowest-order toward higher-order bits.
fxlogbit0 is equivalent to
(lambda (i n) (fxlogand (fxlognot (fxsll 1 i)) n))
but more efficient.
(fxlogbit0 3 #b10101010) #b10100010
(fxlogbit0 4 #b10101010) #b10101010
(fxlogbit0 0 -1) -2
procedure: (fxlogbit1 index fixnum)
returns: the result of setting bit index of fixnum
libraries: (chezscheme)
fixnum is treated as a two's complement integer, regardless of the underlying representation. index must be nonnegative and less than the number of bits in a fixnum, excluding the sign bit, i.e., less than (integer-length (most-positive-fixnum)). The index is zero-based, counting from the lowest-order toward higher-order bits.
fxlogbit1 is equivalent to
(lambda (i n) (fxlogor (fxsll 1 i) n))
but more efficient.
(fxlogbit1 3 #b10101010) #b10101010
(fxlogbit1 4 #b10101010) #b10111010
(fxlogbit1 4 0) #b10000
(fxlogbit1 0 -2) -1
procedure: (fxsll fixnum count)
returns: fixnum shifted left by count
libraries: (chezscheme)
fixnum is treated as a two's complement integer, regardless of the underlying representation. count must be nonnegative and not more than the number of bits in a fixnum, i.e., (+ (integer-length (most-positive-fixnum)) 1). An exception is raised with condition-type &implementation-restriction if the result cannot be represented as a fixnum.
(fxsll 1 2) 4
(fxsll -1 2) -4
procedure: (fxsrl fixnum count)
returns: fixnum logically shifted right by count
libraries: (chezscheme)
fixnum is treated as a two's complement integer, regardless of the underlying representation. count must be nonnegative and not more than the number of bits in a fixnum, i.e., (+ (integer-length (most-positive-fixnum)) 1).
(fxsrl 4 2) 1
(= (fxsrl -1 1) (most-positive-fixnum)) #t
procedure: (fxsra fixnum count)
returns: fixnum arithmetically shifted right by count
libraries: (chezscheme)
fixnum is treated as a two's complement integer, regardless of the underlying representation. count must be nonnegative and not more than the number of bits in a fixnum, i.e., (+ (integer-length (most-positive-fixnum)) 1).
(fxsra 64 3) 8
(fxsra -1 1) -1
(fxsra -64 3) -8
procedure: (random real)
returns: a nonnegative pseudo-random number less than real
libraries: (chezscheme)
real must be a positive integer or positive inexact real number.
(random 1) 0
(random<PHONE_NUMBER>235)<PHONE_NUMBER>001, every now and then
(random 1.0) 0.5, every now and then
thread parameter: random-seed
libraries: (chezscheme)
The random number generator allows the current random seed to be obtained and modified via the parameter random-seed.
When called without arguments, random-seed returns the current random seed. When called with one argument, which must be a nonnegative exact integer ranging from 1 through 232 - 1, random-seed sets the current random seed to the argument.
(let ([s (random-seed)])
(let ([r1 (random 1.0)])
(random-seed s)
(eqv? (random 1.0) r1))) #t
procedure: (= num1 num2 num3 ...)
procedure: (< real1 real2 real3 ...)
procedure: (> real1 real2 real3 ...)
procedure: (<= real1 real2 real3 ...)
procedure: (>= real1 real2 real3 ...)
returns: #t if the relation holds, #f otherwise
libraries: (chezscheme)
These predicates are identical to the Revised6 Report counterparts, except they are extended to accept one or more rather than two or more arguments. When passed one argument, each of these predicates returns #t.
(> 3/4) #t
(< 3/4) #t
(= 3/4) #t
procedure: (1+ num)
procedure: (add1 num)
procedure: (1- num)
procedure: (-1+ num)
procedure: (sub1 num)
returns: num plus 1 or num minus 1
libraries: (chezscheme)
1+ and add1 are equivalent to (lambda (x) (+ x 1)); 1-, -1+, and sub1 are equivalent to (lambda (x) (- x 1)).
(define plus
; x should be a nonnegative integer
(lambda (x y)
(if (zero? x)
y
(plus (1- x) (1+ y)))))
(plus 7 8) 15
(define double
; x should be a nonnegative integer
(lambda (x)
(if (zero? x)
0
(add1 (add1 (double (sub1 x)))))))
(double 7) 14
procedure: (expt-mod int1 int2 int3)
returns: int1 raised to the int2 power, modulo int3
libraries: (chezscheme)
int1, int2 and int3 must be nonnegative integers. expt-mod performs its computation in such a way that the intermediate results are never much larger than int3. This means that when int2 is large, expt-mod is more efficient than the equivalent procedure (lambda (x y z) (modulo (expt x y) z)).
(expt-mod 2 4 3) 1
(expt-mod 2 76543 76543) 2
procedure: (isqrt n)
returns: the integer square root of n
libraries: (chezscheme)
n must be a nonnegative integer. The integer square root of n is defined to be .
(isqrt 0) 0
(isqrt 16) 4
(isqrt 16.0) 4.0
(isqrt 20) 4
(isqrt 20.0) 4.0
(isqrt (* 2 (expt 10 20)))<PHONE_NUMBER>3
procedure: (integer-length n)
returns: see below
libraries: (chezscheme)
The procedure integer-length returns the length in bits of the smallest two's complement representation for n, with an assumed leading 1 (sign) bit for negative numbers. For zero, integer-length returns 0.
(integer-length 0) 0
(integer-length 1) 1
(integer-length 2) 2
(integer-length 3) 2
(integer-length 4) 3
(integer-length #b10000000) 8
(integer-length #b11111111) 8
(integer-length -1) 0
(integer-length -2) 1
(integer-length -3) 2
(integer-length -4) 2
procedure: (nonpositive? real)
returns: #t if real is not greater than zero, #f otherwise
libraries: (chezscheme)
nonpositive? is equivalent to (lambda (x) (<= x 0)).
(nonpositive? 128) #f
(nonpositive? 0.0) #t
(nonpositive? 1.8e-15) #f
(nonpositive? -2/3) #t
procedure: (nonnegative? real)
returns: #t if real is not less than zero, #f otherwise
libraries: (chezscheme)
nonnegative? is equivalent to (lambda (x) (>= x 0)).
(nonnegative? -65) #f
(nonnegative? 0) #t
(nonnegative? -0.0121) #f
(nonnegative? 15/16) #t
procedure: (conjugate num)
returns: complex conjugate of num
libraries: (chezscheme)
The procedure conjugate, when passed a complex argument a + bi, returns its complex conjugate a + (-b)i.
(conjugate 3.0+4.0i) 3.0-4.0i
(conjugate 1e-20-2e-30i) 1e-20+2e-30i
(conjugate 3) 3
procedure: (magnitude-squared num)
returns: magnitude of num squared
libraries: (chezscheme)
The procedure magnitude-squared, when passed a complex argument a + bi returns its magnitude squared, i.e., a2 + b2.
(magnitude-squared 3.0-4.0i) 25.0
(magnitude-squared 3.0) 9.0
procedure: (sinh num)
procedure: (cosh num)
procedure: (tanh num)
returns: the hyperbolic sine, cosine, or tangent of num
libraries: (chezscheme)
(sinh 0.0) 0.0
(cosh 0.0) 1.0
(tanh -0.0) -0.0
procedure: (asinh num)
procedure: (acosh num)
procedure: (atanh num)
returns: the hyperbolic arc sine, arc cosine, or arc tangent of num
libraries: (chezscheme)
(acosh 0.0) 0.0+1.5707963267948966i
(acosh 1.0) 0.0
(atanh -1.0) -inf.0
procedure: (string->number string)
procedure: (string->number string radix)
returns: the number represented by string, or #f
libraries: (chezscheme)
This procedure is identical to the Revised6 Report version except that radix may be any exact integer between 2 and 36, inclusive. The Revised6 Report version requires radix to be in the set {2,8,10,16}.
(string->number "211012" 3) 559
(string->number "tobeornottobe" 36)<PHONE_NUMBER>59812836698
procedure: (number->string num)
procedure: (number->string num radix)
procedure: (number->string num radix precision)
returns: an external representation of num as a string
libraries: (chezscheme)
This procedure is identical to the Revised6 Report version except that radix may be any exact integer between 2 and 36, inclusive. The Revised6 Report version requires radix to be in the set {2,8,10,16}.
(number->string 10000 4) "2130100"
(number->string 10000 27) "DJA"
Chez Scheme Version 9 User's Guide
Copyright © 2016 Cisco Systems, Inc.
Licensed under the Apache License Version 2.0
(full copyright notice.).
Revised June 2016 for Chez Scheme Version 9.4
about this book


HTML5
This project included 5 phases: Brand Research, Visual Design, Website Build, Marketing Strategy and Implementation, and Customer Experience.
The owners of an established agricultural business wanted to grow an additional revenue stream (private event venue). A new brand, website, marketing strategy, and operational processes were needed.
This project included 5 phases: Brand Research, Visual Design, Website Build, Marketing Strategy and Implementation, and Customer Experience.
The primary challenge in this project was solidifying stakeholder buy in to engage in digital marketing. To overcome this challenge, I proposed that I start small with digital marketing and track the results. I presented the initial results/ROI to the stakeholders, enabling them to see the value of this strategy. I then optimized the initial strategy to zero in on where we saw the most results (SEO and B2B partnerships developed via our social media presence).


The Art of Teaching an Old Dog New Tricks
Neuroplasticity:
Neuroplasticity refers to your brains ability to change and adapt through experience. Although your brains ability to grow and take on more information is much more adept at doing so when it is young and growing,
an older brain can as well. The best part about this is that studies show that the more you do this the easier it will become to continue this trend.
The easiest way to utilise this is to do.
When you learn a new skill new neurons are formed. The more you do this the more ingrained it will become. Neurons that represent things rarely used will
eventually die meaning you will have to re-learn that skill. This is we are so good at adapting to a changing environment.
Growth Mindset:
In a nutshell its as simple as "Always look on the bright side of life". Steer away from the negative.
Embrace challenges, persist in the face of setbacks, see effort as the path to success, learn from criticism, finad lessons and inspiration in the success of others. With this you will achieve greater heights.


Course Information
Available Course
Course Code
Course Title
Course Credit
Semester
Session
Offering Dept.
Accepting Dept.
CSE333
Database
3
3-1
2011
CSE
CSE


Are you sure you want to connect with
{{other_user_profile.fullname}}?
Adding
{{other_user_profile.fullname}} to your connections means giving access to your full profile.
Are you sure you want to?
To change your privacy settings click
here. [My Settings > Contact Details Privacy]
{% endblock %}


0, debugger without semicolon
1, debugger with semicolon
2, (multi-statement) debugger with statement after it
3, (multiple statements) debugger with statements before and after it
4, (multi-statement) debugger with statement in front of it
5. Use the debugger generated by Function
6. Multi-parameter debugger generated by Function
7. Prevent simple detection
8. Use eval to execute debugger
9. Use Function.prototype.constructor to execute debugger
10. Use Function.prototype.constructor to execute debugger (obfuscated)