Skip to main content

Find out normal and trace in square matrix

Here given code implementation process.

/*
  C Program 
+ Find normal and trace of a matrix
*/
#include <stdio.h>
#include <math.h>
#define SIZE 3



void find_normal_trace(int matrix[][SIZE])
{
  if(SIZE <=0 )
  {
    return;
  }
  
  int normal = 0;
  //Calculate Normal
  for (int i = 0; i < SIZE; ++i)
  {
    for (int j = 0; j < SIZE; ++j)
    {
      normal += matrix[i][j] * matrix[i][j];
    }
  }

  printf("  Normal : %d\n",(int)sqrt(normal) );


  //Calculate Trace
  //This is sum of diagonal elements
  int trace = matrix[0][0];


  for (int i = 1; i < SIZE; ++i)
  {
    for (int j = 0; j < SIZE; ++j)
    {
      if(i == j )
      {
        //Calculate sum of diagonal elements
        trace += matrix[i][j];
      }
      
      
    }
  }
  
  printf("  Trace : %d\n",trace );
}
void show_data(int matrix[][SIZE])
{
  for (int i = 0; i < SIZE; ++i)
  {
    for (int j = 0; j < SIZE; ++j)
    {
      printf("%3d",matrix[i][j] );
    }
    printf("\n");
  }
  printf("\n");
}
int main(){

  int matrix[][SIZE] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 3}
  }; 
  show_data(matrix);
  find_normal_trace(matrix);



  return 0;
}

Output

  1  2  3
  4  5  6
  7  8  3

  Normal : 14
  Trace : 9
/*
  C++ Program
  Find normal and trace of a matrix
*/
#include<iostream>
#include <math.h>
#define SIZE 3
using namespace std;

class MyMatrix {
	public:
		int size;
	MyMatrix() {
		//Get matrix size
		//Assume that given matrix size is NXN 
		this->size = SIZE;
	}
	void find_normal_trace(int matrix[][SIZE]) {
		if (this->size <= 0) {
			return;
		}
		int normal = 0;
		//Calculate Normal

		for (int i = 0; i < this->size; ++i) {
			for (int j = 0; j < this->size; ++j) {
				normal += matrix[i][j] *matrix[i][j];
			}
		}
		cout << " Normal : " << (int) sqrt(normal) << "\n";
		//Calculate Trace
		//This is sum of diagonal elements
		int trace = matrix[0][0];
		for (int i = 1; i < this->size; ++i) {
			for (int j = 0; j < this->size; ++j) {
				if (i == j) {
					//Calculate sum of diagonal elements
					trace += matrix[i][j];
				}
			}
		}
		cout << " Trace : " << trace << "\n";
	}
	void show_data(int matrix[][SIZE]) {
		for (int i = 0; i < this->size; ++i) {
			for (int j = 0; j < this->size; ++j) {
				cout << " " << matrix[i][j];
			}
			cout << "\n";
		}
		cout << "\n";
	}
};
int main() {
	int matrix[][SIZE] = {
		{
			1,
			2,
			3
		},
		{
			4,
			5,
			6
		},
		{
			7,
			8,
			3
		}
	};
	MyMatrix obj;
	obj.show_data(matrix);
	obj.find_normal_trace(matrix);
	return 0;
}

Output

 1 2 3
 4 5 6
 7 8 3

 Normal : 14
 Trace : 9
/*
  Java Program
  Find normal and trace of a matrix
*/
public class MyMatrix {

  public int size;

  public MyMatrix(int [][]matrix)
  {
    //Get matrix size
    //Assume that given matrix size is NXN 
    this.size = matrix.length;
  }

  public void find_normal_trace(int [][]matrix)
  {
    if(this.size <=0 )
    {
      return;
    }
    
    int normal = 0;
    //Calculate Normal
    for (int i = 0; i < this.size; ++i)
    {
      for (int j = 0; j < this.size; ++j)
      {
        normal += matrix[i][j] * matrix[i][j];
      }
    }

    System.out.print(" Normal : "+(int)Math.sqrt(normal)+"\n" );


    //Calculate Trace
    //This is sum of diagonal elements
    int trace = matrix[0][0];


    for (int i = 1; i < this.size; ++i)
    {
      for (int j = 0; j < this.size; ++j)
      {
        if(i == j )
        {
          //Calculate sum of diagonal elements
          trace += matrix[i][j];
        }
        
        
      }
    }
    
    System.out.print(" Trace :  "+trace+"\n" );
  }
  public void show_data(int [][]matrix)
  {
    for (int i = 0; i < this.size; ++i)
    {
      for (int j = 0; j < this.size; ++j)
      {
        System.out.print("  "+matrix[i][j] );
      }
      System.out.print("\n");
    }
    System.out.print("\n");
  }
  public static void main(String[] args) 
  {
    //Define matrix element
    int [][]matrix =
    {
      {1, 2, 3},
      {4, 5, 6},
      {7, 8, 3}
    }; 
    MyMatrix obj = new MyMatrix(matrix);

    obj.show_data(matrix);
    obj.find_normal_trace(matrix);
  }
}

