Making Things Clear
I came across this list in Forbes and really like it a lot. It matches my experience very well and has got me thinking.
First, the list: Forbes’s 10 Reasons Successful People Change Jobs
Now for my thoughts, building off the list from Forbes.
The list closely represents my experience.
From 2009 to 2015, I doubled and then tripled my salary and gained a host of marketable skills and even some expertise by changing jobs enough to raise the eyebrows of every stability-minded person who knows and loves me. During those years, I had four full-time employers and also spent time freelancing. Grandmaternal eyebrow-raising has definitely accompanied my journey.
Here’s the thing. If you see a career as climbing a corporate ladder, you may be making a mistake. Corporations aren’t really ladders with a single path and a line of people all steadily advancing each in their turn. Really, corporations are more like pyramids with lots of workers, fewer middle managers, even fewer executives, and a single owner or board or CEO or whoever sits atop the whole thing at your company. And the point is that unless the corporation is growing rapidly, someone usually has to die, retire, or leave for a job above you for the position to open up. Taking for granting that the only way to advance your career is to climb the pyramid implies that you only go forward by growing from doing work to managing people who do work. That’s not true.
I don’t just see the corporation where I work. I see the whole labor market for my industry, my profession, and for related industries and professions. I see them all as forming a big pond with lilypads and stones and islands. I step from rock to shallow spot as useful or necessary and I always have all kinds of directions open to me. More more stability-minded friends are amazed or amused, but it doesn’t even give pause to the recruiters who track me down on a regular basis asking if I’d like to make a change. (I love my current employer, am learning tons, and have lots so of potential for career growth without shifting jobs, so I’m probably not looking to shift at the moment, but you can always ask.)
As for changing positions frequently:
-
Employers big and small lay off employees when they cannot afford to pay for or have no use for the employees’ work anymore. It makes sense for employees to change employers when we have no use for or can do better than the employer’s work.
-
Employers big and small lay off employees regularly when they think they can find someone to do the same work for less. It makes sense for workers to leave employers when we think we can get paid more to do the same work elsewhere.
-
Employers big or small eventually sack employees who are fractious and unpleasant to work with.
Incidentally, it’s a false feeling that large employers provide more stability than small ones, even if stability’s your thing. Large companies buy out, get bought out, go bankrupt, lay off workers to keep up the bottom line, and all the rest of it, all the time.
It’s a relatively simple thing: sometimes you really have learned all you are going to learn at a job. Sometimes you really can get more money for the same work, and you know because you see the job listings or because recruiters approach you and tell you. Sometimes you find yourself working three months in a toxic environment and the idea of “sticking it out” for another three or four years (so you look stable) is miserable. To me, these are all signs that it’s time to split. Split gracefully, by all means, burning no bridges if can be managed, and waiting until something better is lined up if at all possible. But still: go.
Valuing stability is fine. Stable communities are good, and stability in family life is key. I have a few friends that have been my friends for thirty or more years. But if you make stability paramount in your career, though, don’t be surprised if you stagnate in your career. Stagnation is what happens when living things become too stable.
In some professions, like teaching, in which stability really is valued and there isn’t really a career ladder or pyramid or whatever if you want to continue teaching, my experience probably doesn’t match up well with yours. But in my industry (software development) and in others that value dynamism, like defense industries, finance, marketing, creative/design work, and more, I think you probably find many experiences that corroborate mine.
Just my $0.02, for what it’s worth, though I have to admit that I’m glad Mr. Forbes agrees with me. He seems to have done OK.


30 Day Stats
GitHub Commits
—
Tweets Sent
—
Steps Taken
—
Places Visited
—
Songs Played
—
Top Album
—
Currently Reading
—


TTP Validator
You can link the result using this permalink.
You can also skip directly to the annotated result below.
{% if issues %}
{{issues|length}} Issues detected
{% for issue in issues %}
- {{ issue[0] }}
{% endfor %}
{% else %}
No issues detected
All looks well.
{% endif %}
Annotated Table Type Pattern
{{ FILE|safe }}


'It's such an exciting time for the city' - Residents react to Nottingham's huge southside redevelopment
'I think the city will be unrecognisable when it's all done'
by Ben ReidNottingham residents have said the city is going through "one of its most exciting times" as the £600m southside redevelopment progresses.
The Broadmarsh is currently undergoing a major £89m regeneration that will bring a cinema and bowling alley to the shopping centre. It is expected to be completed in summer 2021.
The redevelopment of the shopping centre is part of a wider £250 million regeneration scheme of the Broadmarsh area, which includes the demolition and rebuild of the car park and bus station.
Broadmarsh's revamp programme forms part of the £600m worth of regeneration in the southside area of the city such as at Nottingham College, Station Street and Unity Square.
The new Nottingham College City Hub represents a £58m investment in education for the city - with an expected completion date in September 2020.
Nottingham Castle is also undergoing a £30m transformation.
Residents said they expected the area to be "unrecognisable" once all the work is completed.
Jordan Woodward, 26, of St Ann's, said: "It's really one of the city's most exciting times, I reckon. Seeing all the cranes and investment is really positive. If it helps people getting jobs and brings money in then I'm all for it.
"I walk past the work most days to work and it seems to be going up rapidly. It's really cool."
Corey Flint, 28, an IT technician, of the city centre, said: "I think the city will be unrecognisable when it's all done.
"Nottingham has been crying out for investment of this scale for years. I think it will go a long way to helping the city compete. My personal favourite will be the castle. I can't wait to see what they've done with that."
Kirsty Wood, 33, of Sneinton, added: "I'm most looking forward to the Broadmarsh all done up. It needs a bit of love to bring it back.
"Shopping should be good fun, I hope there's lots of choice. I am enjoying seeing all the work go on. It's a good time to live here."
'Thousands more visitors'
Nottingham City Council Leader, David Mellen, said: “There’s a real sense of progress and excitement about the way the city’s southside is being reshaped and repurposed. With the cranes and new developments come opportunities for local people and local businesses.
"Once everything is complete the area will be almost unrecognisable from how it used to be and that transformation will help to breathe new life into this part of the city.
View gallery
“A buzzing college hub and huge new offices along with new flats will attract thousands of students and workers, while new shops, leisure outlets, bars and cafes and a fantastic modern Central Library - all surrounded by pleasant pedestrian-friendly streets - will attract more visitors, who can arrive at a new car park, new bus station or the well-connected train and tram facilities.
"And of course thousands more visitors are expected to be attracted to our revitalised Nottingham Castle experience.”
Nottingham College CEO John van de Laarschot added: “Thanks to funding from the city council and the Local Enterprise Partnership, the college is able to develop a truly iconic building that offers students top class facilities, gives them a first-rate college experience and prepares them for employment or higher level study.
"We’re on track for completion in September 2020 and, once complete, the City Hub will become a real focal point for the redevelopment of the whole Southside area.
"We’re proud to play our part in the regeneration of a significant area of our city centre, improving not only the economic prosperity of the southside zone but leaving a fantastic lasting legacy for further education in Nottingham.”


| Opcode/Instruction | Op/En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
|---|---|---|---|---|
| EAX = 07H ENCLU[EACCEPTCOPY] | IR | V/V | SGX2 | This leaf function initializes a dynamically allocated EPC page from another page in the EPC. |
| Op/En | EAX | RBX | RCX | RDX | |
| IR | EACCEPTCOPY (In) | Return Error Code (Out) | Address of a SECINFO (In) | Address of the destination EPC page (In) | Address of the source EPC page (In) |
This leaf function copies the contents of an existing EPC page into an uninitialized EPC page (created by EAUG). After initialization, the instruction may also modify the access rights associated with the destination EPC page. This instruction leaf can only be executed when inside the enclave.
RBX contains the effective address of a SECINFO structure while RCX and RDX each contain the effective address of an EPC page. The table below provides additional information on the memory parameter of the EACCEPTCOPY leaf function.
| SECINFO | EPCPAGE (Destination) | EPCPAGE (Source) |
| Read access permitted by Non Enclave | Read/Write access permitted by Enclave | Read access permitted by Enclave |
The instruction faults if any of the following:
| The operands are not properly aligned. | If security attributes of the SECINFO page make the page inaccessible. |
| The EPC page is locked by another thread. | If security attributes of the source EPC page make the page inaccessible. |
| The EPC page is not valid. | RBX does not contain an effective address in an EPC page in the running enclave. |
| SECINFO contains an invalid request. | RCX/RDX does not contain an effective address of an EPC page in the running enclave. |
The error codes are:
| Error Code (see Table 40-4) | Description |
|---|---|
| No Error | EACCEPTCOPY successful. |
| SGX_PAGE_ATTRIBUTES_MISMATCH | The attributes of the target EPC page do not match the expected values. |
| Leaf | Parameter | Base Concurrency Restrictions | ||
|---|---|---|---|---|
| Access | On Conflict | SGX_CONFLICT VM Exit Qualification | ||
| EACCEPTCOPY | Target [DS:RCX] | Concurrent | ||
| Source [DS:RDX] | Concurrent | |||
| SECINFO [DS:RBX] | Concurrent |
| Leaf | Parameter | Additional Concurrency Restrictions | |||||
|---|---|---|---|---|---|---|---|
| vs. EACCEPT, EACCEPTCOPY, EMODPE, EMODPR, EMODT | vs. EADD, EEXTEND, EINIT | vs. ETRACK, ETRACKC | |||||
| Access | On Conflict | Access | On Conflict | Access | On Conflict | ||
| EACCEPTCOPY | Target [DS:RCX] | Exclusive | #GP | Concurrent | Concurrent | ||
| Source [DS:RDX] | Concurrent | Concurrent | Concurrent | ||||
| SECINFO [DS:RBX] | Concurrent | Concurrent | Concurrent |
| Name | Type | Size (bits) | Description |
|---|---|---|---|
| SCRATCH_SECINFO | SECINFO | 512 | Scratch storage for holding the contents of DS:RBX. |
IF (DS:RBX is not 64Byte Aligned)
THEN #GP(0); FI;
IF ( (DS:RCX is not 4KByte Aligned) or (DS:RDX is not 4KByte Aligned) )
THEN #GP(0); FI;
IF ((DS:RBX is not within CR_ELRANGE) or (DS:RCX is not within CR_ELRANGE) or (DS:RDX is not within CR_ELRANGE))
THEN #GP(0); FI;
IF (DS:RBX does not resolve within an EPC)
THEN #PF(DS:RBX); FI;
IF (DS:RCX does not resolve within an EPC)
THEN #PF(DS:RCX); FI;
IF (DS:RDX does not resolve within an EPC)
THEN #PF(DS:RDX); FI;
IF ( (EPCM(DS:RBX &~FFFH).VALID = 0) or (EPCM(DS:RBX &~FFFH).R = 0) or (EPCM(DS:RBX &~FFFH).PENDING ≠ 0) or
(EPCM(DS:RBX &~FFFH).MODIFIED ≠ 0) or (EPCM(DS:RBX &~FFFH).BLOCKED ≠ 0) or (EPCM(DS:RBX &~FFFH).PT ≠ PT_REG) or
(EPCM(DS:RBX &~FFFH).ENCLAVESECS ≠ CR_ACTIVE_SECS) or
(EPCM(DS:RBX &~FFFH).ENCLAVEADDRESS ≠ DS:RBX) )
THEN #PF(DS:RBX); FI;
(* Copy 64 bytes of contents *)
SCRATCH_SECINFO ← DS:RBX;
(* Check for misconfigured SECINFO flags*)
IF ( (SCRATCH_SECINFO reserved fields are not zero ) or (SCRATCH_SECINFO.FLAGS.R=0) AND(SCRATCH_SECINFO.FLAGS.W≠0 ) or
(SCRATCH_SECINFO.FLAGS.PT is not PT_REG) )
THEN #GP(0); FI;
(* Check security attributes of the source EPC page *)
IF ( (EPCM(DS:RDX).VALID = 0) or (EPCM(DS:RCX).R = 0) or (EPCM(DS:RDX).PENDING ≠ 0) or (EPCM(DS:RDX).MODIFIED ≠ 0) or
(EPCM(DS:RDX).BLOCKED ≠ 0) or (EPCM(DS:RDX).PT ≠ PT_REG) or (EPCM(DS:RDX).ENCLAVESECS ≠ CR_ACTIVE_SECS) or
(EPCM(DS:RDX).ENCLAVEADDRESS ≠ DS:RDX))
THEN #PF(DS:RDX); FI;
(* Check security attributes of the destination EPC page *)
IF ( (EPCM(DS:RCX).VALID = 0) or (EPCM(DS:RCX).PENDING ≠ 1) or (EPCM(DS:RCX).MODIFIED ≠ 0) or
(EPCM(DS:RDX).BLOCKED ≠ 0) or (EPCM(DS:RCX).PT ≠ PT_REG) or (EPCM(DS:RCX).ENCLAVESECS ≠ CR_ACTIVE_SECS) )
THEN
RFLAGS.ZF ← 1;
RAX ← SGX_PAGE_ATTRIBUTES_MISMATCH;
GOTO DONE;
FI;
(* Check the destination EPC page for concurrency *)
IF (destination EPC page in use )
THEN #GP(0); FI;
(* Re-Check security attributes of the destination EPC page *)
IF ( (EPCM(DS:RCX).VALID = 0) or (EPCM(DS:RCX).PENDING ≠ 1) or (EPCM(DS:RCX).MODIFIED ≠ 0) or
(EPCM(DS:RCX).R ≠ 1) or (EPCM(DS:RCX).W ≠ 1) or (EPCM(DS:RCX).X ≠ 0) or
(EPCM(DS:RCX).PT ≠ SCRATCH_SECINFO.FLAGS.PT) or (EPCM(DS:RCX).ENCLAVESECS ≠ CR_ACTIVE_SECS) or
(EPCM(DS:RCX).ENCLAVEADDRESS ≠ DS:RCX))
THEN
RFLAGS.ZF ← 1;
RAX ← SGX_PAGE_ATTRIBUTES_MISMATCH;
GOTO DONE;
FI;
(* Copy 4KBbytes form the source to destination EPC page*)
DS:RCX[32767:0] ← DS:RDX[32767:0];
(* Update EPCM permissions *)
EPCM(DS:RCX).R ← SCRATCH_SECINFO.FLAGS.R;
EPCM(DS:RCX).W ← SCRATCH_SECINFO.FLAGS.W;
EPCM(DS:RCX).X ← SCRATCH_SECINFO.FLAGS.X;
EPCM(DS:RCX).PENDING ← 0;
RFLAGS.ZF ← 0;
RAX←0;
DONE:
RFLAGS.CF,PF,AF,OF,SF ← 0;
Sets ZF if page is not modifiable, otherwise cleared. Clears CF, PF, AF, OF, SF
| #GP(0) | If executed outside an enclave. |
| If a memory operand effective address is outside the DS segment limit. | |
| If a memory operand is not properly aligned. | |
| If a memory operand is locked. | |
| #PF(error | code) If a page fault occurs in accessing memory operands. |
| If a memory operand is not an EPC page. | |
| If EPC page has incorrect page type or security attributes. |
| #GP(0) | If executed outside an enclave. |
| If a memory operand is non-canonical form. | |
| If a memory operand is not properly aligned. | |
| If a memory operand is locked. | |
| #PF(error | code) If a page fault occurs in accessing memory operands. |
| If a memory operand is not an EPC page. | |
| If EPC page has incorrect page type or security attributes. |


