Principal Operaciones y Figuras

Metodo principal para Operaciones y Figuras:

//Una pequeña clase prinsipal que sirve para elejir el metodo que deseas usar
import java.util.*;
class OperacionesDos{

public static void main( String args[] ){
Scanner leer = new Scanner( System.in );

double a, b, x=0;
int op=0;

OperacionesYFiguras OYF = new OperacionesYFiguras();


//En la clase OperacionesYFiguras tiene mas metodos ingrese los que crea nesesario para el menu
//MENU
System.out.println( "1. Suma" );
System.out.println( "2. Resta" );
System.out.println( "3. Multiplicacion" );
System.out.println( "4. Division" );
System.out.println( "5. Modulo" );
System.out.print( "Seleccione una operacion:" );
op=leer.nextInt();

//Pide los datos para realisar la operacion
System.out.print( "Ingrese el primer numero:" );
a=leer.nextDouble();
System.out.print( "Ingrese el segundo numero:" );
b=leer.nextDouble();

//Dependiendo el menu es dependiendo cuantos "case()" se nesesitaran
switch(op){

   case(1):x = OYF.suma( a,b );
   break;
 
   case(2):x = OYF.resta( a,b );
   break;
 
   case(3):x = OYF.multiplicacion( a,b );
   break;
     
   case(4):x = OYF.division( a,b );
   break;
 
   case(5):x = OYF.modulo( a,b );
   break;
     
   }
 
System.out.print( "El resultado de la operacion es:"+x );
}

}
 

Metodo Operaciones y Figuras

Metodos:

public class OperacionesYFiguras{

/*Suma*/
public double suma( double a,double b ){
return( a+b );}
public int suma( int a,int b ){
return( a+b );}

/*Resta*/
public double resta( double a,double b ){
return( a-b );}
public int resta( int a,int b ){
return( a-b );}

/*Multiplicacion*/
public double multiplicacion( double a,double b ){
return( a*b );}
public int multiplicacion( int a,int b ){
return( a*b );}

/*Divicion*/
public double division( double a,double b ){
double c;
c=( b!=0 )?a/b:0;
return ( c );}
public int division( int a,int b ){
int c;
c=( b!=0 )?a/b:0;
return ( c );}

/*Modulo*/
public double modulo( double a,double b ){
double c;
c=( b!=0 )?a%b:0;
return( c );}
public int modulo( int a,int b ){
int c;
c=( b!=0 )?a%b:0;
return( c );}

/*Potencia*/
public double Potenciacion( double x,int n ){
return( Math.pow( x,n ));}
public double Potenciacion( int x,int n ){
return( Math.pow( x,n ));}

/*Potencia 2*/
public double potenciacion2( double x,int n ){
return( 1/Math.pow( x,n ));}
public double potenciacion2( int x,int n ){
return( 1/Math.pow( x,n ));}

/*Factorial*/
public double factorial( double n ){
if( n==0 )
return 1;
else
return n*factorial(n-1);}
public int factorial( int n ){
if( n==0 )
return 1;
else
return n*factorial(n-1);}

/*Cubo*/
//Volumen del cbno
public double volumenCubo( double l ){
return( l*l*l );}
public int volumenCubo( int l ){
return( l*l*l );}

//Area Base del cobo
public double areaBaseCubo( double l ){
return( l*l );}
public int areaBaseCubo( int l ){
return( l*l );}

//Area Lado del cobo
public double areaLadoCubo( double l ){
return( 4*Math.pow(l,2) );}
public double areaLadoCubo( int l ){
return( 4*Math.pow(l,2) );}

//Area Superior del cobo
public double areaSupCubo( double l ){
return( 6*Math.pow(l,2) );}
public double areaSupCubo( int l ){
return( 6*Math.pow(l,2) );}

/*Paralilepipedo*/
//Volumen Paralilepipedo
public double volumenParalilepipedo( double a, double b, double c ){
return( a*b*c );}
public int volumenParalilepipedo( int a, int b, int c ){
return( a*b*c );}

//Area Base Paralilepipedo
public double areaBaseParalilepipedo( double a, double b ){
return( a*b );}
public int areaBaseParalilepipedo( int a, int b ){
return( a*b );}

//Area Superior Paralilepipedo
public double areaSupParalilepipedo( double a, double b, double c ){
return( 2*( a*b+a*c+b*c ) );}
public double areaSupParalilepipedo( int a, int b, int c ){
return( 2*( a*b+a*c+b*c ) );}

/*Cilindro*/
//Volumen Cilindro
public double volumenCilindro( double r, double h ){
return( Math.PI*((r*r)*h) );}
public double volumenCilindro( int r, int h ){
return( Math.PI*((r*r)*h) );}

//Area Base Cilindro
public double areaBaseCilindro( double r ){
return( Math.PI*Math.pow(r,2) );}
public double areaBaseCilindro( int r ){
return( Math.PI*Math.pow(r,2) );}

//Area Superior Cilindro
public double areaSupCilindro( double r, double h ){
return( 2*Math.PI*(r*h) );}
public double areaSupCilindro( int r, int h ){
return( 2*Math.PI*(r*h));}

/*Esfera*/
//Volumen Esfera
public double volumenEsfera( double r ){
return( 4/3*(Math.PI*Math.pow(r,3)) );}
public double volumenCilindro( int r ){
return( 4/3*(Math.PI*Math.pow(r,3)) );}

//Area Superior Esfera
public double areaSupEsfera( double r, double h ){
return( 4*(Math.PI*Math.pow(r,2)));}
public double areaSupEsfera( int r, int h ){
return( 4*(Math.PI*Math.pow(r,2)));}

/*Cono*/
//Volumen Cono
public double volumenCono( double r, double h ){
return( (Math.PI*(Math.pow( r,2 )*h) )/3 );}
public double volumenCono( int r, int h ){
return( (Math.PI*(Math.pow( r,2 )*h) )/3 );}

//Area Lado Cono
public double areaLadoCono( double r, double h ){
return( ((Math.PI*r)*Math.sqrt(Math.pow(r,2)+Math.pow(h,2)))/2);}
public double areaLadoCono( int r, int h ){
return( ((Math.PI*r)*Math.sqrt(Math.pow(r,2)+Math.pow(h,2)))/2);}

//Area Superior Cono
public double areaSupCono( double r, double h ){
return((Math.PI*r)*Math.sqrt((Math.pow(r,2)+Math.pow(h,2))+Math.PI*Math.pow(r,2)));}
public double areaSupCono( int r, int h ){
return((Math.PI*r)*Math.sqrt((Math.pow(r,2)+Math.pow(h,2))+Math.PI*Math.pow(r,2)));}


}

