How can I correctly handle translation and scaling in matrix_float4x4 coordinate calculations?

I'm attempting to compute coordinates using a matrix_float4x4 and its inverse, but the results don't match my expectations.

I set up the basic height and width as follows:

SWIFTCopied
let rectWidth: CGFloat = 600
let rectHeight: CGFloat = 600

Then I set the origin by moving the view center:

SWIFTCopied
var viewCenter: CGSize = .zero
// move
viewCenter.width = 150
viewCenter.height = 150

I also use a scale value:

SWIFTCopied
var scale: CGFloat = 0.0
scale = 0.5

For two points, I calculate normalized device coordinates like this:

SWIFTCopied
print(SIMD2<Float>(((300 / Float(rectWidth)) * 2.0 - 1.0), ((150 / Float(rectHeight)) * 2.0 - 1.0)))
print(SIMD2<Float>(((600 / Float(rectWidth)) * 2.0 - 1.0), ((150 / Float(rectHeight)) * 2.0 - 1.0)))

The expected outputs are:

SIMD2(0.0, -0.5)
SIMD2(1.0, -0.5)

In my code, I generate the projection matrix as follows (with view matrix calculation):

SWIFTCopied
let viewMatrixCalculation = frameCorrdinate(centerX: Float(viewCenter.width), centerY: Float(viewCenter.height), basicWidth: Float(rectWidth), basicHight: Float(rectHeight), scale: Float(scale))
let matrix = matrix_ortho(left: viewMatrixCalculation.0, right: viewMatrixCalculation.1, bottom: viewMatrixCalculation.2, top: viewMatrixCalculation.3, nearZ: 0, farZ: 1)

func cameraPinchFrameCorrdinate(centerX: Float, centerY:Float, basicWidth: Float, basicHight: Float, scale: Float) -> (Float, Float, Float, Float) {
   // left
   let left = ((centerX - (basicWidth / 2) * scale) / basicWidth) * (2.0)
                
   // right
   let right = ((centerX + (basicWidth / 2) * scale) / basicWidth) * (2.0)
    
   // bottom
   let bottom = ((centerY - (basicHight / 2) * scale) / basicHight) * (2.0)
    
   // top
   let top = ((centerY + (basicHight / 2) * scale) / basicHight) * (2.0)
                
   return (left, right, bottom, top)
}

private func matrix_ortho(left: Float, right: Float, bottom: Float, top: Float, nearZ: Float, farZ: Float) -> matrix_float4x4 {
     let xs = 2 / (right - left)
     let ys = 2 / (top - bottom)
     let zs = -2 / (farZ - nearZ)

     return matrix_float4x4.init(columns: (vector_float4(xs, 0, 0, 0),
                                          vector_float4(0, ys, 0, 0),
                                           vector_float4(0, 0, zs, 0),
                                           vector_float4((left + right) / (left - right), (top + bottom) / (bottom - top), nearZ / (nearZ - farZ), 1)))
}

Later, I use the projection matrix (referred to as ProjMatrix) with:

```swift
print(positionCooordinate(touchX: ((300 / Float(rectWidth)) * 2.0 - 1.0), touchY: ((150 / Float(rectHeight)) * 2.0 - 1.0), cameraMatrix: cameraMatrix))
print(positionCooordinate(touchX: ((600 / Float(rectWidth)) * 2.0 - 1.0), touchY: ((150 / Float(rectHeight)) * 2.0 - 1.0), cameraMatrix: cameraMatrix))

And my coordinate conversion functions are defined as:

SWIFTCopied
func positionCooordinate(touchX: Float, touchY:Float, cameraMatrix: matrix_float4x4) -> SIMD2<Float> {
    //
    let viewMatrix = matrix4x4_translation(0, 0, 0)
    //
    let mousePos = SIMD4<Float>(touchX, touchY, 0, 1)
    //
    let inProjMatrix = cameraMatrix.inverse
    //
    let inViewMatrix = viewMatrix.inverse
    //
    let inversMatrix = simd_mul(inViewMatrix, inProjMatrix)
    //
    let mouseP = inversMatrix * mousePos
       
    let mousePX = mouseP[0]
    let mousePY = mouseP[1]
       
    return SIMD2<Float>(mousePX, mousePY)
}

// move matrix

```swift
func matrix4x4_translation(_ translationX: Float, _ translationY: Float, _ translationZ: Float) -> matrix_float4x4 {
   return matrix_float4x4.init(columns:(vector_float4(1, 0, 0, 0),
                                             vector_float4(0, 1, 0, 0),
                                             vector_float4(0, 0, 1, 0),
                                             vector_float4(translationX, translationY, translationZ, 1)))
}

The result is not as expected. My question is:

- Does using <code>matrix4x4_translation(0, 0, 0)</code> mean that the viewMatrix isn't reflecting the moved viewCenter?
- Since scaling is applied, should that factor be incorporated into the viewMatrix as well?

In summary, how should I correctly set up my transformation to account for both translation and scaling so that the coordinate conversion returns the expected values?