About Us
We've got everything you need to get away from an ordinary day. We were established in 2017 and have been working towards making more happy customers.
Contact us on +1<PHONE_NUMBER> or email us at<EMAIL_ADDRESS>got everything you need to get away from an ordinary day. We were established in 2017 and have been working towards making more happy customers.
Contact us on +1<PHONE_NUMBER> or email us at queries.cafeteria@cafe.ca


How to Use this Book
One of the beauties of Unix is that you can be very productive with
surprisingly little knowledge. Even better, each new trick you learn
can shave minutes off of your day. We've arranged
the chapters in this book by subject area, not by any suggested order
of learning. Skip around to what interests you most or solves your
current problem. If the current hack depends on information in
another hack, we'll include a link for you to
follow.
Furthermore, the "See Also"
sections at the end of individual hacks often include references such
as man fortune. These refer to the manual pages
installed on your machine. If you're not familiar
with these
manpages, start
with [Hack #89] .
|


Column resizable property lets users to manually resize specific columns as they need.
To enable resizable option, simply set resizable
to true in the specific columns and by default resizable is
false.
{{demoSnippet.resizable}}
According to the above example resizable is enabled for all columns.


what is your name
Submit
RULE
input lowercase letters OR Korean OR Number
Don't let the people around you know the answer
Remember the Portfolio


| Tutorial: | Author: | Original Location: | Class: |
| Getting Started with the Half-Life SDK | Drywall | The Wavelength | Half-Life/Coding |
| Triple-Bolt Crossbow | Drywall | The Wavelength | Half-Life/Coding |
| Silenced Glock | Chris Whitman | The Wavelength | Half-Life/Coding |
| Exploding Rounds for the Python | Chris Whitman | The Wavelength | Half-Life/Coding |
| Radio Voices | Decker | The Wavelength | Half-Life/Coding |
| RPG Power | Voidmaster | The Wavelength | Half-Life/Coding |
| Hand Cannon | Phlash[ep] | The Wavelength | Half-Life/Coding |
| Basic Half-Life Weapon Coding | PsychoDude | The Wavelength | Half-Life/Coding |
| Door Fix | Tim Smith | The Wavelength | Half-Life/Coding |
| Cluster Grenades | RR2DO2 | The Wavelength | Half-Life/Coding |
| Snark-Dropping Crossbow | Grunt | The Wavelength | Half-Life/Coding |
| Holster Animation | Trond | The Wavelength | Half-Life/Coding |
| Power Shotgun | Dr Octagon | The Wavelength | Half-Life/Coding |
| Coding New Entities for Half-Life | PsychoDude | The Wavelength | Half-Life/Coding |
| C++ Review | Erik Corradino | The Wavelength | Half-Life/Coding |
| Menus in Half-Life | Tim Smith | The Wavelength | Half-Life/Coding |
| Startup Edits | Dr Schwa | The Wavelength | Half-Life/Coding |
| Printing Stuff | Pink | The Wavelength | Half-Life/Coding |
| Half-Life Observer Mode Tutorial | Blake Grant | The Wavelength | Half-Life/Coding |
| Weapons in the HUD Tutorial | Blake Grant | The Wavelength | Half-Life/Coding |
| Class System Tutorial | Blake Grant | The Wavelength | Half-Life/Coding |
| How to Compile the Half-Life Standard SDK on the Linux Platform | Leon Hartwig | The Wavelength | Half-Life/Coding |
| Changing Damage Amounts Outside the DLL | BigGuy | The Wavelength | Half-Life/Coding |
| Changing Blood and HUD Colors | BigGuy | The Wavelength | Half-Life/Coding |
| Screen Fading and Shaking | BigGuy | The Wavelength | Half-Life/Coding |
| Counterstrike Gameplay, Part 1 | Gooseman and Pink | The Wavelength | Half-Life/Coding |
| Basic Weapon Reference Code | BigGuy | The Wavelength | Half-Life/Coding |
| StealthSuit | BigGuy | The Wavelength | Half-Life/Coding |
| TFC Status Bar Functionality | Robin Walker | The Wavelength | Half-Life/Coding |
| New Menuing System Tutorial | Phillip Peterson | The Wavelength | Half-Life/Coding |
| Red screen after Death and Damage | Nightmare | The Wavelength | Half-Life/Coding |
| HUD Graphics for Half-Life | 2 | The Wavelength | Half-Life/Coding |
| Quick Guide to Debugging | Drywall | The Wavelength | Half-Life/Coding |
| Installing the SDK | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Introduction to Half-Life SDK2 | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Introduction to the Sourcecode | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Using the Microsoft Visual C++ 6 IDE | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Quick Hints and Tips | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| SDK2 Basics: Looking at a simple entity class | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| SDK2 Basics: How to send messages between the client and game DLLs | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| SDK2 Basics: String Handling in the SDK | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| SDK2 Basics: Creating a new Entity class, and adding it to a level | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| SDK2 Basics: Adding a new monster with default AI | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| SDK2 Basics: Explanation of the Weapon code (MP5) by Greg Hudson | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Half-Life Graphics Part 1: 2D Sprites | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Half-Life Graphics Part 2: Effects API | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Half-Life Graphics Part 3: Triangle API | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Advanced: Building an in-game menu entity | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Advanced: How to create a radar for Half-Life | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Advanced: Understanding the Monster AI | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Advanced: Understanding the Monster AI (part 2) | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Playing .mp3 files in Half-Life | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Coding |
| Mad Scientist Entity | Kate | The Half-Life Coding Pages | Half-Life/Coding |
| Precaching | The Half-Life Coding Pages | Half-Life/Coding | |
| Activities and Sequences | The Half-Life Coding Pages | Half-Life/Coding | |
| Entity Variables | The Half-Life Coding Pages | Half-Life/Coding | |
| Engine Functions | The Half-Life Coding Pages | Half-Life/Coding | |
| Good Half-Life Net Play | Adam | The Half-Life Coding Pages | Half-Life/Coding |
| Teleport Command | doketid | Half-Life Programming | Half-Life/Coding |
| How to Make a Desert-Eagle (SDK2.2) | Meastro | Half-Life Programming | Half-Life/Coding |
| Make a player fly | Sneezy | Half-Life Programming | Half-Life/Coding |
| Team Coloured Text and Spectator Chat ( Fix ) | WhiteDragon | Half-Life Programming | Half-Life/Coding |
| The unofficial Half-Life MOD FAQ | botman | botman's Bots | Half-Life/General |
| Milkshape: Creating a new model in Milkshape and adding it to Half-Life | Shadowman | Shadowman's HLSDK2 Resources | Half-Life/Modelling |
| GLUT / OpenGL1 Intro | Shadowman | Shadowman's HLSDK2 Resources | OpenGL/GLUT Coding |
| Windows XP RemoteApp Terminal Server | vs49688 | Windows XP |


{% include head.html %}
Fruity Foodie
{% include nav.html %} {{ content }} {% include footer.html %}


|
FIND US ON
|
INSTALLMENTS BY
|
|
|
|
|
|
|
You received this message because you've registered or accepted our invitation to receive emails from SHEIN, or you've made a purchase from SHEIN.com.
|
|
If you wish to no longer receive our fashion news and offers, simply CLICK HERE TO UNSUBSCRIBE.
|
|
Please contact our customer service if you have any questions.
|
|
112 Robinson Road #03-01 Robinson 112 Singapore
|
|
|


The following forecast is applicable to all twelve astrological signs, and also to three or four of the far more reliable signs in the Blodgett Zodiac.
“You are followed by an obbligato of hoots and grimaces from a derisive posse of ragamuffins.”
This prediction first appeared in Wanderings Of A Globe-Trotter In The Far East by Lewis Wingfield, published in 1889. One hundred and twenty years later, it shall come to pass.


Welcome to the ngBoltJS Demo App
What you see here is an example of the full-screen-bg that you can use to show temporary loading screens.
full-screen-bg


Performance histogram for FWD=fwd1 Link to Run Definitions: format_for_rd1 For loops: None rd1 For loops: None 23:03:18.003 Starting RD=format_for_rd1 23:10:37.000 Starting RD=rd1; elapsed=10; fwdrate=max. For loops: None


--- layout: exhibit_common --- {% include "./partials/coverpage.html" %} {% include "./partials/about_section.html" %} {%- for images in exhibitimages.slice(1) -%} {{images.pritxt}} {%- endfor -%} {{pritxt}} {% include "./partials/author_section.html" %}
{{images.pritxt}}
{{pritxt}}


[t]Your reaction has been added to the article![/t]
[t]Your reaction has been added to the article and will be displayed right after moderator's approval.[/t]
[t]Now you are going to be redirected back to the article in few seconds...[/t]


GMIT Fee Portal
NAME
USN
BRANCH
SEMESTER
AMOUNT
Select the Fees for which you want to make the payment:
Breakage Fees and Others
Tution/College Fees
Hostel Fees
Exam Fees
Select the Payment Mode:
Credit or Debit Card
Net Banking
Pay Fees


:: com :: sun :: star :: rendering ::
|
| unpublished |
interface XBitmapPalette |
|
|
|
- Usage Restrictions
- not published
- Description
- Interface to access the palette of a color-indexed bitmap.
- Since
- OOo 2.0
|
| Methods' Summary |
| getNumberOfEntries |
Request the number of palette entries available.
|
| getIndex |
Request the color for the given palette entry.
|
| setIndex |
Set the color for the given palette entry.
|
| getColorSpace |
Query associated color space. |
| Methods' Details |
getNumberOfEntries
| long |
| getNumberOfEntries(); |
- Description
- Request the number of palette entries available.
- Returns
- the number of entries in this palette.
|
|
getIndex
- Description
- Request the color for the given palette entry.
- Parameter entry
- Output parameter for the color components at the given palette
entry.
- Parameter nIndex
- The index of the palette entry to be retrieved. Valid range is
[0,getNumberOfEntries()-1].
- Returns
- true, if the given palette entry should be displayed
opaque, and false if the entry should be displayed
transparent. This is sometimes used for so-called mask
transparency, by flagging certain palette entries to be fully
transparent when displaying the bitmap.
- Throws
- com::sun::star::lang::IndexOutOfBoundsException
if the index is smaller than zero or larger than
XBitmapPalette::getNumberOfEntries()-1.
|
|
setIndex
- Description
- Set the color for the given palette entry.
- Parameter color
- Sequence of device color values in the associated bitmap's
device color format.
- Parameter transparency
- When true, the specified palette entry is displayed as
opaque color. When false, the given entry displays as fully
transparent during output.
- Parameter nIndex
- The index of the palette entry to be changed. Valid range is
[0,getNumberOfEntries()-1].
- Returns
- whether the palette entry was changed. For read-only
entries, this method always returns false.
- Throws
- com::sun::star::lang::IndexOutOfBoundsException
if the index is smaller than zero or larger than
XBitmapPalette::getNumberOfEntries()-1.
- Throws
- com::sun::star::lang::IllegalArgumentException
if the given sequence of color components does not match the
associated bitmap's device color format.
|
|
getColorSpace
- Description
- Query associated color space.
- Returns
- the color space that is associated with this palette.
|
|
Top of Page
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


8,10
2,8
One additional question: The difference between <=> and = is subtle. Read this Stack Exchange post about the difference (and possibly some pages that are linked from it), and write a short paragraph summarizing your take on the difference.


In order to streamline and automate the creation and use of models that can for describing plots and scenes, Bokeh provides a collection of properties and property mixins. Property classes provide automatic validation and serialization for a large collection of useful types. Mixin classes provide for easy bulk addition of properties to model classes.
Below is the full class inheritance diagram for all standard Bokeh property types. Click on any node to be taken to the corresponding documention.
Properties are objects that can be assigned as class level attributes on Bokeh models, to provide automatic serialization and validation.
For example, the following defines a model that has integer, string, and list[float] properties:
class Model(HasProps):
foo = Int
bar = String
baz = List(Float)
The properties of this class can be initialized by specifying keyword arguments to the initializer:
m = Model(foo=10, bar="a str", baz=[1,2,3,4])
But also by setting the attributes on an instance:
m.foo = 20
Attempts to set a property to a value of the wrong type will result in a ValueError exception:
>>> m.foo = 2.3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Users/bryan/work/bokeh/bokeh/properties.py", line 585, in __setattr__
super(HasProps, self).__setattr__(name, value)
File "/Users/bryan/work/bokeh/bokeh/properties.py", line 159, in __set__
raise e
File "/Users/bryan/work/bokeh/bokeh/properties.py", line 152, in __set__
self.validate(value)
File "/Users/bryan/work/bokeh/bokeh/properties.py", line 707, in validate
(nice_join([ cls.__name__ for cls in self._underlying_type ]), value, type(value).__name__))
ValueError: expected a value of type int8, int16, int32, int64 or int, got 2.3 of type float
Additionally, properties know how to serialize themselves, to be understood by BokehJS.
Angle type property.
Any type property accepts any values.
NumPy array type property.
Boolean type property.
Byte type property.
Accepts color definition in a variety of ways, and produces an appropriate serialization of its value for whatever backend.
For colors, because we support named colors and hex values prefaced with a “#”, when we are handed a string value, there is a little interpretation: if the value is one of the 147 SVG named colors or it starts with a “#”, then it is interpreted as a value.
If a 3-tuple is provided, then it is treated as an RGB (0..255). If a 4-tuple is provided, then it is treated as an RGBa (0..255), with alpha as a float between 0 and 1. (This follows the HTML5 Canvas API.)
Subclass of DataSpec for specifying colors.
Although this serves the same role as a DataSpec, its usage is somewhat different because:
For colors, because we support named colors and hex values prefaced with a “#”, when we are handed a string value, there is a little interpretation: if the value is one of the 147 SVG named colors or it starts with a “#”, then it is interpreted as a value. Otherwise, it is treated as a field name.
If a 3-tuple is provided, then it is treated as an RGB (0..255). If a 4-tuple is provided, then it is treated as an RGBa (0..255), with alpha as a float between 0 and 1. (This follows the HTML5 Canvas API.)
Unlike DataSpec, ColorSpecs do not have a “units” property.
When reading out a ColorSpec, it returns a tuple, hex value, or field name
There are two common use cases for ColorSpec: setting a constant value, and indicating a field name to look for on the datasource:
>>> class Bar(HasProps):
... col = ColorSpec(default="green")
... col2 = ColorSpec("colorfield")
>>> b = Bar()
>>> b.col = "red" # sets a fixed value of red
>>> b.col
"red"
>>> b.col = "myfield" # Use the datasource field named "myfield"
>>> b.col
"myfield"
For more examples, see tests/test_glyphs.py
Returns True if the argument is a literal color. Check for a well-formed hexadecimal color value.
Complex floating point type property.
Base class for Container-like type properties.
Dash type property.
Express patterns that describe line dashes. DashPattern values can be specified in a variety of ways:
To indicate that dashing is turned off (solid lines), specify the empty list [].
Because the BokehJS glyphs support a fixed value or a named field for most data fields, we capture that in this descriptor. Fields can have a fixed value, or be a name that is looked up on the datasource (usually as a column or record array field). Numerical data can also have units of screen or data space.
We mirror the JS convention in this Python descriptor. For details, see renderers/properties.coffee in BokehJS, and specifically the select() function.
There are multiple ways to set a DataSpec, illustrated below with comments and example code.
Setting DataSpecs
Simple example:
class Foo(HasProps):
x = DataSpec("x", units="data")
f = Foo()
f.x = "fieldname" # Use the datasource field named "fieldname"
f.x = 12 # A fixed value of 12
Can provide a dict with the fields explicitly named:
f.width = {"name": "foo"}
f.size = {"name": "foo", "units": "screen"}
Reading DataSpecs
In the cases when the dataspec is set to just a field name or a fixed value, then those are returned. If the no values have been set, then the value of to_dict() is returned.
In all cases, to determine the full dict that will be used to represent this dataspec, use the to_dict() method.
Implementation
The DataSpec instance is stored in the class dict, and acts as a descriptor. Thus, it is shared between all instances of the class. Instance-specific data is stored in the instance dict, in a private variable named _[attrname]. This stores the actual value that the user last set (and does not exist if the user has not yet set the value).
Date (not datetime) type property.
Datetime type property.
Python dict type property.
If a default value is passed in, then a shallow copy of it will be used for each new use of this property.
Takes a list of valid properties and validates against them in succession.
An Enum with a list of allowed values. The first value in the list is the default value, unless a default is provided with the “default” keyword argument.
Event type property.
Floating point type property.
Function type property.
Include other properties from mixin Models, with a given prefix.
Instance type property, for references to other Models in the object graph.
Signed integer type property.
Range type property ensures values are contained inside a given interval.
Python list type property.
Base class for Properties that have type parameters, e.g. List(String).
Percentage type property.
Percents are useful for specifying alphas and coverage and extents; more semantically meaningful than Float(0..1).
A base class for simple property types. Subclasses should define a class attribute _underlying_type that is a tuple of acceptable type values for the property.
Base class for all type properties.
Called by the metaclass to create a new instance of this descriptor if the user just assigned it to a property without trailing parentheses.
Regex type property validates that text values match the given regular expression.
RelativeDelta type property for time deltas.
Sequence (list, tuple) type property.
Size type property.
Note
Size is equivalent to an unsigned int.
String type property.
A reference to an instance of the class being defined.
Tuple type property.
Properties to use when performing fill operations while rendering.
Mirrors the BokehJS properties.Fill class.
property type: DataSpec
An alpha value to use to fill paths with.
Acceptable values are floating point numbers between 0 (transparent) and 1 (opaque).
property type: ColorSpec
A color to use to fill paths with.
Acceptable values are:
Properties to use when performing stroke operations while rendering.
Mirrors the BokehJS properties.Line class.
property type: DataSpec
An alpha value to use to stroke paths with.
Acceptable values are floating point numbers between 0 (transparent) and 1 (opaque).
property type: Enum(‘butt’, ‘round’, ‘square’)
How path segments should be terminated.
Acceptable values are:
property type: ColorSpec
A color to use to stroke paths with.
Acceptable values are:
property type: DashPattern
How should the line be dashed.
property type: Int
The distance into the line_dash (in pixels) that the pattern should start from.
Properties to use when performing text drawing operations while rendering.
Mirrors the BokehJS properties.Text class.
Note
There is currently only support for filling text. An interface to stroke the outlines of text has not yet been exposed.
property type: Enum(‘left’, ‘right’, ‘center’)
Horizontal anchor point to use when rendering text.
Acceptable values are:
property type: DataSpec
An alpha value to use to fill text with.
Acceptable values are floating point numbers between 0 (transparent) and 1 (opaque).
property type: Enum(‘top’, ‘middle’, ‘bottom’, ‘alphabetic’, ‘hanging’)
Vertical anchor point to use when rendering text.
Acceptable values are:
property type: ColorSpec
A color to use to fill text with.
Acceptable values are:


