I have a question on where to put the logic in the following hypothetical:

There’s this class that, at it’s basis, has an int[]. There’s a method that takes the int[]s of two of these classes and returns a third int[].

My question is: where should this logic reside, and why?

Option 1

The first option would be inside the class:

public class SomeClass{
    public int[] publicData;
    // additional contextual data here
    
    SomeClass PerformCalculation(SomeClass otherClass){
        // accesses publicData from both classes and returns a new SomeClass-object
    }
}

Which means you get the following implementation:

var firstClass = new SomeClass();
var secondClass = new SomeClass();
var result = firstClass.PerformCalculation(SecondClass);
// or: secondClass.PerformCalculation(firstClass)

Option 2

The second option would be outside the class:

public class SomeClass{
    public int[] publicData;
    // additional contextual data here
}

public class SomeCalculator{
    public SomeClass PerformCalculation(SomeClass firstClass, SomeClass secondClass){
        // accesses publicData from both classes
        // and returns a new SomeClass-object
    }
}

giving the following implementation:

var firstClass = new SomeClass();
var secondClass = new SomeClass();
var result = _calculator.PerformCalculation(firstClass, secondClass); // _calculator is created via DI

Option 3

Finally, there is a third option, where only the int[] is used:

public class SomeCalculator{
    public int[] PerformCalculation(int[] firstData, int[] secondData){
        // return only the calculated int[]
    }
}

var firstData = new int[]{1,2,3};
var secondData = new int[]{4,5,6};
var result = _calculator.PerformCalculation(firstData, secondData); // _calculator is created via DI

Context

The first option is more OOP, the second more procedural (if I’m correct in my terminology).
In all cases, the operations performed on the int[]s in PerformCalculation is core domain logic; it’s not an arbitrary function that ends up in a helper class.
SomeClass is also part of this domain, giving rise to option 1. Here, the creation of a new SomeClass-object is also non-arbitrary and would warrant the inclusion of PerformCalculation into the class.
At the same time, because the core operations in PerformCalculation is only done on two int[]s, without any required context, options 2 and 3 are also possible.

My question is: which option is best and under what circumstances?