public static RDouble stripKeepNames(RDouble v) {
Names names = v.names();
if (v.size() == 1 && names == null) {
return new ScalarDoubleImpl(v.getDouble(0));
}
return new DoubleImpl(v, null, names, null);
}
public static boolean hasNAorNaN(RDouble d) {
int size = d.size();
for (int i = 0; i < size; i++) {
if (isNAorNaN(d.getDouble(i))) {
return true;
}
}
return false;
}
public static RInt double2int(
RDouble value, ConversionStatus warn) { // eager to keep error semantics eager
int size = value.size();
int[] content = new int[size];
for (int i = 0; i < size; i++) {
double d = value.getDouble(i);
content[i] = Convert.double2int(d, warn);
}
return RInt.RIntFactory.getFor(content, value.dimensions(), value.names());
}
public static RRaw doubleToRaw(
RDouble value, ConversionStatus warn) { // eager to keep error semantics eager
int size = value.size();
byte[] content = new byte[size];
for (int i = 0; i < size; i++) {
double dval = value.getDouble(i);
content[i] = Convert.double2raw(dval, warn);
}
return RRaw.RRawFactory.getFor(content, value.dimensions(), value.names());
}
@Override
public double getDouble(int i) {
assert Utils.check(i < size, "bounds check");
assert Utils.check(i >= 0, "bounds check");
if (i < excludeIndex) {
return orig.getDouble(i);
} else {
return orig.getDouble(i + 1);
}
}
public static RDouble exclude(int excludeIndex, RDouble orig) {
Names names = orig.names();
if (names == null) {
return new RDoubleExclusion(excludeIndex, orig);
}
int size = orig.size();
int nsize = size - 1;
double[] content = new double[nsize];
for (int i = 0; i < excludeIndex; i++) {
content[i] = orig.getDouble(i);
}
for (int i = excludeIndex; i < nsize; i++) {
content[i] = orig.getDouble(i + 1);
}
return RDoubleFactory.getFor(content, null, names.exclude(excludeIndex));
}
public static double[] copyAsDoubleArray(RDouble d) {
int size = d.size();
if (size == 1) {
return new double[] {d.getDouble(0)};
} else {
double[] res = new double[size];
if (d instanceof DoubleImpl) {
System.arraycopy(((DoubleImpl) d).getContent(), 0, res, 0, size);
} else {
for (int i = 0; i < size; i++) {
res[i] = d.getDouble(i);
}
}
return res;
}
}
@Override
public double getDouble(int i) {
int j = index.getInt(i);
assert Utils.check(j > 0);
if (j > vsize) {
return RDouble.NA;
} else {
return value.getDouble(j - 1);
}
}
public static RDouble convertNAandNaNtoZero(RDouble d) {
if (d instanceof ScalarDoubleImpl) {
ScalarDoubleImpl sd = (ScalarDoubleImpl) d;
if (sd.isNAorNaN()) {
return BOXED_ZERO;
} else {
return sd;
}
} else {
RDouble res = d.materialize();
double[] content = res.getContent();
for (int i = 0; i < content.length; i++) {
if (isNAorNaN(content[i])) {
content[i] = 0;
}
}
return res;
}
}
@Override
public void ref() {
orig.ref();
}
public static RDouble copy(RDouble d) {
if (d.size() == 1 && d.dimensions() == null && d.names() == null && d.attributes() == null) {
return new ScalarDoubleImpl(d.getDouble(0));
}
return new DoubleImpl(d, false);
}
public static RDouble strip(RDouble v) {
if (v.size() == 1) {
return new ScalarDoubleImpl(v.getDouble(0));
}
return new DoubleImpl(v, true);
}
@Override
public boolean dependsOn(RAny v) {
return value.dependsOn(v) || index.dependsOn(v);
}
@Override
public void ref() {
value.ref();
index.ref();
}
@Override
public boolean isSharedReal() {
return value.isShared() || index.isShared();
}
public RDoubleSubset(RDouble value, RInt index) {
this.value = value;
this.index = index;
this.isize = index.size();
this.vsize = value.size();
}
@Override
public boolean dependsOn(RAny value) {
return orig.dependsOn(value);
}
@Override
public boolean isSharedReal() {
return orig.isShared();
}
public RDoubleExclusion(int excludeIndex, RDouble orig) {
this.orig = orig;
this.excludeIndex = excludeIndex;
this.size = orig.size() - 1;
}