Skip to content

Commit

Permalink
[Rust] Rename ChunkCompare::eq to ChunkCompare::equal (#1826)
Browse files Browse the repository at this point in the history
  • Loading branch information
@ibENPC
ibENPC committed Nov 19, 2021
1 parent 42eaf72 commit e442937
Show file tree
Hide file tree
Showing 10 changed files with 101 additions and 97 deletions.
114 changes: 57 additions & 57 deletions polars/polars-core/src/chunked_array/comparison.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -61,19 +61,19 @@ where
impl_eq_missing!(self, rhs)
}

fn eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked {
fn equal(&self, rhs: &ChunkedArray<T>) -> BooleanChunked {
// broadcast
match (self.len(), rhs.len()) {
(_, 1) => {
if let Some(value) = rhs.get(0) {
self.eq(value)
self.equal(value)
} else {
BooleanChunked::full("", false, self.len())
}
}
(1, _) => {
if let Some(value) = self.get(0) {
rhs.eq(value)
rhs.equal(value)
} else {
BooleanChunked::full("", false, rhs.len())
}
Expand All @@ -86,19 +86,19 @@ where
}
}

fn neq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked {
fn not_equal(&self, rhs: &ChunkedArray<T>) -> BooleanChunked {
// broadcast
match (self.len(), rhs.len()) {
(_, 1) => {
if let Some(value) = rhs.get(0) {
self.neq(value)
self.not_equal(value)
} else {
BooleanChunked::full("", false, self.len())
}
}
(1, _) => {
if let Some(value) = self.get(0) {
rhs.neq(value)
rhs.not_equal(value)
} else {
BooleanChunked::full("", false, rhs.len())
}
Expand Down Expand Up @@ -231,7 +231,7 @@ impl ChunkCompare<&BooleanChunked> for BooleanChunked {
impl_eq_missing!(self, rhs)
}

fn eq(&self, rhs: &BooleanChunked) -> BooleanChunked {
fn equal(&self, rhs: &BooleanChunked) -> BooleanChunked {
// broadcast
match (self.len(), rhs.len()) {
(_, 1) => {
Expand Down Expand Up @@ -262,7 +262,7 @@ impl ChunkCompare<&BooleanChunked> for BooleanChunked {
}
}

fn neq(&self, rhs: &BooleanChunked) -> BooleanChunked {
fn not_equal(&self, rhs: &BooleanChunked) -> BooleanChunked {
// broadcast
match (self.len(), rhs.len()) {
(_, 1) => {
Expand Down Expand Up @@ -451,17 +451,17 @@ impl ChunkCompare<&Utf8Chunked> for Utf8Chunked {
impl_eq_missing!(self, rhs)
}

fn eq(&self, rhs: &Utf8Chunked) -> BooleanChunked {
fn equal(&self, rhs: &Utf8Chunked) -> BooleanChunked {
// broadcast
if rhs.len() == 1 {
if let Some(value) = rhs.get(0) {
self.eq(value)
self.equal(value)
} else {
BooleanChunked::full("", false, self.len())
}
} else if self.len() == 1 {
if let Some(value) = self.get(0) {
rhs.eq(value)
rhs.equal(value)
} else {
BooleanChunked::full("", false, self.len())
}
Expand All @@ -474,17 +474,17 @@ impl ChunkCompare<&Utf8Chunked> for Utf8Chunked {
}
}

fn neq(&self, rhs: &Utf8Chunked) -> BooleanChunked {
fn not_equal(&self, rhs: &Utf8Chunked) -> BooleanChunked {
// broadcast
if rhs.len() == 1 {
if let Some(value) = rhs.get(0) {
self.neq(value)
self.not_equal(value)
} else {
BooleanChunked::full("", false, self.len())
}
} else if self.len() == 1 {
if let Some(value) = self.get(0) {
rhs.neq(value)
rhs.not_equal(value)
} else {
BooleanChunked::full("", false, self.len())
}
Expand Down Expand Up @@ -612,14 +612,14 @@ where
Rhs: ToPrimitive,
{
fn eq_missing(&self, rhs: Rhs) -> BooleanChunked {
self.eq(rhs)
self.equal(rhs)
}

fn eq(&self, rhs: Rhs) -> BooleanChunked {
fn equal(&self, rhs: Rhs) -> BooleanChunked {
self.primitive_compare_scalar(rhs, |l, rhs| comparison::eq_scalar(l, rhs))
}

fn neq(&self, rhs: Rhs) -> BooleanChunked {
fn not_equal(&self, rhs: Rhs) -> BooleanChunked {
self.primitive_compare_scalar(rhs, |l, rhs| comparison::neq_scalar(l, rhs))
}

Expand Down Expand Up @@ -653,13 +653,13 @@ impl Utf8Chunked {

impl ChunkCompare<&str> for Utf8Chunked {
fn eq_missing(&self, rhs: &str) -> BooleanChunked {
self.eq(rhs)
self.equal(rhs)
}

fn eq(&self, rhs: &str) -> BooleanChunked {
fn equal(&self, rhs: &str) -> BooleanChunked {
self.utf8_compare_scalar(rhs, |l, rhs| comparison::eq_scalar(l, rhs))
}
fn neq(&self, rhs: &str) -> BooleanChunked {
fn not_equal(&self, rhs: &str) -> BooleanChunked {
self.utf8_compare_scalar(rhs, |l, rhs| comparison::neq_scalar(l, rhs))
}

Expand Down Expand Up @@ -717,12 +717,12 @@ impl ChunkCompare<&ListChunked> for ListChunked {
impl_cmp_list!(self, rhs, series_equal_missing)
}

fn eq(&self, rhs: &ListChunked) -> BooleanChunked {
fn equal(&self, rhs: &ListChunked) -> BooleanChunked {
impl_cmp_list!(self, rhs, series_equal)
}

fn neq(&self, rhs: &ListChunked) -> BooleanChunked {
self.eq(rhs).not()
fn not_equal(&self, rhs: &ListChunked) -> BooleanChunked {
self.equal(rhs).not()
}

// following are not implemented because gt, lt comparison of series don't make sense
Expand Down Expand Up @@ -861,19 +861,19 @@ mod test {
let (a1, a2) = create_two_chunked();

assert_eq!(
a1.eq(&a2).into_iter().collect_vec(),
a1.equal(&a2).into_iter().collect_vec(),
repeat(Some(true)).take(6).collect_vec()
);
assert_eq!(
a2.eq(&a1).into_iter().collect_vec(),
a2.equal(&a1).into_iter().collect_vec(),
repeat(Some(true)).take(6).collect_vec()
);
assert_eq!(
a1.neq(&a2).into_iter().collect_vec(),
a1.not_equal(&a2).into_iter().collect_vec(),
repeat(Some(false)).take(6).collect_vec()
);
assert_eq!(
a2.neq(&a1).into_iter().collect_vec(),
a2.not_equal(&a1).into_iter().collect_vec(),
repeat(Some(false)).take(6).collect_vec()
);
assert_eq!(
Expand Down Expand Up @@ -916,19 +916,19 @@ mod test {
let a2 = get_chunked_array();

assert_eq!(
a1.eq(&a2).into_iter().collect_vec(),
a1.equal(&a2).into_iter().collect_vec(),
repeat(Some(true)).take(3).collect_vec()
);
assert_eq!(
a2.eq(&a1).into_iter().collect_vec(),
a2.equal(&a1).into_iter().collect_vec(),
repeat(Some(true)).take(3).collect_vec()
);
assert_eq!(
a1.neq(&a2).into_iter().collect_vec(),
a1.not_equal(&a2).into_iter().collect_vec(),
repeat(Some(false)).take(3).collect_vec()
);
assert_eq!(
a2.neq(&a1).into_iter().collect_vec(),
a2.not_equal(&a1).into_iter().collect_vec(),
repeat(Some(false)).take(3).collect_vec()
);
assert_eq!(
Expand Down Expand Up @@ -979,17 +979,17 @@ mod test {
a2_2chunks.append(&(&[Some(3)]).iter().copied().collect());

assert_eq!(
a1.eq(&a2).into_iter().collect_vec(),
a1.eq(&a2_2chunks).into_iter().collect_vec()
a1.equal(&a2).into_iter().collect_vec(),
a1.equal(&a2_2chunks).into_iter().collect_vec()
);

assert_eq!(
a1.neq(&a2).into_iter().collect_vec(),
a1.neq(&a2_2chunks).into_iter().collect_vec()
a1.not_equal(&a2).into_iter().collect_vec(),
a1.not_equal(&a2_2chunks).into_iter().collect_vec()
);
assert_eq!(
a1.neq(&a2).into_iter().collect_vec(),
a2_2chunks.neq(&a1).into_iter().collect_vec()
a1.not_equal(&a2).into_iter().collect_vec(),
a2_2chunks.not_equal(&a1).into_iter().collect_vec()
);

assert_eq!(
Expand Down Expand Up @@ -1036,8 +1036,8 @@ mod test {
let a1: Int32Chunked = (&[Some(1), Some(2)]).iter().copied().collect();
let a1 = a1.slice(1, 1);
let a2: Int32Chunked = (&[Some(2)]).iter().copied().collect();
assert_eq!(a1.eq(&a2).sum(), a2.eq(&a1).sum());
assert_eq!(a1.neq(&a2).sum(), a2.neq(&a1).sum());
assert_eq!(a1.equal(&a2).sum(), a2.equal(&a1).sum());
assert_eq!(a1.not_equal(&a2).sum(), a2.not_equal(&a1).sum());
assert_eq!(a1.gt(&a2).sum(), a2.gt(&a1).sum());
assert_eq!(a1.lt(&a2).sum(), a2.lt(&a1).sum());
assert_eq!(a1.lt_eq(&a2).sum(), a2.lt_eq(&a1).sum());
Expand All @@ -1046,8 +1046,8 @@ mod test {
let a1: Utf8Chunked = (&["a", "b"]).iter().copied().collect();
let a1 = a1.slice(1, 1);
let a2: Utf8Chunked = (&["b"]).iter().copied().collect();
assert_eq!(a1.eq(&a2).sum(), a2.eq(&a1).sum());
assert_eq!(a1.neq(&a2).sum(), a2.neq(&a1).sum());
assert_eq!(a1.equal(&a2).sum(), a2.equal(&a1).sum());
assert_eq!(a1.not_equal(&a2).sum(), a2.not_equal(&a1).sum());
assert_eq!(a1.gt(&a2).sum(), a2.gt(&a1).sum());
assert_eq!(a1.lt(&a2).sum(), a2.lt(&a1).sum());
assert_eq!(a1.lt_eq(&a2).sum(), a2.lt_eq(&a1).sum());
Expand All @@ -1073,22 +1073,22 @@ mod test {
let true_ = BooleanChunked::new_from_slice("", &[true]);
let false_ = BooleanChunked::new_from_slice("", &[false]);

let out = a.eq(&true_);
let out = a.equal(&true_);
assert_eq!(Vec::from(&out), &[Some(true), Some(false), Some(true)]);
let out = true_.eq(&a);
let out = true_.equal(&a);
assert_eq!(Vec::from(&out), &[Some(true), Some(false), Some(true)]);
let out = a.eq(&false_);
let out = a.equal(&false_);
assert_eq!(Vec::from(&out), &[Some(false), Some(true), Some(false)]);
let out = false_.eq(&a);
let out = false_.equal(&a);
assert_eq!(Vec::from(&out), &[Some(false), Some(true), Some(false)]);

let out = a.neq(&true_);
let out = a.not_equal(&true_);
assert_eq!(Vec::from(&out), &[Some(false), Some(true), Some(false)]);
let out = true_.neq(&a);
let out = true_.not_equal(&a);
assert_eq!(Vec::from(&out), &[Some(false), Some(true), Some(false)]);
let out = a.neq(&false_);
let out = a.not_equal(&false_);
assert_eq!(Vec::from(&out), &[Some(true), Some(false), Some(true)]);
let out = false_.neq(&a);
let out = false_.not_equal(&a);
assert_eq!(Vec::from(&out), &[Some(true), Some(false), Some(true)]);

let out = a.gt(&true_);
Expand Down Expand Up @@ -1134,22 +1134,22 @@ mod test {
let one = Int32Chunked::new_from_slice("", &[1]);
let three = Int32Chunked::new_from_slice("", &[3]);

let out = a.eq(&one);
let out = a.equal(&one);
assert_eq!(Vec::from(&out), &[Some(true), Some(false), Some(false)]);
let out = one.eq(&a);
let out = one.equal(&a);
assert_eq!(Vec::from(&out), &[Some(true), Some(false), Some(false)]);
let out = a.eq(&three);
let out = a.equal(&three);
assert_eq!(Vec::from(&out), &[Some(false), Some(false), Some(true)]);
let out = three.eq(&a);
let out = three.equal(&a);
assert_eq!(Vec::from(&out), &[Some(false), Some(false), Some(true)]);

let out = a.neq(&one);
let out = a.not_equal(&one);
assert_eq!(Vec::from(&out), &[Some(false), Some(true), Some(true)]);
let out = one.neq(&a);
let out = one.not_equal(&a);
assert_eq!(Vec::from(&out), &[Some(false), Some(true), Some(true)]);
let out = a.neq(&three);
let out = a.not_equal(&three);
assert_eq!(Vec::from(&out), &[Some(true), Some(true), Some(false)]);
let out = three.neq(&a);
let out = three.not_equal(&a);
assert_eq!(Vec::from(&out), &[Some(true), Some(true), Some(false)]);

let out = a.gt(&one);
Expand Down
6 changes: 3 additions & 3 deletions polars/polars-core/src/chunked_array/ops/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -414,7 +414,7 @@ pub trait ChunkVar<T> {
/// fn filter_all_ones(df: &DataFrame) -> Result<DataFrame> {
/// let mask = df
/// .column("column_a")?
/// .eq(1);
/// .equal(1);
///
/// df.filter(&mask)
/// }
Expand All @@ -424,10 +424,10 @@ pub trait ChunkCompare<Rhs> {
fn eq_missing(&self, rhs: Rhs) -> BooleanChunked;

/// Check for equality.
fn eq(&self, rhs: Rhs) -> BooleanChunked;
fn equal(&self, rhs: Rhs) -> BooleanChunked;

/// Check for inequality.
fn neq(&self, rhs: Rhs) -> BooleanChunked;
fn not_equal(&self, rhs: Rhs) -> BooleanChunked;

/// Greater than comparison.
fn gt(&self, rhs: Rhs) -> BooleanChunked;
Expand Down
2 changes: 1 addition & 1 deletion polars/polars-core/src/chunked_array/ops/take/take_single.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -188,7 +188,7 @@ mod test {
fn test_oob() {
let data: Series = [1.0, 2.0, 3.0].iter().collect();
let data = data.f64().unwrap();
let matches = data.eq(5.0);
let matches = data.equal(5.0);
let matches_indexes = matches.arg_true();
matches_indexes.get(0);
}
Expand Down
4 changes: 2 additions & 2 deletions polars/polars-core/src/chunked_array/ops/unique/rank.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -80,7 +80,7 @@ pub(crate) fn rank(s: &Series, method: RankMethod) -> Series {
// in bounds
let arr = unsafe { s.take_unchecked(&sort_idx_ca).unwrap() };
let not_consecutive_same = (&arr.slice(1, len - 1))
.neq(&arr.slice(0, len - 1))
.not_equal(&arr.slice(0, len - 1))
.rechunk();
let obs = not_consecutive_same.downcast_iter().next().unwrap();

Expand Down Expand Up @@ -132,7 +132,7 @@ pub(crate) fn rank(s: &Series, method: RankMethod) -> Series {
let arr = unsafe { s.take_unchecked(&sort_idx_ca).unwrap() };
let validity = arr.chunks()[0].validity().cloned();
let not_consecutive_same = (&arr.slice(1, len - 1))
.neq(&arr.slice(0, len - 1))
.not_equal(&arr.slice(0, len - 1))
.rechunk();
// this obs is shorter than that of scipy stats, because we can just start the cumsum by 1
// instead of 0
Expand Down
8 changes: 4 additions & 4 deletions polars/polars-core/src/frame/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2156,7 +2156,7 @@ impl DataFrame {
// make sure that we do not divide by zero
// by replacing with None
let value_length = value_length
.set(&value_length.eq(0), None)?
.set(&value_length.equal(0), None)?
.into_series()
.cast(&DataType::Float64)?;

Expand Down Expand Up @@ -2508,7 +2508,7 @@ mod test {
#[cfg_attr(miri, ignore)]
fn test_select() {
let df = create_frame();
assert_eq!(df.column("days").unwrap().eq(1).sum(), Some(1));
assert_eq!(df.column("days").unwrap().equal(1).sum(), Some(1));
}

#[test]
Expand All @@ -2517,7 +2517,7 @@ mod test {
let df = create_frame();
println!("{}", df.column("days").unwrap());
println!("{:?}", df);
println!("{:?}", df.filter(&df.column("days").unwrap().eq(0)))
println!("{:?}", df.filter(&df.column("days").unwrap().equal(0)))
}

#[test]
Expand All @@ -2530,7 +2530,7 @@ mod test {
println!("{}", df.column(col_name).unwrap());
println!("{:?}", df);

df = df.filter(&df.column(col_name).unwrap().eq("")).unwrap();
df = df.filter(&df.column(col_name).unwrap().equal("")).unwrap();
assert_eq!(df.column(col_name).unwrap().n_chunks(), 1);
println!("{:?}", df);
}
Expand Down

0 comments on commit e442937

Please sign in to comment.