How to get all keys from a Rascal map? - rascal

Suppose I have a map like so:
map[str,int] a = ("apple": 1, "pear": 2, "banana": 3, "kiwi": 4);
Is there any way to return all the keys in the map, i.e. "apple", "pear", "banana", "kiwi"? From the documentation at http://tutor.rascal-mpl.org/Rascal/Expressions/Values/Map/Comprehension/Comprehension.html#/Rascal/Expressions/Values/Map/Map.html , it does not seem like there's a built in way. Is it possible?

A number of ways:
First is just projecting out the first column:
rascal>map[str,int] a = ("apple": 1, "pear": 2, "banana": 3, "kiwi": 4);
map[str, int]: ("banana":3,"pear":2,"kiwi":4,"apple":1)
rascal>a<0>
set[str]: {"banana","pear","kiwi","apple"}
Second is labeling the columns, and doing the same (either the <> notation or the . notation)
rascal>map[str fruit, int count] b = ("apple": 1, "pear": 2, "banana": 3, "kiwi": 4);
map[str fruit, int count]: ("banana":3,"pear":2,"kiwi":4,"apple":1)
rascal>b<fruit>
set[str]: {"banana","pear","kiwi","apple"}
rascal>b.fruit
set[str]: {"banana","pear","kiwi","apple"}
Finally maps are also generators for their own keys, as in:
rascal>[ f | f <- a]
list[str]: ["banana","pear","kiwi","apple"]
rascal>{ f | f <- a}
set[str]: {"banana","pear","kiwi","apple"}
rascal>import IO;
rascal>for (f <- a)
>>>>>>> println(f);
banana
pear
kiwi
apple

Related

Assign fill value to variable if it does not equal to certain values

I am not pro in Fortran95, but I am writing a code in it and I found that I want to mask the array values with -9999, if it does not have certain values.
Example: I have an array 'X' has values vary from 0 to 32768, and I want to mask the values of the array, if 'X' value is not equal to 0,1,2,16 or 18. I solved it with the following syntax:
if (X.eq.0.or.X.eq.1.or.X.eq.2.or.X.eq.16.or.X.eq.18) then
X=X
else
X=-9999
end if
But there any other way to mask array values in FORTRAN 95?
There is the where statement that can mask the array, but given the logical you have shown its a bit ugly
where (.not.(X==0 || X==1 || X==2 || X==16 || X==18)) x = -9999
For these kinds of problems I find it convenient to define the .in. operator, which returns whether or not a scalar is in an array, so:
1 .in. [0, 1, 2] returns .true.
3 .in. [0, 1, 2] returns .false.
[1, 3] .in. [0, 1, 2] returns [.true., .false.]
This can be defined as
module in_module
implicit none
interface operator(.in.)
module procedure element_in_list
module procedure elements_in_list
end interface
contains
function element_in_list(lhs, rhs) result(output)
integer, intent(in) :: lhs
integer, intent(in) :: rhs(:)
logical :: output
output = any(lhs==rhs)
end function
function elements_in_list(lhs, rhs) result(output)
integer, intent(in) :: lhs(:)
integer, intent(in) :: rhs(:)
logical, allocatable :: output(:)
integer :: i
output = [(any(lhs(i)==rhs), i=1, size(lhs))]
end function
end module
With the .in. operator defined, then if X is an array you can write
where (.not. (X .in. [0, 1, 2, 16, 18])) X = -9999
which will convert e.g. X = [4, 5, 1, 3, 16] to X = [-9999, -9999, 1, -9999, 16].
If you want to simplify things further (as the where construct can be quite unwieldy), you can also define the function filter which takes an array of logicals and returns the indices of the .true. values, e.g. filter([.false., .true., .true.]) returns [2, 3].
This can be defined as:
function filter(input) result(output)
logical, intent(in) :: input(:)
integer, allocatable :: output(:)
integer :: i
output = pack([(i, i=1, size(input))], input)
end function
And then you can simply write
X(filter(.not. (X .in. [0, 1, 2, 16, 18]))) = -9999

How Racket streams work in this case?

