- DsSort
- Px c 3883363
- 2.3.1 Hodder
- scriiiii
- AOA Assignments
- Bidirectional Conditional Insertion Sort algorithm; An efficient progress on the classical insertion sort
- Sorting Algorithms
- Merge Sort
- Computer Algoritham for Chennai Univarcity Unit 1 And2
- ACM Syllabus
- Unit 06_DSC_PPT
- Sequential and Parallel Sorting Algorithms
- Sorting
- Convex Hull
- Week 7 Notes
- CS2251DAA2MARKS
- Algorithm Analysis
- data-structures-a-algorithms-multiple-choice-questions-mcqs-objective-set-2
- Black Hole
- lec19
- exam2s13key
- exam2A
- NEW DS
- Edusat Lect
- Enhanced+Search+Widget+URL+Search+Configuration
- Fastexp Copy
- Tcs Assignment 1
- Algorithm Syllabus
- Notas x BMerge.pdf
- CourseHandOut_Data Structures and Algorithms Design
- OpenCL Static C++ Kernel Language Extension
- Jeffrey Dean CSE Summa Sum1990
- Cyclic Test Performance Measurement
- Optimizing sleep to maximize performance: implications and recommendations for elite athletes
- Effect of Green Tea Catechins on Plasma Cholesterol Level in Cholesterol-Fed Rats
- A climbing image nudged elastic band method for finding saddle points and minimum energy paths
- Cooperative Control of Mobile Sensor Networks: Adaptive Gradient Climbing in a Distributed Environment
- Loop Recognition in C++/Java/Go/Scala
- Azure Cosmos Db 2-Cheat Sheet v4-Letter
- Maximum Entropy Modeling Toolkit for Python and C++
- Meta Optimization: Improving Compiler Heuristics with Machine Learning
- ROOT — A C++ Framework for Petabyte Data Storage, Statistical Analysis and Visualization
- The Max Min Hill Climbing Bayesian Network Structure Learning Algorithm
- A Sparse Matrix Library in C++ for High Performance Architectures
- Climbing the Density Functional Ladder: Non-Empirical Meta-Generalized Gradient Approximation Designed for Molecules and Solids
- Rcpp: Seamless R and C++ Integration
- Swirlz Menu
- A Sparse Matrix Library in C++ for High Performance Architectures
- Cool Manual
- Algorithm 871: A C/C++ Precompiler for Autogeneration of Multiprecision Programs
- AttackingAV_syscan08hk
- Opcode64 Preview
- ET++ - An Object-Oriented Application Framework in C++
- s18-das
- Topographica: building and analyzing map-level simulations from Python, C/C++, MATLAB, NEST, or NEURON components
- FSA: An Efficient and Flexible C++ Toolkit for Finite State Automata Using On-Demand Computation
- Opcode32 Preview
- 64 Ia 32 Architectures Software Developer Manual 325462
- A Practical Flow-Sensitive and Context-Sensitive C and C++ Memory Leak Detector

Roger Orr

OR/2 Limited

What does complexity measurement mean?

– ACC 2!"# –

What is Order Notation?

●

$his notation is a %ay o& descri'ing ho% the

number of operations per&ormed 'y an

algorithm (aries 'y the size of the problem

as the si)e increases

●