Output

 1 2 3
 4 5 6
 7 8 3

 Normal : 14
 Trace : 9
/*
  C# Program
  Find normal and trace of a matrix
*/
using System;
public class MyMatrix {
	int size;
	MyMatrix(int[,] matrix) {
		//Get matrix size
		//Assume that given matrix size is NXN 
		this.size = matrix.GetLength(0);
	}
	public void find_normal_trace(int[,] matrix) {
		if (this.size <= 0) {
			return;
		}
		int normal = 0;
		//Calculate Normal

		for (int i = 0; i < this.size; ++i) {
			for (int j = 0; j < this.size; ++j) {
				normal += matrix[i,j] * matrix[i,j];
			}
		}
		Console.Write(" Normal : " + (int) Math.Sqrt(normal) + "\n");
		//Calculate Trace
		//This is sum of diagonal elements
		int trace = matrix[0,0];
		for (int i = 1; i < this.size; ++i) {
			for (int j = 0; j < this.size; ++j) {
				if (i == j) {
					//Calculate sum of diagonal elements
					trace += matrix[i,j];
				}
			}
		}
		Console.Write(" Trace : " + trace + "\n");
	}
	public void show_data(int[,] matrix) {
		for (int i = 0; i < this.size; ++i) {
			for (int j = 0; j < this.size; ++j) {
				Console.Write(" " + matrix[i,j]);
			}
			Console.Write("\n");
		}
		Console.Write("\n");
	}
	public static void Main(String[] args) {
		int[,]
		//Define matrix element
		matrix = {
			{
				1,
				2,
				3
			},
			{
				4,
				5,
				6
			},
			{
				7,
				8,
				3
			}
		};
		MyMatrix obj = new MyMatrix(matrix);
		obj.show_data(matrix);
		obj.find_normal_trace(matrix);
	}
}

Output

 1 2 3
 4 5 6
 7 8 3

 Normal : 14
 Trace : 9
<?php
/*
  Php Program
  Find normal and trace of a matrix
*/
class MyMatrix {
	public $size;

	function __construct($matrix) {
		//Get matrix size
		//Assume that given matrix size is NXN 
		$this->size = count($matrix);
	}
	public 	function find_normal_trace($matrix) {
		if ($this->size <= 0) {
			return;
		}
		$normal = 0;
		//Calculate Normal

		for ($i = 0; $i < $this->size; ++$i) {
			for ($j = 0; $j < $this->size; ++$j) {
				$normal += $matrix[$i][$j] *$matrix[$i][$j];
			}
		}
		echo(" Normal : ". intval(sqrt($normal)) ."\n");
		//Calculate Trace
		//This is sum of diagonal elements
		$trace = $matrix[0][0];
		for ($i = 1; $i < $this->size; ++$i) {
			for ($j = 0; $j < $this->size; ++$j) {
				if ($i == $j) {
					//Calculate sum of diagonal elements
					$trace += $matrix[$i][$j];
				}
			}
		}
		echo(" Trace : ". $trace ."\n");
	}
	public 	function show_data($matrix) {
		for ($i = 0; $i < $this->size; ++$i) {
			for ($j = 0; $j < $this->size; ++$j) {
				echo(" ". $matrix[$i][$j]);
			}
			echo("\n");
		}
		echo("\n");
	}
}

function main() {
	//Define matrix element
	$matrix = array(array(1, 2, 3), array(4, 5, 6), array(7, 8, 3));
	$obj = new MyMatrix($matrix);
	$obj->show_data($matrix);
	$obj->find_normal_trace($matrix);

}
main();

Output

 1 2 3
 4 5 6
 7 8 3

 Normal : 14
 Trace : 9
