MATLAB: Write a function called integerize that takes as its input a matrix A of integers of type double, and returns the name of the “smallest” signed integer class to which A can be converted without loss of information.

data typeshomeworkintroduction to programming

function text = integerize (A)
minimo = min(min(A));
i8 = intmin('int8'); maxi8 = intmax('int8');
i16 = intmin('int16'); maxi16 = intmax('int16');
i32 = intmin('int32'); maxi32 = intmax('int32');
i64 = intmin('int64'); maxi64 = intmax('int64');
if minimo >= i8 && minimo <= maxi8
    text = 'int8';
elseif minimo >= i16 && minimo <= maxi16
    text = 'int16';
elseif minimo >= i32 && minimo <= maxi32
    text = 'int32';
elseif minimo >= i64&& minimo <= maxi64
    text = 'int64';
else
    text = 'NONE';
end

My function make an error for argument: A = [128 127; -127 0]. However, if I test it with argument A = -127 is correct.

Best Answer

A simpler implementation:

function text = integerize(A)
if A >= intmin('int8') & A <= intmax('int8')
    typ = 'int8';
elseif A >= intmin('int16') & A <= intmax('int16')
    typ = 'int16';
elseif A >= intmin('int32') & A <= intmax('int32')
    typ = 'int32';
elseif A >= intmin('int64') & A <= intmax('int64')
    typ = 'int64';
else
    typ = 'NONE';
end
end

And tested:

>> A = [128,127;-127,0];
>> integerize(A)
ans = int16

int16 is correct because 128 cannot be encoded by int8, but can be by int16 or larger:

>> intmax('int8')
ans = 127

Related Solutions

MATLAB: Write a function called integerize that takes as its input a matrix A of integers of type double, and returns the name of the “smallest” signed integer class to which A can be converted without loss of information. If no such class exists, the text

EDIT: see Guillermo Varela Carbajal's answer below for a really neat solution.

Try something like this:

function typ = integerize(A)
if A >= intmin('int8') & A <= intmax('int8')
    typ = 'int8';
elseif A >= intmin('int16') & A <= intmax('int16')
    typ = 'int16';
elseif A >= intmin('int32') & A <= intmax('int32')
    typ = 'int32';
elseif A >= intmin('int64') & A <= intmax('int64')
    typ = 'int64';
else
    typ = 'NONE';
end
end

and tested:

>> integerize([128,127;-127,0])
ans = int16

Just for the sake of discussion, here is a function where the list of accepted classes are specified as an input argument (as long as the order from smallest to largest is kept):

function typ = integerize(A,C)
for k = 1:numel(C)
    typ = C{k};
    if A >= intmin(typ) & A <= intmax(typ)
      return
    end
end
typ = 'NONE';
end

and tested:

>> integerize(A,{'int8','int16','int32','int64'})
ans = int16
>> integerize(A,{'int8','int32','int64'})
ans = int32
>> integerize(A,{'int8','int64'})
ans = int64
>> integerize(A,{'int8'})
ans = NONE

MATLAB: Write a function called integerize that takes as its input a matrix A of integers of type double, and returns the name of the “smallest” signed integer class to which A can be converted without loss of information. If no such class exists, the text

You can't write multiple if conditions this way in MATLAB:

   if -128 <= b <= ((2^7)-1)

You have to break it up into individual conditions. E.g.,

   if -128 <= b & b <= ((2^7)-1)

Why are you doing the following:

     b=min(A);

Hint: The following will turn A into a column vector of all the elements:

    b = A(:);

Instead of using for loops, you can then write logic to test all of the elements of b at once to get your result.

Caution: You are going to have a problem with this part of your test for int64:

       elseif (-2^63)<=b & b<=((2^63)-1)

The reason is that an int64 actually has more precision than a double, so you can get into trouble comparing numbers near the limits. E.g.,

>> intmax('int64')
ans =
  int64
   9223372036854775807
>> b = 2^63;
>> num2strexact(b)
ans =
    '9.223372036854775808e18'

Just looking at these numbers you can see that b is too large to fit in an int64 class variable. But look what happens with the test that you have:

>> b <= ((2^63)-1)
ans =
  logical
   1

It returned true! Obviously this is an incorrect result for what you are trying to test. What is the problem? It is the fact that a double precision variable does not have enough precision to do the (2^63)-1 calculation exactly. E.g.,

>> eps(2^63)
ans =
        2048

The spacing between numbers near 2^63 in IEEE double is 2048, much larger than the 1 you are trying to do arithmetic with. E.g., look at these results:

>> num2strexact((2^63))
ans =
    '9.223372036854775808e18'
>> num2strexact((2^63)-1)
ans =
    '9.223372036854775808e18'
>> num2strexact((2^63)-10)
ans =
    '9.223372036854775808e18'
>> num2strexact((2^63)-100)
ans =
    '9.223372036854775808e18'

You get the same number in each case. Subtracting 1, 10, or 100 had no effect on the answer because they are too far below eps(2^63). So, you will need to rewrite this test. Hint: What would happen if you tried to do this test in int64 arithmetic instead of double arithmetic? Try it out ...

Best Answer

Related Solutions

MATLAB: Write a function called integerize that takes as its input a matrix A of integers of type double, and returns the name of the “smallest” signed integer class to which A can be converted without loss of information. If no such class exists, the text

MATLAB: Write a function called integerize that takes as its input a matrix A of integers of type double, and returns the name of the “smallest” signed integer class to which A can be converted without loss of information. If no such class exists, the text

Related Question