*ou+(e pro'a'ly heard o& order notation

'e&ore – i& you ha(e studied computer

science then the next section is li,ely to 'e

re(ision

Why do %e care?

●

Almost no-one. is actually interested in the

complexity o& an algorithm

●

What %e normally care a'out is the

performance o& a &unction

–

$he complexity measure o& an algorithm %ill

a&&ect the per&ormance o& a &unction

implementing it/ 'ut it is 'y no means the

only &actor

0.Present audience possi'ly excepted1

Ways to measure per&ormance

●

$here are a num'er o& di&&erent %ays to

measure the per&ormance o& a &unction

●

$ypical measures include2

–

Wall cloc, time

–

CP cloc, cycles

–

3emory use

–

4/O 0dis,/ net%or,/ etc1

–

Po%er consumption

–

Num'er o& 56 'rac,ets used

Complexity measurement

●

Complexity measurement is 0normally1

used to approximate the num'er o&

operations per&ormed

●

$his is then used as a proxy &or CP cloc,

cycles

●

4t ignores +details+ such as memory access

costs that ha(e 'ecome increasingly

important o(er time

●

4t o&ten is a measure o& one operation

4ntroduction to Order Notation

●

A classi&ication o& algorithms 'y ho% they

respond to changes in si)e7

●

ses a 'ig O 0also called Landau+s sym'ol/

a&ter the num'er theoretician 8dmund

Landau %ho in(ented the notation1

●

We %rite &0x1 9 O0g0x11 to mean

$here exists a constant C and a (alue N

such that :&0x1: 5 C:g0x1: x 6 N ∀

8xample o& Order Notation

●

4& &0x1 9 2x

2

; <x ; #

●

$hen &0x1 9 O0x

2

1

●

4& h0x1 9 x

2

; <#=>?@x ; #=>?@A

●

$hen h0x1 9 O0x

2

1

●

Note that/ in these t%o cases/ the (alues o&

C and N are li,ely to 'e di&&erent2

–

Bor & %e can use 0</ #1

Bor g %e can use 02/ <#=>?A1 or 0#!!!/ @?1

8xample o& Order Notation

●

Note that & and h are both O0x

2

1 although

they+re di&&erent &unctions7

●

Bor the purposes o& order classi&ication/ it

doesn+t matter %hat the multiplier C is nor

ho% 'ig the (alue N is7

●

Note too that &ormally O is a C59D

relationship7 Eo F0x1 9 "> is also O0x

2

1

●

4& &0x1 9 O0g0x11 and g0x1 9 O0&0x11 then %e

can %rite &0x1 9 θ0g0x11

Eome common orders

●

Gere a some common orders/ %ith the

slo%er gro%ing &unctions &irst2

–

O0"1 – constant

–

O0log0x11 – logarithmic

–

O0x1 – linear

–

O0x

2

1 – Huadratic

–

O0x

n

1 – polynomial

–

O0e

x

1 - exponential

Order arithmetic

●

When t%o &unctions are com'ined the order

o& the resulting &unction can 0usually1 'e

in&erred

●

When adding &unctions/ you simply ta,e the

'iggest order

–

eg7 O0"1 ; O0n1 9 O0n1

●

When multiplying &unctions/ you multiply the

orders

–

eg7 O0n1 . O0n1 9 O0n

2

1

Order arithmetic &or programs

●

Bor a &unction ma,ing a seHuence o&

&unction calls the order o& the &unction is the

same as the highest order o& the called

&unctions

void f(int n) {

g(n); // O(n.log(n))

h(n); // O(n)

}

●

4n this example &01 9 O0n7log0n11

Order arithmetic &or programs

●

Bor a &unction using a loop the order is the

product o& the order o& the loop count and

the loop 'ody

void f(int n) {

int count = g(n); // count is O(log(n))

for (int i = 0; i != count; ++i) {

h(n); // O(n)

}

●

4n this example too &01 9 O0n7log0n11

Order &or standard algorithms

●

3any standard algorithms ha(e a %ell-

understood order7 One o& the 'est ,no%n

non-tri(ial examples is pro'a'ly quicksort

%hich Ce(eryone ,no%sD is O0n7log0n117

Order &or standard algorithms

●

3any standard algorithms ha(e a %ell-

understood order7 One o& the 'est ,no%n

non-tri(ial examples is pro'a'ly quicksort

%hich Ce(eryone ,no%sD is O0n7log0n117

●

8xcept %hen it isn't/ o& courseI

–

On average it is O0n7log0n11

–

$he worst case is O0n

2

1

●

Also/ this is the computational cost/ not the

memory cost

Order &or standard algorithms

●

$he C;; standard mandates the complexity

o& many algorithms7

●

Bor example/ std::sort2

CComplexity2 O0N log0N11 comparisons7D

●

and std::stablesort2

CComplexity2 4t does at most N log

2

0N1 comparisonsJ i&

enough extra memory is a(aila'le/ it is N log0N17D

●

and std::list::sort2

CComplexity2 Approximately N log0N1 comparisonsD

Order &or standard operations

●

$he C;; standard also mandates the

complexity o& many operations7

●

Bor example/ container::si!e2

CComplexity2 constant7D

●

and std::list::"ushbac#2

CComplexity2 4nsertion o& a single element into a list ta,es

constant time and exactly one call to a constructor o& $7D

Order &or standard algorithms

●

7Net lists complexity &or some algorithms7

●

Bor example/ $ist%&'.(ort2

COn a(erage/ this method is an O0n log n1 operation/ %here

n is CountJ in the %orst case it is an O0n K 21 operation7D

●

La(a does the same

●

Bor example/ )rra*s.sort2

C$his implementation is a sta'le/ adapti(e/ iterati(e

mergesort that reHuires &ar &e%er than n lg0n1 comparisons

%hen the input array is partially sorted/ %hile o&&ering the

per&ormance o& a traditional mergesort %hen the input

array is randomly ordered777D

Order &or standard operations

●

Go%e(er/ neither La(a not 7Net seem to

pro(ide much detail &or the cost o& other

operations %ith containers

●

$his ma,es it harder to reason a'out the

per&ormance impact o& the choice o&

container and the methods used7

Let+s try some experiments

●

Eo that+s the theoryJ %hat happens %hen %e

try some o& these out in an actual program

on real hard%are?

–

*33M 0di&&erent cloc, speeds/ amount

o& memory/ speed o& memory access

and cache si)es1

strlen01

●

Ehould 'e simple enough2 O0n1 %here n is

the num'er o& 'ytes in the string7

int strlen(char +s) /+ source: ,-. +/

{

int n;

for(n = 0; +s != /00/; s++)

{

n++;

}

return n;

}

●

Anyone loo,ed inside strlen recently?

strlen01 – more than you %anted to ,no%

strlen:

1ov ra23rc2 ; ra2 4' string

neg rc2

test ra235 ; test if string is aligned on 67 bits

8e 1ainloo"

2chg a23a2

str1isaligned:

1ov dl3b*te "tr 9ra2: ; read ; b*te

inc ra2

test dl3dl

8e b*te5

test al35

8ne str1isaligned ; loo" until aligned

1ainloo":

1ov r<35=>=>=>=>=>=>=>>h

1ov r;;3<;0;0;0;0;0;0;00h

1ov rd23?@ord "tr 9ra2: ; read < b*tes

1ov rA3r<

add ra23<

add rA3rd2

not rd2

2or rd23rA

and rd23r;;

8e 1ainloo"

1ov rd23?@ord "tr 9ra24<: ; found !ero b*te in the loo"

test dl3dl

8e b*te0 ; is it b*te 0B

test dh3dh

8e b*te; ; is it b*te ;B

shr rd23;0h

...

b*te;:

lea ra239rc2+ra245:

ret

b*te0:

lea ra239rc2+ra24<:

ret

strlen01

●

Nai(ely %e compare time &or2

ti1er.start();

strlen(data;);

ti1er.sto"();

●

$he call appears to ta,e no time at all 7777

●

Notcha2 strlen01 use can 'e optimised a%ay

i& the return (alue is not used7

●

It's important to check you're measuring

what you think you're measuring!

strlen01

●

Eet up a couple o& strings2

char const data;9: = C;C;

char const dataD9: = C;DE7F...65<A0...C;

●

Compare time &or v; = strlen(data;) against

vD = strlen(dataD)

●

Notcha2 strlen01 o& a constant string can 'e

e(aluated at compile time2 O0"1

●

It's important to check you're measuring

what you think you're measuring!

strlen01 - O0n1

Linear and consistent

strlen01 - O0dear1

Oiscontinuous 0and no longer as consistent1

strlen01 - )oom in

strlen01 - small n

$his machine has >#P L" ; ="2P L2 cache per core

strlen01

●

O0n1 to a (ery good approximation &or n

'et%een cache si)e and a(aila'le memory

●

Emall discontinuity around cache si)e

●

O0n1 %hen s%apping/ 'ut the &actor +C+ is

much 'igger 02=! – <!! times 'igger here1

string22&ind01

●

Let+s s%ap o(er &rom using strlen01 to using

string22&ind0+Q!+1

●

8xactly the same sort o& operation 'ut %ith

a (ery slightly more generic algorithm

●

We expect this %ill 'eha(e Fust li,e strlen01

string22&ind01

Eorting

●

Let+s start %ith a 0deterministic1 bogo sort

te1"late %t*"ena1e &'

void bogosort(& begin3 & end)

{

do

{

std::ne2t"er1utation(begin3 end);

} @hile (!std::issorted(begin3 end));

}

●

NEBW

●

O0n R nI1 comparisons

Eorting

●

$imings

"!/!!! items – "7"<ms

2!/!!! items – 27<2ms

<!/!!! items - <7==ms

–

#!/!!! items - #7?2ms

●

O0n1 – 'ut S ho%?

●

4 cheated and set the initial state care&ully

●

Te (ery care&ul a'out 'est and %orst casesI

Eorting

●

$imings 0randomised collection1

●

4 got 'ored a&ter 1 items

●

4t loo,s li,e %e hit a +%all+ at "</"#

Eorting

●

$imings 0randomised collection1

●

Eame graph a&ter ! items

●

Note2 the +%all+ e&&ect depends on scale

Eorting

●

std22sort

–

the 'est ,no%n in C;;

●

Hsort

–

the eHui(alent &or C

●

'u''leUsort

–

easy to explain and demonstrate

●

sta'leUsort

–

retain order o& eHui(alent items

●

partialUsort

–

sort +m+ items &rom +n+

Eorting

●

4 must mention AlgoRythmics – illustrating

sort algorithms %ith Gungarian &ol, dance

●

https2//%%%7youtu'e7com/%atch?(9y%WTy>L=g)@

●

Gelps to gi(e some idea o& ho% the

algorithm works

●

Also sho%s the importance o& the multiplier

" in the &ormula

Eorting

●

C4+d li,e to go 'ac, in time and ,ill the in(entor o&

'u''lesortD - Andrei Alexandrescu

Eorting

●

Nranted

Eorting

●

std22sort is &aster than Hsort

–

don+t tell the C programmers

●

*ou do pay 0a little1 &or sta'ility

●

partialUsort is a Cdar, horseD - do you really need

the full set sorted?

●

$hat %as %ith randomised input

●

A lot o& real data is not randomly sorted

Eorting

●

'u''leUsort+s re(enge

List or (ector?

●

$he complexity o& std22sort is the same as

std22list22sort – so %hat+s the di&&erence?

●

3ust copy the %hole o'Fect in a (ector

●

Can Fust s%ap the pointers in a list

List or (ector?

●

List or (ector?

●

Eo at this data si)e list is o(er t%ice as slo%

as (ector to sort 'ut uses Fust o(er hal& as

many comparisons

●

Perhaps measure sort complexity in other

terms than Fust the num'er o& comparisons

●

Go%e(er note that the items sorted in this

example are Huite small 0%raps an int1

List or (ector?

●

$he per&ormance %ill depend on the si)e o&

the o'Fect 'eing copied

●

With a 'igger o'Fect &ootprint

–

Eame num'er o& comparisons

–

Eame num'er o& pointer s%aps 0list1

–

3ore 'ytes copied 0(ector1

●

Repeat the test %ith a 'igger data structure

0%e %on+t display the V o& comparisons1

List or (ector?

List or (ector?

List or (ector?

●

$his is %hat %e expect2 the per&ormance

depends (ery hea(ily on the si)e o& the

o'Fect 'eing copied

Eo/ in this test on this hard%are/ the 'rea,-

e(en point comes at some%here around

"!! 'ytes &or the o'Fect &ootprint

●

$his is 'igger than 4 %as expecting

●

Bor comparison here is the e&&ect on sorting

the list %hen %e change the o'Fect &ootprint

List or (ector?

List or (ector?

●

$his is less expected2 it is a'out 2 – < times

slo%er to sort a list o& "P' o'Fects than a list

o& int o'Fects7

●

$he only di&&erence is the memory access

pattern2 o'Fects are &urther apart and so

cache use is less e&&icient7

●

Tut once you+re &urther apart than a cache

line 0>#'ytes1 %hy does more si)e still ma,e

a di&&erence?

Tac, to 'asics

●

Allocate a range o& memory and access it

seHuentially %ith +n+ steps o& si)e +m+7

●

$here is an o(erall trend/ o& sorts/ %ith

some anomalies

●

$he speci&ics %ill (ary depending on the

hard%are you+re running on and %ill depend

on 'oth the size and associativity o& the

(arious caches

Tac, to 'asics

Tac, to 'asics

Tac, to 'asics

●

While the speci&ics (ary/ the principle o&

locality is important

●

4& it is multiplicative %ith the algorithmic

complexity it can change the complexity

measure o& the o(erall &unction

Cost o& inserting

●

Euppose %e need to insert data into a

collection and the per&ormance is an

issue

●

What might 'e the e&&ect o& using2

–

std22list

–

std22(ector

–

std22deHue

–

std22set

–

std22multiset

Cost o& inserting

●

std22list Cconstant time insert and erase

operations any%here %ithin the seHuenceD

●

std22(ector Clinear in distance to end o& (ectorD

●

std22deHue Clinear in distance to nearer endD

●

std22set W std22multiset ClogarithmicD

●

We also need the time to &ind the insert point

Cost o& inserting

●

Randomly inserting "!/!!! items2

●

std2list X>!!ms

–

(ery slo% – cost o& finding the insertion

point in the list

●

std22(ector X<?ms

–

3uch &aster than list e(en though %e+re

copying each time %e insert

●

std22deHue X<"!ms

–

Eurprisingly poor – spilling 'et%een 'uc,ets

●

std22set X27>ms our %innerI

Cost o& inserting

●

3ay 'e %orth using a helper collection i& the

target collection is costly to create

–

se std22set as the helper and construct

std2list on completion X#ms

–

se a std22map o& iterators into the list so

list 'uilt in right order X#7@ms

●

$he helper collection %ill increase the

o(erall memory use o& the program

Cost o& sorted inserting

●

4nserting "!/!!! sorted items2

●

std2list X!7@@ms

–

Bast insertion 0at known insert point1

●

std22(ector X!7@=ms 0end1 / >!ms 0start1

–

#uch &aster %hen appending

●

std22deHue X<ms

–

Roughly eHual cost at either endJ a 'it

slo%er than a (ector

●

std22set X2ms 0'et%een (ector and deHue1

Cost o& inserting

●

What a'out order notation e&&ects?

●

4& %e use "!x as many items2

–

std2list X>!!s 0"!!!x1

–

std22(ector X<7?s 0"!!x1

–

std22deHue X<<s 0"!!x1

–

std22set X>>ms 0<<x1

●

$he find cost &or list d%ar&s the insert cost/

%hich is o&ten a hidden complexity

Cost o& inserting

●

Can %e 'eat std22set ?

●

$ry naY(e std22unordered$set01 - (ery

slightly slo%er at "!P 0X27@ms (s

X27>ms1 'ut 'etter at "!!P 0X#>ms (s

X>>ms1

●

Go%e(er/ in this particular case %e ha(e

additional ,no%ledge a'out our (alue set

and so can use a trivial hash &unction

●

No% std22unorderedUset01 ta,es X27<ms

0"!P1 and X<@ms 0"!!P1

Conclusion

●

$he algorithm %e choose is o'(iously

important &or the o(erall per&ormance o&

the operation 0measured as elapsed time1

●

As data si)es increase %e e(entually hit the

limits o& the machineJ the 'est algorithms

are those that in(ol(e least s%apping

●

Bor smaller data si)es the characteristics o&

the cache %ill ha(e some e&&ect on the

per&ormance

Conclusion

●

While complexity measure is a good tool %e

must 'ear in mind2

●

What are N 0the rele(ant si)e1 and C 0the

multiplier1?

●

Ga(e %e identi&ied the &unction %ith the

dominant complexity?

●

Can %e re-de&ine the pro'lem to reduce the

cost?

3a,ing it &aster

●

We+(e seen a &e% examples already o&

ma,ing things &aster7

●

Compile-time e(aluation o& strlen01 turns

O0n1 into O0"1

–

Can you pre-process 0or cache1 ,ey

(alues?

–

E%apping setup cost or memory use

&or runtime cost

3a,ing it &aster

●

Oon+t calculate %hat you don+t need

●

We sa% that/ i& you only need the top +n+/

partialUsort is typically much &aster than a

&ull sort

●

4& you ,no% something a'out the

characteristics o& the data then a more

speci&ic algorithm might per&orm 'etter

–

strlen01 (s &ind01

–

Eorting nearly sorted data

–

+$ri(ial+ hash &unction

3a,ing it &aster

●

Pic, the 'est algorithm to %or, %ith

memory hard%are

–

Pre&er seHuential access to memory

–

Emaller is 'etter

–

Eplitting compute-intensi(e data items

&rom the rest can help – at a slight

cost in the complexity o& the program

logic and in memory use

Eome other re&erences

●

Ecott 3eyers at ACC CCP cachesD2

http2//%%%7aristeia7com/$al,Notes/ACC2!""UCPCaches7pd&

●

lrich Orepper CWhat 8(ery Programmer Ehould

Pno% A'out 3emoryD2

http2//people7redhat7com/drepper/cpumemory7pd&

●

Ger' Eutter+s experiments %ith containers2

http2//%%%7got%7ca/got%/!=#7htm

●

and loo,ing at memory use2

http2//%%%7got%7ca/pu'lications/mill"#7htm

●

TFarne Etroustrup+s (ector (s list test2

http2//'ulldo)er!!7com/2!"2/!2/!A/(ectors-and-lists/ 0esp slides #<-#?1

●

Taptiste Wicht+s list (s (ector 'enchmar,s2

http2//%%%7'aptiste-%icht7com/2!"2/"2/cpp-'enchmar,-(ector-list-deHue/

- DsSortUploaded bymanuelq9
- Px c 3883363Uploaded byWidya Utami
- 2.3.1 HodderUploaded byportable
- scriiiiiUploaded byParikshit Ahir
- AOA AssignmentsUploaded by9chand3
- Bidirectional Conditional Insertion Sort algorithm; An efficient progress on the classical insertion sortUploaded byhenderson
- Sorting AlgorithmsUploaded bybhaskar_chintakindi
- Merge SortUploaded byMuhammad Shery
- Computer Algoritham for Chennai Univarcity Unit 1 And2Uploaded bys.mohamed meeran patel
- ACM SyllabusUploaded byHassan Mahfuj
- Unit 06_DSC_PPTUploaded byamreen786
- Sequential and Parallel Sorting AlgorithmsUploaded bykesharwanidurgesh
- SortingUploaded byJonathanLivingston
- Convex HullUploaded bybsudheertec
- Week 7 NotesUploaded bytest
- CS2251DAA2MARKSUploaded bysenathipathik
- Algorithm AnalysisUploaded byTalha Gondal
- data-structures-a-algorithms-multiple-choice-questions-mcqs-objective-set-2Uploaded bytrojan100t
- Black HoleUploaded byGajju Chautala
- lec19Uploaded byMuthukumaran Chandrasekaran
- exam2s13keyUploaded byZahraa Tishreen
- exam2AUploaded byvirpara
- NEW DSUploaded byNarendra Rajput
- Edusat LectUploaded byAbul Hasan
- Enhanced+Search+Widget+URL+Search+ConfigurationUploaded byKarim El Maanani
- Fastexp CopyUploaded bysalafyun
- Tcs Assignment 1Uploaded byAbhi Manyu
- Algorithm SyllabusUploaded byashrafcheru
- Notas x BMerge.pdfUploaded byManuel Pérez
- CourseHandOut_Data Structures and Algorithms DesignUploaded byASIF VORA

- OpenCL Static C++ Kernel Language ExtensionUploaded byStewart Henderson
- Jeffrey Dean CSE Summa Sum1990Uploaded byStewart Henderson
- Cyclic Test Performance MeasurementUploaded byStewart Henderson
- Optimizing sleep to maximize performance: implications and recommendations for elite athletesUploaded byStewart Henderson
- Effect of Green Tea Catechins on Plasma Cholesterol Level in Cholesterol-Fed RatsUploaded byStewart Henderson
- A climbing image nudged elastic band method for finding saddle points and minimum energy pathsUploaded byStewart Henderson
- Cooperative Control of Mobile Sensor Networks: Adaptive Gradient Climbing in a Distributed EnvironmentUploaded byStewart Henderson
- Loop Recognition in C++/Java/Go/ScalaUploaded byStewart Henderson
- Azure Cosmos Db 2-Cheat Sheet v4-LetterUploaded byStewart Henderson
- Maximum Entropy Modeling Toolkit for Python and C++Uploaded byStewart Henderson
- Meta Optimization: Improving Compiler Heuristics with Machine LearningUploaded byStewart Henderson
- ROOT — A C++ Framework for Petabyte Data Storage, Statistical Analysis and VisualizationUploaded byStewart Henderson
- The Max Min Hill Climbing Bayesian Network Structure Learning AlgorithmUploaded byStewart Henderson
- A Sparse Matrix Library in C++ for High Performance ArchitecturesUploaded byStewart Henderson
- Climbing the Density Functional Ladder: Non-Empirical Meta-Generalized Gradient Approximation Designed for Molecules and SolidsUploaded byStewart Henderson
- Rcpp: Seamless R and C++ IntegrationUploaded byStewart Henderson
- Swirlz MenuUploaded byStewart Henderson
- A Sparse Matrix Library in C++ for High Performance ArchitecturesUploaded byStewart Henderson
- Cool ManualUploaded byStewart Henderson
- Algorithm 871: A C/C++ Precompiler for Autogeneration of Multiprecision ProgramsUploaded byStewart Henderson
- AttackingAV_syscan08hkUploaded byStewart Henderson
- Opcode64 PreviewUploaded byStewart Henderson
- ET++ - An Object-Oriented Application Framework in C++Uploaded byStewart Henderson
- s18-dasUploaded byStewart Henderson
- Topographica: building and analyzing map-level simulations from Python, C/C++, MATLAB, NEST, or NEURON componentsUploaded byStewart Henderson
- FSA: An Efficient and Flexible C++ Toolkit for Finite State Automata Using On-Demand ComputationUploaded byStewart Henderson
- Opcode32 PreviewUploaded byStewart Henderson
- 64 Ia 32 Architectures Software Developer Manual 325462Uploaded byStewart Henderson
- A Practical Flow-Sensitive and Context-Sensitive C and C++ Memory Leak DetectorUploaded byStewart Henderson