I want to print address of stack.
void StackOfIntegers::printPop() {
int* p;
p = &(elements[size-1]);
cout << p;
}
cout << "Stack2 :value, adress" << endl;
while (!stack2.empty()) {
cout << " " << stack2.peek() << " ";
stack2.printPop();
stack2.pop();
cout << "\n";
}
When I printed out the address in this code, I expected that the value of the address would gradually increase.
However, on the contrary, the address value is increasingly small.
What is the problem?
Related
I would like to implement the following C program in Perl:
#include <stdio.h>
#include <stdint.h>
uint32_t xorshift32 ()
{
static uint32_t y = 2463534242;
y ^= y << 13;
y ^= y >> 17;
y ^= y << 5;
return y;
}
int main (int argc, char *argv[])
{
int n = 10;
while (n-- > 0)
printf ("%u\n", xorshift32());
}
The output is:
723471715
2497366906
2064144800
2008045182
3532304609
374114282
1350636274
691148861
746858951
2653896249
This is my unsuccessful attempt:
{
package Xorshift;
use strict;
use warnings;
use integer;
sub new
{
my $class = shift;
bless { y => 2463534242 } => $class
}
sub rand ()
{
my $y = $_[0]->{y};
$y ^= $y << 13;
$y ^= $y >> 17;
$y ^= $y << 5;
$_[0]->{y} = $y;
return $y;
}
}
my $xor = Xorshift->new;
my $n = 10;
while ($n-- > 0) {
print $xor->rand(), "\n";
}
The output is this:
660888219700579
3396719463693796860
-1120433007023638100
2588568168682748299
1469630995924843144
-8422345229424035168
1449080611344244726
-4722527344582589597
8061824971057606814
-3113862584906767882
The problems:
Perl uses 64 bit arithmetic.
The integers are signed.
How to do 32 bit unsigned arithmetic instead?
If you want to simulate the result of 32-bit ops, you can simply apply a mask:
{
package Xorshift;
use strict;
use warnings;
use integer;
sub new
{
my $class = shift;
bless { y => 2463534242 } => $class
}
sub to32{
return ($_[0] & 0xFFFFFFFF);
}
sub rand ()
{
my $y = $_[0]->{y};
$y ^= to32($y << 13);
$y ^= to32($y >> 17);
$y ^= to32($y << 5);
$_[0]->{y} = $y;
return $y;
}
}
my $xor = Xorshift->new;
my $n = 10;
while ($n-- > 0) {
print $xor->rand(), "\n";
}
#include <iostream>
using namespace std;
void asknumber(int,int,int,int,int,int,int);
void getClassnumbers();
int main() {
getClassnumbers();
asknumber();
system("pause");
return 0;
}
void asknumber(int &tests, int &projects, int &labs, int &attendance,
int &max_test, int &max_projects, int &max_labs, int &max_attendance) {
int min = 0;
getClassnumbers();
cout << "Enter a number between 0 and " << max_test << ":";
cin >> tests;
while (tests > max_test || tests < min) {
cout << "Invalid input. Enter a number between 0 and " << max_test <<
":";
cin >> tests;
}
cout << "Enter a number between 0 and " << max_projects << ":";
cin >> projects;
while (projects > max_projects || projects < min) {
cout << "Invalid input. Enter a number between 0 and " << max_projects
<< ":";
cin >> projects;
}
cout << "Enter a number between 0 and " << max_labs << ":";
cin >> labs;
while (labs > max_labs || labs < min) {
cout << "Invalid input. Enter a number between 0 and " << max_labs <<
":";
cin >> labs;
}
cout << "Enter a number between 0 and " << max_attendance << ":";
cin >> attendance;
while (attendance> max_attendance || attendance < min) {
cout << "Invalid input. Enter a number between 0 and " << max_attendance << ":";
cin >> attendance;
}
}
void getClassnumbers() {
int tests; int projects; int labs; int attendance;
const int max_test = 4; const int max_projects = 5; const int max_labs = 7; const int max_attendance = 50;
cout << "Enter number of tests: ";
cin >> tests;
cout << "Enter number of projects: ";
cin >> projects;
cout << "Enter number of labs: ";
cin >> labs;
cout << "Enter number of attendance days: ";
cin >> attendance;
}
I was wondering how to properly use pass by reference for me to use the cin values entered in the function getClassnumbers() to be used in the while loops in the function asknumber() in order to compare them with the maximum values declared in getClassnumbers()?
I try to convert the following C function to Perl:
uint32_t xorshift32 (uint32_t x32)
{
x32 ^= x32 << 13;
x32 ^= x32 >> 17;
x32 ^= x32 << 5;
return x32;
}
I came up with the following:
sub xorshift32
{
my $r = '';
vec ($r, 0, 32) = int($_[0]);
vec ($r, 0, 32) ^= vec ($r, 0, 32) << 13;
vec ($r, 0, 32) ^= vec ($r, 0, 32) >> 17;
vec ($r, 0, 32) ^= vec ($r, 0, 32) << 5;
return vec ($r, 0, 32);
}
Is this the canonical way to force 32 bit overflows in Perl or is there a better and faster way to do it?
I am also not sure if the code is correct. Will the result of the shift operations be a float on 32 bit systems?
Just add & 0xFFFF_FFFF where needed.
sub xorshift32 {
my ($x32) = #_;
$x32 ^= ($x32 << 13) & 0xFFFF_FFFF;
$x32 ^= $x32 >> 17;
$x32 ^= ($x32 << 5) & 0xFFFF_FFFF;
return $x32;
}
I don't always know my canon, but I like the 0xFFFF_FFFF bitmask for cases like this.
sub xorshift32 {
my $x32 = shift;
$x32 ^= $x32 << 13;
$x32 ^= (($x32 & 0xFFFF_FFFF) >> 17);
0xFFFF_FFFF & ($x32 ^ ($x32 << 5));
}
(haven't benchmarked this, don't know how it compares to vec)
And to answer your second question, no, the result of a << bit shift operation will never be a float whether it is a 32-bit or 64-bit system, even if either operand is a float.
It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 9 years ago.
Ok, for a school project I'm doing, I'm creating a little quiz in Perl,
#########################################
# Solar Game #
# #
# (C) 2013 Donovan Roudabush #
# GPU/Creative Commons #
# #
# sharksfan98#gmail.com #
# github.com/sharksfan98/solargame #
#########################################
print " _________ .__ ________ \n";
print " / _____/ ____ | | _____ _______ / _____/_____ _____ ____ \n";
print " \_____ \ / _ \| | \__ \\_ __ \ / \ ___\__ \ / \_/ __ \ \n";
print " / ( <_> ) |__/ __ \| | \/ \ \_\ \/ __ \| Y Y \ ___/ \n";
print "/_______ /\____/|____(____ /__| \______ (____ /__|_| /\___ > \n";
print " \/ \/ \/ \/ \/ \/ \n";
print "Version 1.0 Beta\n\n";
print "Developed by Donovan Roudabush\n";
print "https://github.com/sharksfan98/solargame\n\n";
print "Press enter to start\n";
$ok = <STDIN>;
chomp $ok;
print "Enter the number of players\n";
$num = <STDIN>;
chomp $num;
my #names;
for (1 .. $num) {
print "Please enter your name\n";
my $name = <STDIN>;
chomp $name;
push #names, $name;
}
print "Hello, Players! Have you played before? (Y/N)\n";
$exp = <STDIN>;
chomp $exp;
if ($exp == Y) {
print "Ok! The game will begin.\n";
print "Press Enter to begin the questions\n\n";
}
if ($exp == N) {
print "Then I will explain the rules\n";
$ok2 = <STDIN>;
chomp $ok2;
} # Add rules here later
print "Part 1: Measurements\n\n";
print "Question 1\n";
print "What measurement is used to measurements within our Solar System?\n\n";
print "A) Astronomical Unit (AU)\n";
print "B) Light Year\n";
print "C) Parsec\n";
$q1 = <STDIN>;
chomp $q1;
if ($q1 == A) {
print "Correct!\n\n";
}
if ($q1 == B) {
print "Wrong!\n\n";
}
if ($q1 == C) {
print "Close! The Parsec is only used by Professionals, like NASA\n\n";
}
print "Question 2\n\n";
print "What do you use to measure farther objects, like stars and galaxies?\n";
print "A) Astronomical Unit (AU)\n";
print "B) Light Year\n";
print "C) Parsec\n";
$q2 = <STDIN>;
chomp $q2;
if ($q2 == A) {
print "Wrong!\n\n";
}
if ($q2 == B) {
print "Correct!\n\n";
}
if ($q2 == C) {
print "Wrong!\n\n";
}
print "Question 3\n";
print "Which measurement would you use to measure Earth to the Sun?\n\n";
print "A) Astronomical Unit (AU)\n";
print "B) Light Year\n";
print "C) Parsec\n";
$q3 = <STDIN>;
chomp $q3;
if ($q3 == A) {
print "Correct!\n\n";
}
if ($q3 == B) {
print "Wrong!\n\n";
}
if ($q3 == C) {
print "Wrong!\n\n";
}
print "Question 4\n";
print "Which measurement would you use measure the Sun to Polaris?\n\n";
print "A) Astronomical Unit (AU)\n";
print "B) Light Year\n";
print "C) Parsec\n";
$q4 = <STDIN>;
chomp $q4;
if ($q4 == A) {
print "Correct!\n\n";
}
if ($q4 == B) {
print "Wrong!\n\n";
}
if ($q4 == C) {
print "Wrong!\n\n";
}
print "Question 5\n";
print "Which would you use to measure Earth to Uranus?\n\n";
print "A) Astronomical Unit (AU)\n";
print "B) Light Year\n";
print "C) Parsec\n";
$q5 = <STDIN>;
chomp $q5;
if ($q5 == A) {
print "Correct!\n\n";
}
if ($q5 == B) {
print "Wrong!\n\n";
}
if ($q5 == C) {
print "Wrong!\n\n";
}
At the end of my code, I want to calculate and list the amount of questions right and wrong, and the percentage right. How do I go about doing this?
You could have a variable that gets incremented each time a question is answered correctly, and one that's incremented each time that a question is answered incorrectly.
my $correct = 0;
my $incorrect = 0;
...
if ($q1 eq 'A') {
print "Correct!\n\n";
$correct++;
} else {
print "Wrong!\n\n";
$incorrect++;
}
print "Percentage: ", int($correct/($correct + $incorrect) * 100 + 0.5), "%\n";
You can't use bare words like A to compare text. Use the string equals operator (eq) with a string. Like $q1 eq 'A'. You can also use an else block instead of comparing with everything else.
You actually only need a variable for the number of questions answered correctly if you're going to have a fixed number of questions, because then $incorrect will be the same as (total questions) - $correct, and $correct + $incorrect will always be the total number of questions.
I am attempting to add non-interlaced GIF images other than 8-bit to a PDF document without having to fully decode the bitstream using PDF::Create for Perl.
The LZWDecode algorithm that is part of the PDF standard requires all images to have a minimum LZW code size of 8-bits, and PDF::Create is hard-coded to only embed 8-bit images.
So far, I have adapted the image loader from PDF::Create to read a 5-bit image and to fully decode the LZW stream. I am then able to use the encoder algorithm from PDF::Create to re-pack the image as 8-bit.
What I'd like to do is to eliminate the memory-intensive decode/encode step. This thread suggests that this is possible by "widening or shifting bits" to make LZW codes the proper length for LZWDecode.
I contacted the thread author and he provided some additional details, in particular that codes for color indices remain the same but are padded with zeros (e.g., [10000] becomes [000010000]), that <Clear> and <End> codes are changed to <256> and <257> respectively, and that all other codes are offset by 256 - original <Clear> code.
However, he was unable to elaborate further due to restrictions by his employer. In particular, I am uncertain how to handle a code when its modified value exceeds <4095> (the maximum index for the LZW code table). I am also unsure how to re-pack the revised codes into a bitstream.
The algorithms I am currently using are below.
# Read 5-bit data stream
sub ReadData5 {
my $data = shift;
my $c_size = 6; # minimium LZW code size
my $t_size = 33; # initial code table size
my ($i_buff,$i_bits) = (0,0); # input buffer
my ($o_buff,$o_bits) = (0,0); # output buffer
my $stream = ''; # bitstream
my $pos = 0;
SUB_BLOCK: while (1){
my $s = substr($data, $pos++, 1);
# get sub-block size
my $n_bytes = unpack('C', $s) or last SUB_BLOCK;
my $c_mask = (1 << $c_size) - 1;
BYTES: while (1){
# read c_size bits
while ($i_bits < $c_size){
# end of sub-block
!$n_bytes-- and next SUB_BLOCK;
$s = substr($data, $pos++, 1);
my $c = unpack('C', $s);
$i_buff |= $c << $i_bits;
$i_bits += 8;
}
# write c_size bits
my $code = $i_buff & $c_mask;
my $w_bits = $c_size;
$i_buff >>= $c_size;
$i_bits -= $c_size;
$t_size++;
if ($o_bits > 0){
$o_buff |= $code >> ($c_size - 8 + $o_bits);
$w_bits -= 8 - $o_bits;
$stream .= pack('C', $o_buff & 0xFF);
}
if ($w_bits >= 8){
$w_bits -= 8;
$stream .= pack('C', ($code >> $w_bits) & 0xFF);
}
if (($o_bits = $w_bits) > 0){
$o_buff = $code << (8 - $o_bits);
}
# clear code
if ($code == 32){
$c_size = 6;
$t_size = 33;
$c_mask = (1 << $c_size) - 1;
}
# end code
if ($code == 33){
$stream .= pack('C', $o_buff & 0xFF);
last SUB_BLOCK;
}
if ($t_size == (1 << $c_size)){
if (++$c_size > 12){
$c_size--;
} else {
$c_mask = (1 << $c_size) - 1;
}
}
}
}
# Pad with zeros to byte boundary
$stream .= '0' x (8 - length($stream) % 8);
return $stream;
}
#---------------------------------------------------------------------------
# Decode 5-bit data stream
sub UnLZW5 {
my $data = shift;
my $c_size = 6; # minimium LZW code size
my $t_size = 33; # initial code table size
my ($i_buff,$i_bits) = (0,0); # input buffer
my $stream = ''; # bitstream
my $pos = 0;
# initialize code table
my #table = map { chr($_) } 0..$t_size-2;
$table[32] = '';
my $prefix = '';
my $suffix = '';
# get first code word
while ($i_bits < $c_size){
my $d = unpack('C', substr($data, $pos++, 1));
$i_buff = ($i_buff << 8) + $d;
$i_bits += 8;
}
my $c2 = $i_buff >> ($i_bits - $c_size);
$i_bits -= $c_size;
my $c_mask = (1 << $i_bits) - 1;
$i_buff &= $c_mask;
# get remaining code words
DECOMPRESS: while ($pos < length($data)){
my $c1 = $c2;
while ($i_bits < $c_size){
my $d = unpack('C', substr($data, $pos++, 1));
$i_buff = ($i_buff << 8) + $d;
$i_bits += 8;
}
$c2 = $i_buff >> ($i_bits - $c_size);
$i_bits -= $c_size;
$c_mask = (1 << $i_bits) - 1;
$i_buff &= $c_mask;
# clear code
if ($c2 == 32){
$stream .= $table[$c1];
$#table = 32;
$c_size = 6;
$t_size = 33;
next DECOMPRESS;
}
# end code
if ($c2 == 33){
$stream .= $table[$c1];
last DECOMPRESS;
}
# get prefix and suffix
$prefix = $table[$c1] if $c1 < $t_size;
$suffix = $c2 < $t_size ? substr($table[$c2], 0, 1) : substr($prefix, 0, 1);
# write prefix
$stream .= $prefix;
# write multiple-character sequence
$table[$t_size++] = $prefix . $suffix;
# increase code size
if ($t_size == 2 ** $c_size){
if (++$c_size > 12){
$c_size--;
}
}
}
return $stream;
}
Doing one at a time is slow. Doing them all at once takes too much memory for you. Do them a chunk at a time.
my $BUFFER_SIZE = 5 * 50_000; # Must be a multiple of 5.
my $in_bytes = ...;
my $out_bytes = '';
while (my ($bytes) = $in_bytes =~ s/^(.{1,$BUFFER_SIZE})//s) {
# Unpack from 5 bit fields.
my #vals = map { pack('B*', "000$_") } unpack('B*', $bytes) =~ /(.{5})/g;
# Transform #vals into 8 bit values here.
# Pack to 8 bit fields.
$out_bytes .= pack('C*', #vals);
}
Since you're not transforming the values at all (just how they are stored), that simplifies to:
my $BUFFER_SIZE = 5 * 50_000; # Must be a multiple of 40.
my $in_bytes = ...;
my $out_bytes = '';
while (my ($bytes) = $in_bytes =~ s/^(.{1,$BUFFER_SIZE})//s) {
# Unpack from 5 bit fields.
my $bits = unpack('B*', $bytes);
$bits =~ s/(.{5})/000$1/g;
$out_bytes .= pack('B*', $bits);
}
You didn't say what to do with the extra bits. I simply ignored them.
Alternative approach with no bit string creation:
my $in_bytes = ...;
my $out_bytes = '';
while (my ($bytes) = $in_bytes =~ s/^(.{1,5})//s) {
my #bytes = map ord, split //, $bytes;
# 00000111 11222223 33334444 45555566 66677777
$out_bytes .= chr( (($bytes[0] >> 3) & 0x1F));
last if #bytes == 1;
$out_bytes .= chr((($bytes[0] << 2) & 0x1C) | (($bytes[1] >> 6) & 0x03));
$out_bytes .= chr( (($bytes[1] >> 1) & 0x1F));
last if #bytes == 2;
$out_bytes .= chr((($bytes[1] << 4) & 0x10) | (($bytes[2] >> 4) & 0x0F));
last if #bytes == 3;
$out_bytes .= chr((($bytes[2] << 1) & 0x1E) | (($bytes[3] >> 7) & 0x01));
$out_bytes .= chr( (($bytes[3] >> 2) & 0x1F));
last if #bytes == 4;
$out_bytes .= chr((($bytes[3] << 3) & 0x18) | (($bytes[4] >> 5) & 0x07));
$out_bytes .= chr( ( $bytes[4] & 0x1F));
}
The advantage of the above solution is that it's particularly efficient in C.
STRLEN in_len;
const char* in = SvPVbyte(sv, in_len);
STRLEN out_len = (in_len * 8 / 5) * 8;
char* out = (char*)malloc(out_len);
char* out_cur = out;
char* in_end = in + in_len;
while (in != in_end) {
*(out_cur++) = ((*in >> 3) & 0x1F));
if (++in == in_end) break;
*(out_cur++) = ((in[-1] << 2) & 0x1C) | ((*in >> 6) & 0x03));
*(out_cur++) = ((*in >> 1) & 0x1F));
if (++in == in_end) break;
*(out_cur++) = ((in[-1] << 4) & 0x10) | ((*in >> 4) & 0x0F));
if (++in == in_end) break;
*(out_cur++) = ((in[-1] << 1) & 0x1E) | ((*in >> 7) & 0x01));
*(out_cur++) = ((*in >> 2) & 0x1F));
if (++in == in_end) break;
*(out_cur++) = ((in[-1] << 3) & 0x18) | ((*in >> 5) & 0x07));
*(out_cur++) = ( *in & 0x1F));
}
return newSVpvn(out, out_len);