/*
  Node Js Program
  Find normal and trace of a matrix
*/
class MyMatrix {
	;
	constructor(matrix) {
		//Get matrix size
		//Assume that given matrix size is NXN 
		this.size = matrix.length;
	}
	find_normal_trace(matrix) {
		if (this.size <= 0) {
			return;
		}
		var normal = 0;
		//Calculate Normal

		for (var i = 0; i < this.size; ++i) {
			for (var j = 0; j < this.size; ++j) {
				normal += matrix[i][j] *matrix[i][j];
			}
		}

		process.stdout.write(" Normal : " + parseInt(Math.sqrt(normal)) + "\n");
		//Calculate Trace
		//This is sum of diagonal elements
		var trace = matrix[0][0];
		for (var i = 1; i < this.size; ++i) {
			for (var j = 0; j < this.size; ++j) {
				if (i == j) {
					//Calculate sum of diagonal elements
					trace += matrix[i][j];
				}
			}
		}

		process.stdout.write(" Trace : " + trace + "\n");
	}
	show_data(matrix) {
		for (var i = 0; i < this.size; ++i) {
			for (var j = 0; j < this.size; ++j) {
				process.stdout.write(" " + matrix[i][j]);
			}

			process.stdout.write("\n");
		}

		process.stdout.write("\n");
	}
}

function main(args) {
	//Define matrix element
	var matrix = [
		[1, 2, 3],
		[4, 5, 6],
		[7, 8, 3]
	];
	var obj = new MyMatrix(matrix);
	obj.show_data(matrix);
	obj.find_normal_trace(matrix);
}

main();

Output

 1 2 3
 4 5 6
 7 8 3

 Normal : 14
 Trace : 9
#  Python 3 Program
#  Find normal and trace of a matrix
import math
class MyMatrix :
	
	def __init__(self, matrix) :
		# Get matrix size
		# Assume that given matrix size is NXN 
		self.size = len(matrix)
	
	def find_normal_trace(self, matrix) :
		if (self.size <= 0) :
			return
		
		normal = 0
		# Calculate Normal
		i = 0
		while (i < self.size) :
			j = 0
			while (j < self.size) :
				normal += matrix[i][j] * matrix[i][j]
				j += 1
			
			i += 1
		
		print(" Normal : ", int(math.sqrt(normal)) ,"\n", end = "")
		trace = matrix[0][0]
		i = 1
		while (i < self.size) :
			j = 0
			while (j < self.size) :
				if (i == j) :
					# Calculate sum of diagonal elements
					trace += matrix[i][j]
				
				j += 1
			
			i += 1
		
		print(" Trace : ", trace ,"\n", end = "")
	
	def show_data(self, matrix) :
		i = 0
		while (i < self.size) :
			j = 0
			while (j < self.size) :
				print(" ", matrix[i][j], end = "")
				j += 1
			
			print("\n", end = "")
			i += 1
		
		print("\n", end = "")
	

def main() :
	matrix = [
		[1, 2, 3],
		[4, 5, 6],
		[7, 8, 3]
	]
	obj = MyMatrix(matrix)
	obj.show_data(matrix)
	obj.find_normal_trace(matrix)


if __name__ == "__main__":
	main()

Output

  1  2  3
  4  5  6
  7  8  3

 Normal :  14
 Trace :  9
# Ruby Program
# Find normal and trace of a matrix
class MyMatrix 
	# Define the accessor and reader of class MyMatrix
	attr_reader :size
	attr_accessor :size
	def initialize(matrix) 
		# Get matrix size
		# Assume that given matrix size is NXN 
		self.size = matrix.length
	end
	def find_normal_trace(matrix) 
		if (self.size <= 0) 
			return
		end
		normal = 0
		# Calculate Normal
		i = 0
		while (i < self.size) 
			j = 0
			while (j < self.size) 
				normal += matrix[i][j] * matrix[i][j]
				j += 1
			end
			i += 1
		end
		print(" Normal  :", (Math.sqrt(normal)).to_i ,"\n")
		trace = matrix[0][0]
		i = 1
		while (i < self.size) 
			j = 0
			while (j < self.size) 
				if (i == j) 
					# Calculate sum of diagonal elements
					trace += matrix[i][j]
				end
				j += 1
			end
			i += 1
		end
		print(" Trace  :", trace ,"\n")
	end
	def show_data(matrix) 
		i = 0
		while (i < self.size) 
			j = 0
			while (j < self.size) 
				print(" ", matrix[i][j])
				j += 1
			end
			print("\n")
			i += 1
		end
		print("\n")
	end
