DEPARTAMENTO DE ELÉCTRICA Y ELECTRÓNICA

CARRERA DE:

INGENIERÍA ELECTRÓNICA EN TELECOMUNICACIONES

ASIGNATURA: TECNOLOGÍA DE SOFTWARE PARA ELECTRÓNICA

DEBER 1_1_3654

EJERCICIOS DE JNI

TUTOR: ING. EVELIO GRANIZO

NOMBRE: MARTINEZ DENNIS

FECHA: 2019-10-27

QUITO - ECUADOR
CONTENIDO

CONTENIDO................................................................................................................................................... 2
1. Ejercicio 1. ............................................................................................................................................... 3
1. Enunciado del Problema ...................................................................................................................... 3
2. Código del Programa ........................................................................................................................... 3
3. Prueba de Escritorio ............................................................................................................................ 4
4. Análisis de resultados .......................................................................................................................... 4
2. Ejercicio 2. ............................................................................................................................................... 5
1. Enunciado del Problema ...................................................................................................................... 5
2. Código del Programa ........................................................................................................................... 5
3. Prueba de Escritorio ............................................................................................................................ 6
4. Análisis de resultados .......................................................................................................................... 6
3. Ejercicio 3. ............................................................................................................................................... 7
1. Enunciado del Problema ...................................................................................................................... 7
2. Código del Programa ........................................................................................................................... 7
3. Prueba de Escritorio ............................................................................................................................ 9
4. Análisis de resultados ........................................................................................................................ 10
4. Ejercicio 4. ............................................................................................................................................. 11
1. Enunciado del Problema .................................................................................................................... 11
2. Código del Programa ......................................................................................................................... 11
3. Prueba de Escritorio .......................................................................................................................... 13
4. Análisis de resultados ........................................................................................................................ 14
5. Ejercicio 5. ............................................................................................................................................. 15
1. Enunciado del Problema .................................................................................................................... 15
2. Código del Programa ......................................................................................................................... 15
3. Prueba de Escritorio .......................................................................................................................... 17
4. Análisis de resultados ........................................................................................................................ 17
1. Ejercicio 1.

1. Enunciado del Problema

Escribir un programa en java que lea una cadena de caracteres llamada TEXTO, y
tenga un método nativo que reciba la cadena TEXTO para calcular la fr ecuencia
relativa de cada letra del alfabeto inglés en la cadena de caracteres. Luego en java
imprimir la cadena de caracteres y una tabla con cada letra y su frecuencia.

2. Código del Programa

// Abecedario.java
// Clase Abecedario
import java.util.Scanner;
public class Abecedario {
private native String pideTexto(String prompt);
private native int[] letra(String cadena);
public static void main( String args[] ) {
int repe[]=new int[58];
Scanner leer = new Scanner(System.in);
Abecedario p = new Abecedario();
System.out.println("Ingrese un Texto ");
String TEXTO=leer.nextLine();
String texto = p.pideTexto(TEXTO);
System.out.println("El texto sin caracteres especiales es: " + texto);
repe=p.letra(texto);
System.out.println("Letra Frecuencia");
for(int i=0;i<58;i++){
if(repe[i]!=0)
System.out.println(Character.toString((char)(i+65))+" "+repe[i]);

}
}
static {
System.loadLibrary( "Abecedario" );
}
}

// Abecedario.c
#include <jni.h>
#include <string.h>
#include <stdio.h>
#include "Abecedario.h"
JNIEXPORT jstring JNICALL
Java_Abecedario_pideTexto (JNIEnv *env, jobject obj, jstring prompt)
{
char buffer[128];
int j=0;
const jbyte* prompt_c = (*env)->GetStringUTFChars( env, prompt, NULL );
printf( "Texto Ingresado: ");
puts(prompt_c);

for(int i=0;i<strlen(prompt_c);i++){
int cad=0;
cad=prompt_c[i]-65;
if((cad>-1 && cad<26) || (cad>31 && cad<58) ){
buffer[j]=prompt_c[i];
j++;
}
}

(*env)->ReleaseStringUTFChars( env, prompt, prompt_c );

 return (*env)->NewStringUTF( env, buffer );
}
JNIEXPORT jintArray JNICALL
Java_Abecedario_letra (JNIEnv *env, jobject obj, jstring cadena)
{
const jbyte* T = (*env)->GetStringUTFChars( env, cadena, NULL );
jint* arreglo;
jint cad;
jintArray C;
C = (*env)->NewIntArray( env, 60);
arreglo= (jint*)(*env)->GetPrimitiveArrayCritical( env,C, NULL );
for(int i=0;i<strlen(T);i++){
cad=0;
cad=T[i]-65;
if((cad>-1 && cad<26) || (cad>31 && cad<58) ){
arreglo[cad]=arreglo[cad]+1;
}
}
(*env)->ReleaseStringUTFChars( env, cadena,T );
(*env)->ReleasePrimitiveArrayCritical( env, C , arreglo, 0 );
return C;
}

