Expressions, ready to copy.

ratio = 16 / 9;
[value[0], value[0] / ratio];

fadeDuration = .5 ; // Set the duration of your "Fade"
fadeIn = linear(time, inPoint, inPoint + fadeDuration, 0, 100);
fadeOut = linear(time, outPoint - fadeDuration, outPoint, 0, 100);
fadeIn-fadeOut;

dur = 0.5;
linear(outPoint - time, 0, dur, 0, 100);

e = .5; //elasticity
g = 1000; //gravity
nMax = 5; //number of bounces allowed
n = 0;
if (numKeys > 0){ n = nearestKey(time).index; if (key(n).time > time) n--;
}
if (n > 0){ t = time - key(n).time; v = -velocityAtTime(key(n).time - .001)*e; vl = length(v); if (value instanceof Array){ vu = (vl > 0) ? normalize(v) : [0,0,0];
}else{ vu = (v < 0) ? -1 : 1; } tCur = 0; segDur = 2*vl/g; tNext = segDur; nb = 1; // number of bounces while (tNext < t && nb <= nMax){ vl *= e; segDur *= e; tCur = tNext; tNext += segDur; nb++ } if(nb <= nMax){ delta = t - tCur; value + vu*delta*(vl - g*delta/2); }else{ value }
}else value

timeToStart = .5; if (time > timeToStart) {
maxDev = 30; // max deviation in pixels
spd = 30; //speed of oscillation
decay = 1.0; //how fast it slows down
t = time - inPoint;
x = scale[0] + maxDev*Math.sin(spd*t)/Math.exp(decay*t);
y = scale[0]*scale[1]/x;
[x,y]
} else { value; }

clamp(value, 0, 100);

time * 100;

nLoops = 10;
if (numKeys > 1){
loopDur = key(numKeys).time - key(1).time;
n = Math.floor((time - key(1).time)/loopDur);
if (n < nLoops){
t = (time - key(1).time)%loopDur;
valueAtTime(key(1).time + t);
}else{
valueAtTime(key(numKeys).time);
}
}else
value;

delay = 5; // number of delayed frames
d = delay*thisComp.frameDuration*(index - 1);
thisComp.layer(1).rotation.valueAtTime(time - d)

loopIn() + loopOut() - value; // You can put "pingpong" or "offset" in the brackets to suit your needs.

ease(time, 0, 2, 0, 100);

dur = 0.5;
linear(time - inPoint, 0, dur, 0, 100);

n = 0;
if (numKeys > 1) {
  n = nearestKey(time).index;
  if (nearestKey(time).time > time) n--;
}
if (n == 0) { t = 0; }
else { t = time - key(n).time; }
if (n > 0 && t < 1) {
  v = velocityAtTime(key(n).time - thisComp.frameDuration / 10);
  amp = 0.05; freq = 3; decay = 8;
  v * amp * Math.sin(freq * t * 2 * Math.PI) / Math.exp(decay * t);
} else { 0; }

linear(time, 0, 2, 0, 100);

frequency = 2;
amplitude = 40;
secondsToLoop = 3; // loop duration in seconds
// --------
t = time % secondsToLoop;
wiggle1 = wiggle(frequency, amplitude, 1, 0.5, t);
wiggle2 = wiggle(frequency, amplitude, 1, 0.5, t - secondsToLoop);
linear(t, 0, secondsToLoop, wiggle1, wiggle2)/* Replace by for scale:w=linear(t, 0, secondsToLoop, wiggle1, wiggle2);
[w[0], w[0]] */

loopIn("cycle");

loopIn("cycle", 0);
loopOut("cycle", 0);

loopOut("cycle");

loopOut("continue");

loopOut("pingpong");

if (numKeys > 1 && time > key(numKeys).time) {
  t1 = key(1).time;
  t2 = key(numKeys).time;
  span = t2 - t1;
  delta = time - t2;
  t = delta % span;
  valueAtTime(t1 + t);
} else {
  value;
}

cx = thisComp.width / 2;
cy = thisComp.height / 2;
[2 * cx - value[0], value[1]];

posterizeTime(12); value;

posterizeTime(12);
loopOut('cycle');

posterizeTime(8);
wiggle(3, 20);

on = 100;
off = 0;
x = wiggle(5,50)
if (x>50) onelse off

seedRandom(index, true);
random(50, 200);

Math.abs(wiggle(10, 50));

freq=1;
amp=50;
wind = amp*Math.sin(time*freq*2*Math.PI);
[transform.position[0],(height/2)+wind]

smooth(0.2, 5);

wiggle(5, 30);

freq = 2;
amp = 30;
dur = 4;
t = Math.floor(time / dur) * dur;
seedRandom(Math.floor(time / dur), true);
wiggle(freq, amp);

min = 0;
max = 30;
freq = 1; // Number of oscillations per second
avgVal = (min + max)/2;
amp = (max - min)/2
avgVal + amp *(Math.sin(time*freq*Math.PI*2))

frequency = 2;
amplitude = 10;
w = wiggle(frequency, amplitude);
[w[0],value[1]]

y=value[1]-sourceRectAtTime(time).height/2;
[0,y]

thisComp.name;

"$" + Math.round(effect("Slider Control")("Slider"));

val = effect("Slider Control")("Slider");
totalSec = Math.max(0, Math.round(val));
m = Math.floor(totalSec / 60);
s = totalSec % 60;
function pad(n) { return n < 10 ? "0" + n : "" + n; }
pad(m) + ":" + pad(s);

Math.floor(time * thisComp.frameRate);

d = new Date(Date(0));
// Format parameter
divider = "/"
yearLength = 2; // use 2 for one year AA format, 4 for AAAA format
function padZeros(n){ if(n <= 9){ return "0" + n; } return n
}
yearTrim = (yearLength===2) ? 2 : 0;
"" + padZeros(d.getMonth()+1) + divider + padZeros(d.getDate()) + divider + d.getFullYear().toString().substring(yearTrim,4);

num = effect("Slider Control")("Slider").value;
finalVal = num * 0.01;
finalVal.toFixed(2);

num = effect("Slider Control")("Slider").value;
num.toFixed(2);

s = Math.round(effect("Slider Control")("Slider")).toString();
while (s.length < 3) s = "0" + s;
s;

num = value;
num.toLocaleString();

Math.round(effect("Slider Control")("Slider")) + "%";

s = "ABC#!@012";
s[Math.floor(random(s.length))];

Math.round(effect("Slider Control")("Slider"));

t = time;
h = Math.floor(t / 3600);
m = Math.floor((t % 3600) / 60);
s = Math.floor(t % 60);
f = Math.floor((t % 1) * thisComp.frameRate);
function pad(n) { return n < 10 ? "0" + n : "" + n; }
pad(h) + ":" + pad(m) + ":" + pad(s) + ":" + pad(f);

thisLayer.name;

var hour = Math.floor((time/60)/60);
var min = Math.floor(time/60);
var sec = Math.floor(time);
var mili = Math.floor(time*60);
if (mili > 59){ mili = mili - sec*60; }
if (mili < 10){ mili = "0" + mili; } if (sec > 59){ sec = sec - min*60; }
if (sec < 10){ sec = "0" + sec; } if (min >= 59){ min = min - hour*60; }
if (min < 10){ min = "0" + min; }
if (hour < 10){ hour = "0" + hour; }
//Output
hour + ' : ' + min + ' : ' + sec + ' : ' + mili;

// Start and end variables (can be modified)
var startAt = 0; var endAt = 9; // Text part
var maxLetters = Math.floor(linear(time, startAt, endAt, 0, value.length));
var result = value.substring(0, maxLetters);
result

value.substr(0, Math.round(effect('Slider Control')('Slider')));

Math.floor(time * 2) % 2 === 0 ? 100 : 0;

value.toUpperCase();

/* 1 */
box=thisComp.layer("dfd").sourceRectAtTime();
Width=box.width;
Height=box.height;
p=effect("Slider Control")("Slider");
x=Width+p;
y=Height+p;
[x,y] /* 2 */
box=thisComp.layer("dfd").sourceRectAtTime();
Width=box.width;
Height=box.height;
Top=box.top;
Left=box.left;
p=effect("Slider Control")("Slider");
x=Width/-2-Left;
y=Height/-2-Top;
[x,y]

textW = thisLayer.sourceRectAtTime(time, false).width;
maxW = 800;
if (textW > maxW) {
  s = (maxW / textW) * 100;
  [s, s];
} else {
  [100, 100];
}

t = thisComp.layer("Text Layer");
w = t.sourceRectAtTime().width;
h = t.sourceRectAtTime().height;
[w, h];

(thisProperty.propertyGroup(1).copies - 1) / -2

radius = 200;
speed = 1;
angle = time * speed * 2 * Math.PI;
cx = thisComp.width / 2;
cy = thisComp.height / 2;
[cx + Math.cos(angle) * radius, cy + Math.sin(angle) * radius];

padding = 150;
[value[0], value[1] + (index - 1) * padding];

length(toComp([0,0]), toComp([0.7071,0.7071])) || 0.001;

s = transform.scale[0];
value * (100 / s);

cols = 3;
padX = 200;
padY = 150;
col = (index - 1) % cols;
row = Math.floor((index - 1) / cols);
startX = thisComp.width / 2 - (cols - 1) * padX / 2;
startY = 200;
[startX + col * padX, startY + row * padY];

[thisComp.width,thisComp.height] * 0.5;

val = effect("Slider Control")("Slider");
val / 100;

val = effect("Slider Control")("Slider");
maxW = 600;
[maxW * (val / 100), value[1]];

amp = 20;
freq = 2;
s = 100 + amp * Math.sin(time * freq * 2 * Math.PI);
[s, s];

x = transform.position[0];
y = transform.position[1];
w = thisComp.width;
h = thisComp.height;
margin = 100;
outside = (x < margin || x > w - margin || y < margin || y > h - margin);
outside ? Math.abs(Math.sin(time * 8)) * 100 : 0;

t = thisComp.layer("Text Layer");
r = t.sourceRectAtTime(time, false);
pad = 50;
[r.width + pad * 2, r.height + pad * 2];

grid = 50;
[Math.round(value[0] / grid) * grid, Math.round(value[1] / grid) * grid];

radius = 40 + time * 50;
speed = 2;
angle = time * speed * 2 * Math.PI;
[thisComp.width/2 + Math.cos(angle) * radius, thisComp.height/2 + Math.sin(angle) * radius];

check = comp("MAIN").layer("CONTROL_PANEL").effect("Checkbox Control")("Checkbox");
(check == 1) ? 100 : 0;

value * effect("Control Name")("Checkbox"); // replace by your checkbox effect

comp("MAIN").layer("CONTROL_PANEL").effect("Color Control")("Color");

comp("MAIN").layer("CONTROL_PANEL").transform.position;

comp("MAIN").layer("CONTROL_PANEL").effect("Slider Control")("Slider");

idx = effect("Index Control")("Slider");
idx == 1 ? 100 : idx == 2 ? 50 : 0;

fromComp(thisComp.layer("Parent").toComp([0, 0]));

select = effect("Dropdown Control")("Menu").value;

toComp([0, 0, 0]);

thisComp.layer("3D Layer Name").toComp([0,0,0]);

Math.sin(time * 10) > 0 ? 100 : 0;

