When writing shader or during any procedural creation process (texturing, modeling, shading, animation...) you often find yourself modifying signals in different ways so they behave the way you need. It is common to use smoothstep() to threshold some values, or pow() to shape a signal, or clamp() to clip it, fmod() to make it repeat, a mix() to blend between two signals, exp() for attenuatation, etc etc. All these functions are often conveniently available by default in most languages. However there are some operations that are also relativelly used that don't come by default in any language. The following is a list of some of the functions that I find myself using over and over again:

float almostIdentity( float x, float m, float n )
{
if( x>m ) return x;
const float a = 2.0*n - m;
const float b = 2.0*m - 3.0*n;
const float t = x/m;
return (a*t + b)*t*t + n;
}

An extra nice thing is that this function can be used, unaltered, as an smooth-abs() function, which comes handy for symmetric funtions such as mirrored SDFs.

float almostIdentity( float x, float n )
{
return sqrt(x*x+n);
}

float almostUnitIdentity( float x )
{
return x*x*(2.0-x);
}

float integralSmoothstep( float x, float T )
{
if( x>T ) return x - T/2.0;
return x*x*x*(1.0-x*0.5/T)/T/T;
}

float expImpulse( float x, float k )
{
const float h = k*x;
return h*exp(1.0-h);
}

float quaImpulse( float k, float x )
{
return 2.0*sqrt(k)*x/(1.0+k*x*x);
}

You can easily generalize it to other powers to get different falloff shapes, where

float polyImpulse( float k, float n, float x )
{
return (n/(n-1.0))*pow((n-1.0)*k,1.0/n)*x/(1.0+k*pow(x,n));
}

These generalized impulses peak at x = [k(n-1)]

float expSustainedImpulse( float x, float f, float k )
{
float s = max(x-f,0.0)
return min( x*x/(f*f), 1+(2.0/f)*s*exp(-k*s));
}

float cubicPulse( float c, float w, float x )
{
x = fabs(x - c);
if( x>w ) return 0.0;
x /= w;
return 1.0 - x*x*(3.0-2.0*x);
}

float expStep( float x, float k, float n )
{
return exp( -k*pow(x,n) );
}

float gain(float x, float k)
{
const float a = 0.5*pow(2.0*((x<0.5)?x:1.0-x), k);
return (x<0.5)?a:1.0-a;
}

float parabola( float x, float k )
{
return pow( 4.0*x*(1.0-x), k );
}

float pcurve( float x, float a, float b )
{
const float k = pow(a+b,a+b)/(pow(a,a)*pow(b,b));
return k*pow(x,a)*pow(1.0-x,b);
}

Note that

float sinc( float x, float k )
{
const float a = PI*((k*x-1.0);
return sin(a)/a;
}