.gitignore

@@ -0,0 +1,12 @@
+# Compiled source #
+###################
+*.o
+genodsp
+
+# Makefile variants #
+###################
+Makefile.*
+
+# OS generated files #
+######################
+.DS_Store

Makefile

@@ -1,5 +1,4 @@
 CFLAGS = -O3 -Wall -Wextra -Werror
-CC     = gcc
 LDLIBS = -lm
 
 operators = sum clump percentile add multiply mask logical minmax morphology map opio variables
@@ -21,7 +20,7 @@ cleano:
 	rm -f *.o
 
 install:
-	mv genodsp ${HOME}/${MACHTYPE}/bin
+	mv genodsp $${HOME}/bin
 
 archive:
 	rm -f  genodsp.tar.gz

README.md

@@ -146,4 +146,3 @@ percentile or better over 100 bp.
       = clump --average=percentile99.5 --length=100 \
       > clumps.dat
 
-

add.c

@@ -197,8 +197,8 @@ void op_add_apply
 	dspop_add*	op = (dspop_add*) _op;
 	char*		filename = op->filename;
 	FILE*		f;
-	char		lineBuffer[1000];
-	char		prevChrom[1000];
+	char		lineBuffer[1001];
+	char		prevChrom[1001];
 	valtype*	v = NULL;
 	char*		chrom;
 	spec*		chromSpec;
@@ -240,7 +240,7 @@ void op_add_apply
 			v = NULL;
 			chromSpec = find_chromosome_spec (chrom);
 			if (chromSpec != NULL) v = chromSpec->valVector;
-			strncpy (prevChrom, chrom, sizeof(prevChrom));
+			safe_strncpy (prevChrom, chrom, sizeof(prevChrom)-1);
 			}
 
 		if (chromSpec == NULL) continue;
@@ -490,8 +490,8 @@ void op_subtract_apply
 	dspop_subtract*	op = (dspop_subtract*) _op;
 	char*			filename = op->filename;
 	FILE*			f;
-	char			lineBuffer[1000];
-	char			prevChrom[1000];
+	char			lineBuffer[1001];
+	char			prevChrom[1001];
 	valtype*		v = NULL;
 	char*			chrom;
 	spec*			chromSpec;
@@ -533,7 +533,7 @@ void op_subtract_apply
 			v = NULL;
 			chromSpec = find_chromosome_spec (chrom);
 			if (chromSpec != NULL) v = chromSpec->valVector;
-			strncpy (prevChrom, chrom, sizeof(prevChrom));
+			safe_strncpy (prevChrom, chrom, sizeof(prevChrom)-1);
 			}
 
 		if (chromSpec == NULL) continue;

clump.c

@@ -20,6 +20,7 @@ typedef struct dspop_clump
 	char*		averageVarName;
 	valtype		average;
 	u32			minLength;
+	double		relativeLength;	// ratio of minLength to chromosome length
 	valtype		oneVal;
 	valtype		zeroVal;
 	int			debug;
@@ -29,6 +30,7 @@ typedef struct dspop_clump
 
 // prototypes
 
+static void parse_min_length (char* name, char* arg, char*argVal, dspop_clump* op, int maxOk);
 static void clump_search (dspop* _op, char* vName, u32 vLen, valtype* v,
                           int aboveThresh);
 
@@ -112,6 +114,9 @@ static void op_clump_usage_args (char* name, FILE* f, char* indent)
 	fprintf (f, "%s                           (default is 0.0)\n",                                   indent);
 	fprintf (f, "%s  --average=<variable>     (T=) get average from named variable\n",                                      indent);
 	fprintf (f, "%s  --length=<length>        (L=) minimum length of qualifying interval\n",         indent);
+	fprintf (f, "%s                           <length> can also be in form <scale>*CL, in\n",        indent);
+	fprintf (f, "%s                           which case it is relative to the chromosome\n",        indent);
+	fprintf (f, "%s                           length\n",                                             indent);
 	fprintf (f, "%s                           (default is 100)\n",                                   indent);
 	fprintf (f, "%s  --one=<value>            (O=) value to fill qualifying intervals\n",            indent);
 	fprintf (f, "%s                           (default is 1.0)\n",                                   indent);
@@ -127,7 +132,6 @@ dspop* op_clump_parse (char* name, int _argc, char** _argv)
 	int				argc = _argc;
 	char**			argv = _argv;
 	char*			arg, *argVal;
-	int				tempInt;
 	valtype			tempVal;
 	int				haveAverage;
 
@@ -141,6 +145,7 @@ dspop* op_clump_parse (char* name, int _argc, char** _argv)
 	op->averageVarName = NULL;
 	op->average        = 0.0;
 	op->minLength      = 100;
+	op->relativeLength = 0.0;
 	op->oneVal         = 1.0;
 	op->zeroVal        = 0.0;
 	op->debug          = false;
@@ -175,12 +180,7 @@ dspop* op_clump_parse (char* name, int _argc, char** _argv)
 		 || (strcmp_prefix (arg, "L=")        == 0)
 		 || (strcmp_prefix (arg, "--L=")      == 0))
 			{
-			tempInt = string_to_unitized_int (argVal, /*thousands*/ true);
-			if (tempInt == 0)
-				chastise ("[%s] minimum length can't be zero (\"%s\")\n", name, arg);
-			if (tempInt < 0)
-				chastise ("[%s] minimum length can't be negative (\"%s\")\n", name, arg);
-			op->minLength = (u32) tempInt;
+			parse_min_length (name, arg, argVal, op, /*maxOK*/true);
 			goto next_arg;
 			}
 