end
def main() 
	matrix = [
		[1, 2, 3],
		[4, 5, 6],
		[7, 8, 3]
	]
	obj = MyMatrix.new(matrix)
	obj.show_data(matrix)
	obj.find_normal_trace(matrix)
end


main()

Output

 1 2 3
 4 5 6
 7 8 3

 Normal  :14
 Trace  :9

/*
  Scala Program
  Find normal and trace of a matrix
*/
class MyMatrix(var size: Int) {
	;

	def this(matrix: Array[Array[Int]]) {
		//Get matrix size
		//Assume that given matrix size is NXN 
		this(matrix.length);
	}
	def find_normal_trace(matrix: Array[Array[Int]]): Unit = {
		if (this.size <= 0) {
			return;
		}
		var normal: Int = 0;

		//Calculate Normal
		var i: Int = 0;
      	var j: Int = 0;
		while (i < this.size) {
			j = 0;
			while (j < this.size) {
				normal += matrix(i)(j) * matrix(i)(j);
				j += 1;
			}
			i += 1;
		}
		print(" Normal : " + (Math.sqrt(normal)).toInt + "\n");
		var trace: Int = matrix(0)(0);
		i = 1;
		while (i < this.size) {
			j = 0;
			while (j < this.size) {
				if (i == j) {
					//Calculate sum of diagonal elements
					trace += matrix(i)(j);
				}
				j += 1;
			}
			i += 1;
		}
		print(" Trace : " + trace + "\n");
	}
	def show_data(matrix: Array[Array[Int]]): Unit = {
		var i: Int = 0;
		while (i < this.size) {
			var j: Int = 0;
			while (j < this.size) {
				print(" " + matrix(i)(j));
				j += 1;
			}
			print("\n");
			i += 1;
		}
		print("\n");
	}
}
object Main {
	def main(args: Array[String]): Unit = {
		val matrix: Array[Array[Int]] = Array(
			Array(1, 2, 3),
			Array(4, 5, 6),
			Array(7, 8, 3));
		val obj: MyMatrix = new MyMatrix(matrix);
		obj.show_data(matrix);
		obj.find_normal_trace(matrix);
	}
}

Output

 1 2 3
 4 5 6
 7 8 3

 Normal : 14
 Trace : 9
/*
  Swift Program
  Find normal and trace of a matrix
*/
import Foundation
class MyMatrix {
	var size: Int;
	init(_ matrix: [
		[Int]
	]) {
		//Get matrix size
		//Assume that given matrix size is NXN 
		self.size = matrix.count;
	}
	func find_normal_trace(_ matrix: [
		[Int]
	]) {
		if (self.size <= 0) {
			return;
		}
		var normal: Int = 0;
		//Calculate Normal
		var i: Int = 0;
      	var j: Int = 0;
		while (i < self.size) {
			j = 0;
			while (j < self.size) {
				normal += matrix[i][j] * matrix[i][j];
				j += 1;
			}
			i += 1;
		}
		print(" Normal : ", Int(sqrt(Double(normal))) ,"\n", terminator: "");
		var trace: Int = matrix[0][0];
		i = 1;
		while (i < self.size) {
			j = 0;
			while (j < self.size) {
				if (i == j) {
					//Calculate sum of diagonal elements
					trace += matrix[i][j];
				}
				j += 1;
			}
			i += 1;
		}
		print(" Trace : ", trace ,"\n", terminator: "");
	}
	func show_data(_ matrix: [
		[Int]
	]) {
		var i: Int = 0;
		while (i < self.size) {
			var j: Int = 0;
			while (j < self.size) {
				print(" ", matrix[i][j], terminator: "");
				j += 1;
			}
			print("\n", terminator: "");
			i += 1;
		}
		print("\n", terminator: "");
	}
}
func main() {
	let matrix: [
		[Int]
	] = [
		[1, 2, 3],
		[4, 5, 6],
		[7, 8, 3]
	];
	let obj: MyMatrix = MyMatrix(matrix);
	obj.show_data(matrix);
	obj.find_normal_trace(matrix);
}
main();

Output

  1  2  3
  4  5  6
  7  8  3

 Normal :  14
 Trace :  9
Last updated on by Kalkicode




Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment