diff --git a/model/src/main/java/com/msd/gin/halyard/model/AbstractArrayLiteral.java b/model/src/main/java/com/msd/gin/halyard/model/AbstractArrayLiteral.java
new file mode 100644
index 000000000..6166ad28b
--- /dev/null
+++ b/model/src/main/java/com/msd/gin/halyard/model/AbstractArrayLiteral.java
@@ -0,0 +1,135 @@
+package com.msd.gin.halyard.model;
+
+import java.util.Arrays;
+
+import org.eclipse.rdf4j.model.IRI;
+import org.eclipse.rdf4j.model.Literal;
+import org.eclipse.rdf4j.model.Value;
+import org.eclipse.rdf4j.model.ValueFactory;
+import org.eclipse.rdf4j.model.base.CoreDatatype;
+import org.eclipse.rdf4j.model.base.CoreDatatype.XSD;
+import org.eclipse.rdf4j.model.util.Values;
+import org.eclipse.rdf4j.query.algebra.evaluation.ValueExprEvaluationException;
+
+import com.msd.gin.halyard.model.vocabulary.HALYARD;
+
+public abstract class AbstractArrayLiteral<T> extends AbstractDataLiteral implements ObjectLiteral<T> {
+	private static final long serialVersionUID = -6423024672894102212L;
+
+	public static boolean isArrayLiteral(Value v) {
+		return v != null && v.isLiteral() && HALYARD.ARRAY_TYPE.equals(((Literal)v).getDatatype());
+	}
+
+	public static Value[] toValues(Object[] oarr, ValueFactory vf) {
+		Value[] varr = new Value[oarr.length];
+		for (int i=0; i<oarr.length; i++) {
+			varr[i] = Values.literal(vf, oarr[i], false);
+		}
+		return varr;
+	}
+
+	public static AbstractArrayLiteral<?> createFromValues(Value[] values) {
+		AbstractArrayLiteral<?> arrLiteral = null;
+		if (values.length > 0) {
+			Literal l = asLiteral(values[0]);
+			if (l.getCoreDatatype().asXSDDatatypeOrNull() == XSD.FLOAT) {
+				float[] farr = new float[values.length];
+				farr[0] = l.floatValue();
+				for (int i=1; i<values.length; i++) {
+					l = asLiteral(values[i]);
+					if (l.getCoreDatatype().asXSDDatatypeOrNull() != XSD.FLOAT) {
+						farr = null;
+						break;
+					}
+					farr[i] = l.floatValue();
+				}
+				if (farr != null) {
+					arrLiteral = new FloatArrayLiteral(farr);
+				}
+			}
+			if (arrLiteral == null) {
+				Object[] objs = new Object[values.length];
+				for (int i=0; i<values.length; i++) {
+					objs[i] = fromValue(values[i]);
+				}
+				arrLiteral = new ObjectArrayLiteral(objs);
+			}
+		} else {
+			arrLiteral = new ObjectArrayLiteral();
+		}
+		return arrLiteral;
+	}
+
+	private static Object fromValue(Value v) {
+		Object o;
+		Literal l = asLiteral(v);
+		XSD xsd = l.getCoreDatatype().asXSDDatatypeOrNull();
+		if (xsd != null) {
+			try {
+				switch (xsd) {
+					case SHORT:
+						o = l.shortValue();
+						break;
+					case INT:
+						o = l.intValue();
+						break;
+					case LONG:
+						o = l.longValue();
+						break;
+					case FLOAT:
+						o = l.floatValue();
+						break;
+					case DOUBLE:
+						o = l.doubleValue();
+						break;
+					default:
+						o = l.getLabel();
+				}
+			} catch (NumberFormatException nfe) {
+				o = l.getLabel();
+			}
+		} else if (HALYARD.ARRAY_TYPE.equals(l.getDatatype())) {
+			o = ObjectArrayLiteral.objectArray(l);
+		} else if (HALYARD.MAP_TYPE.equals(l.getDatatype())) {
+			o = MapLiteral.objectMap(l);
+		} else {
+			o = l.getLabel();
+		}
+		return o;
+	}
+
+	private static Literal asLiteral(Value v) {
+		if (!v.isLiteral()) {
+			throw new ValueExprEvaluationException(String.format("not a literal: %s", v));
+		}
+		return (Literal) v;
+	}
+
+	@Override
+	public final IRI getDatatype() {
+		return HALYARD.ARRAY_TYPE;
+	}
+
+	@Override
+	public final CoreDatatype getCoreDatatype() {
+		return CoreDatatype.NONE;
+	}
+
+	public abstract Object[] elements();
+
+	public abstract int length();
+
+	@Override
+	public final boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+
+		if (o instanceof AbstractArrayLiteral) {
+			AbstractArrayLiteral<?> other = (AbstractArrayLiteral<?>) o;
+			return Arrays.equals(elements(), other.elements());
+		} else {
+			return super.equals(o);
+		}
+	}
+}
diff --git a/model/src/main/java/com/msd/gin/halyard/model/ArrayLiteral.java b/model/src/main/java/com/msd/gin/halyard/model/ArrayLiteral.java
deleted file mode 100644
index 3c421e661..000000000
--- a/model/src/main/java/com/msd/gin/halyard/model/ArrayLiteral.java
+++ /dev/null
@@ -1,134 +0,0 @@
-package com.msd.gin.halyard.model;
-
-import java.util.Arrays;
-
-import org.eclipse.rdf4j.model.IRI;
-import org.eclipse.rdf4j.model.Literal;
-import org.eclipse.rdf4j.model.Value;
-import org.eclipse.rdf4j.model.ValueFactory;
-import org.eclipse.rdf4j.model.base.CoreDatatype;
-import org.eclipse.rdf4j.model.base.CoreDatatype.XSD;
-import org.eclipse.rdf4j.model.util.Values;
-import org.eclipse.rdf4j.query.algebra.evaluation.ValueExprEvaluationException;
-import org.json.JSONArray;
-
-import com.msd.gin.halyard.model.vocabulary.HALYARD;
-
-public final class ArrayLiteral extends AbstractDataLiteral implements ObjectLiteral<Object[]> {
-	private static final long serialVersionUID = -6399155325720068478L;
-
-	public static boolean isArrayLiteral(Value v) {
-		return v != null && v.isLiteral() && HALYARD.ARRAY_TYPE.equals(((Literal)v).getDatatype());
-	}
-
-	public static Object[] objectArray(Literal l) {
-		if (l instanceof ArrayLiteral) {
-			return ((ArrayLiteral)l).values;
-		} else {
-			return parse(l.getLabel());
-		}
-	}
-
-	public static Value[] toValues(Object[] oarr, ValueFactory vf) {
-		Value[] varr = new Value[oarr.length];
-		for (int i=0; i<oarr.length; i++) {
-			varr[i] = Values.literal(vf, oarr[i], false);
-		}
-		return varr;
-	}
-
-	private static Object[] parse(CharSequence s) {
-		JSONArray arr = new JSONArray(s.toString());
-		int len = arr.length();
-		Object[] values = new Object[len];
-		for (int i=0; i<len; i++) {
-			values[i] = arr.get(i);
-		}
-		return values;
-	}
-
-	public static ArrayLiteral createFromValues(Value[] values) {
-		Object[] objs = new Object[values.length];
-		for (int i=0; i<values.length; i++) {
-			objs[i] = fromValue(values[i]);
-		}
-		return new ArrayLiteral(objs);
-	}
-
-	private static Object fromValue(Value v) {
-		if (!v.isLiteral()) {
-			throw new ValueExprEvaluationException(String.format("not a literal: %s", v));
-		}
-		Object o;
-		Literal l = (Literal) v;
-		XSD xsd = l.getCoreDatatype().asXSDDatatypeOrNull();
-		if (xsd != null && xsd.isIntegerDatatype()) {
-			// use exact integer representation if available
-			// NB: floating-point values aren't guaranteed to have an exact representation so coerce them from string instead
-			try {
-				if (xsd == XSD.INT) {
-					o = l.intValue();
-				} else {
-					o = l.longValue();
-				}
-			} catch (NumberFormatException nfe) {
-				o = l.getLabel();
-			}
-		} else if (HALYARD.ARRAY_TYPE.equals(l.getDatatype())) {
-			o = ArrayLiteral.objectArray(l);
-		} else if (HALYARD.MAP_TYPE.equals(l.getDatatype())) {
-			o = MapLiteral.objectMap(l);
-		} else {
-			o = l.getLabel();
-		}
-		return o;
-	}
-
-	private final Object[] values;
-
-	public ArrayLiteral(String s) {
-		this.values = parse(s);
-	}
-
-	public ArrayLiteral(Object... values) {
-		this.values = values;
-	}
-
-	@Override
-	public String getLabel() {
-		JSONArray arr = new JSONArray();
-		for (Object o : this.values) {
-			arr.put(o);
-		}
-		return arr.toString(0);
-	}
-
-	@Override
-	public IRI getDatatype() {
-		return HALYARD.ARRAY_TYPE;
-	}
-
-	@Override
-	public CoreDatatype getCoreDatatype() {
-		return CoreDatatype.NONE;
-	}
-
-	@Override
-	public Object[] objectValue() {
-		return values;
-	}
-
-	@Override
-	public boolean equals(Object o) {
-		if (this == o) {
-			return true;
-		}
-
-		if (o instanceof ArrayLiteral) {
-			ArrayLiteral other = (ArrayLiteral) o;
-			return Arrays.equals(values, other.values);
-		} else {
-			return super.equals(o);
-		}
-	}
-}
diff --git a/model/src/main/java/com/msd/gin/halyard/model/FloatArrayLiteral.java b/model/src/main/java/com/msd/gin/halyard/model/FloatArrayLiteral.java
new file mode 100644
index 000000000..e4813b6bc
--- /dev/null
+++ b/model/src/main/java/com/msd/gin/halyard/model/FloatArrayLiteral.java
@@ -0,0 +1,59 @@
+package com.msd.gin.halyard.model;
+
+import org.eclipse.rdf4j.model.Literal;
+import org.json.JSONArray;
+
+import com.msd.gin.halyard.model.vocabulary.HALYARD;
+
+public final class FloatArrayLiteral extends AbstractArrayLiteral<float[]> {
+	private static final long serialVersionUID = -5786623818445151749L;
+
+	private final float[] values;
+
+	public FloatArrayLiteral(float... values) {
+		this.values = values;
+	}
+
+	@Override
+	public String getLabel() {
+		JSONArray arr = new JSONArray();
+		for (float o : this.values) {
+			arr.put(o);
+		}
+		return arr.toString(0);
+	}
+
+	@Override
+	public float[] objectValue() {
+		return values;
+	}
+
+	@Override
+	public Object[] elements() {
+		Object[] arr = new Object[values.length];
+		for (int i=0; i<values.length; i++) {
+			arr[i] = values[i];
+		}
+		return arr;
+	}
+
+	@Override
+	public int length() {
+		return values.length;
+	}
+
+	public static float[] floatArray(Literal l) {
+		if (l instanceof FloatArrayLiteral) {
+			return ((FloatArrayLiteral)l).objectValue();
+		} else if (HALYARD.ARRAY_TYPE.equals(l.getDatatype())){
+			Object[] arr = ObjectArrayLiteral.objectArray(l);
+			float[] farr = new float[arr.length];
+			for (int i=0; i<arr.length; i++) {
+				farr[i] = (Float) arr[i];
+			}
+			return farr;
+		} else {
+			throw new IllegalArgumentException("Incorrect datatype");
+		}
+	}
+}
diff --git a/model/src/main/java/com/msd/gin/halyard/model/ObjectArrayLiteral.java b/model/src/main/java/com/msd/gin/halyard/model/ObjectArrayLiteral.java
new file mode 100644
index 000000000..28838934f
--- /dev/null
+++ b/model/src/main/java/com/msd/gin/halyard/model/ObjectArrayLiteral.java
@@ -0,0 +1,60 @@
+package com.msd.gin.halyard.model;
+
+import org.eclipse.rdf4j.model.Literal;
+import org.json.JSONArray;
+
+public final class ObjectArrayLiteral extends AbstractArrayLiteral<Object[]> {
+	private static final long serialVersionUID = 6409948385114916596L;
+
+	private final Object[] values;
+
+	public ObjectArrayLiteral(String s) {
+		this.values = parse(s);
+	}
+
+	public ObjectArrayLiteral(Object... values) {
+		this.values = values;
+	}
+
+	@Override
+	public String getLabel() {
+		JSONArray arr = new JSONArray();
+		for (Object o : this.values) {
+			arr.put(o);
+		}
+		return arr.toString(0);
+	}
+
+	@Override
+	public Object[] objectValue() {
+		return values;
+	}
+
+	@Override
+	public Object[] elements() {
+		return values;
+	}
+
+	@Override
+	public int length() {
+		return values.length;
+	}
+
+	public static Object[] objectArray(Literal l) {
+		if (l instanceof AbstractArrayLiteral) {
+			return ((AbstractArrayLiteral<?>)l).elements();
+		} else {
+			return parse(l.getLabel());
+		}
+	}
+
+	private static Object[] parse(CharSequence s) {
+		JSONArray arr = new JSONArray(s.toString());
+		int len = arr.length();
+		Object[] values = new Object[len];
+		for (int i=0; i<len; i++) {
+			values[i] = arr.get(i);
+		}
+		return values;
+	}
+}
diff --git a/model/src/main/java/com/msd/gin/halyard/model/impl/AdvancedValueFactory.java b/model/src/main/java/com/msd/gin/halyard/model/impl/AdvancedValueFactory.java
index 4fd14f041..4df99f417 100644
--- a/model/src/main/java/com/msd/gin/halyard/model/impl/AdvancedValueFactory.java
+++ b/model/src/main/java/com/msd/gin/halyard/model/impl/AdvancedValueFactory.java
@@ -1,12 +1,5 @@
 package com.msd.gin.halyard.model.impl;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