3. Prueba de Escritorio

4. Análisis de resultados
El programa nos indica la frecuencia relativa de cada letra, comprueba la primera letra de la
palabra ingresada y la compara, al ser iguales es contada y enviada por medio de mensaje
a la pantalla y asi sucesivamente para cada letra.
2. Ejercicio 2.

1. Enunciado del Problema

Realizar un programa en java que tenga un método nativo que acepte como parámetro una cadena de
caracteres arbitraria y que determine si se trata de una cadena de caracteres palíndromo o no. Un palíndromo
es una cadena de caracteres que se lee igual hacia adelante que hacia atrás, considerando que en los textos
más complejos se ignoran los espacios y los signos de puntuación. Por ejemplo, las siguientes cadenas de
caracteres son palíndromos: "OSO" y "Ana ama mamá Ana". El programa en java debe ingresar varias
cadenas de caracteres, imprimirlas y determine cuáles son cadenas de caracteres palíndromos.

2. Código del Programa

// Palindromo.java
// Clase Palindromo
import java.util.Scanner;
public class Palindromo {
private native boolean pideTexto(String prompt);
public static void main( String args[] ) {
Scanner leer = new Scanner(System.in);
Palindromo p = new Palindromo();
System.out.println("Cuantas frases desea ingresar");
String f[] =new String[100];
int num=leer.nextInt();
String a=leer.nextLine();

for(int i=0;i<num;i++){
System.out.println("Digite la frase "+(i+1)+" :");
f[i]=leer.nextLine();
}

for(int i=0;i<num;i++){
System.out.print("Frase: "+f[i]+ " -> ");
if(p.pideTexto(f[i])==false)
System.out.println("No es una cadena palindromo");
else
System.out.println("Si es una cadena palindromo");
}
}
static {
System.loadLibrary( "Palindromo" );
}
}
//Palindromo.c
#include <jni.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>
#include "Palindromo.h"
JNIEXPORT jboolean JNICALL
Java_Palindromo_pideTexto (JNIEnv *env, jobject obj, jstring prompt)
{
const jbyte* TEXTO = (*env)->GetStringUTFChars( env, prompt, NULL );
char palabra[128]="",palabran[128]="";
int j=0;
bool pal=false;

for(int i=0;i<strlen(TEXTO);i++){
if(TEXTO[i]>=97 && TEXTO[i]<=122){
palabra[j]=TEXTO[i];
j++;
}
 if((TEXTO[i]>=65 && TEXTO[i]<=90)){
palabra[j]=TEXTO[i]+32;
j++;
}
}

int longi=strlen(palabra);

for (int k=0;k<longi;k++){

palabran[k]=palabra[longi-k-1];
}

(*env)->ReleaseStringUTFChars( env, prompt,TEXTO);

if(strcmp(palabra,palabran)==0)
return true;
else
return false;

3. Prueba de Escritorio

4. Análisis de resultados
En este programa podemos entender el concepto de palabra palíndromo es muy importante
especificar la definición al momento de programar se da una comparación para saber si es
palíndromo.
3. Ejercicio 3.

1. Enunciado del Problema

Una empresa le paga por comisión a su personal de ventas. Los vendedores reciben
una cantidad entera de 200 dólares por semana más el 9% de sus ventas brutas de
dicha semana.
Por ejemplo, un vendedor que vende 3000 dólares en ventas brutas en una semana
recibe 200 dólares más el 9% de 3000 dólares, o sea un total de 470 dólares.
Escribir un programa en java que ingrese desde teclado las ventas de los
vendedores, utilizando un arreglo que determine cuántos de los vendedores
ganaron salarios en cada uno de los r angos siguientes:

1. 200 - 299 dólares

2. 300 - 399 dólares
3. 400 - 499 dólares
4. 500 - 599 dólares
5. 600 - 699 dólares
6. 700 - 799 dólares
7. 800 - 899 dólares
8. 900 - 999 dólares
9. 1000 dólares o más

El programa java debe tener un método nativo con un arreglo de las ventas de los
vendedores como parámetro, este método retorna un arreglo con los el número de
vendedores que ganaron salarios en cada uno de los rangos indicados
anteriormente.

2. Código del Programa

// Salarios.java
// Clase Salarios
import java.util.Scanner;
import java.io.*;
public class Salarios {

private native int[] sumaArreglos(int[]A, int[]B);

public static void main( String args[] ) {

Salarios p = new Salarios();

Scanner reader = new Scanner(System.in);
int cant;
System.out.println("Ingrese la cantidad de personas: ");
cant = reader.nextInt();

while(cant<=0){
System.out.println("Reingrese: ");
cant=reader.nextInt();
}
 int[] A = new int [cant];
int[] B = new int [cant];

for(int i=0; i<A.length; i++){

System.out.println("=====>EMPLEADO "+(i+1)+" ");
System.out.print("Semanas de trabajo:");
A[i]=reader.nextInt();

while(A[i]<=0){
System.out.println("Reingrese: ");
A[i]=reader.nextInt();
}

System.out.print("Ganancias en dolares:");
B[i]=reader.nextInt();

while(B[i]<=0){
System.out.println("Reingrese: ");
B[i]=reader.nextInt();
}}

int[] C = p.sumaArreglos(A, B);

System.out.println("RESULTADOS");

for(int i=0; i<C.length; i++){

System.out.println(""+(i+1)+": "+C[i]); }

int c1=0,c2=0,c3=0,c4=0,c5=0,c6=0,c7=0,c8=0,c9=0;

for(int i=0; i<C.length; i++){

if(C[i]>=200 && C[i]<=299){
c1++;
}
if(C[i]>=300 && C[i]<=399){
c2++;
}
if(C[i]>=400 && C[i]<=499){
c3++;
}
if(C[i]>=500 && C[i]<=599){
c4++;
}
if(C[i]>=600 && C[i]<=699){
c5++;
}
if(C[i]>=700 && C[i]<=799){
c6++;
}
if(C[i]>800 && C[i]<=899){
c7++;
}
if(C[i]>900 && C[i]<=999){
c8++;
}
if(C[i]>=1000){
c9++;
}
}
System.out.println("==========>TABLA CON RESULTADOS<==========");
System.out.println("1. 200 - 299 Existen:"+c1+" personas.");
System.out.println("2. 300 - 399 Existen:"+c2+" personas.");
System.out.println("3. 400 - 499 Existen:"+c3+" personas.");
System.out.println("4. 500 - 599 Existen:"+c4+" personas.");
System.out.println("5. 600 - 699 Existen:"+c5+" personas.");
System.out.println("6. 700 - 799 Existen:"+c6+" personas.");
 System.out.println("7. 800 - 899 Existen:"+c7+" personas.");
System.out.println("8. 900 - 999 Existen:"+c8+" personas.");
System.out.println("9. 1000 o mas Existen:"+c9+" personas.");
}

static {
System.loadLibrary( "Salarios" );
}
}

// Salarios.c

#include <jni.h>
#include "Salarios.h"

JNIEXPORT jintArray JNICALL

Java_Salarios_sumaArreglos (JNIEnv *env, jobject obj, jintArray arregloA, jintArray arregloB)
{
jintArray arregloC;
jint* A;
jint* B;
jint* C;
jsize i;
jsize longitud = (*env)->GetArrayLength( env, arregloA );
// Creamos un nuevo arreglo con la solución
arregloC = (*env)->NewIntArray( env, longitud );

A = (jint*)(*env)->GetPrimitiveArrayCritical( env, arregloA, NULL );

B = (jint*)(*env)->GetPrimitiveArrayCritical( env, arregloB, NULL );
C = (jint*)(*env)->GetPrimitiveArrayCritical( env, arregloC, NULL );

for ( i=0; i < longitud; i++ )

C[i]=B[i]*(0.09)+A[i]*200;
(*env)->ReleasePrimitiveArrayCritical( env, arregloA, A, JNI_ABORT );
(*env)->ReleasePrimitiveArrayCritical( env, arregloB, B, JNI_ABORT );
(*env)->ReleasePrimitiveArrayCritical( env, arregloC, C, 0 );

return arregloC;
}

3. Prueba de Escritorio
 4. Análisis de resultados
En este programa se ingresa un número n de empleados, se requiere de cuantas semanas
esta y cuantas ganancias de ventas tuvo. Así se realiza el estimado de cuando esta ganando
y lo mostramos en una tabla.
4. Ejercicio 4.

1. Enunciado del Problema

Ordenar una lista de n números en punto flotante de modo que se pueda realizar cualquiera de las siguientes
ordenaciones en métodos nativos:
a) Menor a mayor en magnitud
b) Menor a mayor algebraicamente (por signo)
c) Mayor a menor en magnitud
d) Mayor a menor algebraicamente (por signo)
Escribir un programa en java que lea un arreglo unidimensional de n elementos en punto flotante e incluir un
menú que permita al usuario seleccionar una de las ordenaciones anteriores para ejecutar ese programa.