Principal Vectores

Metodo principal para vector:

import java.io.*;
import java.util.*;

public class Vector{
public static void main (String args[]){
Scanner leer = new Scanner (System.in);
int n;
Metodos met = new Metodos();

System.out.print("Ingresa el numero de renglones del vector");
n=leer.nextInt();
int a[] = met.leerVector(n);
int b[] = met.leerVector(n);
//Dependiendo el metodo es el nombre que le pondran por ejemplo "met.sumaVector, met.restaVector, met.multiplicacionVector
int c[] = met.sumaVector(a,b);
met.escribeVector(c);
}
}

Metodo Vectores

Metodos

import java.util.*;
public class Metodos{
Scanner leer = new Scanner (System.in);

//Leer vectores.
public int[] leerVector (int n){
int i;
int x[] = new int [n];
System.out.println("Leer elementos del vector");
for (i=0 ; i<x.length ; i++){
x[i] = leer.nextInt();}
return (x);
}

//Suma vectores.
public int[] sumaVector (int a[], int b[]){
int i, n=a.length;
int c[] = new int [n];
for (i=0 ; i<c.length ; i++){
c[i] = a[i] + b[i];}
return (c);
}

//Resta vectores.
public int[] restaVector (int a[], int b[]){
int i, n=a.length;
int c[] = new int [n];
for (i=0 ; i<c.length ; i++){
c[i] = a[i] - b[i];}
return (c);
}

//Multiplicacion vectores.
public int[] multiplicacionVector (int a[], int b[]){
int i, n=a.length;
int c[] = new int [n];
for (i=0 ; i<c.length ; i++){
c[i] = a[i] * b[i];}
return (c);
}


//Escribe vectores.
public void escribeVector (int c[]){
int i;
for (i=0 ; i<c.length ; i++){
System.out.println(c[i]);}
}

}