Hello, I am a software engineer based in Minneapolis, Minnesota. I specialize in front-end development and growth hacking.
I love building beautiful products with amazing UX. Please use the contact form to reach me. I am currently available to hire.
With this project I built a Kickstarter clone from scratch using Python and Flask.
One-page portfolio and email signup page. See the example here.
Use this area of the page to describe your project. The icon above is part of a free icon set by Flat Icons. On their website, you can download their free set with 16 icons, or you can purchase the entire set with 146 icons for only $12!


View SVG:
Properties:
Width: -
Height: -
Number of Paths: -
Selected Path Length: -
Tools:
Custom:
Set Dimensions:
Options:
Pick Custom Points:
Custom Input:
Output:
Cubic Parametric Equation:
X = a*t^3 + b*t^2 + c*t + d
Y = p*t^3 + q*t^2 + r*t + s
Width: -
Height: -
Number of Paths: -
Selected Path Length: -
Set Dimensions:
X = a*t^3 + b*t^2 + c*t + d
Y = p*t^3 + q*t^2 + r*t + s


| About an orphaned child whose dreams - and nightmares - manifest physically as he sleeps. | |
| Genres: | Drama, Fantasy, Horror, Thriller |
| Director: | Mike Flanagan |
| Writer: | Mike Flanagan, Jeff Howard |
Cast: | Mark - Thomas Jane Cody - Jacob Tremblay Jessie - Kate Bosworth Teacher - Scottie Thompson Natalie - Annabeth Gish Whelan - Dash Mihok Peter - Jay Karnes Annie - Kyla Deaver Detective - Lance E. Nichols Tate - Hunter Wenzel Hospital Guest - Ginger McNamara Andrea - Courtney Bell Vice Principal - Jason Alan Smith Home Director - Avis-Marie Barnes Doctor Tennant - Justin Gordon Police Officer - Brett Luciana Murray Physcian in Mental Ward Dayroom - Jack Teague Nurse - Erika Hoveland Katie - Natalie Roers Sean - Antonio Evan Romero Therapy patient - Thad August Young Cody - Rigby Flanagan-Bell Mental Patient - Angel Ellis |