startFade = 500; // Start fade 500 pixels from camera. endFade = 1500; // End fade 1500 pixels from camera. try{ // Check whether there's a camera. C = thisComp.activeCamera.toWorld([0,0,0]); }catch(err){ // No camera, so assume 50mm. w = thisComp.width * thisComp.pixelAspect; z = (w/2)/Math.tan(degreesToRadians(19.799)); C = [0,0,-z]; } P = toWorld(anchorPoint); d = length(C,P); linear(d,startFade,endFade,100,0)

delay = 0.1;
offset = (index - 1) * delay;
baseOpacity = thisComp.layer("Leader").transform.opacity.valueAtTime(time - offset);
baseOpacity * (1 - (index - 1) * 0.15);

delay = 0.08;
offset = (index - 1) * delay;
thisComp.layer("Leader").transform.position.valueAtTime(time - offset);

delay = 0.08;
offset = (index - 1) * delay;
thisComp.layer("Leader").transform.scale.valueAtTime(time - offset);

value - parent.transform.rotation

v = thisComp.layer("Target").transform.position - transform.position;
radiansToDegrees(Math.atan2(v[1], v[0]));

magnetPos = thisComp.layer("MAGNET").transform.position;
strength = thisComp.layer("MAGNET").effect("Strength")("Slider") / 100;
lerp(value, magnetPos, strength);

master = thisComp.layer("WAVE_MASTER");
amp = master.effect("Wave Amplitude")("Slider");
phase = master.effect("Wave Phase")("Slider");
freq = 2;
phaseOffset = (index - 1) * 0.3;
wave = amp * Math.sin(time * freq * 2 * Math.PI + phaseOffset + phase);
[100 + wave, 100 + wave];

d = length(thisComp.layer("Trigger").transform.position, transform.position);
if (d < 200) 100; else 20;

d = length(thisComp.layer("Attractor").transform.position, transform.position);
maxDist = 400;
s = linear(d, 0, maxDist, 150, 100);
[s, s];

rowSize = 4;
row = Math.floor((index - 1) / rowSize);
shiftSlider = thisComp.layer("WAVE_MASTER").effect("Wave Phase")("Slider");
rowOffset = row * 0.5;
amp = 80;
amp * Math.sin(time * 2 * Math.PI + rowOffset + shiftSlider);

thisComp.layer("Video").sampleImage(transform.position, [1,1]);

seedRandom(index, true);
wiggle(2, 40);

mass = 20;
stiffness = 50;
damping = 8;
fps = 1 / thisComp.frameDuration;
numInt = 16;
dt = 1 / (fps * numInt);
x = position;
v = velocity;
for (i = 0; i < numInt; i++) {
  f = -stiffness * (x - value) - damping * v;
  a = f / mass;
  v += a * dt;
  x += v * dt;
}
x;

delay = 0.08;
offset = (index - 1) * delay;
numKeys > 0 ? thisProperty.valueAtTime(time - offset) : value;

fps = 6;
posterizeTime(fps);
wiggle(1, 50);