I am currently learning Racket (just for fun) and I stumbled upon this example:
(define doubles
(stream-cons
1
(stream-map
(lambda (x)
(begin
(display "map applied to: ")
(display x)
(newline)
(* x 2)))
doubles)))
It produces 1 2 4 8 16 ...
I do not quite understand how it works.
So it creates 1 as a first element; when I call (stream-ref doubles 1) it creates a second element which is obviously 2.
Then I call (stream-ref doubles 2) which should force creating the third element so it calls stream-map for a stream which already has 2 elements – (1 2) – so it should produce (2 4) then and append this result to the stream.
Why is this stream-map always applied to the last created element? How it works?
Thank you for your help!
This is a standard trick that makes it possible for lazy streams to be defined in terms of their previous element. Consider a stream as an infinite sequence of values:
s = x0, x1, x2, ...
Now, when you map over a stream, you provide a function and produce a new stream with the function applied to each element of the stream:
map(f, s) = f(x0), f(x1), f(x2), ...
But what happens when a stream is defined in terms of a mapping over itself? Well, if we have a stream s = 1, map(f, s), we can expand that definition:
s = 1, map(f, s)
= 1, f(x0), f(x1), f(x2), ...
Now, when we actually go to evaluate the second element of the stream, f(x0), then x0 is clearly 1, since we defined the first element of the stream to be 1. But when we go to evaluate the third element of the stream, f(x1), we need to know x1. Fortunately, we just evaluated x1, since it is f(x0)! This means we can “unfold” the sequence one element at a time, where each element is defined in terms of the previous one:
f(x) = x * 2
s = 1, map(f, s)
= 1, f(x0), f(x1), f(x2), ...
= 1, f(1), f(x1), f(x2), ...
= 1, 2, f(x1), f(x2), ...
= 1, 2, f(2), f(x2), ...
= 1, 2, 4, f(x2), ...
= 1, 2, 4, f(4), ...
= 1, 2, 4, 8, ...
This knot-tying works because streams are evaluated lazily, so each value is computed on-demand, left-to-right. Therefore, each previous element has been computed by the time the subsequent one is demanded, and the self-reference doesn’t cause any problems.

How to convert an array into a 2D matrix in Lua?