2. Código del Programa

// Ordenar.java
// Clase Ordenar
import java.util.Scanner;

public class Ordenar {

private native float[] Mms(float[] arreglo);
private native float[] mMs(float[] arreglo);
private native float[] Mm(float[] arreglo);
private native float[] mM(float[] arreglo);
public static void main( String args[] ) {
Scanner leer = new Scanner(System.in);
Ordenar p = new Ordenar();

System.out.println("Ingrese una list de n números");

int cuan=leer.nextInt();
float ubi[] =new float[cuan];
float list[] =new float[cuan];

for(int i=0;i<cuan;i++){
System.out.println("Ingrese el elemento "+(i+1)+" :");
list[i]=leer.nextFloat();
}

int men=0;
do{
System.out.println("");
System.out.println("--------MENU DE ORDENACION------");
System.out.println("Como desea Ordenar el arreglo?");
System.out.println("1. Menor a mayor en magnitud");
System.out.println("2. Menor a mayor algebraicamente (por signo)");
System.out.println("3. Mayor a menor en magnitud");
System.out.println("4. Mayor a menor algebraicamente (por signo)");
System.out.println("5. Salir");
men=leer.nextInt();
if(men<=4 && men>=1){
System.out.println("Vector Original");
for(int i=0;i<cuan;i++)
System.out.print(list[i]+ ", ");
System.out.println("");

switch(men){
case 1:
System.out.println("El arreglo de menor a mayor en magnitud");
ubi=p.mM(list);
break;
case 2:
System.out.println("El arreglo de menor a mayor algebraicamente (por
signo)");
ubi=p.mMs(list);
 break;
case 3:
System.out.println("El arreglo de mayor a menor en magnitud");
ubi=p.Mm(list);
break;
case 4:
System.out.println("El arreglo de mayor a menor algebraicamente (por
signo)");
ubi=p.Mms(list);
break;
}

for(int i=0;i<cuan;i++)
System.out.print(ubi[i]+ ", ");

}
else if(men==5)
System.out.print("Fin del Programa");
else
System.out.print("menion incorrecta, porfavor ingrese un cuanero del 1 al 5");
}while(men!=5);
}
static {
System.loadLibrary( "Ordenar" );
}
}
// Ordenar.c
#include <jni.h>
#include <stdio.h>
#include <math.h>
#include "Ordenar.h"
JNIEXPORT jfloatArray JNICALL
Java_Ordenar_Mms(JNIEnv *env, jobject obj, jfloatArray arreglo)
{
jfloat* arre;
arre= (*env)->GetFloatArrayElements (env, arreglo, NULL);
jsize numero = (*env)->GetArrayLength( env, arreglo );
float aux;
for(int i=0;i<numero;i++){
for(int j=i+1;j<numero;j++){
if(arre[i]<arre[j]){
aux=arre[i];
arre[i]=arre[j];
arre[j]=aux;
}
}
}

(*env)->ReleaseFloatArrayElements (env, arreglo, arre,0);

return arreglo;

JNIEXPORT jfloatArray JNICALL

Java_Ordenar_mMs(JNIEnv *env, jobject obj, jfloatArray arreglo)
{
jfloat* arre;
arre= (*env)->GetFloatArrayElements (env, arreglo, NULL);
jsize numero = (*env)->GetArrayLength( env, arreglo );
float aux;
for(int i=0;i<numero;i++){
for(int j=i+1;j<numero;j++){
if(arre[i]>arre[j]){
aux=arre[i];
arre[i]=arre[j];
 arre[j]=aux;
}
}
}
(*env)->ReleaseFloatArrayElements (env, arreglo, arre,0);

return arreglo;

JNIEXPORT jfloatArray JNICALL

Java_Ordenar_Mm(JNIEnv *env, jobject obj, jfloatArray arreglo)
{
jfloat* arre;
arre= (*env)->GetFloatArrayElements (env, arreglo, NULL);
jsize numero = (*env)->GetArrayLength( env, arreglo );
float aux;
for(int i=0;i<numero;i++){
for(int j=i+1;j<numero;j++){
if(fabs(arre[i])<fabs(arre[j])){
aux=arre[i];
arre[i]=arre[j];
arre[j]=aux;
}
}
}
(*env)->ReleaseFloatArrayElements (env, arreglo, arre,0);

return arreglo;

JNIEXPORT jfloatArray JNICALL

Java_Ordenar_mM(JNIEnv *env, jobject obj, jfloatArray arreglo)
{
jfloat* arre;
arre= (*env)->GetFloatArrayElements (env, arreglo, NULL);
jsize numero = (*env)->GetArrayLength( env, arreglo );
float aux;

for(int i=0;i<numero;i++){
for(int j=i+1;j<numero;j++){
if(fabs(arre[i])>fabs(arre[j])){
aux=arre[i];
arre[i]=arre[j];
arre[j]=aux;
}
}
}

(*env)->ReleaseFloatArrayElements (env, arreglo, arre,0);

return arreglo;

3. Prueba de Escritorio
 4. Análisis de resultados
Este programa ordena de Menor a mayor en magnitud, Menor a mayor algebraicamente (por signo),
Mayor a menor en magnitud, Mayor a menor algebraicamente (por signo); se puede observar que los
vectores son ordenados de menor a mayor y depende de la opción que escojamos.
5. Ejercicio 5.

1. Enunciado del Problema

Escribir un programa en java para procesar las notas de un grupo de estudiantes en un curso de
programación. Empezar especificando el número de notas del examen para cada estudiante (asumir que este
valor es el mismo para todos los estudiantes de la clase). Después introducir el nombre de cada estudiante y
las notas de los exámenes con pesos desiguales de las notas de los exámenes individuales, por lo que
también deben ser ingresados. Por ejemplo, asumir que cada uno de los primeros cuatro exámenes
contribuye con el 15 a 100 de nota final y cada uno de los dos últimos con el 20 por 100.

Almacenar los nombres de los estudiantes en un arreglo de caracteres y las notas en un arreglo
bidimensional de punto flotante. Hacer el programa lo más general posible. A continuación en métodos
nativos calcular la media para cada estudiante, la media de la clase, y la desviación de la media de cada
estudiante respecto de la media general. Luego imprimir la ponderación de cada examen y etiquetar
claramente la salida como se muestra en el siguiente ejemplo:

2. Código del Programa

// Notasprogra.java
// Clase Notasprogra
import java.util.Scanner;
public class Notasprogra {
private native float[] getmedia(int[][] A, float[] B);
private native float getmediaClase(float[] A);
private native float[] getmedia(float[] A,float media);

public static void main( String args[] ) {

Notasprogra p=new Notasprogra();
Scanner leer = new Scanner(System.in);
System.out.print("Ingrese la cantidad de notas para el examen: ");
int cuan=leer.nextInt();
System.out.print("Cuantos alum desea ingresar: ");
int cuan2=leer.nextInt();
float autsos[] =new float[cuan];
int lista [][]=new int[cuan2][cuan];
String alum[] =new String[cuan2];
float media[]= new float[cuan2];
float medias[]= new float[cuan2];

for(int i=0;i<cuan2;i++){
System.out.print("Ingrese el nombre del alumno "+(i+1)+": ");
alum[i]=leer.next();
}

String[] n,aut;
for(int i=0;i<cuan2;i++){
for(int j=0;j<cuan;j++){
System.out.print("Ingrese la nota "+ (j+1)+ " de " +alum[i]+": ");
lista[i][j]=leer.nextInt();
}
 }

for(int i=0;i<cuan;i++){
System.out.print("Ingrese el peso en porcentaje de la nota "+(i+1)+": ");
autsos[i]=leer.nextFloat();
}

media=p.getmedia(lista, autsos);
float media_clase=p.getmediaClase(media);
medias=p.getmedia(media, media_clase);
System.out.println("Nombre Notasprogra de examenes(Porcentajes) Promedio
Desviacion");

for(int i=0;i<cuan2;i++){
System.out.print(alum[i]+" \t");
for(int j=0;j<cuan;j++)
System.out.print(lista[i][j]+"\t");
System.out.print(media[i]+"\t");
System.out.print(medias[i]+"\t");
System.out.println("");
}
System.out.println("Media de la clase: "+media_clase);
}
static {
System.loadLibrary( "Notasprogra" );
}
}
// Notasprogra.c
#include <jni.h>
#include "Notasprogra.h"
# include <stdio.h>

JNIEXPORT jfloatArray JNICALL

Java_Notasprogra_getmedias(JNIEnv *env, jobject obj,jobjectArray A, jfloatArray B)
{
jfloatArray media;
jfloat* porcentaje;
jfloat* med;
jsize aua = (*env)->GetArrayLength( env, A );
jsize aun = (*env)->GetArrayLength( env, B );
porcentaje = (jfloat*)(*env)->GetPrimitiveArrayCritical(env,B,NULL);
media = (*env)->NewFloatArray(env,aua);
med = (jfloat*)(*env)->GetPrimitiveArrayCritical(env,media,NULL);

for ( int i=0; i<aua; i++ ) {

med[i]=0;
jint* buffernotas;
jfloat* buffermed;
jintArray notas = (jintArray)(*env)->GetObjectArrayElement( env, A, i );
buffernotas = (*env)->GetIntArrayElements(env, notas ,NULL);
for ( int j=0; j<aun; j++ ){
med[i]=med[i]+(buffernotas[j]*porcentaje[j]/100);
}
(*env)->ReleasePrimitiveArrayCritical( env, media,med, 0 );
(*env)->ReleaseIntArrayElements( env, notas, buffernotas, JNI_ABORT );
(*env)->DeleteLocalRef( env, notas );
}
return media;
}

JNIEXPORT jfloat JNICALL

Java_Notasprogra_getmediaClase(JNIEnv *env, jobject obj, jfloatArray A)
{
jfloat media;
jfloat* medias;
 medias = (*env)->GetFloatArrayElements(env, A ,NULL);
jsize aua = (*env)->GetArrayLength( env, A );

for ( int i=0; i<aua; i++ )

media=media+medias[i];
media=media/aua;
(*env)->ReleasePrimitiveArrayCritical( env,A, medias, JNI_ABORT );
return media;
}

JNIEXPORT jfloatArray JNICALL

Java_Notasprogra_getmedia(JNIEnv *env, jobject obj,jfloatArray A, jfloat mediaClase)
{
jfloat* medias;
jfloat* M;
jfloatArray media;
jsize aua = (*env)->GetArrayLength( env, A );
medias = (*env)->GetFloatArrayElements(env, A ,NULL);
media = (*env)->NewFloatArray(env,aua);
M = (jfloat*)(*env)->GetPrimitiveArrayCritical(env,media,NULL);
for ( int i=0; i<aua; i++ )
M[i]=mediaClase-medias[i];
(*env)->ReleaseFloatArrayElements(env, A ,medias,JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical( env, media,M, 0 );
return media;
}

3. Prueba de Escritorio

4. Análisis de resultados
En este programa ingresamos notas para sacar promedios de estudiantes, es un uso que se
implementa para calcular notas de los alumnos, es muy importante saber como podemos
ingresar y guardar en cada vector y hacer los cálculos respectivos