@@ -350,6 +350,139 @@ void op_skimp_apply
 	arg_dont_complain(valtype*	v))
 	{ clump_search (_op,vName,vLen,v,/*above thresh*/ false); }
 
+//----------
+//
+// parse_min_length--
+//	Perform the clump-finding.
+//
+//----------
+
+static void parse_min_length
+   (char*			name,
+	char*			arg,
+	char*			argVal,
+	dspop_clump*	op,
+	int				maxOk)
+	{
+	int				tempInt;
+	dspop_clump		tempOp1, tempOp2;
+
+	// parse as, e.g., max(CL/3,1000)
+
+	if ((maxOk)
+	 && (strcmp_prefix (argVal, "max(") == 0)
+	 && (strcmp_suffix (argVal, ")") == 0))
+		{
+		char* field1, *field2;
+
+		// split into two fields
+		field1 = copy_string (argVal+strlen("max("));
+		field1[strlen(field1)-1] = 0;
+		field2 = strchr(field1,',');
+		if (field2 == NULL) goto bad_relative_length;
+		*(field2++) = 0;
+
+		// parse the fields
+		tempOp1.minLength      = 0;
+		tempOp1.relativeLength = 0.0;
+		parse_min_length (name, arg, field1, &tempOp1, /*maxOK*/false);
+		tempOp2.minLength      = 0;
+		tempOp2.relativeLength = 0.0;
+		parse_min_length (name, arg, field2, &tempOp2, /*maxOK*/false);
+
+		// make sure one field was relative, the other wasn't
+		if ((tempOp1.relativeLength > 0) == (tempOp2.relativeLength > 0))
+			goto bad_relative_length;
+
+		if (tempOp1.relativeLength > 0)
+			{
+			op->relativeLength = tempOp1.relativeLength;
+			op->minLength      = tempOp2.minLength;
+			}
+		else
+			{
+			op->relativeLength = tempOp2.relativeLength;
+			op->minLength      = tempOp1.minLength;
+			}
+
+		free (field1);
+		return;
+		}
+
+	// parse as CL
+
+	if (strcmp (argVal, "CL") == 0)
+		{
+		op->relativeLength = 1.0;
+		op->minLength = 0;
+		return;
+		}
+
+	// parse as, e.g., CL*.50
+
+	if (strcmp_prefix (argVal, "CL*") == 0)
+		{
+		op->relativeLength = string_to_double(argVal+strlen("CL*"));
+		if (op->relativeLength <= 0.0) goto relative_length_not_positive;
+		if (op->relativeLength >  1.0) goto relative_length_too_large;
+		op->minLength = 0;
+		return;
+		}
+
+	// parse as, e.g., .50*CL
+
+	if (strcmp_suffix (argVal, "*CL") == 0)
+		{
+		char* tempStr = copy_string (argVal);
+		tempStr[strlen(tempStr)-strlen("*CL")] = 0;
+		op->relativeLength = string_to_double(tempStr);
+		if (op->relativeLength <= 0.0) goto relative_length_not_positive;
+		if (op->relativeLength >  1.0) goto relative_length_too_large;
+		op->minLength = 0;
+		free(tempStr);
+		return;
+		}
+
+	// parse as, e.g., CL/3
+
+	if (strcmp_prefix (argVal, "CL/") == 0)
+		{
+		op->relativeLength = string_to_double(argVal+strlen("CL*"));
+		if (op->relativeLength < 0.0) goto relative_length_not_positive;
+		if (op->relativeLength < 1.0) goto relative_length_too_large;
+		op->relativeLength = 1.0 / op->relativeLength;
+		op->minLength = 0;
+		return;
+		}
+
+	// parse as, e.g., 100
+
+	tempInt = string_to_unitized_int (argVal, /*thousands*/ true);
+	if (tempInt == 0)
+		chastise ("[%s] minimum length can't be zero (\"%s\")\n", name, arg);
+	if (tempInt < 0)
+		chastise ("[%s] minimum length can't be negative (\"%s\")\n", name, arg);
+	op->minLength = (u32) tempInt;
+	op->relativeLength = 0.0;
+
+	return;
+
+bad_relative_length:
+	fprintf (stderr, "[%s] can't parse relative length (at \"%s\")\n",
+	                 name, arg);
+	exit(EXIT_FAILURE);
+
+relative_length_not_positive:
+	fprintf (stderr, "[%s] relative length has to be positive (at \"%s\")\n",
+	                 name, arg);
+	exit(EXIT_FAILURE);
+
+relative_length_too_large:
+	fprintf (stderr, "[%s] relative length can't be more than 1 (at \"%s\")\n",
+	                 name, arg);
+	exit(EXIT_FAILURE);
+	// (never reaches here)
+	}
 
 //----------
 //
@@ -380,6 +513,14 @@ static void clump_search
 	u32				start, end, prevStart, prevEnd;
 	int				allMonotonic;
 
+	if (op->relativeLength > 0.0)
+		{
+		u32 relLength = (u32) (op->relativeLength * vLen);
+		if (relLength > minLength) minLength = relLength;
+		if (op->debug)
+			fprintf (stderr, " vLen=%u minLength=%u\n",vLen,minLength);
+		}
+
 	// if the threshold is a named variable, fetch it now;  note that we copy
 	// the value from the named variable, then destroy our reference to the
 	// named variable