Written By: ph34r

A quick cheat sheet for programmers who want to do shell
scripting. This is not intended to teach programming, etc. but
it is intended for a someone who knows one programming language
to begin learning about bash scripting.

Basics

All bash scripts must tell the o/s what to use as the
interpreter. The first line of any script should be:

#!/bin/bash

You must make bash scripts executable.

chmod +x filename

Variables

Create a variable – just assign value. Variables are
non-datatyped (a variable can hold strings, numbers, etc. with
out being defined as such).

varname=value

Access a variable by putting $ on the front of the name

echo $varname

Values passed in from the command line as arguments are
accessed as $# where #= the index of the variable in the array
of values being passed in. This array is base 1 not base 0.

command var1 var2 var3 …. varX

$1 contains whatever var1 was, $2 contains whatever var2 was,
etc.

Built in variables:

Quote Marks

Regular double quotes (“like these”) make the shell ignore
whitespace and count it all as one argument being passed or
string to use. Special characters inside are still
noticed/obeyed.

Single quotes ‘like this’ make the interpreting shell ignore
all special characters in whatever string is being passed.

The back single quote marks (`command`) perform a different
function. They are used when you want to use the results of a
command in another command. For example, if you wanted to set
the value of the variable contents equal to the list of files
in the current directory, you would type the following command:
contents=`ls`, the results of the ls program are put in the
variable contents.

Logic and comparisons

A command called test is used to evaluate conditional
expressions, such as a if-then statement that checks the
entrance/exit criteria for a loop.

test expression

Or

[ expression ]

Numeric Comparisons

String Comparisons

File Comparisons

Expression Comparisons

!expression

Returns true if expression is not true

expr1 -a expr2

Returns True if expr1 and expr2 are true. ( && , and
)

expr1 -o expr2

Returns True if expr1 or expr2 is true. ( ||, or )

Logic Con’t.

If…then

if [ expression ]

then

commands

fi

If..then…else

if [ expression ]

then

commands

else

commands

fi

If..then…else If…else

if [ expression ]

then

commands

elif [ expression2 ]

then

commands

else

commands

fi

Case select

case string1 in

str1)

commands;;

str2)

commands;;

*)

commands;;

esac