-import com.msd.gin.halyard.model.MapLiteral;
-import com.msd.gin.halyard.model.TupleLiteral;
-import com.msd.gin.halyard.model.WKTLiteral;
-import com.msd.gin.halyard.model.XMLLiteral;
-import com.msd.gin.halyard.model.vocabulary.HALYARD;
-
 import org.eclipse.rdf4j.model.IRI;
 import org.eclipse.rdf4j.model.Literal;
 import org.eclipse.rdf4j.model.base.AbstractValueFactory;
@@ -14,6 +7,13 @@
 import org.eclipse.rdf4j.model.vocabulary.GEO;
 import org.eclipse.rdf4j.model.vocabulary.RDF;
 
+import com.msd.gin.halyard.model.MapLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
+import com.msd.gin.halyard.model.TupleLiteral;
+import com.msd.gin.halyard.model.WKTLiteral;
+import com.msd.gin.halyard.model.XMLLiteral;
+import com.msd.gin.halyard.model.vocabulary.HALYARD;
+
 public final class AdvancedValueFactory extends AbstractValueFactory {
 	private Literal createAdvancedLiteral(String label, IRI datatype, CoreDatatype coreDatatype) {
 		try {
@@ -24,7 +24,7 @@ private Literal createAdvancedLiteral(String label, IRI datatype, CoreDatatype c
 			} else if (HALYARD.TUPLE_TYPE.equals(datatype)) {
 				return new TupleLiteral(label);
 			} else if (HALYARD.ARRAY_TYPE.equals(datatype)) {
-				return new ArrayLiteral(label);
+				return new ObjectArrayLiteral(label);
 			} else if (HALYARD.MAP_TYPE.equals(datatype)) {
 				return new MapLiteral(label);
 			}
diff --git a/model/src/test/java/com/msd/gin/halyard/model/ArrayLiteralTest.java b/model/src/test/java/com/msd/gin/halyard/model/ArrayLiteralTest.java
deleted file mode 100644
index c76c073b0..000000000
--- a/model/src/test/java/com/msd/gin/halyard/model/ArrayLiteralTest.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package com.msd.gin.halyard.model;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import java.util.Collections;
-
-import org.eclipse.rdf4j.model.Literal;
-import org.junit.jupiter.api.Test;
-
-public class ArrayLiteralTest extends AbstractCustomLiteralTest {
-	@Override
-	protected Literal createLiteral() throws Exception {
-		return new ArrayLiteral(new int[] {8, 5});
-	}
-
-	@Override
-	protected Literal createOtherLiteral() throws Exception {
-		return new ArrayLiteral(new Object[] {"foo", "bar"});
-	}
-
-	@Test
-	public void testNestedArrays() {
-		ArrayLiteral l = new ArrayLiteral(new Object[] {"abc", new Object[] {"a", "b", "c"}});
-		assertEquals("[\"abc\",[\"a\",\"b\",\"c\"]]", l.getLabel());
-	}
-
-	@Test
-	public void testNestedMap() {
-		ArrayLiteral l = new ArrayLiteral(new Object[] {"abc", Collections.singletonMap("key", "value")});
-		assertEquals("[\"abc\",{\"key\":\"value\"}]", l.getLabel());
-	}
-}
diff --git a/model/src/test/java/com/msd/gin/halyard/model/FloatArrayLiteralTest.java b/model/src/test/java/com/msd/gin/halyard/model/FloatArrayLiteralTest.java
new file mode 100644
index 000000000..a7723da47
--- /dev/null
+++ b/model/src/test/java/com/msd/gin/halyard/model/FloatArrayLiteralTest.java
@@ -0,0 +1,25 @@
+package com.msd.gin.halyard.model;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.eclipse.rdf4j.model.Literal;
+import org.junit.jupiter.api.Test;
+
+public class FloatArrayLiteralTest extends AbstractCustomLiteralTest {
+	@Override
+	protected Literal createLiteral() throws Exception {
+		return new FloatArrayLiteral(3.5f, 2.1f);
+	}
+
+	@Override
+	protected Literal createOtherLiteral() throws Exception {
+		return new FloatArrayLiteral(0.7f, -3.7f);
+	}
+
+	@Test
+	public void testSameAsDifferentImpl() {
+		FloatArrayLiteral l1 = new FloatArrayLiteral(3.5f, 2.1f);
+		ObjectArrayLiteral l2 = new ObjectArrayLiteral(3.5f, 2.1f);
+		assertEquals(l1, l2);
+	}
+}
diff --git a/model/src/test/java/com/msd/gin/halyard/model/ObjectArrayLiteralTest.java b/model/src/test/java/com/msd/gin/halyard/model/ObjectArrayLiteralTest.java
new file mode 100644
index 000000000..a244432dd
--- /dev/null
+++ b/model/src/test/java/com/msd/gin/halyard/model/ObjectArrayLiteralTest.java
@@ -0,0 +1,39 @@
+package com.msd.gin.halyard.model;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Collections;
+
+import org.eclipse.rdf4j.model.Literal;
+import org.junit.jupiter.api.Test;
+
+public class ObjectArrayLiteralTest extends AbstractCustomLiteralTest {
+	@Override
+	protected Literal createLiteral() throws Exception {
+		return new ObjectArrayLiteral(8, 5);
+	}
+
+	@Override
+	protected Literal createOtherLiteral() throws Exception {
+		return new ObjectArrayLiteral("foo", "bar");
+	}
+
+	@Test
+	public void testNestedArrays() {
+		ObjectArrayLiteral l = new ObjectArrayLiteral(new Object[] {"abc", new Object[] {"a", "b", "c"}});
+		assertEquals("[\"abc\",[\"a\",\"b\",\"c\"]]", l.getLabel());
+	}
+
+	@Test
+	public void testNestedMap() {
+		ObjectArrayLiteral l = new ObjectArrayLiteral(new Object[] {"abc", Collections.singletonMap("key", "value")});
+		assertEquals("[\"abc\",{\"key\":\"value\"}]", l.getLabel());
+	}
+
+	@Test
+	public void testSameAsDifferentImpl() {
+		ObjectArrayLiteral l1 = new ObjectArrayLiteral(3.5f, 2.1f);
+		FloatArrayLiteral l2 = new FloatArrayLiteral(3.5f, 2.1f);
+		assertEquals(l1, l2);
+	}
+}
diff --git a/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/Array.java b/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/Array.java
index 49fe1dd23..2b67ebc43 100644
--- a/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/Array.java
+++ b/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/Array.java
@@ -6,7 +6,7 @@
 import org.eclipse.rdf4j.query.algebra.evaluation.function.Function;
 import org.kohsuke.MetaInfServices;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.AbstractArrayLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 
 /**
@@ -22,6 +22,6 @@ public String getURI() {
 
 	@Override
 	public Value evaluate(ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException {
-		return ArrayLiteral.createFromValues(args);
+		return AbstractArrayLiteral.createFromValues(args);
 	}
 }
diff --git a/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/CosineSimilarity.java b/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/CosineSimilarity.java
index 044b8eb8f..abf915b6b 100644
--- a/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/CosineSimilarity.java
+++ b/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/CosineSimilarity.java
@@ -7,7 +7,8 @@
 import org.eclipse.rdf4j.query.algebra.evaluation.function.Function;
 import org.kohsuke.MetaInfServices;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.AbstractArrayLiteral;
+import com.msd.gin.halyard.model.FloatArrayLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 
 @MetaInfServices(Function.class)
@@ -20,11 +21,11 @@ public String getURI() {
 
 	@Override
 	public Value evaluate(ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException {
-		if (args.length != 2 || !args[0].isLiteral() || !args[1].isLiteral()) {
-			throw new ValueExprEvaluationException(String.format("%s requires 2 literal arguments", getURI()));
+		if (args.length != 2 || !AbstractArrayLiteral.isArrayLiteral(args[0]) || !AbstractArrayLiteral.isArrayLiteral(args[1])) {
+			throw new ValueExprEvaluationException(String.format("%s requires 2 array arguments", getURI()));
 		}
-		Object[] v1 = ArrayLiteral.objectArray((Literal) args[0]);
-		Object[] v2 = ArrayLiteral.objectArray((Literal) args[1]);
+		float[] v1 = FloatArrayLiteral.floatArray((Literal) args[0]);
+		float[] v2 = FloatArrayLiteral.floatArray((Literal) args[1]);
 		if (v1.length != v2.length) {
 			throw new ValueExprEvaluationException("Arrays have incompatible dimensions");
 		}
@@ -32,8 +33,8 @@ public Value evaluate(ValueFactory valueFactory, Value... args) throws ValueExpr
 		double normSqr1 = 0.0;
 		double normSqr2 = 0.0;
 		for (int i=0; i<v1.length; i++) {
-			double x = ((Number)v1[i]).doubleValue();
-			double y = ((Number)v2[i]).doubleValue();
+			double x = v1[i];
+			double y = v2[i];
 			dot += x*y;
 			normSqr1 += x*x;
 			normSqr2 += y*y;
diff --git a/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/DynamicFunctionRegistry.java b/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/DynamicFunctionRegistry.java
index 61ff2b950..782449515 100644
--- a/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/DynamicFunctionRegistry.java
+++ b/queryalgebra/src/main/java/com/msd/gin/halyard/query/algebra/evaluation/function/DynamicFunctionRegistry.java
@@ -37,8 +37,8 @@
 import org.eclipse.rdf4j.rio.RDFWriter;
 import org.eclipse.rdf4j.rio.Rio;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
 import com.msd.gin.halyard.model.MapLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.ObjectLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 
@@ -141,7 +141,7 @@ static final class XPathSparqlFunction implements Function {
 			} else {
 				IRI dt = l.getDatatype();
 				if (HALYARD.ARRAY_TYPE.equals(dt)) {
-					return ArrayLiteral.objectArray(l);
+					return ObjectArrayLiteral.objectArray(l);
 				} else if (HALYARD.MAP_TYPE.equals(dt)) {
 					return MapLiteral.objectMap(l);
 				} else {
@@ -222,7 +222,7 @@ public Value evaluate(ValueFactory vf, Value... args) throws ValueExprEvaluation
 
 	private static Value toValue(ValueFactory vf, Object v) throws XPathException {
 		if (v instanceof Object[]) {
-			return new ArrayLiteral((Object[]) v);
+			return new ObjectArrayLiteral((Object[]) v);
 		} else if (v instanceof Map<?,?>) {
 			return new MapLiteral((Map<String,Object>)v);
 		} else {
diff --git a/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/ArrayTest.java b/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/ArrayTest.java
index 98fcb0e55..b84dda480 100644
--- a/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/ArrayTest.java
+++ b/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/ArrayTest.java
@@ -3,13 +3,15 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import org.eclipse.rdf4j.model.Literal;
 import org.eclipse.rdf4j.model.Value;
 import org.eclipse.rdf4j.model.ValueFactory;
 import org.eclipse.rdf4j.query.algebra.evaluation.TripleSource;
 import org.eclipse.rdf4j.query.algebra.evaluation.ValueExprEvaluationException;
 import org.junit.jupiter.api.Test;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.FloatArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.query.algebra.evaluation.EmptyTripleSource;
 
 public class ArrayTest {
@@ -19,9 +21,34 @@ public void test() {
 		ValueFactory vf = ts.getValueFactory();
 		Value v1 = vf.createLiteral("foobar");
 		Value v2 = vf.createLiteral(5);
-		ArrayLiteral l = (ArrayLiteral) new Array().evaluate(ts, v1, v2);
-		assertEquals("foobar", l.objectValue()[0]);
-		assertEquals(5, l.objectValue()[1]);
+		Object[] objs = ObjectArrayLiteral.objectArray((Literal) new Array().evaluate(ts, v1, v2));
+		assertEquals("foobar", objs[0]);
+		assertEquals(5, objs[1]);
+	}
+
+	@Test
+	public void test_float() {
+		TripleSource ts = new EmptyTripleSource();
+		ValueFactory vf = ts.getValueFactory();
+		Value v1 = vf.createLiteral(2.5f);
+		Value v2 = vf.createLiteral(5f);
+		Object[] objs = ObjectArrayLiteral.objectArray((Literal) new Array().evaluate(ts, v1, v2));
+		assertEquals(2.5f, objs[0]);
+		assertEquals(5f, objs[1]);
+		float[] farr = FloatArrayLiteral.floatArray((Literal) new Array().evaluate(ts, v1, v2));
+		assertEquals(2.5f, farr[0]);
+		assertEquals(5f, farr[1]);
+	}
+
+	@Test
+	public void test_mixed() {
+		TripleSource ts = new EmptyTripleSource();
+		ValueFactory vf = ts.getValueFactory();
+		Value v1 = vf.createLiteral(-0.15f);
+		Value v2 = vf.createLiteral("foobar");
+		Object[] objs = ObjectArrayLiteral.objectArray((Literal) new Array().evaluate(ts, v1, v2));
+		assertEquals(-0.15f, objs[0]);
+		assertEquals("foobar", objs[1]);
 	}
 
 	@Test
diff --git a/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/CosineSimilarityTest.java b/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/CosineSimilarityTest.java
index bb7de8591..7bcebd1b6 100644
--- a/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/CosineSimilarityTest.java
+++ b/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/CosineSimilarityTest.java
@@ -7,15 +7,25 @@
 import org.eclipse.rdf4j.query.algebra.evaluation.TripleSource;
 import org.junit.jupiter.api.Test;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.FloatArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.query.algebra.evaluation.EmptyTripleSource;
 
 public class CosineSimilarityTest {
 	@Test
 	public void test() {
 		TripleSource ts = new EmptyTripleSource();
-		Value v1 = new ArrayLiteral(1, 0);
-		Value v2 = new ArrayLiteral(1, 1);
+		Value v1 = new FloatArrayLiteral(1.0f, 0.0f);
+		Value v2 = new FloatArrayLiteral(1.0f, 1.0f);
+		Literal l = (Literal) new CosineSimilarity().evaluate(ts, v1, v2);
+		assertEquals(1.0/Math.sqrt(2), l.doubleValue());
+	}
+
+	@Test
+	public void test_objectArray() {
+		TripleSource ts = new EmptyTripleSource();
+		Value v1 = new ObjectArrayLiteral(1.0f, 1.0f);
+		Value v2 = new ObjectArrayLiteral(1.0f, 0.0f);
 		Literal l = (Literal) new CosineSimilarity().evaluate(ts, v1, v2);
 		assertEquals(1.0/Math.sqrt(2), l.doubleValue());
 	}
diff --git a/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/DynamicFunctionRegistryTest.java b/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/DynamicFunctionRegistryTest.java
index 3a3e96e0b..0a2ced5d9 100644
--- a/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/DynamicFunctionRegistryTest.java
+++ b/queryalgebra/src/test/java/com/msd/gin/halyard/query/algebra/evaluation/function/DynamicFunctionRegistryTest.java
@@ -13,8 +13,8 @@
 import org.eclipse.rdf4j.query.algebra.evaluation.TripleSource;
 import org.junit.jupiter.api.Test;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
 import com.msd.gin.halyard.model.MapLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.query.algebra.evaluation.EmptyTripleSource;
 
 public class DynamicFunctionRegistryTest {
@@ -54,8 +54,8 @@ public void testIsWholeNumber() {
 	public void testArray_put() {
 		TripleSource ts = new EmptyTripleSource();
 		ValueFactory vf = ts.getValueFactory();
-		ArrayLiteral result = (ArrayLiteral) new DynamicFunctionRegistry().get("http://www.w3.org/2005/xpath-functions/array#put").get().evaluate(ts,
-				new ArrayLiteral("foo", "bar"), vf.createLiteral(2), vf.createLiteral(5));
+		ObjectArrayLiteral result = (ObjectArrayLiteral) new DynamicFunctionRegistry().get("http://www.w3.org/2005/xpath-functions/array#put").get().evaluate(ts,
+				new ObjectArrayLiteral("foo", "bar"), vf.createLiteral(2), vf.createLiteral(5));
 		assertEquals(2, result.objectValue().length);
 		// NB: xsd:ints get coerced to xsd:integers
 		assertEquals(BigInteger.valueOf(5), result.objectValue()[1]);
@@ -65,7 +65,7 @@ public void testArray_put() {
 	public void testArray_size() {
 		TripleSource ts = new EmptyTripleSource();
 		ValueFactory vf = ts.getValueFactory();
-		ArrayLiteral array = new ArrayLiteral("foo", "bar");
+		ObjectArrayLiteral array = new ObjectArrayLiteral("foo", "bar");
 		// check works for non-specialist Literal type
 		Literal unparsedArray = vf.createLiteral(array.getLabel(), array.getDatatype());
 		Literal result = (Literal) new DynamicFunctionRegistry().get("http://www.w3.org/2005/xpath-functions/array#size").get().evaluate(ts,
diff --git a/sail/src/main/java/com/msd/gin/halyard/sail/model/embedding/function/VectorEmbedding.java b/sail/src/main/java/com/msd/gin/halyard/sail/model/embedding/function/VectorEmbedding.java
index 5f3f82d7b..c5bce8c0d 100644
--- a/sail/src/main/java/com/msd/gin/halyard/sail/model/embedding/function/VectorEmbedding.java
+++ b/sail/src/main/java/com/msd/gin/halyard/sail/model/embedding/function/VectorEmbedding.java
@@ -1,6 +1,6 @@
 package com.msd.gin.halyard.sail.model.embedding.function;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.FloatArrayLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 import com.msd.gin.halyard.query.algebra.evaluation.ExtendedTripleSource;
 
@@ -44,10 +44,6 @@ public Value evaluate(TripleSource ts, Value... args) throws ValueExprEvaluation
 		ExtendedTripleSource extTs = (ExtendedTripleSource) ts;
 		Response<Embedding> resp = extTs.getQueryHelper(EmbeddingModel.class).embed(l.getLabel());
 		float[] vec = resp.content().vector();
-		Object[] arr = new Object[vec.length];
-		for (int i = 0; i < vec.length; i++) {
-			arr[i] = Float.valueOf(vec[i]);
-		}
-		return new ArrayLiteral(arr);
+		return new FloatArrayLiteral(vec);
 	}
 }
diff --git a/sail/src/main/java/com/msd/gin/halyard/sail/search/KNNTupleFunction.java b/sail/src/main/java/com/msd/gin/halyard/sail/search/KNNTupleFunction.java
index bbc280c95..c51d9c07f 100644
--- a/sail/src/main/java/com/msd/gin/halyard/sail/search/KNNTupleFunction.java
+++ b/sail/src/main/java/com/msd/gin/halyard/sail/search/KNNTupleFunction.java
@@ -2,7 +2,7 @@
 
 import com.msd.gin.halyard.common.RDFFactory;
 import com.msd.gin.halyard.common.StatementIndices;
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.ObjectLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 import com.msd.gin.halyard.query.algebra.evaluation.ExtendedTripleSource;
@@ -46,7 +46,7 @@ public CloseableIteration<? extends List<? extends Value>> evaluate(TripleSource
 			throw new QueryEvaluationException("Invalid query value");
 		}
 		int argPos = 0;
-		Object[] query = ArrayLiteral.objectArray((Literal) args[argPos++]);
+		Object[] query = ObjectArrayLiteral.objectArray((Literal) args[argPos++]);
 		Float[] vec = new Float[query.length];
 		for (int i = 0; i < query.length; i++) {
 			vec[i] = ((Number) query[i]).floatValue();
diff --git a/sail/src/main/java/com/msd/gin/halyard/sail/search/SearchTupleFunction.java b/sail/src/main/java/com/msd/gin/halyard/sail/search/SearchTupleFunction.java
index 042241c1f..73db3d781 100644
--- a/sail/src/main/java/com/msd/gin/halyard/sail/search/SearchTupleFunction.java
+++ b/sail/src/main/java/com/msd/gin/halyard/sail/search/SearchTupleFunction.java
@@ -3,7 +3,8 @@
 import com.google.common.collect.Lists;
 import com.msd.gin.halyard.common.RDFFactory;
 import com.msd.gin.halyard.common.StatementIndices;
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.FloatArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.ObjectLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 import com.msd.gin.halyard.query.algebra.evaluation.ExtendedTripleSource;
@@ -123,15 +124,11 @@ protected List<Value> convert(List<Hit<? extends SearchDocument>> matchValues) t
 					for (MatchParams.FieldParams fieldParams : matchParams.fields) {
 						Literal l;
 						if (SearchDocument.VECTOR_FIELD.equals(fieldParams.name)) {
-							Object[] arr = new Object[doc.vector.length];
-							for (int k = 0; k < doc.vector.length; k++) {
-								arr[k] = doc.vector[k];
-							}
-							l = new ArrayLiteral(arr);
+							l = new FloatArrayLiteral(doc.vector);
 						} else {
 							Object v = doc.getAdditionalField(fieldParams.name);
 							if (v instanceof List<?>) {
-								l = new ArrayLiteral(((List<?>) v).toArray());
+								l = new ObjectArrayLiteral(((List<?>) v).toArray());
 							} else if (v != null) {
 								l = Values.literal(valueFactory, v, false);
 							} else {
diff --git a/sail/src/main/java/com/msd/gin/halyard/sail/search/function/EscapeTerm.java b/sail/src/main/java/com/msd/gin/halyard/sail/search/function/EscapeTerm.java
index bdef5e288..df281de8a 100644
--- a/sail/src/main/java/com/msd/gin/halyard/sail/search/function/EscapeTerm.java
+++ b/sail/src/main/java/com/msd/gin/halyard/sail/search/function/EscapeTerm.java
@@ -1,6 +1,6 @@
 package com.msd.gin.halyard.sail.search.function;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 
 import java.util.Locale;
@@ -36,7 +36,7 @@ public Value evaluate(ValueFactory valueFactory, Value... args) throws ValueExpr
 		}
 		Literal l = (Literal) args[0];
 		if (HALYARD.ARRAY_TYPE.equals(l.getDatatype())) {
-			Object[] entries = ArrayLiteral.objectArray(l);
+			Object[] entries = ObjectArrayLiteral.objectArray(l);
 			Object[] escaped = new Object[entries.length];
 			for (int i = 0; i < entries.length; i++) {
 				Object o = entries[i];
@@ -45,7 +45,7 @@ public Value evaluate(ValueFactory valueFactory, Value... args) throws ValueExpr
 				}
 				escaped[i] = o;
 			}
-			return new ArrayLiteral(escaped);
+			return new ObjectArrayLiteral(escaped);
 		} else {
 			String s = l.getLabel();
 			return valueFactory.createLiteral(escape(s));
diff --git a/sail/src/main/java/com/msd/gin/halyard/sail/search/function/GroupTerms.java b/sail/src/main/java/com/msd/gin/halyard/sail/search/function/GroupTerms.java
index 1a4d48480..7d7155f69 100644
--- a/sail/src/main/java/com/msd/gin/halyard/sail/search/function/GroupTerms.java
+++ b/sail/src/main/java/com/msd/gin/halyard/sail/search/function/GroupTerms.java
@@ -1,6 +1,6 @@
 package com.msd.gin.halyard.sail.search.function;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 
 import org.eclipse.rdf4j.model.Literal;
@@ -48,7 +48,7 @@ public Value evaluate(ValueFactory valueFactory, Value... args) throws ValueExpr
 			}
 			Literal l = (Literal) arg;
 			if (HALYARD.ARRAY_TYPE.equals(l.getDatatype())) {
-				Object[] entries = ArrayLiteral.objectArray(l);
+				Object[] entries = ObjectArrayLiteral.objectArray(l);
 				for (Object entry : entries) {
 					String s = entry.toString();
 					if (!s.isEmpty()) {
diff --git a/sail/src/test/java/com/msd/gin/halyard/sail/search/function/EscapeTermTest.java b/sail/src/test/java/com/msd/gin/halyard/sail/search/function/EscapeTermTest.java
index 83b7b4663..a0d7dc2e9 100644
--- a/sail/src/test/java/com/msd/gin/halyard/sail/search/function/EscapeTermTest.java
+++ b/sail/src/test/java/com/msd/gin/halyard/sail/search/function/EscapeTermTest.java
@@ -1,6 +1,6 @@
 package com.msd.gin.halyard.sail.search.function;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 
 import org.eclipse.rdf4j.model.Literal;
 import org.eclipse.rdf4j.model.ValueFactory;
@@ -62,7 +62,7 @@ public void testEscapeUrl() {
 
 	@Test
 	public void testEscapeList() {
-		Literal escaped = (Literal) new EscapeTerm().evaluate(vf, new ArrayLiteral(":", "/"));
-		assertEquals(new ArrayLiteral("\\:", "\\/"), escaped);
+		Literal escaped = (Literal) new EscapeTerm().evaluate(vf, new ObjectArrayLiteral(":", "/"));
+		assertEquals(new ObjectArrayLiteral("\\:", "\\/"), escaped);
 	}
 }
diff --git a/sail/src/test/java/com/msd/gin/halyard/sail/search/function/GroupTermsTest.java b/sail/src/test/java/com/msd/gin/halyard/sail/search/function/GroupTermsTest.java
index 449298f7d..ded0e4df9 100644
--- a/sail/src/test/java/com/msd/gin/halyard/sail/search/function/GroupTermsTest.java
+++ b/sail/src/test/java/com/msd/gin/halyard/sail/search/function/GroupTermsTest.java
@@ -1,6 +1,6 @@
 package com.msd.gin.halyard.sail.search.function;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 
 import org.eclipse.rdf4j.model.Literal;
 import org.eclipse.rdf4j.model.ValueFactory;
@@ -32,7 +32,7 @@ public void testEmpty() {
 
 	@Test
 	public void testArray() {
-		Literal group = (Literal) new GroupTerms().evaluate(vf, vf.createLiteral("AND"), new ArrayLiteral("foo", "bar"));
+		Literal group = (Literal) new GroupTerms().evaluate(vf, vf.createLiteral("AND"), new ObjectArrayLiteral("foo", "bar"));
 		assertEquals("(foo AND bar)", group.stringValue());
 	}
 }
diff --git a/spin/src/main/java/com/msd/gin/halyard/spin/function/spif/ForEach.java b/spin/src/main/java/com/msd/gin/halyard/spin/function/spif/ForEach.java
index 6df692bc1..84ab05687 100644
--- a/spin/src/main/java/com/msd/gin/halyard/spin/function/spif/ForEach.java
+++ b/spin/src/main/java/com/msd/gin/halyard/spin/function/spif/ForEach.java
@@ -24,7 +24,8 @@
 import org.eclipse.rdf4j.query.QueryEvaluationException;
 
 import com.google.common.collect.Iterators;
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.AbstractArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.TupleLiteral;
 import com.msd.gin.halyard.spin.function.InverseMagicProperty;
 
@@ -43,8 +44,8 @@ public CloseableIteration<? extends List<? extends Value>> evaluate(
 				Arrays.stream(args).flatMap(v -> {
 					if (TupleLiteral.isTupleLiteral(v)) {
 						return Arrays.stream(TupleLiteral.valueArray((Literal)v, valueFactory));
-					} else if (ArrayLiteral.isArrayLiteral(v)) {
-						return Arrays.stream(ArrayLiteral.toValues(ArrayLiteral.objectArray((Literal)v), valueFactory));
+					} else if (AbstractArrayLiteral.isArrayLiteral(v)) {
+						return Arrays.stream(AbstractArrayLiteral.toValues(ObjectArrayLiteral.objectArray((Literal)v), valueFactory));
 					} else {
 						return Stream.of(v);
 					}
diff --git a/spin/src/test/java/com/msd/gin/halyard/spin/SailSpifTest.java b/spin/src/test/java/com/msd/gin/halyard/spin/SailSpifTest.java
index f2bd27b3c..b1fb80dc5 100644
--- a/spin/src/test/java/com/msd/gin/halyard/spin/SailSpifTest.java
+++ b/spin/src/test/java/com/msd/gin/halyard/spin/SailSpifTest.java
@@ -25,7 +25,7 @@
 import org.junit.Before;
 import org.junit.Test;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.TupleLiteral;
 
 /**
@@ -177,7 +177,7 @@ public void testForEachTupleLiteral() throws Exception {
 
 	@Test
 	public void testForEachArrayLiteral() throws Exception {
-		String al = NTriplesUtil.toNTriplesString(new ArrayLiteral(2, 3));
+		String al = NTriplesUtil.toNTriplesString(new ObjectArrayLiteral(2, 3));
 		TupleQuery tq = conn.prepareTupleQuery(QueryLanguage.SPARQL, "prefix spif: <http://spinrdf.org/spif#> prefix halyard: <http://merck.github.io/Halyard/ns#> " + "select ?x where {?x spif:foreach (1 "+ al + " 4)}");
 		try (TupleQueryResult tqr = tq.evaluate()) {
 			for (int i = 1; i <= 4; i++) {
diff --git a/strategy/src/main/java/com/msd/gin/halyard/strategy/MathOpEvaluator.java b/strategy/src/main/java/com/msd/gin/halyard/strategy/MathOpEvaluator.java
index 32d51365f..b0c0eab99 100644
--- a/strategy/src/main/java/com/msd/gin/halyard/strategy/MathOpEvaluator.java
+++ b/strategy/src/main/java/com/msd/gin/halyard/strategy/MathOpEvaluator.java
@@ -1,6 +1,7 @@
 package com.msd.gin.halyard.strategy;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.FloatArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 
 import javax.annotation.concurrent.ThreadSafe;
@@ -47,23 +48,55 @@ public Literal evaluate(Literal a, Literal b, MathOp op, ValueFactory vf) {
 	}
 
 	private static Literal operationBetweenVectors(Literal a, Literal b, MathOp op, ValueFactory vf) {
-		Object[] aarr = ArrayLiteral.objectArray(a);
-		Object[] barr = ArrayLiteral.objectArray(b);
-		if (aarr.length != barr.length) {
-			throw new ValueExprEvaluationException("Arrays have incompatible dimensions");
-		}
-		try {
+		if ((a instanceof FloatArrayLiteral) && (b instanceof FloatArrayLiteral)) {
+			float[] aarr = ((FloatArrayLiteral) a).objectValue();
+			float[] barr = ((FloatArrayLiteral) b).objectValue();
+			if (aarr.length != barr.length) {
+				throw new ValueExprEvaluationException("Arrays have incompatible dimensions");
+			}
 			switch (op) {
 				case PLUS:
-					return new ArrayLiteral(add(aarr, barr));
+					return new FloatArrayLiteral(add(aarr, barr));
 				case MINUS:
-					return new ArrayLiteral(subtract(aarr, barr));
+					return new FloatArrayLiteral(subtract(aarr, barr));
 				default:
 					throw new AssertionError("Unsupported operator: " + op);
 			}
-		} catch (ClassCastException ex) {
-			throw new ValueExprEvaluationException(ex);
+		} else {
+			Object[] aarr = ObjectArrayLiteral.objectArray(a);
+			Object[] barr = ObjectArrayLiteral.objectArray(b);
+			if (aarr.length != barr.length) {
+				throw new ValueExprEvaluationException("Arrays have incompatible dimensions");
+			}
+			try {
+				switch (op) {
+					case PLUS:
+						return new ObjectArrayLiteral(add(aarr, barr));
+					case MINUS:
+						return new ObjectArrayLiteral(subtract(aarr, barr));
+					default:
+						throw new AssertionError("Unsupported operator: " + op);
+				}
+			} catch (ClassCastException ex) {
+				throw new ValueExprEvaluationException(ex);
+			}
+		}
+	}
+
+	private static float[] add(float[] a, float[] b) {
+		float[] y = new float[a.length];
+		for (int i=0; i<a.length; i++) {
+			y[i] = a[i] + b[i];
+		}
+		return y;
+	}
+
+	private static float[] subtract(float[] a, float[] b) {
+		float[] y = new float[a.length];
+		for (int i=0; i<a.length; i++) {
+			y[i] = a[i] - b[i];
 		}
+		return y;
 	}
 
 	private static Object[] add(Object[] a, Object[] b) {
@@ -100,45 +133,65 @@ private static Object[] subtract(Object[] a, Object[] b) {
 
 	private static Literal operationScalarMultiplyVector(Literal scalar, Literal vec, MathOp op, ValueFactory vf) {
 		CoreDatatype.XSD sdt = scalar.getCoreDatatype().asXSDDatatype().get();
-		Object[] arr = ArrayLiteral.objectArray(vec);
-		Object[] y = new Object[arr.length];
-		try {
-			for (int i=0; i<arr.length; i++) {
-				if (sdt == CoreDatatype.XSD.DOUBLE || sdt == CoreDatatype.XSD.DECIMAL || arr[i] instanceof Double) {
-					y[i] = scalar.doubleValue() * ((Number) arr[i]).doubleValue();
-				} else if (sdt == CoreDatatype.XSD.FLOAT || arr[i] instanceof Float) {
-					y[i] = scalar.floatValue() * ((Number) arr[i]).floatValue();
-				} else if (sdt == CoreDatatype.XSD.LONG || sdt == CoreDatatype.XSD.INTEGER || arr[i] instanceof Long) {
-					y[i] = scalar.longValue() * ((Number) arr[i]).longValue();
-				} else {
-					y[i] = scalar.intValue() * ((Number) arr[i]).intValue();
+		if ((sdt == CoreDatatype.XSD.FLOAT) && (vec instanceof FloatArrayLiteral)) {
+			float s = scalar.floatValue();
+			float[] v = ((FloatArrayLiteral) vec).objectValue();
+			float[] y = new float[v.length];
+			for (int i=0; i<v.length; i++) {
+				y[i] = s * v[i];
+			}
+			return new FloatArrayLiteral(y);
+		} else {
+			Object[] arr = ObjectArrayLiteral.objectArray(vec);
+			Object[] y = new Object[arr.length];
+			try {
+				for (int i=0; i<arr.length; i++) {
+					if (sdt == CoreDatatype.XSD.DOUBLE || sdt == CoreDatatype.XSD.DECIMAL || arr[i] instanceof Double) {
+						y[i] = scalar.doubleValue() * ((Number) arr[i]).doubleValue();
+					} else if (sdt == CoreDatatype.XSD.FLOAT || arr[i] instanceof Float) {
+						y[i] = scalar.floatValue() * ((Number) arr[i]).floatValue();
+					} else if (sdt == CoreDatatype.XSD.LONG || sdt == CoreDatatype.XSD.INTEGER || arr[i] instanceof Long) {
+						y[i] = scalar.longValue() * ((Number) arr[i]).longValue();
+					} else {
+						y[i] = scalar.intValue() * ((Number) arr[i]).intValue();
+					}
 				}
+			} catch (ClassCastException ex) {
+				throw new ValueExprEvaluationException(ex);
 			}
-		} catch (ClassCastException ex) {
-			throw new ValueExprEvaluationException(ex);
+			return new ObjectArrayLiteral(y);
 		}
-		return new ArrayLiteral(y);
 	}
 
 	private static Literal operationVectorDivideScalar(Literal vec, Literal scalar, MathOp op, ValueFactory vf) {
 		CoreDatatype.XSD sdt = scalar.getCoreDatatype().asXSDDatatype().get();
-		Object[] arr = ArrayLiteral.objectArray(vec);
-		Object[] y = new Object[arr.length];
-		try {
-			for (int i=0; i<arr.length; i++) {
-				if (sdt == CoreDatatype.XSD.DOUBLE || sdt == CoreDatatype.XSD.DECIMAL || arr[i] instanceof Double) {
-					y[i] = ((Number) arr[i]).doubleValue() / scalar.doubleValue();
-				} else if (sdt == CoreDatatype.XSD.FLOAT || arr[i] instanceof Float) {
-					y[i] = ((Number) arr[i]).floatValue() / scalar.floatValue();
-				} else if (sdt == CoreDatatype.XSD.LONG || sdt == CoreDatatype.XSD.INTEGER || arr[i] instanceof Long) {
-					y[i] = ((Number) arr[i]).doubleValue() / scalar.doubleValue();
-				} else {
-					y[i] = ((Number) arr[i]).floatValue() / scalar.floatValue();
+		if ((vec instanceof FloatArrayLiteral) && (sdt == CoreDatatype.XSD.FLOAT)) {
+			float[] v = ((FloatArrayLiteral) vec).objectValue();
+			float s = scalar.floatValue();
+			float[] y = new float[v.length];
+			for (int i=0; i<v.length; i++) {
+				y[i] = v[i] / s;
+			}
+			return new FloatArrayLiteral(y);
+		} else {
+			Object[] arr = ObjectArrayLiteral.objectArray(vec);
+			Object[] y = new Object[arr.length];
+			try {
+				for (int i=0; i<arr.length; i++) {
+					if (sdt == CoreDatatype.XSD.DOUBLE || sdt == CoreDatatype.XSD.DECIMAL || arr[i] instanceof Double) {
+						y[i] = ((Number) arr[i]).doubleValue() / scalar.doubleValue();
+					} else if (sdt == CoreDatatype.XSD.FLOAT || arr[i] instanceof Float) {
+						y[i] = ((Number) arr[i]).floatValue() / scalar.floatValue();
+					} else if (sdt == CoreDatatype.XSD.LONG || sdt == CoreDatatype.XSD.INTEGER || arr[i] instanceof Long) {
+						y[i] = ((Number) arr[i]).doubleValue() / scalar.doubleValue();
+					} else {
+						y[i] = ((Number) arr[i]).floatValue() / scalar.floatValue();
+					}
 				}
+			} catch (ClassCastException ex) {
+				throw new ValueExprEvaluationException(ex);
 			}
-		} catch (ClassCastException ex) {
-			throw new ValueExprEvaluationException(ex);
+			return new ObjectArrayLiteral(y);
 		}
-		return new ArrayLiteral(y);
 	}
 }
diff --git a/strategy/src/main/java/com/msd/gin/halyard/strategy/aggregators/GroupIntoArraysAggregateFactory.java b/strategy/src/main/java/com/msd/gin/halyard/strategy/aggregators/GroupIntoArraysAggregateFactory.java
index aad3e27dd..ec0bfe13c 100644
--- a/strategy/src/main/java/com/msd/gin/halyard/strategy/aggregators/GroupIntoArraysAggregateFactory.java
+++ b/strategy/src/main/java/com/msd/gin/halyard/strategy/aggregators/GroupIntoArraysAggregateFactory.java
@@ -1,6 +1,6 @@
 package com.msd.gin.halyard.strategy.aggregators;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.AbstractArrayLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 
 import java.util.function.Function;
@@ -29,7 +29,7 @@ public AggregateCollector getCollector() {
 		return new ValuesCollector(values -> {
 			// NB: values.size() is expensive
 			Value[] varr = values.toArray(new Value[0]);
-			return (varr.length > 0) ? ArrayLiteral.createFromValues(varr) : null;
+			return (varr.length > 0) ? AbstractArrayLiteral.createFromValues(varr) : null;
 		});
 	}
 }
diff --git a/strategy/src/test/java/com/msd/gin/halyard/strategy/HalyardStrategyExtendedTest.java b/strategy/src/test/java/com/msd/gin/halyard/strategy/HalyardStrategyExtendedTest.java
index e7c533cd4..6c542b119 100644
--- a/strategy/src/test/java/com/msd/gin/halyard/strategy/HalyardStrategyExtendedTest.java
+++ b/strategy/src/test/java/com/msd/gin/halyard/strategy/HalyardStrategyExtendedTest.java
@@ -19,7 +19,7 @@
 import static junit.framework.TestCase.assertFalse;
 import static junit.framework.TestCase.assertTrue;
 
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
 import com.msd.gin.halyard.model.vocabulary.SCHEMA_ORG;
 
@@ -320,16 +320,16 @@ public void testConstantIn() {
 
     @Test
     public void testVectorMath() {
-    	Literal a = new ArrayLiteral(3, 2.0, 0.5f);
-    	Literal b = new ArrayLiteral(-5.15f, 1, 2.32);
+    	Literal a = new ObjectArrayLiteral(3, 2.0, 0.5f);
+    	Literal b = new ObjectArrayLiteral(-5.15f, 1, 2.32);
 		String q = "SELECT (?a+?b as ?sum) (?a-?b as ?diff) (3*?a as ?mult) (?b/0.25 as ?div) { BIND("+a+" as ?a) BIND("+b+" as ?b) }";
 		try (TupleQueryResult res = con.prepareTupleQuery(q).evaluate()) {
 		    assertTrue(res.hasNext());
 		    BindingSet bs = res.next();
-		    assertArrayEquals(new Object[] {-2.1500000000000004,3,2.82}, ArrayLiteral.objectArray((Literal)bs.getValue("sum")));
-		    assertArrayEquals(new Object[] {8.15,1,-1.8199999999999998}, ArrayLiteral.objectArray((Literal)bs.getValue("diff")));
-		    assertArrayEquals(new Object[] {9l,6l,1.5}, ArrayLiteral.objectArray((Literal)bs.getValue("mult")));
-		    assertArrayEquals(new Object[] {-20.6,4.0,9.28}, ArrayLiteral.objectArray((Literal)bs.getValue("div")));
+		    assertArrayEquals(new Object[] {-2.1500000000000004,3,2.82}, ObjectArrayLiteral.objectArray((Literal)bs.getValue("sum")));
+		    assertArrayEquals(new Object[] {8.15,1,-1.8199999999999998}, ObjectArrayLiteral.objectArray((Literal)bs.getValue("diff")));
+		    assertArrayEquals(new Object[] {9l,6l,1.5}, ObjectArrayLiteral.objectArray((Literal)bs.getValue("mult")));
+		    assertArrayEquals(new Object[] {-20.6,4.0,9.28}, ObjectArrayLiteral.objectArray((Literal)bs.getValue("div")));
         }
     }
 
diff --git a/strategy/src/test/java/com/msd/gin/halyard/strategy/MathOpEvaluatorTest.java b/strategy/src/test/java/com/msd/gin/halyard/strategy/MathOpEvaluatorTest.java
new file mode 100644
index 000000000..1539caeec
--- /dev/null
+++ b/strategy/src/test/java/com/msd/gin/halyard/strategy/MathOpEvaluatorTest.java
@@ -0,0 +1,41 @@
+package com.msd.gin.halyard.strategy;
+
+import com.msd.gin.halyard.model.FloatArrayLiteral;
+
+import org.eclipse.rdf4j.model.Literal;
+import org.eclipse.rdf4j.model.ValueFactory;
+import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
+import org.eclipse.rdf4j.query.algebra.MathExpr.MathOp;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+public class MathOpEvaluatorTest {
+	@Test
+	public void testAdd_floatVector() {
+		ValueFactory vf = SimpleValueFactory.getInstance();
+		Literal r = new MathOpEvaluator().evaluate(new FloatArrayLiteral(0.7f, -1.2f), new FloatArrayLiteral(0.1f,0.5f), MathOp.PLUS, vf);
+		assertArrayEquals(new float[] {0.8f, -0.70000005f}, FloatArrayLiteral.floatArray(r));
+	}
+
+	@Test
+	public void testSubtract_floatVector() {
+		ValueFactory vf = SimpleValueFactory.getInstance();
+		Literal r = new MathOpEvaluator().evaluate(new FloatArrayLiteral(0.7f, -1.2f), new FloatArrayLiteral(0.1f,0.5f), MathOp.MINUS, vf);
+		assertArrayEquals(new float[] {0.59999996f, -1.7f}, FloatArrayLiteral.floatArray(r));
+	}
+
+	@Test
+	public void testScalarMultiply_floatVector() {
+		ValueFactory vf = SimpleValueFactory.getInstance();
+		Literal r = new MathOpEvaluator().evaluate(vf.createLiteral(0.7f), new FloatArrayLiteral(0.1f,0.5f), MathOp.MULTIPLY, vf);
+		assertArrayEquals(new float[] {0.07f, 0.35f}, FloatArrayLiteral.floatArray(r));
+	}
+
+	@Test
+	public void testScalarDivide_floatVector() {
+		ValueFactory vf = SimpleValueFactory.getInstance();
+		Literal r = new MathOpEvaluator().evaluate(new FloatArrayLiteral(-0.7f, 1.2f), vf.createLiteral(-0.15f), MathOp.DIVIDE, vf);
+		assertArrayEquals(new float[] {4.6666665f, -8.0f}, FloatArrayLiteral.floatArray(r));
+	}
+}
diff --git a/tools/src/main/java/com/msd/gin/halyard/tools/HalyardElasticIndexer.java b/tools/src/main/java/com/msd/gin/halyard/tools/HalyardElasticIndexer.java
index 56bb630ea..5c6c8b6c2 100644
--- a/tools/src/main/java/com/msd/gin/halyard/tools/HalyardElasticIndexer.java
+++ b/tools/src/main/java/com/msd/gin/halyard/tools/HalyardElasticIndexer.java
@@ -22,7 +22,7 @@
 import com.msd.gin.halyard.common.SSLSettings;
 import com.msd.gin.halyard.common.StatementIndex;
 import com.msd.gin.halyard.common.StatementIndices;
-import com.msd.gin.halyard.model.ArrayLiteral;
+import com.msd.gin.halyard.model.ObjectArrayLiteral;
 import com.msd.gin.halyard.model.TermRole;
 import com.msd.gin.halyard.model.TupleLiteral;
 import com.msd.gin.halyard.model.vocabulary.HALYARD;
@@ -33,6 +33,7 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.HttpURLConnection;
+import java.net.URI;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.security.GeneralSecurityException;
@@ -234,7 +235,7 @@ public int run(CommandLine cmd) throws Exception {
         configureIRI(cmd, 'g', null);
         String source = getConf().get(SOURCE_NAME_PROPERTY);
         String target = getConf().get(INDEX_URL_PROPERTY);
-        URL targetUrl = new URL(target);
+        URL targetUrl = new URI(target).toURL();
         String indexName = targetUrl.getPath().substring(1);
         boolean createIndex = getConf().getBoolean(CREATE_INDEX_PROPERTY, false);
         String snapshotPath = getConf().get(SNAPSHOT_PATH_PROPERTY);
@@ -492,7 +493,7 @@ private Object toObject(Value v) throws IOException {
 		   	    			return l.getLabel();
 		   				}
 		    		} else if (HALYARD.ARRAY_TYPE.equals(l.getDatatype())) {
-		    			return ArrayLiteral.objectArray(l);
+		    			return ObjectArrayLiteral.objectArray(l);
 		    		} else if (HALYARD.TUPLE_TYPE.equals(l.getDatatype())) {
 		    			Value[] varr = TupleLiteral.valueArray(l, valueFactory);
 		    			Object[] oarr = new Object[varr.length];