Principal Matrices

Metodo principal para la matriz:

import java.io.*;
import java.util.*;

public class Matriz{
public static void main (String args[]){
Scanner leer = new Scanner (System.in);
int m,n;
Metodos met = new Metodos();
System.out.print("Ingresa el numero de renglones de la matriz");
m=leer.nextInt();
System.out.print("Ingresa el numero de colubnas de la matriz");
n=leer.nextInt();
double a[][] = met.leerMatriz(m,n);
double b[][] = met.leerMatriz(m,n);
//Dependiendo el metodo es el nombre que le pondran por ejemplo "met.sumaMatriz, met.restaMariz, met.multiplicacionMatriz, etc."
double c[][] = met.sumaMatriz(a,b);
met.escribeMatriz(c);
}
}

Metodo Matrices

METODOS:

import java.util.*;
public class Metodos{
Scanner leer = new Scanner (System.in);

//Leer matrices.
public double[][] leerMatriz (int m, int n){
int i,j;
double x[][] = new double [m][n];
System.out.println("Leer elementos de la matriz");
for (i=0 ; i<x.length ; i++){
for (j=0 ; j<x[0].length ; j++){
x[i][j] = leer.nextInt();}
}
return (x);
}

//Sumar matrices.
public double [][]sumaMatriz (double a[][], double b[][]){
int i,j, m=a.length,n=a[0].length;
double c[][] = new double [m][n];
for (i=0 ; i<c.length ; i++){
for (j=0 ; j<c[0].length ; j++){
c[i][j] = a[i][j] + b[i][j];}
}
return (c);
}

//Resta matrices.
public double [][]restaMatriz (double a[][], double b[][]){
int i,j, m=a.length,n=a[0].length;
double c[][] = new double [m][n];
for (i=0 ; i<c.length ; i++){
for (j=0 ; j<c[0].length ; j++){
c[i][j] = a[i][j] - b[i][j];}
}
return (c);
}

//Multiplicacion matrices.
public double [][]multiplicacionMatriz (double a[][], double b[][]){
int i,j,k, m=a.length,n=a[0].length;
double c[][] = new double [m][n];
for (i=0 ; i<c.length ; i++){
for (j=0 ; j<c[0].length ; j++){
c[i][j] = 0;
for (k=0 ; k<c.length ; k++){
c[i][j] = c[i][j] + a[i][k] * b[k][j];}
}
}
return (c);
}

//Transpuesta matrices.
public double [][]transpuestaMatriz (double a[][]){
int i,j, m=a.length,n=a[0].length;
double c[][] = new double [m][n];
for (i=0 ; i<c.length ; i++){
for (j=0 ; j<c[0].length ; j++){
c[i][j] = a[j][i];}
}
return (c);
}

//Diagonal matrices.
public double [][] diagonalMatriz (double a[][]){
int i,j, n=a.length;
double c[][] = new double [n][n];
for ( i=0;i<c.length;i++){
for ( j=0;j<c[0].length;j++){
c[i][j] =(i==j)?1:0;}
}
return (c);
}

//Cuadrado matrices.
public double [][] cuadroMatriz (double a[][]){
int i,j, n=a.length;
double c[][] = new double [n][n];
for ( i=0;i<c.length;i++){
for ( j=0;j<c[0].length;j++){
if((i==0)||(j==0)||(i==c.length-1)||(j==c[0].length-1))
c[i][j]=1;
else
c[i][j]=0;}
}
return (c);
}

//CuadroDiagonal matrices.
public double [][] CuadroDiagonal( int n ){
double c[][]= new double [n][n];
for(int i=0; i<c.length; i++ ){
for(int j=0; j<c[0].length; j++ ){
if((i==0)||(j==0)||(i==j)||(n-1-i==j)||(i==c.length-1)||(j==c[0].length-1))
c[i][j]=1;
else
c[i][j]=0;}
}
return (c);
}

//Escribe matrices.
public void escribeMatriz (double c[][]){
int i,j;
for (i=0 ; i<c.length ; i++){
for (j=0 ; j<c[0].length ; j++){
System.out.print("\t"+c[i][j]);}
System.out.println();}
}
}