string1 is compared to str1 and str2. If one of these strings
matches string1, the commands up until the double semicolon (;
are executed. If neither str1 nor str2 matches string1, the
commands associated with the asterisk are executed. This is the
default case condition because the asterisk matches all
strings.

Iteration (Loops)

for var1 in list

do

commands

done

This executes once for each item in the list. This list can be
a variable that contains several words separated by spaces
(such as output from ls or cat), or it can be a list of values
that is typed directly into the statement. Each time through
the loop, the variable var1 is assigned the current item in the
list, until the last one is reached.

while [ expression ]

do

commands

done

until [ expression ]

do

commands

done

Functions

Create a function:

fname(){

commands

}

Call it by using the following syntax: fname

Or, create a function that accepts arguments:

fname2 (arg1,arg2…argN){

commands

}

And call it with: fname2 arg1 arg2 … argN

Orignal Location  :http://linux-sxs.org/programming/bashcheat.html

• Program according to standards
• Use intrinsics

• Use inline, embedded assembly
• Use Toolchain specific things.

Example Compilation
GCC Command line

gcc -mcpu=Cortex-A8 -mfloat-abi=softfp -O3 …

RVCT Command line

armcc -cpu=Cortex-A8 -vfp=softvfp+vfpv3 -O3  -Otime …

The ABI for the ARM Architecture is a standard developed by ARM and its partners that explains how compilers, assemblers, linkers, and other similar tools should generate object files and executable files. The “ARM EABI” is an informal name for the ABI for the ARM Architecture.

Portability and Optimizations of GNU Applications for ARM Embedded Linux – http://tree.celinuxforum.org/CelfPubWiki/ELCEurope2008Presentations?action=AttachFile&do=get&target=ARM_EmbeddedLinux_Apps_Port.pdf

ARM NEON technology is a 128 bit SIMD (Single Instruction, Multiple Data)
architecture extension for the ARM CortexTM-A series processors, designed to provide flexible and powerful acceleration for intensive multimedia applications, thereby delivering a significantly enhanced user experience.

Some of the benefits…

• Aligned and unaligned data access allows for efficient vectorization of SIMD operations.
• Support for both integer and floating point operations
• Tight coupling to the ARM core provides a single instruction stream and a unified view of memory, presenting a single development platform target with a simpler tool flow.
• The large NEON register file with its multiple views enables efficient handling of data and minimizes access to memory, enhancing data throughput performance.

Reference:

Portability and Optimizations of GNU Applications for ARM Embedded Linux – http://tree.celinuxforum.org/CelfPubWiki/ELCEurope2008Presentations?action=AttachFile&do=get&target=ARM_EmbeddedLinux_Apps_Port.pdf

Of Course all of these do most of the major stuff

http://www.realvnc.com/cgi-bin/download.cgi

An n – norm is defined as

The most common norm is &

= rms value

and

= max( |u(t)| )

The creast factor of a non-zero signal is defined as the ratio of peak to rms value

CF(u) = 1

A CF of 1 indicates a signal which only stays at

Therefore a signal with a low crest factor spends most of the time near the peek values.

A creast factor of 1 implies a square wave of amplitude

In terms of amplitude distribution –

, where is the total length of set E

the proportion of the time a where |u(t)| > a

= min{a|=0}

and

Which is a weighted integral of the amplitude distribution or if we plot a graph of vs a, is the

todo: update the crest factor definition in Wiki http://en.wikipedia.org/wiki/Normed_vector_space

Crest factor of a multi-tone Signal

For a following multitone signal with N tones

We have mean, = , regardless of phase

The goal is to minimize the crest factor

+ Libraries
+ Android runtime
- Dalbik VM (JAva VM improved – memory optimized etc.)
+ Applications
- Primarily in Java ->

Eclipse Based Development with Android Plugin for ARM platforms

Applications
+ No Main entry Point
+ Provides
- Activity (has UI)
- Services ( no UI)
- Broadcast reciver (broadcast message)
- Content Provider (makes data aviable to other application)
+ AndroidManifest.xml – define program

android presentation from mentor graphics

http://cnx.org/content/m11714/latest/

• Voiced Signals : high energy – low frequency (low zero crossing)
• Unvoiced Signals : low energy – high frequency (big zero crossing)
• Noise : Low energy + low frequency (overall low zero crossing)

Vowels :

Consonants :

formants : Peak of frequency spectrum

LPC
Another method, which is used to obtain a frequency spectrum is that of Linear Predictive Coding(LPC). This is the most successful method in widespread use today. The idea behind LPC is that the values of the signal can be expressed as a linear combination of the preceding values. That is, if s(i) is the amplitude at time i,
s(i) = a1*s(i-1) + a2*s(i-2) + … + ap*s(i-p)
When the input data is filled in, this becomes a system of linear equations which can be solved to determine the values of a1 through ap. These values then produce a very noise free signal, which clearly identifies the formants. Typical values for p are 10-12.

http://www.cs.dartmouth.edu/~dwagn/aiproj/speech.html

Easy Solution: Floating point representation of a number separates the number into an exponent, a sign and a mantissa. The number represented is then N=M*2^E.

The log of that number would be LOG(N)=LOG(M * 2^E)=LOG(M) + E*LOG(2). If we assume M is normalized, 1<=M<2, then 0 <=LOG(M) <=LOG(2). The LOG of the exponent gives us the coarse estimate of the LOG (to 6dB), which can be found by just multiplying the exponent by a constant (LOG(2) in the appropriate base). (A constant offset may need to be added to the exponent e.g. for IEEE representation we need to compensate for offset of 128 in offset)

For Finer precision obtain an estimate of the log of mantissa and add that to the logarithm of the exponent. The logarithm of the mantissa can be found using a small look-up table addressed by the most significant bits of M. By only using 32 entry long table (5 bits) an accuracy of around 0.25 dB can be obtained.

Other Log for floating point notes from the web

• DSP Trick: Quick-and-Dirty Logarithms
• Fast Logarithms on a Floating-Point Device
• Fast Logarithms on a Floating-Point Device