rename oth -> other

Author: schaumb

src/base/type/uniquelist.h

@@ -237,7 +237,7 @@ template <class T> class UniqueList
 	struct CommonIterateVal
 	{
 		const T &value;
-		const std::size_t *othIx;
+		const std::size_t *otherIx;
 	};
 
 	struct common_iterator

src/chart/generator/buckets.h

@@ -44,9 +44,10 @@ struct Buckets
 			    });
 		}
 
-		[[nodiscard]] bool operator!=(const const_iterator &oth) const
+		[[nodiscard]] bool operator!=(
+		    const const_iterator &other) const
 		{
-			return data.data() != oth.data.data();
+			return data.data() != other.data.data();
 		}
 
 		const_iterator &operator++();

src/chart/rendering/drawinterlacing.cpp

@@ -34,35 +34,36 @@ void DrawInterlacing::drawGeometries(Gen::AxisId axisIndex) const
 	    || guides.interlacings == false)
 		return;
 
-	std::map<double, double> othWeights{{0.0, 0.0}, {1.0, 0.0}};
+	std::map<double, double> otherWeights{{0.0, 0.0}, {1.0, 0.0}};
 
-	const auto &othGuides = parent.plot->guides.at(!axisIndex);
-	const auto &othAxisStyle =
+	const auto &otherGuides = parent.plot->guides.at(!axisIndex);
+	const auto &otherAxisStyle =
 	    parent.rootStyle.plot.getAxis(!axisIndex);
-	if (!othAxisStyle.interlacing.color->isTransparent()
-	    && othGuides.interlacings != false)
-		for (const auto &othInterval :
+	if (!otherAxisStyle.interlacing.color->isTransparent()
+	    && otherGuides.interlacings != false)
+		for (const auto &otherInterval :
 		    parent.getIntervals(!axisIndex)) {
-			if (Math::Floating::is_zero(othInterval.isSecond))
+			if (Math::Floating::is_zero(otherInterval.isSecond))
 				continue;
-			auto min = std::max(othInterval.range.getMin(), 0.0);
-			auto max = std::min(othInterval.range.getMax(), 1.0);
-			auto mprev = std::prev(othWeights.upper_bound(min));
-			auto mnext = othWeights.lower_bound(max);
+			auto min = std::max(otherInterval.range.getMin(), 0.0);
+			auto max = std::min(otherInterval.range.getMax(), 1.0);
+			auto mprev = std::prev(otherWeights.upper_bound(min));
+			auto mnext = otherWeights.lower_bound(max);
 
 			if (mprev->first < min)
-				mprev =
-				    othWeights.try_emplace(mprev, min, mprev->second);
+				mprev = otherWeights.try_emplace(mprev,
+				    min,
+				    mprev->second);
 			if (mnext->first > max)
-				mnext = othWeights.try_emplace(mnext,
+				mnext = otherWeights.try_emplace(mnext,
 				    max,
 				    std::prev(mnext)->second);
 
 			while (mprev != mnext)
 				mprev++->second +=
-				    Math::FuzzyBool::And<double>(othInterval.weight,
-				        othInterval.isSecond,
-				        othGuides.interlacings);
+				    Math::FuzzyBool::And<double>(otherInterval.weight,
+				        otherInterval.isSecond,
+				        otherGuides.interlacings);
 		}
 
 	auto orientation = !+axisIndex;
@@ -94,28 +95,28 @@ void DrawInterlacing::drawGeometries(Gen::AxisId axisIndex) const
 		    guides.interlacings);
 		auto interlacingColor = *axisStyle.interlacing.color * weight;
 
-		for (auto first = othWeights.begin(),
+		for (auto first = otherWeights.begin(),
 		          next = std::next(first),
-		          last = othWeights.end();
+		          last = otherWeights.end();
 		     next != last;
 		     ++next, ++first) {
 			if (Math::Floating::is_zero(first->second))
 				drawInterlacing(axisIndex,
 				    interlacingColor,
 				    rect(first->first, next->first));
 			else if (axisIndex == Gen::AxisId::y) {
-				auto color =
-				    interlacingColor
-				    + *othAxisStyle.interlacing.color * first->second;
-
-				color.alpha =
-				    1
-				    - (1
-				          - axisStyle.interlacing.color->alpha
-				                * weight)
-				          * (1
-				              - othAxisStyle.interlacing.color->alpha
-				                    * first->second);
+				auto color = interlacingColor
+				           + *otherAxisStyle.interlacing.color
+				                 * first->second;
+
+				color.alpha = 1
+				            - (1
+				                  - axisStyle.interlacing.color->alpha
+				                        * weight)
+				                  * (1
+				                      - otherAxisStyle.interlacing
+				                                .color->alpha
+				                            * first->second);
 
 				if (weight + first->second > 1.0)
 					color = Math::Niebloid::interpolate(

src/dataframe/impl/dataframe.cpp

@@ -347,7 +347,7 @@ void dataframe::add_series_by_other(std::string_view,
     const std::function<cell_value(record_type, cell_reference)> &,
     std::span<const std::pair<const char *, const char *>>) &
 {
-	if (as_if()) error(error_type::unimplemented, "by oth");
+	if (as_if()) error(error_type::unimplemented, "by other");
 }
 
 void dataframe::remove_series(

src/dataframe/interface.h

@@ -58,14 +58,14 @@ struct custom_aggregator
 	id_type (*create)();
 	double (*add)(id_type &, cell_reference const &);
 
-	auto operator<=>(const custom_aggregator &oth) const
+	auto operator<=>(const custom_aggregator &other) const
 	{
-		return name <=> oth.name;
+		return name <=> other.name;
 	}
 
-	auto operator==(const custom_aggregator &oth) const
+	auto operator==(const custom_aggregator &other) const
 	{
-		return name == oth.name;
+		return name == other.name;
 	}
 };
 

src/dataframe/old/datatable.cpp

@@ -55,9 +55,9 @@ void DataTable::pushRow(const std::span<const char *const> &cells)
 
 std::string DataTable::getInfos() const { return df.as_string(); }
 
-bool DataCube::iterator_t::operator!=(const iterator_t &oth) const
+bool DataCube::iterator_t::operator!=(const iterator_t &other) const
 {
-	return parent != oth.parent;
+	return parent != other.parent;
 }
 
 void DataCube::iterator_t::operator++() { parent->incr(*this); }

src/dataframe/old/datatable.h

@@ -125,7 +125,7 @@ class DataCube
 		const DataCube *parent{};
 		MultiIndex index;
 
-		[[nodiscard]] bool operator!=(const iterator_t &oth) const;
+		[[nodiscard]] bool operator!=(const iterator_t &other) const;
 
 		void operator++();