| package iar.tools.configuro |
|
Command-line configuration tool for IAR Embedded Workbench
This command-line tool computes the appropriate configuro options from the
set of options passed from the IAR Workbench (for ex. target/platform
from compile options). With these options, the xdc.tools.configuro tool
is executed to compute the set of libraries, command-line flags and
the other artifacts needed to build the application in IAR Workbench.
[
more ... ]
package iar.tools.configuro [1, 0, 0] {
// Command implementation
}
USAGE
xs iar.tools.configuro [--help]
[-o outdir (optional)]
[-c codegen_dir]
[--cc compiler_name_string]
[--device device_name]
[--cfgArgs args_string]
[--compileOptions compile_options_string]
[--linkOptions linker_options_string]
[--profile profile]
[--projFile project_file (optional)]
infile.cfg (optional)
OPTIONS
- -o
- Pathname of the output directory
A directory containing the generated build artifacts, in particular
the compiler.defs and linker.cmd files.
The last component of the output directory path must be a valid
ANSI C identifier; i.e., it must consist entirely of alphanumeric or
'_' characters and must not start with a number. So, the names
'0app' and 'app-test' are not valid but '0app/config' and
'app-test/config' are valid.
This is optional parameter. By default, the output directory has the
name configPkg and will be within the {#cfgDir} directory.
- -c
- Root directory of the code generation tools
The path to the installation directory of the compiler and linker
for the selected target. The definition of "installation directory"
can vary from compiler to compiler, but is most commonly the
directory that contains a "bin" subdirectory.
- --device
- The name of the device
The device name has to be passed to the xdc.tools.configuro tool.
- --compileOptions
- Compile options used for building C files
The compiler options are required to find the target and platform
options for xdc.tools.configuro.
- --linkOptions
- Linker options used for linking libraries
The linker options are required to pull in the correct libraries
during link.
- --profile
- Build profile
- --cfgArgs
- Optional arguments passed to configuration script
This option lets the user pass values into the configuration script
from the command line. The argument is an expression in JavaScript
syntax. Its value is available in the configuration script under the
name Program.build.cfgArgs.
The JavaScript expression is evaluated in the configuration domain
after the platform package is imported, immediately before calling
the user's configuration script.
This string has the same effect as the cfgArgs string in
xdc.bld.Executable.Attrs.
You can pass multiple values to configuration scripts using the
syntax of a JavaScript Object constant:
xs xdc.tools.configuro --cfgArgs '{foo:"hello", bar:2}' ... app.cfg
The configuration script can read the various fields as, e.g.:
if (Program.build.cfgArgs.foo == "hello") {
:
}
- --projFile
- IAR Embedded project file
This file is searched for the RTSC configuration file (.cfg).
DETAILS
This command-line tool computes the appropriate configuro options from the
set of options passed from the IAR Workbench (for ex. target/platform
from compile options). With these options, the xdc.tools.configuro tool
is executed to compute the set of libraries, command-line flags and
the other artifacts needed to build the application in IAR Workbench.
INPUTS
- -o outdir (Optional)
-
Optionally an output directory can be provided.
- -c codegen_dir
-
Root directory of the code generation tools.
- --device device_name_string
-
The name of the device.
- --compileOptions compile_options_string
-
The command line options passed to the compiler.
- --linkOptions linker_options_string
-
The command line options passed to the linker.
- --profile profile
-
The build profile.
- --projFile project_file (Optional)
-
IAR Embedded Workbench project file. This is optional when
infile.cfg is passed on command line.
- infile.cfg (Optional)
-
A user-supplied configuration script that names a set of RTSC
modules, and optionally changes their configuration settings.
If provided, it will override the --projFile option.
OUTPUTS
- outdir/
-
A directory containing all generated build artifacts.
- outdir/compiler.defs
-
A file containing C compiler command-line flags. These flags must
included on the compiler command line for any C source file that
directly accesses the RTSC content. The flags define the header file
and include paths to ensure object code compatibility between all
all included content.
- outdir/linker.cmd
-
A file containing linker command-line flags. These flags must be
included on the linker command line for the final link of the
application. The flags list needed libraries and object files,
and on some platforms define the embedded system memory map.
For example:
xs iar.tools.configuro -c "<codegen_dir>" --cc "<compiler>"
--device "<device_name>" --cfgArgs "<cfg_script_args>"
--compileOptions "<compiler_options>" --linkOptions "<link_options>"
--profile "<profile>" infile.cfg
generated on Wed, 28 Aug 2019 17:00:46 GMT


class Values
constructor: (@engine) ->
@_observers = {}
@_watchers = {}
indexOf: (array, a, b, c) ->
if array
for op, index in array by 3
if op == a && array[index + 1] == b && array[index + 2] == c
return index
return -1
watch: (id, property, operation, continuation, scope) ->
path = @engine.getPath(id, property)
if @indexOf(@_watchers[path], operation, continuation, scope) == -1
observers = @_observers[continuation] ||= []
observers.push(operation, path, scope)
watchers = @_watchers[path] ||= []
watchers.push(operation, continuation, scope)
return @get(path)
unwatch: (id, property, operation, continuation, scope) ->
path = @engine.getPath(id, property)
observers = @_observers[continuation]
index = @indexOf observers, operation, path, scope
observers.splice index, 3
delete @_observers[continuation] unless observers.length
watchers = @_watchers[path]
index = @indexOf watchers, operation, continuation, scope
watchers.splice index, 3
delete @_watchers[path] unless watchers.length
clean: (continuation) ->
for path in @engine.getPossibleContinuations(continuation)
if observers = @_observers[path]
while observers[0]
@unwatch(observers[1], undefined, observers[0], path, observers[2])
@
pull: (object) ->
@merge(object)
get: (id, property) ->
return @[@engine.getPath(id, property)]
set: (id, property, value, buffered, meta) ->
if arguments.length == 2
value = property
property = undefined
path = @engine.getPath(id, property)
old = @[path]
return if old == value
if value?
@[path] = value
else
delete @[path]
if @engine.onChange
@engine.onChange path, value, old
if watchers = @_watchers?[path]
for watcher, index in watchers by 3
break unless watcher
unless capture?
capture = @engine.expressions.capture(path) || false
@engine.expressions.evaluate watcher.parent, watchers[index + 1], watchers[index + 2], meta, watcher.index, value
@engine.expressions.release() if capture && !buffered
return value
suggest: (id, property, value) ->
if arguments.length == 2
value = property
property = undefined
(@engine.measured ||= {})[@engine.getPath(id, property)] = value
if capture = @engine.expressions.capture('suggest ' + (id || '') + '[' + (property || '') + '] ' + value)
@engine.flush()
return value
merge: (object) ->
capturing = @engine.expressions.buffer == undefined
for path, value of object
@set path, undefined, value, capturing
if capturing && @engine.expressions.buffer != undefined
@engine.expressions.release()
@


Python 101
Instructed by Gary Tong
1 Fake St
Friday May 19th , 2017
2PM - 4PM
50 Points!
Intro To Java
Instructed by Gary Tong
22 Real St
Friday May 26th , 2017
4PM - 8PM
30 Points!
#CREATE4COMMUNITY
Held at The Delta Hotel
75 Lower Simcoe St
Thursday May 18th , 2017
4PM - 8PM
400 Points!


That was a fun Seattle adventure! Now it's time to go to bed. Goodnight Bear! Goodnight Otter! Goodnight Platypus!


Nishan Mudalige
Home
Education
Awards
Coding Skills
>
Coding Skills
Home
Coding Skills
Statistics Software
R
SAS
SPSS
Stata
Mathematics Software
Matlab
Maple
Mathematica
General Purpose
C++
Java
Python
Relational Databases
Microsoft SQL Server
MySQL
Markup Languages
HTML
LaTeX
Markdown
Style Sheet Languages
CSS
Scripting Languages
Bash
macOS Terminal
JavaScript


Water My Plants
Sign Up- Ensuring that all your plants are consistently watered is actually pretty difficult.
- Water My Plants is an app that helps to solve those problems.
- With an easy to use interface for creating a plant watering schedule tailored to each individual plant, WaterMyPlants will remind users when it's time to feed that foliage and quench your plants' thirst.


Basic dialog with all default jQuery UI behavior. The dialog window can be moved, resized and closed via Escape key. (Note there is no close icon by default.)
Standard jQuery UI markup can be used to add icons. Buttons are specified in markup.
Standard jQuery UI markup can be used to add icons. Buttons are specified in markup.
If you have a lot of dialogs with the same button text, you could specify default text values + other dialog defaults on the body tag.
Show close icon (the 'x' at top-right; default is don't show). Custom button events. Custom width.
Use delayed loading for dialogs that are not expected to be used very often or for dialogs whose markup has to be loaded via AJAX before it can be shown.
{id}: user indicated {type}


| I l@ve RuBoard |
Do you ever watch old black-and-white war movies? The weary soldier advances cautiously out of the brush. There's a clearing ahead: are there any land mines, or is it safe to cross? There aren't any indications that it's a minefield—no signs, barbed wire, or craters. The soldier pokes the ground ahead of him with his bayonet and winces, expecting an explosion. There isn't one. So he proceeds painstakingly through the field for a while, prodding and poking as he goes. Eventually, convinced that the field is safe, he straightens up and marches proudly forward, only to be blown to pieces.
The soldier's initial probes for mines revealed nothing, but this was merely lucky. He was led to a false conclusion—with disastrous results.
As developers, we also work in minefields. There are hundreds of traps just waiting to catch us each day. Remembering the soldier's tale, we should be wary of drawing false conclusions. We should avoid programming by coincidence—relying on luck and accidental successes— in favor of programming deliberately.
Suppose Fred is given a programming assignment. Fred types in some code, tries it, and it seems to work. Fred types in some more code, tries it, and it still seems to work. After several weeks of coding this way, the program suddenly stops working, and after hours of trying to fix it, he still doesn't know why. Fred may well spend a significant amount of time chasing this piece of code around without ever being able to fix it. No matter what he does, it just doesn't ever seem to work right.
Fred doesn't know why the code is failing because he didn't know why it worked in the first place. It seemed to work, given the limited "testing" that Fred did, but that was just a coincidence. Buoyed by false confidence, Fred charged ahead into oblivion. Now, most intelligent people may know someone like Fred, but we know better. We don't rely on coincidences—do we?
Sometimes we might. Sometimes it can be pretty easy to confuse a happy coincidence with a purposeful plan. Let's look at a few examples.
Accidents of implementation are things that happen simply because that's the way the code is currently written. You end up relying on undocumented error or boundary conditions.
Suppose you call a routine with bad data. The routine responds in a particular way, and you code based on that response. But the author didn't intend for the routine to work that way—it was never even considered. When the routine gets "fixed," your code may break. In the most extreme case, the routine you called may not even be designed to do what you want, but it seems to work okay. Calling things in the wrong order, or in the wrong context, is a related problem.
paint(g); invalidate(); validate(); revalidate(); repaint(); paintImmediately(r);
Here it looks like Fred is desperately trying to get something out on the screen. But these routines were never designed to be called this way; although they seem to work, that's really just a coincidence.
To add insult to injury, when the component finally does get drawn, Fred won't try to go back and take out the spurious calls. "It works now, better leave well enough alone…."
It's easy to be fooled by this line of thought. Why should you take the risk of messing with something that's working? Well, we can think of several reasons:
It may not really be working—it might just look like it is.
The boundary condition you rely on may be just an accident. In different circumstances (a different screen resolution, perhaps), it might behave differently.
Undocumented behavior may change with the next release of the library.
Additional and unnecessary calls make your code slower.
Additional calls also increase the risk of introducing new bugs of their own.
For code you write that others will call, the basic principles of good modularization and of hiding implementation behind small, well-documented interfaces can all help. A well-specified contract (see Design by Contract) can help eliminate misunderstandings.
For routines you call, rely only on documented behavior. If you can't, for whatever reason, then document your assumption well.
You can have "accidents of context" as well. Suppose you are writing a utility module. Just because you are currently coding for a GUI environment, does the module have to rely on a GUI being present?  Literate users? What else are you relying on that isn't guaranteed?
Coincidences can mislead at all levels—from generating requirements through to testing. Testing is particularly fraught with false causalities and coincidental outcomes. It's easy to assume that X causes Y, but as we said in Debugging: don't assume it, prove it.
At all levels, people operate with many assumptions in mind—but these assumptions are rarely documented and are often in conflict between different developers. Assumptions that aren't based on well-established facts are the bane of all projects.
Tip 44
Don't Program by Coincidence
We want to spend less time churning out code, catch and fix errors as early in the development cycle as possible, and create fewer errors to begin with. It helps if we can program deliberately:
Always be aware of what you are doing. Fred let things get slowly out of hand, until he ended up boiled, like the frog in Stone Soup and Boiled Frogs.
Don't code blindfolded. Attempting to build an application you don't fully understand, or to use a technology you aren't familiar with, is an invitation to be misled by coincidences.
Proceed from a plan, whether that plan is in your head, on the back of a cocktail napkin, or on a wall-sized printout from a CASE tool.
Rely only on reliable things. Don't depend on accidents or assumptions. If you can't tell the difference in particular circumstances, assume the worst.
Document your assumptions. Design by Contract, can help clarify your assumptions in your own mind, as well as help communicate them to others.
Don't just test your code, but test your assumptions as well. Don't guess; actually try it. Write an assertion to test your assumptions (see Assertive Programming). If your assertion is right, you have improved the documentation in your code. If you discover your assumption is wrong, then count yourself lucky.
Prioritize your effort. Spend time on the important aspects; more than likely, these are the hard parts. If you don't have fundamentals or infrastructure correct, brilliant bells and whistles will be irrelevant.
 Don't let existing code dictate future code. All code can be replaced if it is no longer appropriate. Even within one program, don't let what you've already done constrain what you do next—be ready to refactor (see Refactoring). This decision may impact the project schedule. The assumption is that the impact will be less than the cost of not making the change.[1]
[1] You can also go too far here. We once knew a developer who rewrote all source he was given because he had his own naming conventions.
So next time something seems to work, but you don't know why, make sure it isn't just a coincidence.
| I l@ve RuBoard |


--- layout: page title: "About" description: "Statement" active: about header-img: "img/about-bg.jpg" ---
Image Source: Unsplash


Gridlines
Easily arrange your content with gridlines
simply add
gem 'gridlines'
to your gemfile
Designed to work with
Twitter Bootstrap
Zurb Foundation
Semantic-UI
Gridlines automatically adds styling to your rows and columns in development
This makes it easy to see how your content is being layed out
Flooat content by adding empty grids


Fuctions to generate $\mu$'s and $\sigma^2$'s
Filtering
#
Fishmetica.sigma2f
— Function.
filtering: returns a vector of deviations ($sigma^2^f$) for a cohort sigma^2_0 - variance for initial age sigma^2_e - variance for the evidance vector (catches) sigma^2_x - variance for the state vector (population) l - the length of the cohort
#
Fishmetica.muf
— Function.
filtering: returns a vector of means (mu^f) for a cohort alpha - coefficients for the state x_{t+1}=x_t +alpha_t beta - coefficients for the observation y_{t}=x_t +beta_t e - the evidance vector mu_0 - mean for the initial age sigma^2_0 - variance (deviation is the square root of its variance) for initial age mu_e - mean for the evidence sigma^2_e - variance for the evidance (catch) mu_x - mean for the state sigma^2_e - variance for the state (population) l - the length of the cohort
#
Fishmetica.genmus2f
— Function.
filtering: returns filtered cohorts represented as vecs: csvlogts1muf - means,csvlogts1s2f - sigmas^2 (deviations),
Prediction
#
Fishmetica.sigma2p
— Function.
prediction: returns the vector of deviation predictions (sigma^2^p_{t+1},..., sigma^2^p_{t+k+1}) for a cohort sigma^2_x - variance for the state vector (population) l - the length of the cohort
#
Fishmetica.mup
— Function.
prediction: returns the vector of mean predictions (mu^p_{t+1}, ..., mu^p_{t+k+1}) for a cohort alphak=(alpha^t, ..., alpha_{t+k}) - (virtual) coefficients for x_{t+k+1}=x_{t+k} +alpha_{t+k} - muft - mu^f_t mu_x - mean for the state k >= 1 - the prediction step
#
Fishmetica.genmus2p
— Function.
makes k predictions for all cohorts (a^e+1, .., a^e+k) with yr>=yr2. cuts extra elements with age greater than jmax. returns filtered cohorts represented as vecs: csvlogts1mup - means,csvlogts1s2p - sigmas^2 (deviations), mup and s2p (means and sigmas^2 (deviations))
Smoothing
#
Fishmetica.sigma2b
— Function.
backward: returns a vector of deviations (sigma^2^b) for a cohort sigma^2_0 - variance for initial age sigma^2_e - variance for the evidance vector (catches) sigma^2_x - variance for the state vector (population) l - the length of the cohort
#
Fishmetica.genmus2s
— Function.
smoothing: makes several cohorts represented as vecs: csvlogts1mus - means,csvlogts1s2s - sigmas^2 (deviations)
Auxilary
#
Fishmetica.genG
— Function.
generates G with M (natural mortality) and F (catch mortality), Z (full mortality)
#
Fishmetica.genZ
— Function.
generates Z (full) with M (natural mortality) and F (catch mortality)
#
Fishmetica.genQuantile
— Function.
at +p%
#
Fishmetica.genQuantile1
— Function.
at -p%


Here is a list of all namespace members with links to the namespace documentation for each member:
- c -
- calculate_concatenate_shape()
: arm_compute::misc::shape_calculator
, arm_compute::test::validation
- calculate_depth_concatenate_shape()
: arm_compute::test::validation
- calculate_end_on_index()
: arm_compute::helpers::tensor_transform
- calculate_matrix_scale()
: arm_compute
- calculate_max_enlarged_window()
: arm_compute
- calculate_max_window()
: arm_compute
- calculate_max_window_horizontal()
: arm_compute
- calculate_quantized_multiplier_greater_than_one()
: arm_compute::quantization
- calculate_quantized_multiplier_less_than_one()
: arm_compute::quantization
- calculate_same_pad()
: arm_compute
- calculate_start_on_index()
: arm_compute::helpers::tensor_transform
- calculate_stride_on_index()
: arm_compute::helpers::tensor_transform
- calculate_strided_slice_coords()
: arm_compute::helpers::tensor_transform
- calculate_subsampled_shape()
: arm_compute
- calculate_unstack_shape()
: arm_compute::misc::shape_calculator
- calculate_valid_region_scale()
: arm_compute
- calculator()
: arm_compute::test::validation
- call_all_const_node_accessors()
: arm_compute::graph::detail
- call_all_input_node_accessors()
: arm_compute::graph::detail
- call_all_output_node_accessors()
: arm_compute::graph::detail
- call_all_tasks()
: arm_compute::graph::detail
- call_tensor_accessor()
: arm_compute::graph::detail
- canny_edge_detector()
: arm_compute::test::validation::reference
- canny_edge_parameters()
: arm_compute::test::validation
- cast
: arm_compute::test::validation
- ceil_to_multiple()
: arm_compute
- Channel
: arm_compute
- channel_combine()
: arm_compute::test::validation::reference
- channel_extract()
: arm_compute::test::validation::reference
- channel_idx_from_format()
: arm_compute
- channel_shuffle()
: arm_compute::test::validation::reference
- check_aligned()
: arm_compute::utility
- check_value_range()
: arm_compute
- cl_winograd_convolution_layer_supported()
: arm_compute
- CLAbsLayerFixture
: arm_compute::test::validation
- CLAbsLayerFixture< float >
: arm_compute::test::validation
- CLAbsoluteDifferenceFixture
: arm_compute::test::validation
- CLAccumulateFixture
: arm_compute::test::validation
- CLAccumulateSquaredFixture
: arm_compute::test::validation
- CLAccumulateWeightedFixture
: arm_compute::test::validation
- CLActivationLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLActivationLayerFixture< float >
: arm_compute::test::validation
- CLActivationLayerQuantizedFixture< int16_t >
: arm_compute::test::validation
- clamp()
: arm_compute::utility
- CLArgMinMaxValidationFixture
: arm_compute::test::validation
- CLArgMinMaxValidationFixture< float >
: arm_compute::test::validation
- CLArgMinMaxValidationFixture< half >
: arm_compute::test::validation
- CLArithmeticAdditionBroadcastFixture
: arm_compute::test::validation
- CLArithmeticAdditionFixture
: arm_compute::test::validation
- CLArithmeticAdditionFixture< half >
: arm_compute::test::validation
- CLArithmeticDivisionBroadcastFixture
: arm_compute::test::validation
- CLArithmeticDivisionFixture
: arm_compute::test::validation
- CLArithmeticSubtractionBroadcastFixture
: arm_compute::test::validation
- CLArithmeticSubtractionFixture
: arm_compute::test::validation
- CLArithmeticSubtractionFixture< half >
: arm_compute::test::validation
- CLBatchConcatenateLayerFixture
: arm_compute::test::validation
- CLBatchNormalizationLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLBatchNormalizationLayerFixture< half >
: arm_compute::test::validation
- CLBatchNormalizationLayerFusionFixture
: arm_compute::test::validation
- CLBatchToSpaceLayerFixture
: arm_compute::test::validation
- CLBitwiseAndFixture
: arm_compute::test::validation
- CLBitwiseNotFixture
: arm_compute::test::validation
- CLBitwiseOrFixture
: arm_compute::test::validation
- CLBitwiseXorFixture
: arm_compute::test::validation
- CLBlobMemoryManagerSimpleWithinFunctionLevelFixture
: arm_compute::test::validation
- CLBoundingBoxTransformFixture
: arm_compute::test::validation
- CLBoundingBoxTransformFixture< half >
: arm_compute::test::validation
- CLBox3x3Fixture
: arm_compute::test::validation
- CLCannyEdgeFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLCastToF16Fixture
: arm_compute::test::validation
- CLCastToF32Fixture
: arm_compute::test::validation
- CLCastToS16Fixture
: arm_compute::test::validation
- CLCastToS32Fixture
: arm_compute::test::validation
- CLCastToS8Fixture
: arm_compute::test::validation
- CLCastToU16Fixture
: arm_compute::test::validation
- CLCastToU32Fixture
: arm_compute::test::validation
- CLCastToU8Fixture
: arm_compute::test::validation
- CLChannelCombineFixture
: arm_compute::test::validation
- CLChannelCombineFixture< uint8_t >
: arm_compute::test::validation
- CLChannelExtractFixture
: arm_compute::test::validation
- CLChannelExtractFixture< uint8_t >
: arm_compute::test::validation
- CLChannelShuffleLayerFixture
: arm_compute::test::validation
- CLCoefficientTableArray
: arm_compute
- CLCol2Im
: arm_compute::test::validation
- CLCol2ImFixture
: arm_compute::test::validation
- CLColorConvertFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLComparisonFixture
: arm_compute::test::validation
- CLComparisonFixture< float >
: arm_compute::test::validation
- CLComputeAllAnchorsFixture
: arm_compute::test::validation
- CLComputeAllAnchorsFixture< half >
: arm_compute::test::validation
- CLConvertFullyConnectedWeightsFixture
: arm_compute::test::validation
- CLConvolution3x3Kernel
: arm_compute
- CLConvolution5x5
: arm_compute
- CLConvolution5x5Kernel
: arm_compute
- CLConvolution7x7
: arm_compute
- CLConvolution7x7Kernel
: arm_compute
- CLConvolution9x9
: arm_compute
- CLConvolution9x9Kernel
: arm_compute
- CLConvolutionFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLConvolutionFixture< int16_t >
: arm_compute::test::validation
- CLCoordinates2DArray
: arm_compute
- CLCopyFixture
: arm_compute::test::validation
- CLCopyFixture< uint16_t >
: arm_compute::test::validation
- CLCopyFixture< uint8_t >
: arm_compute::test::validation
- CLCropResizeFixture
: arm_compute::test::validation
- CLCropResizeFixture< int16_t >
: arm_compute::test::validation
- CLCropResizeFixture< int32_t >
: arm_compute::test::validation
- CLCropResizeFixture< uint16_t >
: arm_compute::test::validation
- CLCropResizeFixture< uint32_t >
: arm_compute::test::validation
- CLDeconvolutionLayerFixture1x1
: arm_compute::test::validation
- CLDeconvolutionLayerFixture1x1< float >
: arm_compute::test::validation
- CLDeconvolutionLayerFixture1x1< half >
: arm_compute::test::validation
- CLDeconvolutionLayerFixture2x2
: arm_compute::test::validation
- CLDeconvolutionLayerFixture2x2< float >
: arm_compute::test::validation
- CLDeconvolutionLayerFixture2x2< half >
: arm_compute::test::validation
- CLDeconvolutionLayerFixture3x3
: arm_compute::test::validation
- CLDeconvolutionLayerFixture3x3< float >
: arm_compute::test::validation
- CLDeconvolutionLayerFixture3x3< half >
: arm_compute::test::validation
- CLDeconvolutionLayerFixture4x4
: arm_compute::test::validation
- CLDeconvolutionLayerFixture4x4< half >
: arm_compute::test::validation
- CLDeconvolutionLayerQuantizedFixture1x1
: arm_compute::test::validation
- CLDeconvolutionLayerQuantizedFixture1x1< uint8_t >
: arm_compute::test::validation
- CLDeconvolutionLayerQuantizedFixture2x2
: arm_compute::test::validation
- CLDeconvolutionLayerQuantizedFixture2x2< uint8_t >
: arm_compute::test::validation
- CLDeconvolutionLayerQuantizedFixture3x3
: arm_compute::test::validation
- CLDeconvolutionLayerQuantizedFixture3x3< uint8_t >
: arm_compute::test::validation
- CLDepthConcatenateLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLDepthConvertLayerToF16Fixture
: arm_compute::test::validation
- CLDepthConvertLayerToF32Fixture
: arm_compute::test::validation
- CLDepthConvertLayerToS16Fixture
: arm_compute::test::validation
- CLDepthConvertLayerToS32Fixture
: arm_compute::test::validation
- CLDepthConvertLayerToU16Fixture
: arm_compute::test::validation
- CLDepthConvertLayerToU32Fixture
: arm_compute::test::validation
- CLDepthConvertLayerToU8Fixture
: arm_compute::test::validation
- CLDepthToSpaceLayerFixture
: arm_compute::test::validation
- CLDepthToSpaceLayerFixture< half >
: arm_compute::test::validation
- CLDepthwiseConvolutionLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLDepthwiseConvolutionLayerFixture< float >
: arm_compute::test::validation
- CLDepthwiseConvolutionLayerFixture< half >
: arm_compute::test::validation
- CLDepthwiseConvolutionLayerQuantizedFixture< uint8_t >
: arm_compute::test::validation
- CLDepthwiseSeparableConvolutionLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLDequantizationLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLDequantizationLayerFixture< float >
: arm_compute::test::validation
- CLDerivativeFixture
: arm_compute::test::validation
- CLDetectionWindowArray
: arm_compute
- CLDilateFixture
: arm_compute::test::validation
- CLDirectConvolutionLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLDirectConvolutionLayerFixture< float >
: arm_compute::test::validation
- CLDirectConvolutionValidationWithTensorShapesFixture
: arm_compute::test::validation
- CLDirectConvolutionValidationWithTensorShapesFixture< float >
: arm_compute::test::validation
- CLDirectConvolutionValidationWithTensorShapesQuantizedFixture
: arm_compute::test::validation
- CLDirectConvolutionValidationWithTensorShapesQuantizedFixture< uint8_t >
: arm_compute::test::validation
- CLElementwiseMaxBroadcastFixture
: arm_compute::test::validation
- CLElementwiseMaxFixture
: arm_compute::test::validation
- CLElementwiseMaxQuantizedFixture
: arm_compute::test::validation
- CLElementwiseMinBroadcastFixture
: arm_compute::test::validation
- CLElementwiseMinFixture
: arm_compute::test::validation
- CLElementwiseMinQuantizedFixture
: arm_compute::test::validation
- CLElementwisePowerBroadcastFixture
: arm_compute::test::validation
- CLElementwisePowerFixture
: arm_compute::test::validation
- CLElementwisePowerFixture< float >
: arm_compute::test::validation
- CLElementwiseSquaredDiffBroadcastFixture
: arm_compute::test::validation
- CLElementwiseSquaredDiffFixture
: arm_compute::test::validation
- CLElementwiseSquaredDiffQuantizedFixture
: arm_compute::test::validation
- CLEqual
: arm_compute
- CLEqualizeHistogramFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLErodeFixture
: arm_compute::test::validation
- CLExpLayerFixture
: arm_compute::test::validation
- CLExpLayerFixture< float >
: arm_compute::test::validation
- CLFastCornersFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLFFT1DFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLFFT2DFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLFFTConvolutionLayerFixture
: arm_compute::test::benchmark
- CLFlattenLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLFloatArray
: arm_compute
- CLFloorFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLFloorFixture< float >
: arm_compute::test::validation
- CLFullyConnectedLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLFullyConnectedLayerQuantizedFixture
: arm_compute::test::validation
- CLFuseBatchNormalizationConvFixture
: arm_compute::test::validation
- CLFuseBatchNormalizationConvFixture< half >
: arm_compute::test::validation
- CLFuseBatchNormalizationDWCFixture
: arm_compute::test::validation
- CLFuseBatchNormalizationDWCFixture< float >
: arm_compute::test::validation
- CLFuseBatchNormalizationDWCFixture< half >
: arm_compute::test::validation
- CLGatherFixture
: arm_compute::test::validation
- CLGatherFixture< float >
: arm_compute::test::validation
- CLGatherFixture< uint16_t >
: arm_compute::test::validation
- CLGatherFixture< uint8_t >
: arm_compute::test::validation
- CLGaussian3x3Fixture
: arm_compute::test::validation
- CLGaussian5x5Fixture
: arm_compute::test::validation
- CLGaussianPyramidFixture
: arm_compute::test::benchmark
- CLGaussianPyramidHalfFixture
: arm_compute::test::validation
- CLGEMMConvolutionLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLGEMMConvolutionLayerFixture< float >
: arm_compute::test::validation
- CLGEMMDilatedConvolutionLayerFixture
: arm_compute::test::validation
- CLGEMMDilatedConvolutionLayerQuantizedFixture
: arm_compute::test::validation
- CLGEMMFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLGEMMGroupedConvolutionLayerFixture< half >
: arm_compute::test::validation
- CLGEMMInputOutput3DFixture
: arm_compute::test::validation
- CLGEMMInputOutput3DFixture< half >
: arm_compute::test::validation
- CLGEMMLowpFixture
: arm_compute::test::benchmark
- CLGEMMLowpMatrixMultiplyCoreFixture
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyCoreFusedOffsetOutputFixture
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyNative
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyNative3DFixture
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyNativeFixture
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyReshaped
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyReshaped3DFixture
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyReshapedFixture
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyReshapedOnlyRHS
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyReshapedOnlyRHS3DFixture
: arm_compute::test::validation
- CLGEMMLowpMatrixMultiplyReshapedOnlyRHSFixture
: arm_compute::test::validation
- CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointFixture
: arm_compute::test::validation
- CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointFixture
: arm_compute::test::validation
- CLGEMMLowpQuantizeDownInt32ToUint8ScaleFixture
: arm_compute::test::validation
- CLGEMMMatrixMultiplyNative
: arm_compute::test::validation
- CLGEMMMatrixMultiplyNative3DFixture
: arm_compute::test::validation
- CLGEMMMatrixMultiplyNativeFixture
: arm_compute::test::validation
- CLGEMMMatrixMultiplyNativeFixture< half >
: arm_compute::test::validation
- CLGEMMMatrixMultiplyReshaped
: arm_compute::test::validation
- CLGEMMMatrixMultiplyReshaped3DFixture
: arm_compute::test::validation
- CLGEMMMatrixMultiplyReshapedFixture
: arm_compute::test::validation
- CLGEMMMatrixMultiplyReshapedFixture< half >
: arm_compute::test::validation
- CLGEMMMatrixMultiplyReshapedOnlyRHS
: arm_compute::test::validation
- CLGEMMMatrixMultiplyReshapedOnlyRHS3DFixture
: arm_compute::test::validation
- CLGEMMMatrixMultiplyReshapedOnlyRHSFixture
: arm_compute::test::validation
- CLGEMMOutput3DFixture
: arm_compute::test::validation
- CLGEMMOutput3DFixture< float >
: arm_compute::test::validation
- CLGEMMOutput3DFixture< half >
: arm_compute::test::validation
- CLGEMMReshapeLHSMatrix
: arm_compute::test::validation
- CLGEMMReshapeLHSMatrix3DFixture
: arm_compute::test::validation
- CLGEMMReshapeLHSMatrix3DFixture< char >
: arm_compute::test::validation
- CLGEMMReshapeLHSMatrix3DFixture< short >
: arm_compute::test::validation
- CLGEMMReshapeLHSMatrixFixture
: arm_compute::test::validation
- CLGEMMReshapeLHSMatrixFixture< char >
: arm_compute::test::validation
- CLGEMMReshapeLHSMatrixFixture< short >
: arm_compute::test::validation
- CLGEMMReshapeRHSMatrix
: arm_compute::test::validation
- CLGEMMReshapeRHSMatrixFixture
: arm_compute::test::validation
- CLGEMMReshapeRHSMatrixFixture< char >
: arm_compute::test::validation
- CLGEMMReshapeRHSMatrixFixture< short >
: arm_compute::test::validation
- CLGlobalPoolingLayerFixture
: arm_compute::test::validation
- CLGreater
: arm_compute
- CLGreaterEqual
: arm_compute
- CLHarrisCornersFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLHeightConcatenateLayerFixture
: arm_compute::test::validation
- CLHistogramFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLHOGDescriptorFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLHOGDetectorFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLHOGMultiDetectionFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLIm2Col
: arm_compute::test::validation
- CLIm2ColFixture
: arm_compute::test::validation
- CLImage
: arm_compute
- CLInt16Array
: arm_compute
- CLInt32Array
: arm_compute
- CLIntegralImageFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLKeyPointArray
: arm_compute
- CLL2NormalizeLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLL2NormalizeLayerFixture< half >
: arm_compute::test::validation
- CLLaplacianPyramidFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLLaplacianReconstructFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLLess
: arm_compute
- CLLessEqual
: arm_compute
- CLLKInternalKeypointArray
: arm_compute
- CLLocallyConnectedFixture
: arm_compute::test::validation
- CLLocallyConnectedLayerFixture
: arm_compute::test::benchmark
- CLLogLayerFixture
: arm_compute::test::validation
- CLLogLayerFixture< float >
: arm_compute::test::validation
- CLLSTMLayerFixture
: arm_compute::test::validation
- CLLSTMLayerFixture< half >
: arm_compute::test::validation
- CLMagnitudeFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLMagnitudeFixture< int32_t >
: arm_compute::test::validation
- CLMeanStdDevFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLMeanStdDevFixture< float >
: arm_compute::test::validation
- CLMeanStdDevFixture< half >
: arm_compute::test::validation
- CLMeanStdDevNormalizationLayerFixture
: arm_compute::test::validation
- CLMeanStdDevNormalizationLayerFixture< float >
: arm_compute::test::validation
- CLMedian3x3Fixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLMemoryGroup
: arm_compute
- CLMinMaxLocationFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLNegLayerFixture
: arm_compute::test::validation
- CLNegLayerFixture< float >
: arm_compute::test::validation
- CLNonLinearFilterFixture
: arm_compute::test::validation
- CLNormalizationLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLNormalizationLayerFixture< float >
: arm_compute::test::validation
- CLNormalizePlanarYUVLayerFixture
: arm_compute::test::validation
- CLNormalizePlanarYUVLayerQuantizedFixture
: arm_compute::test::validation
- CLNotEqual
: arm_compute
- CLOldValueArray
: arm_compute
- CLOpticalFlowFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLPaddingFixture
: arm_compute::test::validation
- CLPaddingFixture< half >
: arm_compute::test::validation
- CLPaddingFixture< uint8_t >
: arm_compute::test::validation
- CLPhaseFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLPhaseFixture< int32_t >
: arm_compute::test::validation
- CLPixelWiseMultiplicationBroadcastFixture
: arm_compute::test::validation
- CLPixelWiseMultiplicationBroadcastFixture< float >
: arm_compute::test::validation
- CLPixelWiseMultiplicationQuantizedFixture
: arm_compute::test::validation
- CLPixelWiseMultiplicationQuantizedFixture< int16_t >
: arm_compute::test::validation
- CLPixelWiseMultiplicationToF16Fixture
: arm_compute::test::validation
- CLPixelWiseMultiplicationToF32Fixture
: arm_compute::test::validation
- CLPixelWiseMultiplicationToF32Fixture< float >
: arm_compute::test::validation
- CLPoolingLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLPoolingLayerFixture< half >
: arm_compute::test::validation
- CLPReluLayerBroadcastFixture
: arm_compute::test::validation
- CLPReluLayerFixture
: arm_compute::test::validation
- CLPReluLayerQuantizedFixture
: arm_compute::test::validation
- CLPriorBoxLayerFixture
: arm_compute::test::validation
- CLQuantizationLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLQuantizationLayerFixture< half >
: arm_compute::test::validation
- CLRangeFixture
: arm_compute::test::validation
- CLRangeFixture< float >
: arm_compute::test::validation
- CLRangeFixture< half >
: arm_compute::test::validation
- CLRangeFixture< int16_t >
: arm_compute::test::validation
- CLRangeFixture< uint8_t >
: arm_compute::test::validation
- CLReduceMeanFixture
: arm_compute::test::validation
- CLReduceMeanFixture< float >
: arm_compute::test::validation
- CLReductionOperationFixture
: arm_compute::test::validation
- CLReductionOperationFixture< float >
: arm_compute::test::validation
- CLRemapFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLReorgLayerFixture
: arm_compute::test::validation
- CLReorgLayerFixture< int16_t >
: arm_compute::test::validation
- CLReorgLayerFixture< int8_t >
: arm_compute::test::validation
- CLReshapeLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLReverseFixture
: arm_compute::test::validation
- CLReverseFixture< float >
: arm_compute::test::validation
- CLReverseFixture< uint8_t >
: arm_compute::test::validation
- CLRNNLayerFixture
: arm_compute::test::validation
- CLRNNLayerFixture< half >
: arm_compute::test::validation
- CLROIAlignLayerFixture
: arm_compute::test::validation
- CLROIPoolingLayerFixture
: arm_compute::test::benchmark
- CLRoundLayerFixture
: arm_compute::test::validation
- CLRoundLayerFixture< float >
: arm_compute::test::validation
- CLRsqrtLayerFixture
: arm_compute::test::validation
- CLRsqrtLayerFixture< float >
: arm_compute::test::validation
- CLScaleFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLScaleFixture< half >
: arm_compute::test::validation
- CLScaleFixture< int16_t >
: arm_compute::test::validation
- CLScaleFixture< uint8_t >
: arm_compute::test::validation
- CLScharr3x3Fixture
: arm_compute::test::validation
- CLSelectFixture
: arm_compute::test::validation
- CLSeparableConvolution5x5HorKernel
: arm_compute
- CLSeparableConvolution5x5VertKernel
: arm_compute
- CLSeparableConvolution7x7HorKernel
: arm_compute
- CLSeparableConvolution7x7VertKernel
: arm_compute
- CLSeparableConvolution9x9HorKernel
: arm_compute
- CLSeparableConvolution9x9VertKernel
: arm_compute
- CLSinLayerFixture
: arm_compute::test::validation
- CLSinLayerFixture< float >
: arm_compute::test::validation
- CLSize2DArray
: arm_compute
- CLSliceFixture
: arm_compute::test::validation
- CLSliceFixture< float >
: arm_compute::test::validation
- CLSobel3x3Fixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLSobel5x5Fixture
: arm_compute::test::validation
- CLSobel7x7Fixture
: arm_compute::test::validation
- CLSoftmaxLayerFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLSoftmaxLayerQuantizedFixture
: arm_compute::test::validation
- CLSpaceToBatchLayerFixture
: arm_compute::test::validation
- CLSpaceToBatchLayerFixture< half >
: arm_compute::test::validation
- CLSpaceToDepthLayerFixture
: arm_compute::test::validation
- CLSpaceToDepthLayerFixture< half >
: arm_compute::test::validation
- CLSpecialPoolingLayerFixture
: arm_compute::test::validation
- CLSplitFixture
: arm_compute::test::validation
- CLSplitFixture< float >
: arm_compute::test::validation
- CLStackLayerFixture
: arm_compute::test::validation
- CLStackLayerFixture< char >
: arm_compute::test::validation
- CLStackLayerFixture< int >
: arm_compute::test::validation
- CLStackLayerFixture< short >
: arm_compute::test::validation
- CLStridedSliceFixture
: arm_compute::test::validation
- CLStridedSliceFixture< float >
: arm_compute::test::validation
- CLTableLookupFixture
: arm_compute::test::validation
- CLThresholdFixture
: arm_compute::test::validation
- CLTileFixture
: arm_compute::test::validation
- CLTileFixture< float >
: arm_compute::test::validation
- CLTileFixture< int8_t >
: arm_compute::test::validation
- CLTileFixture< uint8_t >
: arm_compute::test::validation
- CLTransposeFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLTransposeFixture< uint16_t >
: arm_compute::test::validation
- CLTransposeFixture< uint32_t >
: arm_compute::test::validation
- CLTunerMode
: arm_compute
- CLUInt16Array
: arm_compute
- CLUInt32Array
: arm_compute
- CLUInt8Array
: arm_compute
- CLUnstackFixture
: arm_compute::test::validation
- CLUpsampleLayerFixture
: arm_compute::test::validation
- CLUpsampleLayerFixture< half >
: arm_compute::test::validation
- CLVersion
: arm_compute
- CLWarpAffineFixture
: arm_compute::test::benchmark
, arm_compute::test::validation
- CLWarpPerspectiveFixture
: arm_compute::test::validation
- CLWeightsReshape
: arm_compute::test::validation
- CLWeightsReshapeFixture
: arm_compute::test::validation
- CLWeightsRetentionFixture
: arm_compute::test::validation
- CLWidthConcatenateLayerFixture
: arm_compute::test::validation
- CLWinogradConvolutionLayerFastMathFixture
: arm_compute::test::validation
- CLWinogradConvolutionLayerFastMathFixture16
: arm_compute::test::validation
- CLWinogradFilterTransform
: arm_compute::test::validation
- CLWinogradFilterTransformFixtureFP16
: arm_compute::test::validation
- CLWinogradFilterTransformFixtureFP32
: arm_compute::test::validation
- CLWinogradInputTransformFixtureFP16
: arm_compute::test::validation
- CLWinogradInputTransformFixtureFP32
: arm_compute::test::validation
- CLWinogradLayerFixture
: arm_compute::test::benchmark
- CLWinogradOutputTransform
: arm_compute::test::validation
- CLWinogradOutputTransformFixtureFP16
: arm_compute::test::validation
- CLWinogradOutputTransformFixtureFP32
: arm_compute::test::validation
- CLYOLOLayerFixture
: arm_compute::test::validation
- CLYOLOLayerFixture< half >
: arm_compute::test::validation
- col2im()
: arm_compute::test::validation::reference
- color_convert()
: arm_compute::test::validation::reference
- colorconvert_iyuv_to_nv12()
: arm_compute
- colorconvert_iyuv_to_rgb()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_iyuv_to_yuv4()
: arm_compute
- colorconvert_nv12_to_iyuv()
: arm_compute
- colorconvert_nv12_to_rgb()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_nv12_to_yuv4()
: arm_compute
- colorconvert_nv_to_iyuv()
: arm_compute::test::colorconvert_helper::detail
- colorconvert_nv_to_yuv4()
: arm_compute::test::colorconvert_helper::detail
- colorconvert_rgb_to_iyuv()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_rgb_to_nv12()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_rgb_to_rgbx()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_rgb_to_u8()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_rgb_to_yuv4()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_rgbx_to_rgb()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_yuyv_to_iyuv()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_yuyv_to_nv12()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- colorconvert_yuyv_to_rgb()
: arm_compute
, arm_compute::test::colorconvert_helper::detail
- combine()
: arm_compute::test::benchmark
, arm_compute::test::framework::dataset
, arm_compute::test::validation
- compare()
: arm_compute::test::validation::reference
- compare_detection_windows()
: arm_compute::test::validation
- compare_dimensions()
: arm_compute::test::validation
- compare_keypoints()
: arm_compute::test::validation
- compare_tensor()
: arm_compute::utils
- ComparisonOperation
: arm_compute
- compute_all_anchors()
: arm_compute::test::validation::reference
- compute_batch_to_space_shape()
: arm_compute::misc::shape_calculator
- compute_col2im_shape()
: arm_compute::misc::shape_calculator
- compute_col_sums()
: arm_gemm
- compute_deconvolution_output_shape()
: arm_compute::misc::shape_calculator
- compute_deconvolution_upsampled_shape()
: arm_compute::misc::shape_calculator
- compute_deep_convolution_shape()
: arm_compute::misc::shape_calculator
- compute_depth_to_space_shape()
: arm_compute::misc::shape_calculator
- compute_depthwise_convolution_shape()
: arm_compute::misc::shape_calculator
- compute_flatten_shape()
: arm_compute::misc::shape_calculator
- compute_gather_shape()
: arm_compute::misc::shape_calculator
- compute_im2col_conv_shape()
: arm_compute::misc::shape_calculator
- compute_interleaved_shape()
: arm_compute::misc::shape_calculator
- compute_lhs_reshaped_shape()
: arm_compute::misc::shape_calculator
- compute_min_max()
: arm_compute::test::validation::reference
- compute_min_max_shape()
: arm_compute::misc::shape_calculator
- compute_mm_shape()
: arm_compute::misc::shape_calculator
- compute_output_stage_shape()
: arm_compute::misc::shape_calculator
- compute_padded_shape()
: arm_compute::misc::shape_calculator
- compute_permutation_output_shape()
: arm_compute::misc::shape_calculator
- compute_pool_shape()
: arm_compute::misc::shape_calculator
- compute_prior_box_shape()
: arm_compute::misc::shape_calculator
- compute_reduced_shape()
: arm_compute::misc::shape_calculator
- compute_reduction_operation()
: arm_compute::test::validation::reference
- compute_reductionA_shape()
: arm_compute::misc::shape_calculator
- compute_reductionB_shape()
: arm_compute::misc::shape_calculator
- compute_reorg_output_shape()
: arm_compute::misc::shape_calculator
- compute_reshaped_depthwise_weights_shape()
: arm_compute::misc::shape_calculator
- compute_rgb_value()
: arm_compute::test::colorconvert_helper::detail
- compute_rhs_reshaped_shape()
: arm_compute::misc::shape_calculator
- compute_rnn_shape()
: arm_compute::misc::shape_calculator
- compute_roi_align_shape()
: arm_compute::misc::shape_calculator
- compute_row_sums()
: arm_gemm
- compute_slice_shape()
: arm_compute::misc::shape_calculator
- compute_softmax_shape()
: arm_compute::misc::shape_calculator
- compute_space_to_batch_shape()
: arm_compute::misc::shape_calculator
- compute_space_to_depth_shape()
: arm_compute::misc::shape_calculator
- compute_split_shape()
: arm_compute::misc::shape_calculator
- compute_stack_shape()
: arm_compute::misc::shape_calculator
- compute_strided_slice_output_shape()
: arm_compute::helpers::tensor_transform
- compute_strided_slice_shape()
: arm_compute::misc::shape_calculator
- compute_strides()
: arm_compute
- compute_tiled_shape()
: arm_compute::misc::shape_calculator
- compute_transpose1xW_shape()
: arm_compute::misc::shape_calculator
- compute_transpose1xW_with_element_size_shape()
: arm_compute::misc::shape_calculator
- compute_transposed_shape()
: arm_compute::misc::shape_calculator
- compute_upsample_shape()
: arm_compute::misc::shape_calculator
- compute_vector_to_tensor_output_shape()
: arm_compute::misc::shape_calculator
- compute_weights_reshaped_shape()
: arm_compute::misc::shape_calculator
- compute_winograd_convolution_tiles()
: arm_compute
- compute_winograd_filter_transform_shape()
: arm_compute::misc::shape_calculator
- compute_winograd_input_transform_shape()
: arm_compute::misc::shape_calculator
- compute_winograd_output_transform_shape()
: arm_compute::misc::shape_calculator
- concat()
: arm_compute::test::framework::dataset
- concatenate_layer()
: arm_compute::test::validation::reference
- configure_all_nodes()
: arm_compute::graph::detail
- configure_all_tensors()
: arm_compute::graph::detail
- configure_lhs_rhs_info()
: arm_compute::cl_gemm
- configure_tensor()
: arm_compute::graph
- configure_transition_manager()
: arm_compute::graph::detail
- const_ptr_t
: arm_compute
- CONSTANT_BORDER_VALUE
: arm_compute
- construct_slice_end_mask()
: arm_compute::helpers::tensor_transform
- consume_common_graph_parameters()
: arm_compute::utils
- conv()
: arm_compute::test::validation
- conv2d_dft()
: arm_compute::test::validation::reference
- conv_bias_info
: arm_compute::test::validation
- conv_dataset_dft
: arm_compute::test::validation
- conv_info
: arm_compute::test::validation
- convert_from_asymmetric()
: arm_compute::test::validation
- convert_from_symmetric()
: arm_compute::test::validation
- convert_fully_connected_weights()
: arm_compute::test::validation::reference
- convert_policy
: arm_compute::test::validation
- convert_range_pair()
: arm_compute::test::detail
- convert_to_asymmetric()
: arm_compute::test::validation
- convert_to_symmetric()
: arm_compute::test::validation
- convert_window_coord_to_position()
: arm_compute
- ConvertPolicy
: arm_compute
- convolution
: arm_compute::test::validation
, arm_compute::test::validation::reference
- convolution3d()
: arm_compute::test::convolution_3d::detail
- convolution_layer()
: arm_compute::test::validation::reference
- convolution_layer_nchw()
: arm_compute::test::validation::reference
- Convolution_method_from_name()
: arm_compute::graph
- ConvolutionMethod
: arm_compute
, arm_compute::graph
- convolve_3x3()
: arm_compute::detail
- convolve_3x3< 1 >()
: arm_compute::detail
- convolve_3x3< 2 >()
: arm_compute::detail
- convolve_3x3< 3 >()
: arm_compute::detail
- convolve_3x3_dilation()
: arm_compute::detail
- convolve_3x3_dilation< 1 >()
: arm_compute::detail
- convolve_3x3_dilation< 2 >()
: arm_compute::detail
- convolve_3x3_dilation< 3 >()
: arm_compute::detail
- coord2index()
: arm_compute::test
- Coordinates2DArray
: arm_compute
- coords2index()
: arm_compute
- copy()
: arm_compute::test::validation::reference
- copy_tensor()
: arm_compute::test
- copysign()
: arm_compute::support::cpp11
- CPPNonMaxSuppressionFixture
: arm_compute::test::validation
- CPPPermuteFixture
: arm_compute::test::validation
- cpu_model_to_string()
: arm_compute
- CPUModel
: arm_compute
- create_activation_layer()
: arm_compute::graph::backends::detail
- create_batch_normalization_layer()
: arm_compute::graph::backends::detail
- create_bounding_box_transform_layer()
: arm_compute::graph::backends::detail
- create_channel_shuffle_layer()
: arm_compute::graph::backends::detail
- create_concatenate_layer()
: arm_compute::graph::backends::detail
- create_configure_kernel()
: arm_compute
- create_convolution_layer()
: arm_compute::graph::backends::detail
- create_convolution_layer< GCConvolutionLayerFunctions, GCTargetInfo >()
: arm_compute::graph::backends::detail
- create_convolution_layer< NEConvolutionLayerFunctions, NETargetInfo >()
: arm_compute::graph::backends::detail
- create_deconvolution_layer()
: arm_compute::graph::backends::detail
- create_default_pass_manager()
: arm_compute::graph
- create_depthwise_convolution_layer()
: arm_compute::graph::backends::detail
- create_depthwise_convolution_layer< GCDepthwiseConvolutionLayerFunctions, GCTargetInfo >()
: arm_compute::graph::backends::detail
- create_detection_output_layer()
: arm_compute::graph::backends::detail
- create_detection_output_layer< CPPDetectionOutputLayer, CLTargetInfo >()
: arm_compute::graph::backends::detail
- create_detection_post_process_layer()
: arm_compute::graph::backends::detail
- create_detection_post_process_layer< CPPDetectionPostProcessLayer, CLTargetInfo >()
: arm_compute::graph::backends::detail
- create_eltwise_layer()
: arm_compute::graph::backends::detail
- create_eltwise_layer< GCEltwiseFunctions, GCTargetInfo >()
: arm_compute::graph::backends::detail
- create_error()
: arm_compute
- create_error_va_list()
: arm_compute
- create_flatten_layer()
: arm_compute::graph::backends::detail
- create_fully_connected_layer()
: arm_compute::graph::backends::detail
- create_fused_convolution_batch_normalization_layer()
: arm_compute::graph::backends::detail
- create_fused_depthwise_convolution_batch_normalization_layer()
: arm_compute::graph::backends::detail
- create_generate_proposals_layer()
: arm_compute::graph::backends::detail
- create_HOG()
: arm_compute::test
- create_kernel()
: arm_compute
- create_multi_image()
: arm_compute::test
- create_named_function()
: arm_compute::graph::backends
- create_named_memory_managed_function()
: arm_compute::graph::backends
- create_normalization_layer()
: arm_compute::graph::backends::detail
- create_normalization_layer< NENormalizationLayer, NETargetInfo >()
: arm_compute::graph::backends::detail
- create_normalize_planar_yuv_layer()
: arm_compute::graph::backends::detail
- create_opencl_context_and_device()
: arm_compute
- create_pad_layer()
: arm_compute::graph::backends::detail
- create_permute_layer()
: arm_compute::graph::backends::detail
- create_pooling_layer()
: arm_compute::graph::backends::detail
- create_priorbox_layer()
: arm_compute::graph::backends::detail
- create_pyramid()
: arm_compute::test
- create_quantization_layer()
: arm_compute::graph::backends::detail
- create_reorg_layer()
: arm_compute::graph::backends::detail
- create_reshape_layer()
: arm_compute::graph::backends::detail
- create_resize_layer()
: arm_compute::graph::backends::detail
- create_roi_align_layer()
: arm_compute::graph::backends::detail
- create_slice_layer()
: arm_compute::graph::backends::detail
- create_softmax_layer()
: arm_compute::graph::backends::detail
- create_stack_layer()
: arm_compute::graph::backends::detail
- create_tensor()
: arm_compute::test
- create_upsample_layer()
: arm_compute::graph::backends::detail
- create_window_iterator()
: arm_compute
- create_yolo_layer()
: arm_compute::graph::backends::detail
- crop_and_resize()
: arm_compute::test::validation::reference


ni
CBC’s full name is cannabichromene, and it is one of the many ‘minor’ cannabinoids present in Cannabis that are being studied. Early work indicated that CBC has important pain relief and anti-anxiety properties (see references), and the NIH recently awarded $3 million in research funding towards minor cannabinoids and terpenes, including CBC. Some preclinical trials are also looking at CBC and CBC’s ability to kill colon cancer cells.
Some work has been done to determine how CBC plays a role in the body’s endocannabinoid system, and the big takeaway is that CBC could potentially be a big a player working with CBD to carry out its’ effects on the body.
CBC is currently very rare in hemp plants, and being rare and having biological effects, makes it sought after. In order to produce CBC, the right genetic network, including the CBCA synthase, has to be present in plants to create more than negligible amounts of CBC. With diligent breeding that CBC creating network can be assembled, and the plants produce CBC. This is how Blue DelicaC can express up to 3% CBC, whereas other hemp cultivars expres 0% CBC.
So far CBC distillate has commanded a very high price, upwards of $30,000 for a kg. This is in part because CBC has been so rare in the starting hemp material that it is very costly to produce distillate. However, CBC is very desirable in today’s marketplace, so extractors are willing to scrape together the CBC they can to make distillate.
Now, with the creation of CBC hemp lines like Blue DelicaC , extractors can create those very high value distillates with dramatically reduced production costs. In turn, the value of CBC hemp material could be quite high in 2020. As for the smokables market, many consumers are attracted to novel cannabinoids (note the rise of CBG, CBN, etc) and CBC varieties should create a similar buzz.
Our Blue DelicaC behaves like any other fully CBD plant, and it has an intact cannabinod pathway, unlike many CBG varieties. Subsequently, it exhibits great pest and disease resistance and is vigorous in the field. Unlike CBG which has chemical properties that make it difficult to extract, CBC doesn’t carry the same baggage and can be processed in the same manner as CBD.