I have the following array of numbers.
arr = {3412323450, 8912745671, 3212367894}
I want to convert it into a simple two-dimensional matrix.
mat = {
{3, 4, 1, 2, 3, 2, 3, 4, 5, 0},
{8, 9, 1, 2, 7, 4, 5, 6, 7, 1},
{3, 2, 1, 2, 3, 6, 7, 8, 9, 4}
}
Initially, I would iterate over arr, convert it into a string, then split the string, iterate over each string char and convert it back to number storing every row and number in mat accordingly. This would be really ugly.
Is there a more conventional method to convert an array into a matrix in
Lua?
Is there a luarock package that people use frequently to convert an array to a matrix?
Personally I think converting to a string and grabbing all of the digits is far prettier than the alternatives (massively dividing by 10, or any other elaborate means you can think of). This is especially true if you wrap the operations up in functions, so your conversions are not constantly appearing throughout your code.
function Digits(n)
local digits = {}
for d in tostring(n):gmatch('%d') do
digits[#digits+1] = tonumber(d)
end
return digits
end
function ArrayToMatrix(array)
local matrix = {}
for i,v in ipairs(array) do
matrix[i] = Digits(v)
end
return matrix
end
Ok, here is my try.
arr = {3412323450, 8912745671, 3212367894}
function arr2matrix(arr)
local mat = {}
for i, row in ipairs(arr) do
mat[i] = {}
local j = 0
row_str = string.gsub(row, '%d', '%0 ')
for c in string.gmatch(row_str, '%S') do
j = j + 1
mat[i][j] = tonumber(c)
end
end
return mat
end
-- checking the result
m = arr2matrix(arr)
for i=1, #m do
for j=1, #m[i] do
io.write(m[i][j]..',')
end
io.write('\n')
end
Running the above gives:
3,4,1,2,3,2,3,4,5,0,
8,9,1,2,7,4,5,6,7,1,
3,2,1,2,3,6,7,8,9,4,

insert table values with string keys into Lua table

I'm relatively new to the Lua language and there's something I'm obviously missing about table structures.
I'm trying to create a table of tables, with each table in the table having a key and the value being the respective table.
Ok, that statement can be confusing. Here's an example:
{{ key = "RC", value = {1, 2, 3, 4}},
{ key = "M", value = {4, 8, 7}},
{ key = "D", value = {3, 8, 9}}
...}
for this I used the following algorithm:
local listOfLists = {};
...
if condition1 then
listOfLists[key1] = list1;
end
...
if condition2 then
listOfLists[key2] = list2;
end
...
And so on...
I hope to use the keys to later determine which lists have been added to the table.
But the thing is, no lists seem to be added to the table even if all the conditions are met.
I can use table.insert(listOfLists, list1) in place of listOfLists[key1] = list1 but then I won't be able to tell which lists were added to the collection.
Ant suggestions?
Lua tables are a flexible data structure. Elements are key-value pairs. A key is any Lua value except nil. A value can have any value except nil. Assigning nil to the value obliterates the pair.
The (possibly empty) subset of a table that has key values of the number type that are integers from 1 to n is called a sequence. n is determined as the last such key that is paired with a nil value. Several table functions and operators work only with sequences.
Table constructors allow several syntaxes for keys:
Implied via a sequence: {1, 2, 3}
Explicit keys: {[1] = 1, [3] = 3, ["two"] = "value"}
Identifier keys: {one = 1, two = 2}
A table constructor can use any combination of them.
You have defined a sequence of elements, each of which is a table with two elements, the
second of which is a sequence.
It appears you want keys to be strings and values to be sequences:
{
RC = {1, 2, 3, 4},
M = {4, 8, 7},
D = {3, 8, 9}
}
It's hard to understand, what do you wanna achieve. So, if you want more specific answer, provide more info.
You can create associative table of tables.
local map = {}
map["key"] = { 1, 2, 3, 4 }
print(map.key[3])
Or you can create an array of tables
local vector = {}
vector[1] = { 1, 2, 3, 4 }
print(vector[1][2])
Or you can combine approaches.
To create
{{ key = "RC", value = {1, 2, 3, 4}},
{ key = "M", value = {4, 8, 7}},
{ key = "D", value = {3, 8, 9}}
...}
You can use table constructor or smth from code.
local tbl = { { key = "RC", value = {1, 2, 3, 4}} } -- init first elem from constructor
table.insert(tbl, { key = "M", value = {4, 8, 7}}) -- table insert & constructor
tbl[2] = {} -- Array-based access.
tbl[2].key = "D" --key access
tbl[2]["value"] = { 3, 8, 9 } -- other way
Note, that each table consists of two parts: vector for sequental keys from 1 to N, and map otherwise. Some functions, like table length operator or ipairs iterator are guaranteed to work only with vector-part of table. But they are significantly faster.
EDIT: (last paragraph explanation)
If you have a table with some keys and want to iterate through, you can use ipairs or pairs.
ipairs is ordered, and goes from 1 to first not-nil element. It doesn't iterate over not-integer keys. pairs goes trough any key, but doesn't guarantee order.
local map = { 1, 2, 3, key = 6, [5] = 5 }
for i, v in ipairs(map) do
print(v) -- will output 1, 2, 3. first nil element is map[4]. map[5] will mot be visited.
end
for i, v in pairs(map) do -- NOTE pairs usage
print(v) -- will output 1, 2, 3, 5, 6 in ANY order
end
map[4] = 4 -- Fill gap
for i, v in ipairs(map) do
print(v) -- will output 1, 2, 3, 4, 5. Now first nil element is map[6]
end
Length operator works similar to ipairs, it doesn't count elements not visited by ipairs method.
table.maxn works with numerical indices, and will return zero for your table.
Reference say that table.maxn
Returns the largest positive numerical index of the given table, or zero if the table has no positive numerical indices. (To do its job this function does a linear traversal of the whole table.)
Little example about length and table.maxn
local a = { 1, 2, 3, [5] = 5}
print(table.maxn(a)) -- 5
print(#a) -- 3
a = { key = 4 }
print(table.maxn(a)) -- 0
print(#a) -- 0
print(a["key"]) -- 4, nothing is lost
local num = 0
for _, __ in pairs(a) do num = num + 1 end
print(num) -- 1 We find it.

Prolog print value as result instead of true

I need to write a program, which returns a new list from a given list with following criteria.
If list member is negative or 0 it should and that value 3 times to new list. If member is positive it should add value 2 times for that list.
For example :
goal: dt([-3,2,0],R).
R = [-3,-3,-3,2,2,0,0,0].
I have written following code and it works fine for me, but it returns true as result instead of R = [some_values]
My code :
dt([],R):- write(R). % end print new list
dt([X|Tail],R):- X =< 0, addNegavite(Tail,X,R). % add 3 negatives or 0
dt([X|Tail],R):- X > 0, addPositive(Tail,X,R). % add 2 positives
addNegavite(Tail,X,R):- append([X,X,X],R,Z), dt(Tail, Z).
addPositive(Tail,X,R):- append([X,X],R,Z), dt(Tail, Z).
Maybe someone know how to make it print R = [] instead of true.
Your code prepares the value of R as it goes down the recursing chain top-to-bottom, treating the value passed in as the initial list. Calling dt/2 with an empty list produces the desired output:
:- dt([-3,2,0],[]).
Demo #1 - Note the reversed order
This is, however, an unusual way of doing things in Prolog: typically, R is your return value, produced in the other way around, when the base case services the "empty list" situation, and the rest of the rules grow the result from that empty list:
dt([],[]). % Base case: empty list produces an empty list
dt([X|Like],R):- X =< 0, addNegavite(Like,X,R).
dt([X|Like],R):- X > 0, addPositive(Like,X,R).
% The two remaining rules do the tail first, then append:
addNegavite(Like,X,R):- dt(Like, Z), append([X,X,X], Z, R).
addPositive(Like,X,R):- dt(Like, Z), append([X,X], Z, R).
Demo #2
Why do you call write inside your clauses?
Better don't have side-effects in your clauses:
dt([], []).
dt([N|NS], [N,N,N|MS]) :-
N =< 0,
dt(NS, MS).
dt([N|NS], [N,N|MS]) :-
N > 0,
dt(NS, MS).
That will work:
?- dt([-3,2,0], R).
R = [-3, -3, -3, 2, 2, 0, 0, 0] .
A further advantage of not invoking functions with side-effects in clauses is that the reverse works, too:
?- dt(R, [-3, -3, -3, 2, 2, 0, 0, 0]).
R = [-3, 2, 0] .
Of cause you can invoke write outside of your clauses:
?- dt([-3,2,0], R), write(R).
[-3,-3,-3,2,2,0,0,0]
R = [-3, -3, -3, 2, 2, 0, 0, 0] .

Resources