n=0;
if(marker.numKeys>0) { n=marker.nearestKey(time).index; if(marker.key(n).time>time) { n--; } if(n==0) { value; } else { t=time-marker.key(n).time; //time since marker //Do Stuff }
} else { value;
}

v = velocity;
radiansToDegrees(Math.atan2(v[1], v[0]));

val = effect("Slider Control")("Slider");
rounded = Math.round(val * 10) / 10;
prefix = rounded >= 0 ? "+" : "";
prefix + rounded + "%";

master = thisComp.layer("GRAPH_MASTER");
val = master.effect("Bar 1 Value")("Slider");
thresh = 50;
low  = [0.9, 0.2, 0.2, 1];
mid  = [1.0, 0.75, 0.1, 1];
high = [0.2, 0.8, 0.3, 1];
val < thresh * 0.5 ? low : val < thresh ? mid : high;

val = effect("Slider Control")("Slider");
sym = "$";
sym + Math.round(val).toLocaleString();

master = thisComp.layer("GRAPH_MASTER");
val = master.effect("Bar 1 Value")("Slider");
[80, Math.abs(val)];

frames = 10;
total = 0;
for (i = 0; i < frames; i++) {
  total += effect("Slider Control")("Slider").valueAtTime(time - i * thisComp.frameDuration);
}
total / frames;

val = Math.abs(effect("Slider Control")("Slider"));
if (val >= 1000000000) {
  (val / 1000000000).toFixed(1) + "B";
} else if (val >= 1000000) {
  (val / 1000000).toFixed(1) + "M";
} else if (val >= 1000) {
  (val / 1000).toFixed(1) + "K";
} else {
  Math.round(val).toString();
}

val = effect("Slider Control")("Slider");
minVal = 0; maxVal = 100;
minX = -300; maxX = 300;
minY = 100; maxY = -100;
x = linear(val, minVal, maxVal, minX, maxX);
y = linear(val, minVal, maxVal, minY, maxY);
[x, y];

total = effect("Total")("Slider");
part  = effect("Part")("Slider");
frac  = total > 0 ? part / total : 0;
maxH  = 300;
[80, maxH * frac];

baseColor = [0.4, 0.6, 1.0, 1];
depth = (index - 1);
darkness = Math.max(0, 1 - depth * 0.06);
[baseColor[0] * darkness, baseColor[1] * darkness, baseColor[2] * darkness, 1];

depthStep = 4;
[value[0] + (index - 1) * depthStep * 0.866, value[1] + (index - 1) * depthStep * 0.5];

scaleX = 100;
scaleY = 57.735;
[scaleX, scaleY];

// Scale
[100, 57.735];
// Then set Rotation to +45 degrees

// Scale - flip X to mirror
[-100, 57.735];
// Then set Rotation to -45 degrees

// Scale
[100, 57.735];
// Then set Rotation to -45 degrees manually

zCtrl = thisComp.layer("ISO_Z_CONTROLLER");
zh = zCtrl.effect("Z-Height")("Slider");
base = [value[0], value[1]];
[base[0], base[1] - zh * 0.5];

amp = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");
[100 + amp, 100 + amp];

bpm = 120;
freq = bpm / 60;
beat = Math.floor(time * freq);
phase = time * freq - beat;
amp = 30;
s = 100 + amp * Math.pow(1 - phase, 3);
[s, s];

leftAmp  = thisComp.layer("Audio Amplitude").effect("Left Channel")("Slider");
rightAmp = thisComp.layer("Audio Amplitude").effect("Right Channel")("Slider");
[100 + leftAmp, 100 + rightAmp];

val = effect("Slider Control")("Slider");
t = val / 127;
r = Math.abs(Math.sin(t * Math.PI));
g = Math.abs(Math.sin(t * Math.PI + 2.094));
b = Math.abs(Math.sin(t * Math.PI + 4.189));
[r, g, b, 1];

amp = 40;
freq = 3;
phase = (index - 1) * 0.25;
[value[0], value[1] + amp * Math.sin(time * freq * 2 * Math.PI + phase)];

a = thisComp.layer("Point B").transform.position;
b = thisComp.layer("Point A").transform.position;
v = a - b;
radiansToDegrees(Math.atan2(v[1], v[0])) + 90;

dashOffset = time * 200;
dashOffset;

a = thisComp.layer("Node A").transform.position;
b = thisComp.layer("Node B").transform.position;
mid = [(a[0]+b[0])/2, (a[1]+b[1])/2];
dist = length(a, b);
angle = radiansToDegrees(Math.atan2(b[1]-a[1], b[0]-a[0]));
// Apply mid to Position, dist to Scale X, angle to Rotation

start = thisComp.layer("Route Start").transform.position;
end = thisComp.layer("Route End").transform.position;
pct = effect("Progress")("Slider") / 100;
lerp(start, end, pct);

v = length(velocity);
Math.round(v) + " px/s";