I tweaked the method of compiling 1D LUTs. This is how you do it.

The free/learning version of Nuke does the job, so get hold of any version from the last few years. Only one node is required, so you don't have to get bogged down with Nuke's intimidating infrastructure. Once launched, select a ColorLookup node.

Select Red, Green, and Blue from the list on the left.

Right-click in the middle, and select Edit > Edit Expression

The following little table pops up.

Paste an expression into each channel space. Here I pasted the Cineon Log to Linear expression, the result on the right representing the output value when the input value is 1.

This is the resulting curve.

Next, right-click the middle and select File > Export Ascii

Another little table pops up. The default increment will be 1/255, but that's only 8bit, so to get 14bit enter 16383 (because 0 is also counted as a value, so 16384 is still achieved)

When exporting values, the very last one is omitted for some reason, so change End at: to 1.00001 and the last value gets included.

This is the first set of values of the exported list. Note the first value.

This is the last set of values. Note the final value, and also note that the list goes right up to 16384. Full 14bit.

Press the node's reset button, then repeat the initial procedure, this time entering the inverse expression (Linear to Cineon Log).

A little extra work is required for the next step. The Start at and End at values correspond with the first and last values from the previous exported list. The increment value of 1 is replaced by the full extent of the previous export expansion. The 16383 value from before is repeated.

As was the case before, the End at value needs to be extended by a token amount to include the final value. Here I rounded up to 4 decimal places.

Here's the first set of values from the exported list. Note how the 1st value isn't quite 0, but the difference is minuscule and that value can be changed to 0.0000000000 in a text editor and saved as such.

Here are the last few values. Pretty spot on, without any need to clamp values.

To convert the lists into 1D LUTs that Resolve will read, simply copy and paste the headers from the appropriate 1D LUT in their VFX IO folder. The only things changed (when required) are the Size and Range values.

Here (for the Cineon Log to Linear LUT) the size was changed to 16384, while the range values remain the same (0,1).

Save the LUT as a .cube file.

For the Linear to Cineon Log LUT, the Size becomes 16384 as before, but the Range becomes the first and last values from the preceding LUT.

Save as a .cube file, and you have a matching pair of 14bit Cineon LUTs. The process can be repeated with any of the expressions for the other transfer functions. You can find the expressions for the various Log to Linear transfers by pressing S in the Properties pane, selecting one of the gammas in the LUT section, right-clicking, and selecting Edit>Edit Expression.

Here's a list of the more popular expressions.

Cineon Log to Linear:

(pow(10,(1023*x-685)/300)-.0108)/(1-.0108)

Linear to Cineon Log:

(((log10(x*(1-.0108)+.0108))*300)+685)/1023

Arri LogC to Linear:

x > 0.1496582 ? (pow(10.0, (x - 0.385537) / 0.2471896) - 0.052272) / 5.555556 : (x - 0.092809) / 5.367655

Linear to Arri LogC:

x > 0.010591 ? 0.247190 * log10(5.555556 * x + 0.052272) + 0.385537 : 5.367655 * x + 0.092809

sRGB to Linear:

x < .04045 ? x/12.92 : pow((x+.055)/1.055, 2.4)

Linear to sRGB:

x < .0031308 ? x*12.92 : (1.055*pow(x,1/2.4)) -0.055

rec709 to Linear:

x < .081 ? x/4.5 : pow((x+.099)/1.099, 1/.45)

Linear to rec709:

x <= 0.018 ? (x * 4.5) : 1.099 * pow( x, (0.45) ) - 0.099

Gamma 2.4 to Linear:

pow(x,2.4)

Linear to Gamma 2.4:

pow(x,1/2.4)

I'll follow this up with a look at how to read both 1D and 3D LUTs, so you can tell what they're about just by looking at them in a text editor.