language
large_stringclasses 1
value | text
stringlengths 9
2.95M
|
|---|---|
C
|
#include <stdio.h>
/**
*main - entry data
*@argc: counts arg
*@argv: cointains arg
*Return: cero
*/
int main(int argc __attribute__((unused)), char *argv[])
{
int count;
for (count = 0; count < argc; count++)
{
printf("%s\n", argv[count]);
}
return (0);
}
|
C
|
/* future.c - future implementation */
#include <xinu.h>
future_t* future_alloc(future_mode_t mode)
{
future_t *f = (future_t *)getmem(sizeof(*f));
if (!f)
{
return NULL;
}
f->state = FUTURE_EMPTY;
f->mode = mode;
linked_queue_initialize(f->get_queue);
linked_queue_initialize(f->set_queue);
return f;
}
syscall future_free(future_t* f)
{
intmask mask = disable();
linked_queue_destroy(f->get_queue);
linked_queue_destroy(f->set_queue);
freemem((char *)f, sizeof(*f));
restore(mask);
return OK;
}
syscall future_get(future_t* f, int* value)
{
pid32 pid;
struct procent *prptr;
intmask mask = disable();
if (f->state == FUTURE_READY)
{
// currently set value is available for use
*value = f->value;
}
else if (f->state == FUTURE_EMPTY)
{
// no value available
// wait in queue
f->state = FUTURE_WAITING;
prptr = &proctab[currpid];
prptr->prstate = PR_WAIT; /* Set state to waiting */
linked_queue_insert(f->get_queue, currpid);
resched(); /* and reschedule */
// on wakeup
*value = f->value;
}
else if (f->state == FUTURE_WAITING)
{
if (f->mode == FUTURE_EXCLUSIVE)
{
// More than one process calling future_get on an exclusive future
restore(mask);
return SYSERR;
}
// no value available
// wait in queue
prptr = &proctab[currpid];
prptr->prstate = PR_WAIT; /* Set state to waiting */
linked_queue_insert(f->get_queue, currpid);
resched(); /* and reschedule */
// wakeup
*value = f->value;
}
if (f->mode == FUTURE_QUEUE)
{
f->state = FUTURE_EMPTY;
if(!linked_queue_is_empty(f->set_queue))
{
// wakeup a process from the set queue
pid = linked_queue_remove(f->set_queue);
ready(pid);
}
}
restore(mask);
return OK;
}
syscall future_set(future_t* f, int value)
{
struct procent *prptr;
pid32 pid;
intmask mask = disable();
if (f->state == FUTURE_EMPTY)
{
f->value = value;
f->state = FUTURE_READY;
}
else if (f->state == FUTURE_WAITING)
{
f->value = value;
f->state = FUTURE_READY;
if (f->mode == FUTURE_SHARED)
{
resched_cntl(DEFER_START);
// wake all processes from get queue
while(!linked_queue_is_empty(f->get_queue))
{
pid = linked_queue_remove(f->get_queue);
ready(pid);
}
resched_cntl(DEFER_STOP);
}
else
{
// wakeup a single process from the get queue
pid = linked_queue_remove(f->get_queue);
ready(pid);
}
}
else if (f->state == FUTURE_READY)
{
if (f->mode == FUTURE_EXCLUSIVE || f->mode == FUTURE_SHARED)
{
// multiple calls to future_set not allowed
restore(mask);
return SYSERR;
}
// there is already an unread value set
// wait in queue
prptr = &proctab[currpid];
prptr->prstate = PR_WAIT; /* Set state to waiting */
linked_queue_insert(f->set_queue, currpid);
resched(); /* and reschedule */
// on wakeup
f->value = value;
f->state = FUTURE_READY;
}
restore(mask);
return OK;
}
|
C
|
/*
* Name : light_sensor.h
*
*
* Description : Light Sensor I2C driver header file
* that contains all the prototypes
* for functions defined in
* light_sensor.c
*
*
* Authors : Ashwath Gundepally, CU, ECEE
* Sahana Sadagopan, CU, ECEE
*/
#ifndef LIGHT_SENSOR_H
#define LIGHT_SENSOR_H
#include <stdint.h>
#include "i2c.h"
#define LIGHT_SENSOR_DEV_ADDR 0x39
#define CMD_REG 0x80
#define CMD_REG_WORD 0xA0
#define CONTROL_REG_ADDR 0x00
#define CONTROL_REG_ON 0x03
#define CONTROL_REG_OFF 0x00
#define ID_REG_ADDRESS 0x0A
/* timing reg stuff */
#define TIMING_REG_ADDR 0x01
#define ADC_GAIN_MASK 0x08
#define MANUAL_TIMING_MASK 0x04
#define INTEG_TIME_MASK 0x03
/* ADC reg stuff */
#define LOWER_BYTE_CH0_ADDR 0x0C
#define UPPER_BYTE_CH0_ADDR 0x0D
#define LOWER_BYTE_CH1_ADDR 0x0E
#define UPPER_BYTE_CH1_ADDR 0x0F
typedef enum {MIN_INTEG_TIME=0, MODERATE_INTEG_TIME=1, MAX_INTEG_TIME=2, INTEG_NA=3} integ_time_t;
typedef enum {MIN_GAIN=0, MAX_GAIN=1} gain_t;
/* THRESHOLD_LOW register stuff */
#define THRESH_LOW_LOW_ADDR 0x02
#define THRESH_LOW_HIGH_ADDR 0x03
/* Interrupt Control register stuff */
#define IC_REG_ADDR 0x06
#define INTERRUPT_ENABLE_MASK 0x10
#define NUMBER_OF_CYCLES_MASK 0x0F
typedef enum {INTERRUPT_ENABLE=0x10, INTERRUPT_DISABLE=0} ic_t;
/* struct to store the attrs associated with the interrupt control register */
typedef struct
{
/* enum to help with enabling or disabling interrupts */
ic_t interrupts;
/* uint8_t to store the number of cycles after which the interrupt is to be triggered */
uint8_t number_of_cycles;
}ic_reg_val;
/* struct to store the light sensor's id in */
typedef struct
{
/* light sensor's part number */
uint8_t part_no;
/* light sensor's rev number */
uint8_t rev_no;
}ls_id_val;
/* struct to store the various attrs associated with the timing register */
typedef struct
{
/* gain value for the sensor */
gain_t gain_val;
/* integration time for the sensor */
integ_time_t integ_time;
/* whether manual cycling is required */
uint8_t if_manual;
}timing_reg_val;
/* all the function prototypes */
i2c_rc read_id_reg(int light_sensor_fd, uint8_t* part_no, uint8_t* rev_no);
i2c_rc read_control_reg(int light_sensor_fd, uint8_t* control_reg_byte);
i2c_rc write_control_reg(int light_sensor_fd, uint8_t* control_reg_byte);
i2c_rc light_sensor_write_reg(int light_sensor_fd, uint8_t reg_addr, uint8_t* val);
i2c_rc write_timing_reg(int light_sensor_fd, gain_t adc_gain, integ_time_t integ_time, uint8_t if_manual);
i2c_rc read_timing_reg(int light_sensor_fd, gain_t* adc_gain, integ_time_t* integ_time, uint8_t* if_manual);
i2c_rc light_sensor_read_reg(int light_sensor_fd, uint8_t reg_addr, uint8_t* val);
i2c_rc turn_on_light_sensor(int light_sensor_fd);
i2c_rc read_adc(int light_sensor_fd, uint16_t* ch0_adc_val, uint16_t* ch1_adc_val);
i2c_rc get_luminosity(int light_sensor_fd, float* luminosity);
i2c_rc light_sensor_read_word_reg(int light_sensor_fd, uint8_t reg_addr, uint16_t* word);
i2c_rc light_sensor_write_word_reg(int light_sensor_fd, uint8_t reg_addr, uint16_t* word);
i2c_rc light_sensor_read_thresh_low_reg(int light_sensor_fd, uint16_t* thresh_low);
i2c_rc light_sensor_write_thresh_low_reg(int light_sensor_fd, uint16_t* thresh_low);
i2c_rc light_sensor_read_ic_register(int light_sensor_fd, ic_t* if_enabled, uint8_t* number_of_cycles);
i2c_rc light_sensor_write_ic_register(int light_sensor_fd, ic_t if_enabled, uint8_t number_of_cycles);
#endif
|
C
|
/*
* Lab 2 2.2.2.c
*
* Created: 9/13/2018 5:13:58 PM
* Author : zzh
*/
#include <avr/io.h>
#include <stdio.h>
#include <util/delay.h>
#include "uart.h"
#include <avr/interrupt.h>
volatile int flag = 0;
volatile unsigned int value1 = 0;
volatile unsigned int value2 = 0;
volatile int overflow = 0;
volatile unsigned int diff = 0;
volatile unsigned int pulse_width =0;
void output_length();
void volume_ctrl();
//set 8 stages for freqency range
#define C7 60;
#define B7 64;
#define A7 71;
#define G6 80;
#define F6 90;
#define E6 95;
#define D6 107;
#define C6 120;
#define ADC_max = 600;
#define ADC_min = 300;
float voltage = 0.0f;
int main(void)
{
uart_init(); // init UART
DDRB = 0x00; // init PORTB to be all inputs
//DDRC = 0xFF; // init PORTC to be all outputs
DDRD = 0x40; // enable PD6 to be output
DDRC = 0x0; // init PORTC to be all inputs
PORTC &= ~(1 << PORTC0); // set PC0 active high
TCCR1A = 0x00; // init High byte to zero
TCCR1B = 0x00; // init Mid byte to zero
TCCR1C = 0x00; // init Low byte to zero
DDRB |= (1<<PORTB1) | (1<<PORTB2); // enable PB1 to be output channel
PORTD |= (1<<PORTD6); //enable PD6 to be output channel
PORTB |= (1<<PORTB1);// change PB1 PB2 to high
//TIMSK1 |= (1<<ICIE1) | (1<<TOIE1); // set overflow interrupt
//TCCR1B |= (1<<CS11 ) | (1<<ICES1); // set clock prescale to 8 and enable rising edge capture
TCNT1 = 0; // reset Counter 1
TCCR0A |= (1 << COM0A0) | (1 << WGM01); //Toggle OC1A on compare match;CTC mode
TCCR0B |= (1 << CS01) | (1 << CS00); // prescaler 64
TCCR1A |= (1 << COM1B1) | (1 << WGM11) | (1 << WGM10);
TCCR1B |= (1 << CS12) | (1 << CS10) | (1 << WGM12);
ADMUX |= (1 << REFS0); //AVcc refer
ADCSRA |= (1 << ADEN); //turn on ADC
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); //division factor = 128, ADC works in
ADCSRA |= (1 << ADATE); //Signal source, in this case is the free-running
ADCSRA |= (1 << ADSC); //Start conversation
ADCSRB &= ~((1 << ADTS2)|(1 << ADTS1)|(1 << ADTS0));//ADC in free-running mode
sei(); // enable interrupt
while (1)
{
TIMSK1 |= (1<<ICIE1) | (1<<TOIE1);
//PORTB ^= (1<<PORTB1);
output_length();
volume_ctrl();
TIMSK0 |= (1 << OCIE0A);
//volume control
//printf("OCR1B:%d", OCR1B);
}
}
void output_length(void){
if (value2 < value1){overflow--;} // get rid of extra flow count if value2 < value1
diff = value2 - value1;
pulse_width = (int)overflow * 65536u + (int)diff;
/*
if (pulse_width!=0){
printf("%d \n",-pulse_width); // print to serial
}
*/
}
ISR(TIMER1_CAPT_vect){
if (flag){
TCCR1B |= (1<<ICES1); // detect rising edge
TIFR1 |= 0x20; // clears flag
value1 = ICR1; // stores time 1
flag = 0;
}
else{
TCCR1B &= ~(1<<ICES1); // detect falling edge
TIFR1 |= 0x20; // clears flag
value2 = ICR1; // stores time 2
flag = 1;
}
TIMSK1 &= ~(1<<ICIE1) | (1<<TOIE1);
}
ISR(TIMER1_OVF_vect){
overflow++; //count overflow
}
// control the frequency by ping sensor
ISR(TIMER0_COMPA_vect)
{
if(pulse_width > - 1187){
OCR0A = C7;
//printf("C7 ");
}
else if(pulse_width > -1874){
OCR0A = B7;
//printf("B7 ");
}
else if(pulse_width > -2561){
OCR0A = A7;
//printf("A7 ");
}
else if(pulse_width > -3248){
OCR0A = G6;
//printf("G6 ");
}
else if(pulse_width > -3935){
OCR0A = F6;
//printf("F6 ");
}
else if(pulse_width > -4622){
OCR0A = E6;
//printf("E6 ");
}
else if(pulse_width > -5309){
OCR0A = D6;
//printf("D6 ");
}
else{
OCR0A = C6;
//printf("C6 ");
}
TIMSK0 &= ~(1 << OCIE0A);
//printf("pulse_width: %d, OCR0A: %d\n",-pulse_width,OCR0A); // print to serial
}
// control the volume by light resistor
void volume_ctrl(void){
//ADC: 350 ~600
OCR1A = 5; //set 100 Hz
OCR1B = OCR1A / (700.0f/(float)ADC/5.0f);
}
|
C
|
//Eli Mauskopf
//Fall 2018
#include <stdlib.h>
#include <stdio.h>
#include "dlist.h"
#include "dnode.h"
#include "allocator.h"
int
allocator_init(size_t size){
mem_pointer = malloc(size);
if (mem_pointer == NULL){
return -1;
}
free_list = dlist_create();
allocated_list = dlist_create();
dlist_add_front(free_list, mem_pointer, size ); //add node with memory to list
return 0;
}
struct dnode *Firstfit(size_t size, struct dlist *free){
struct dnode *cur_node = dlist_iter_begin(free);
if(size <= cur_node->size){
return cur_node;
}
while(cur_node != NULL){
if(size <= cur_node->size){
return cur_node;
} else {
cur_node = dlist_iter_next(free);
}
}
return NULL; //couldnt find apprpriate size
}
struct dnode *Bestfit(size_t size, struct dlist *free){
struct dnode *cur_node = dlist_iter_begin(free); //initialize best fit node to return, and cur node for iteration
struct dnode *best_fit_node = NULL;
int diff = 999999; //create diff and temp dif for comparison of fits
int temp_diff;
if (cur_node == NULL){
return NULL; // list was empy
}
while(cur_node != NULL){ //loop through free list and find node with best fit
if(size <= cur_node->size){
temp_diff = cur_node->size - size;
if(temp_diff < diff){
best_fit_node = cur_node;
diff = temp_diff;
}
}
cur_node = dlist_iter_next(free);
}
if(best_fit_node == NULL){
return NULL;
}
return best_fit_node;
}
struct dnode *Worstfit(size_t size, struct dlist *free){
struct dnode *cur_node = dlist_iter_begin(free); //initialize best fit node to return, and cur node for iteration
struct dnode *worst_fit_node = NULL;
int diff = -999999; //create diff and temp dif for comparison of fits
int temp_diff;
if(cur_node == NULL){
return NULL; //list was empty
}
while(cur_node != NULL){ //loop through free list and find node with best fit
if(size <= cur_node->size){
temp_diff = cur_node->size - size;
if(temp_diff > diff){
worst_fit_node = cur_node;
diff = temp_diff;
}
}
cur_node = dlist_iter_next(free);
}
if(worst_fit_node == NULL){
return NULL;
}
return worst_fit_node; //couldnt find apprpriate size
}
int *allocate(int strategy, size_t size, struct dlist *free, struct dlist *allocated){
struct dnode *found_node = NULL;
if(strategy ==1){
found_node = Firstfit(size, free);
}
else if (strategy == 2){
found_node = Bestfit(size, free);
}
else {
found_node = Worstfit(size, free);
}
if(found_node == NULL){
printf("could not find node\n");
return NULL;
}
printf("found node has size: %d\n", found_node->size);
int *pointer = found_node->data;
dlist_add_front(allocated, found_node->data, size);
found_node->size -= size;
found_node->data += size;
return pointer;
}
int deallocate(void *ptr){
struct dnode *temp = dlist_iter_begin(allocated_list);
struct dnode *result = NULL;
bool found = false;
//check first node
if(temp->data == ptr){
result = temp;
found = true;
}
while(dlist_iter_has_next(allocated_list) && found == false){
if (temp->data == ptr){
found = true;
result = temp;
}
temp = dlist_iter_next(allocated_list);
}
if( result == NULL){
return -1;
}
// printf("found node size %d\n", result->size);
dlist_add_front(free_list, result->data, result->size);
dlist_find_remove(allocated_list, ptr);
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <linux/fb.h>
#include <string.h>
#include "base.h"
void clear_memory(unsigned long startAddress, unsigned long size) {
int fd = open("/dev/mem", O_RDWR);
unsigned long int i = 0;
unsigned char *virtual_addr_in;
virtual_addr_in = (unsigned char *)mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)startAddress);
for(i = 0; i < size; i++) {
virtual_addr_in[i] = 0;
}
munmap((void *)virtual_addr_in, size);
close(fd);
}
// Write input data to AXI data stream
void copy_mem2dev(unsigned char *R, unsigned char *G, unsigned char *B, unsigned long size, int ncols, int nrows, unsigned long in_buffer) {
int i, j;
int count = 0;
int index;
unsigned long int map_len = size;
int fd = open("/dev/mem", O_RDWR);
unsigned char *virtual_addr_in;
virtual_addr_in = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)in_buffer);
if(virtual_addr_in == MAP_FAILED) {
perror("Virtual_addr_in mapping for absolute memory access failed!\n");
return;
}
unsigned char tempR, tempG, tempB;
for(i = 0; i < nrows; i++) {
for(j = 0; j < ncols; j++) {
index = i * ncols + j;
tempR = R[index];
tempG = G[index];
tempB = B[index];
/*tempR = (unsigned char)(i+32);
tempG = (unsigned char)(j+128);
tempB = (unsigned char)(i+j+64);*/
REG_CHWRITE(virtual_addr_in, count, tempB);
REG_CHWRITE(virtual_addr_in, count+1, tempG);
REG_CHWRITE(virtual_addr_in, count+2, tempR);
count += 4;
}
}
munmap((void*)virtual_addr_in, map_len);
close(fd);
}
// Read output data from AXI data stream
void copy_dev2mem(unsigned char *edge_grey, unsigned long size, int nrows, int ncols, unsigned long out_buffer) {
int i, j;
int count = 0;
int index;
unsigned long int map_len = size;
int fd = open("/dev/mem", O_RDWR);
unsigned char *virtual_addr_out;
virtual_addr_out = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)out_buffer);
if(virtual_addr_out == MAP_FAILED) {
perror("Virtual_addr_out mapping for absolute memory access failed!\n");
return;
}
unsigned char temp_edge_grey;
for(i = 0; i < nrows; i++) {
for(j = 0; j < ncols; j++) {
index = i*ncols+j;
temp_edge_grey = (unsigned char)REG_READ(virtual_addr_out, count);
edge_grey[index] = temp_edge_grey;
count += 4;
}
}
munmap((void *)virtual_addr_out, map_len);
close(fd);
}
// Read output data
void mem_output(unsigned char *R, unsigned char *G, unsigned char *B, unsigned long size, int nrows, int ncols, unsigned long out_buffer) {
int i, j;
int count = 0;
int index;
unsigned long int map_len = size;
int fd = open("/dev/mem", O_RDWR);
unsigned char *virtual_addr_out;
virtual_addr_out = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)out_buffer);
if(virtual_addr_out == MAP_FAILED) {
perror("Virtual_addr_out mapping for absolute memory access failed!\n");
return;
}
unsigned int temp;
for(i = 0; i < nrows; i++) {
for(j = 0; j < ncols; j++) {
index = i*ncols+j;
temp = REG_READ(virtual_addr_out, count);
B[index] = (unsigned char)( temp & 0xff);
G[index] = (unsigned char)((temp >> 8 ) & 0xff);
R[index] = (unsigned char)((temp >> 16) & 0xff);
count += 4;
}
}
munmap((void *)virtual_addr_out, map_len);
close(fd);
}
// mmap offset is aligned with 4096
// rw: 1: write; 0: read
int mem_rw(int rw, unsigned int reg_addr, int *reg_value) {
int map_len = 0x1000;
int fd = open("/dev/mem", O_RDWR);
unsigned int reg_offset = reg_addr % map_len;
int reg_base = reg_addr - reg_offset;
unsigned char *map_addr = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)reg_base);
if(map_addr == MAP_FAILED) {
perror("Mapping memory for absolute memory access failed.\n");
return -1;
}
if (rw == 1) { // write
REG_WRITE(map_addr, reg_offset, *reg_value);
} else { // read
//printf("0x%08x, 0x%08x, 0x%08x\n", (int)map_addr, reg_base, reg_offset);
*reg_value = REG_READ(map_addr, reg_offset);
}
munmap((void *)map_addr, map_len);
close(fd);
return 0;
}
void delay_ms(int ms_count) {
int count;
for (count = 0; count < ((ms_count * 100000) + 1); count++);
}
int rx_test_not_empty (unsigned char *map_addr) {
// & 0x40 is 0, RX is not empty
unsigned int value = REG_READ(map_addr, 0x104);
int num = 1;
while ((value & 0x40) != 0) {
value = REG_READ(map_addr, 0x104);
num++;
if (num > 10000) {
printf("test rx not empty time out. [num = %d]\n", num);
break;
}
}
delay_ms(1);
if (num > 10000) return -1;
else return value;
}
int tx_test_empty (unsigned char *map_addr) {
// & 0x80 is not 0, TX is empty
unsigned int value = REG_READ(map_addr, 0x104);
int num = 1;
while ((value & 0x80) == 0) {
value = REG_READ(map_addr, 0x104);
num++;
if (num > 10000) {
printf("test tx empty time out. [num = %d]\n", num);
break;
}
}
delay_ms(1);
if (num > 10000) return -1;
else return value;
}
int ov_iic_read(unsigned int base_addr, unsigned int target_addr, unsigned int io_addr) {
int map_len = 0x1000;
int fd = open("/dev/mem", O_RDWR);
unsigned int addr;
unsigned char *map_addr = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)base_addr);
if(map_addr == MAP_FAILED) {
perror("Mapping memory for absolute memory access failed.\n");
return -1;
}
// reset tx fifo
REG_WRITE(map_addr, 0x100, 0x002);
// enable iic
REG_WRITE(map_addr, 0x100, 0x001);
// target select
REG_WRITE(map_addr, 0x108, 0x100 + ((target_addr % 256) / 2) * 2);
// target address
REG_WRITE(map_addr, 0x108, 0x200 + (io_addr % 256));
tx_test_empty(map_addr);
// target select
REG_WRITE(map_addr, 0x108, 0x101 + ((target_addr % 256) / 2) * 2);
// target data
REG_WRITE(map_addr, 0x108, 0x201);
// & 0x40 is 0, RX is not empty
if (rx_test_not_empty(map_addr) < 0) {
printf("RX is empty, read(0x%02x) of 0x%02x error\n", io_addr % 256, target_addr % 256);
return -1;
} else {
return REG_READ(map_addr, 0x10C);
}
}
int mux_iic_read(unsigned int base_addr, unsigned int target_addr, unsigned int io_addr) {
int map_len = 0x1000;
int fd = open("/dev/mem", O_RDWR);
unsigned int addr;
unsigned char *map_addr = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)base_addr);
if(map_addr == MAP_FAILED) {
perror("Mapping memory for absolute memory access failed.\n");
return -1;
}
// reset tx fifo
REG_WRITE(map_addr, 0x100, 0x002);
// enable iic
REG_WRITE(map_addr, 0x100, 0x001);
// target select
REG_WRITE(map_addr, 0x108, 0x100 + ((target_addr % 256) / 2) * 2);
// target address
REG_WRITE(map_addr, 0x108, io_addr % 256);
tx_test_empty(map_addr);
// target select
REG_WRITE(map_addr, 0x108, 0x101 + ((target_addr % 256) / 2) * 2);
// target data
REG_WRITE(map_addr, 0x108, 0x201);
// & 0x40 is 0, RX is not empty
if (rx_test_not_empty(map_addr) < 0) {
printf("RX is empty, read(0x%02x) of 0x%02x error\n", io_addr % 256, target_addr % 256);
return -1;
} else {
return REG_READ(map_addr, 0x10C);
}
}
int io_iic_read(unsigned int base_addr, unsigned int target_addr, unsigned int io_addr) {
int map_len = 0x1000;
int fd = open("/dev/mem", O_RDWR);
unsigned int addr;
unsigned char *map_addr = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)base_addr);
if(map_addr == MAP_FAILED) {
perror("Mapping memory for absolute memory access failed.\n");
return -1;
}
// reset tx fifo
REG_WRITE(map_addr, 0x100, 0x002);
// enable iic
REG_WRITE(map_addr, 0x100, 0x001);
// target select
REG_WRITE(map_addr, 0x108, 0x100 + ((target_addr % 256) / 2) * 2);
// target address
REG_WRITE(map_addr, 0x108, (io_addr >> 8) & 0xff);
REG_WRITE(map_addr, 0x108, io_addr & 0xff);
tx_test_empty(map_addr);
// target select
REG_WRITE(map_addr, 0x108, 0x101 + ((target_addr % 256) / 2) * 2);
// target data
REG_WRITE(map_addr, 0x108, 0x201);
if (rx_test_not_empty(map_addr) < 0) {
printf("RX is empty, read(0x%04x) of 0x%02x error\n", io_addr % 256, target_addr % 256);
return -1;
} else {
return REG_READ(map_addr, 0x10C);
}
}
int ov_iic_write(unsigned int base_addr, unsigned int target_addr, unsigned int io_addr, unsigned int wr_data) {
int map_len = 0x1000;
int fd = open("/dev/mem", O_RDWR);
unsigned int addr;
unsigned char *map_addr = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)base_addr);
if(map_addr == MAP_FAILED) {
perror("Mapping memory for absolute memory access failed.\n");
return -1;
}
// reset tx fifo
REG_WRITE(map_addr, 0x100, 0x002);
// enable iic
REG_WRITE(map_addr, 0x100, 0x001);
// target select
REG_WRITE(map_addr, 0x108, 0x100 + ((target_addr % 256) / 2) * 2);
// target address
REG_WRITE(map_addr, 0x108, io_addr % 256);
// target data
REG_WRITE(map_addr, 0x108, 0x200 + (wr_data % 256));
if (tx_test_empty(map_addr) < 0) {
printf("TX is not empty, write(0x%02x) of 0x%02x error\n", io_addr % 256, wr_data % 256);
return -1;
}
//printf("./iic_rw 0x%x 0x%x 0x%x 0x%x\n", base_addr, target_addr, io_addr, wr_data);
return 0;
}
int io_iic_write(unsigned int base_addr, unsigned int target_addr, unsigned int io_addr, unsigned int wr_data) {
int map_len = 0x1000;
int fd = open("/dev/mem", O_RDWR);
unsigned int addr;
unsigned char *map_addr = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)base_addr);
if(map_addr == MAP_FAILED) {
perror("Mapping memory for absolute memory access failed.\n");
return -1;
}
// reset tx fifo
REG_WRITE(map_addr, 0x100, 0x002);
// enable iic
REG_WRITE(map_addr, 0x100, 0x001);
// target select
REG_WRITE(map_addr, 0x108, 0x100 + ((target_addr % 256) / 2) * 2);
// target address
REG_WRITE(map_addr, 0x108, (io_addr >> 8) & 0xff);
REG_WRITE(map_addr, 0x108, io_addr & 0xff);
// target data
REG_WRITE(map_addr, 0x108, 0x200 + (wr_data % 256));
if (tx_test_empty(map_addr) < 0) {
printf("TX is not empty, write(0x%02x) of 0x%02x error\n", io_addr % 256, wr_data % 256);
return -1;
}
return 0;
}
int iic_select(unsigned int sel) {
int map_len = 0x1000;
int fd = open("/dev/mem", O_RDWR);
unsigned int addr;
unsigned base_addr = 0x40070000;
unsigned char *map_addr = (unsigned char *)mmap(NULL, map_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (off_t)base_addr);
if(map_addr == MAP_FAILED) {
perror("Mapping memory for absolute memory access failed.\n");
return -1;
}
// reset tx fifo
REG_WRITE(map_addr, 0x100, 0x002);
// enable iic
REG_WRITE(map_addr, 0x100, 0x001);
// mux select
REG_WRITE(map_addr, 0x108, 0x1e8);
// enable selected device
REG_WRITE(map_addr, 0x108, 0x200 + (sel % 256));
if (tx_test_empty(map_addr) < 0) {
printf("TX is not empty, write error\n");
return -1;
}
delay_ms(1);
// reset tx fifo
REG_WRITE(map_addr, 0x100, 0x002);
// enable iic
REG_WRITE(map_addr, 0x100, 0x001);
// mux select
REG_WRITE(map_addr, 0x108, 0x1e9);
// read back data
REG_WRITE(map_addr, 0x108, 0x201);
if (rx_test_not_empty(map_addr) < 0) {
printf("RX is empty, read error\n");
return -1;
} else {
return REG_READ(map_addr, 0x10C);
}
}
void bit_write_spec(int index, int bit_value) {
int value;
value = 0x00000000; mem_rw(1, 0x4000000C, &value);
mem_rw(0, 0x40000008, &value);
if (bit_value == 1) {
value = value | (1 << index);
} else {
value = value & (~(1 << index));
}
mem_rw(1, 0x40000008, &value);
value = 0xFFFFFFFF; mem_rw(1, 0x4000000C, &value);
}
void bit_write_common(unsigned int addr, int index, int bit_value) {
int value;
mem_rw(0, addr, &value);
if (bit_value == 1) {
value = value | (1 << index);
} else {
value = value & (~(1 << index));
}
mem_rw(1, addr, &value);
}
|
C
|
#include "stdio.h"
#define SIZE 2000000
int n,k,i,mx;
long long int d;
char c;
int minP[SIZE*2+1];
int max(int a, int b){
return a>b?a:b;
}
int main(){
scanf("%d%d ",&n,&k);
minP[SIZE] = 1;
for(i = 2,n += 2; i < n; i++){
if(getchar()=='R') d -= k;
else d++;
if(d>=-SIZE&&d<=SIZE){
if(minP[d+SIZE]!=0){
mx = max(mx,i-minP[d+SIZE]);
}else{
minP[d+SIZE] = i;
}
}
}
printf("%d\n",mx);
}
|
C
|
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node *next;
struct node *prev;
};
struct node *getnode(int data)
{
struct node *new=(struct node *)malloc(sizeof(struct node));
new->data=data;
new->next=new->prev=NULL;
return new;
}
struct node *head=NULL;
void insertatend(int data)
{
struct node *new,*temp=head;
new=getnode(data);
if(head==NULL)
head=new;
else
{
while(temp->next!=NULL)
temp=temp->next;
temp->next=new;
new->prev=temp;
}
}
void iterativedisplay()
{
struct node *temp=head;
while(temp!=NULL)
{
printf("%d\t",temp->data);
temp=temp->next;
}
}
void recursivedisplay(struct node *temp)
{
if(temp==NULL)
return;
else
{
printf("%d\t",temp->data);
recursivedisplay(temp->next);
}
}
void iterativecount()
{
int count=0;
struct node *temp=head;
while(temp!=NULL)
{
count++;
temp=temp->next;
}
printf("%d\n",count);
}
int recursivecount(struct node *temp)
{
if(temp==NULL)
return 0;
else
{
return(1+recursivecount(temp->next));
}
}
void deletenodeatn(int n)
{
struct node *temp=head;
int i=1;
if(n==1)
{
head=head->next;
head->prev=NULL;
free(temp);
}
else
{
while(i<n)
{
temp=temp->next;
i++;
}
temp->prev->next=temp->next; //NICE
if(temp->next) //Should be done only if temp->next is not NULL
temp->next->prev=temp->prev;
free(temp);
}
}
void recursivereversedoublylinkedlist(struct node *p)
{
struct node *prev,*temp,*curr;
if(p==NULL)
return;
else
{
curr=p;
recursivereversedoublylinkedlist(p->next);
if(p->next==NULL)
head=p;
prev=curr->prev;
curr->prev=curr->next;
curr->next=prev;
}
}
void iterativereversedoublylinkedlist(struct node *p)
{
struct node *temp;
while(p!=NULL)
{
temp=p->next;
p->next=p->prev;
p->prev=temp;
p=p->prev;
if(p!=NULL && p->next==NULL) //Before checking p's next we should check if p is NULL or not
head=p;
}
}
int main()
{
int ch,value,p,n;
printf("1-Insert at end\n2-Iteratvedisplay\n3-Recursive Display\n4-Iterative count\n5-Recursive count\n6-Delete node at n(starting from 1)\n7-Reverse doubly linkedlist\n");
while(1)
{
printf("\nEnter your choice:");
scanf("%d",&ch);
switch(ch)
{
case 1:printf("Enter value to be entered:");
scanf("%d",&value);
insertatend(value);
break;
case 2:iterativedisplay();
printf("\n");
break;
case 3:recursivedisplay(head);
printf("\n");
break;
case 4:iterativecount();
break;
case 5:value=recursivecount(head);
printf("\nThe no. of elements in Linked list is %d\n",value);
break;
case 6: printf("Enter the position for deletion of the particular node:");
scanf("%d",&n);
deletenodeatn(n);
break;
case 7:recursivereversedoublylinkedlist(head);
break;
case 8: iterativereversedoublylinkedlist(head);
break;
}
}
return 0;
}
|
C
|
/*
* ** client.c -- a stream socket client demo
* */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#define MAXDATASIZE 100 /* max number of bytes we can get at once */
/* get sockaddr, IPv4 or IPv6: */
void *get_in_addr(struct sockaddr *sa) {
if (sa->sa_family == AF_INET) {
return &(((struct sockaddr_in*) sa)->sin_addr);
}
return &(((struct sockaddr_in6*) sa)->sin6_addr);
}
int main(int argc, char *argv[]) {
char *inputLine;
char *closeLine = "close";
size_t buffer = 512;
ssize_t chars;
/* int bytes_read; */
int sockfd, numbytes;
char buf[MAXDATASIZE];
struct addrinfo hints, *servinfo, *p;
int rv;
char s[INET6_ADDRSTRLEN];
if (argc != 3) {
fprintf(stderr, "usage: client hostname\n");
exit(1);
}
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if ((rv = getaddrinfo(argv[1], argv[2], &hints, &servinfo)) != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
return 1;
}
/* loop through all the results and connect to the first we can */
for (p = servinfo; p != NULL; p = p->ai_next) {
if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol))
== -1) {
perror("client: socket");
continue;
}
if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
close(sockfd);
perror("client: connect");
continue;
}
break;
}
if (p == NULL) {
fprintf(stderr, "client: failed to connect\n");
return 2;
}
inet_ntop(p->ai_family, get_in_addr((struct sockaddr *) p->ai_addr), s,
sizeof s);
printf("client: connecting to %s\n", s);
freeaddrinfo(servinfo); /* all done with this structure */
while (1) {
inputLine = (char *) malloc(buffer + 1);
/* use getline to get input from the command line */
chars = getline(&inputLine, &buffer, stdin);
if ((inputLine)[chars - 1] == '\n') {
(inputLine)[chars - 1] = '\0';
--chars;
}
if (strcmp(inputLine, closeLine) == 0) {
printf("Sender was close, exiting.\n");
break;
}
send(sockfd, inputLine, buffer, 0);
free(inputLine);
}
close(sockfd);
return 0;
}
|
C
|
double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
int c1,c2;
c1 = c2 = 0;
int sumSize = nums1Size+nums2Size;
int sArray[sumSize];
while( c1<nums1Size || c2<nums2Size ){
if(c1>=nums1Size){
sArray[c1+c2]=nums2[c2++];
}else if(c2>=nums2Size){
sArray[c1+c2]=nums1[c1++];
}else{
sArray[c1+c2] = nums1[c1]<nums2[c2] ? nums1[c1++] : nums2[c2++];
}
}
if(1 == sumSize%2)
return (double)sArray[(sumSize-1)/2];
else
return (double)(sArray[(sumSize/2)-1]+sArray[sumSize/2])/2;
return 0;
}
|
C
|
//僵尸进程
/*
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
int main()
{
pid_t id = fork();
if(id<0)
{
perror("fail to fork");
exit(1);
}
else if(id == 0) //child
{
printf("the pid is %d, parent is %d",getpid(),getppid());
sleep(5);
exit(1);
}
else //parent
{
while(1)
{
printf("the parent is %d\n",getpid());
sleep(3);
}
}
return 0;
}*/
//孤儿进程
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
int main()
{
pid_t id = fork();
if(id<0)
{
perror("fail to fork");
exit(1);
}
else if(id == 0) //child
{
printf("the pid is %d, parent is %d",getpid(),getppid());
sleep(20);
}
else //parent
{
printf("the parent is %d\n",getpid());
sleep(5);
exit(1);
}
return 0;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* block_tools.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: plogan <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/23 15:38:05 by plogan #+# #+# */
/* Updated: 2019/04/23 15:38:35 by plogan ### ########.fr */
/* */
/* ************************************************************************** */
#include "../inc/malloc.h"
t_block *init_block(t_range *range, size_t block_size)
{
t_block *new;
t_block *temp;
temp = NULL;
if (!range)
return (NULL);
if ((range->type == TINY && TINY_RANGE_SIZE - sizeof(t_range) >
range->space) || (range->type == SMALL && SMALL_RANGE_SIZE -
sizeof(t_range) > range->space))
{
new = (t_block *)((char *)range + sizeof(t_range));
while (new->next)
new = new->next;
temp = new;
new = (t_block *)((char *)temp + sizeof(t_block) + temp->size);
temp->next = new;
}
else
new = (t_block *)((char *)range + sizeof(t_range));
new->freed = false;
new->size = block_size;
new->next = NULL;
range->space -= (block_size + sizeof(t_block));
return (new);
}
t_block *check_free_blocks(int type, size_t size)
{
t_range *range;
t_block *block;
range = *get_first_range();
block = NULL;
while (range)
{
if (range->type == type)
{
block = (t_block *)((char *)range + sizeof(t_range));
while (block)
{
if (block->freed && block->size >= size + sizeof(t_block))
return (block);
block = block->next;
}
}
range = range->next;
}
return (block);
}
t_block *split_block(t_block *block, size_t size)
{
t_block *new;
new = (t_block *)((char *)block + sizeof(t_block) + size);
new->freed = 1;
new->size = block->size - size - sizeof(t_block);
new->next = block->next;
block->freed = 0;
block->size = size;
block->next = new;
return (block);
}
|
C
|
#include <stdio.h>
int main()
{
int a, b, res;
res = 0;
printf("\nPlease, enter the value of variable a: ");
scanf("%d", &a);
printf("\nPlease, enter the value of variable b: ");
scanf("%d", &b);
while(b != 0)
{
res += a;
b--;
}
printf("\nEnding result = %d\n", res);
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char *argv[]) {
int answer= 59;
int n;
int i=0;
do{
printf("input a number:");
scanf("%i", &n);
if (n>answer)
printf("smaller\n");
else if (n<answer)
printf("bigger\n");
i++;
}while (n != answer);
printf("Yeah!, trial numbers:%i\n", i);
return 0;
}
|
C
|
/*******************************************************************************
* (C) 2016 Stanislav Moiseev. All rights reserved.
*
* This test computes some properties of the sublattices of R3(2),
* containing 0, 1, 2, min, max.
*
******************************************************************************/
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "utils.h"
#include "colors.h"
#include "closure/closure-straightforward.h"
#include "closure/closure2-trace.h"
#include "pred-essential.h"
#include "lattice.h"
#include "sublattice-0-1-2-min-max/sublattice33.h"
/********************************************************************/
/** This function prints the list of all predicates in P3, preserving
* 0, 1, 2, min, max.
*/
void script_filter_predicates() {
printf("list of all predicates in P3, preserving 0, 1, 2, min, max:\n");
fun f_0, f_1, f_2;
fun_scan("fun3_0_0", &f_0);
fun_scan("fun3_0_1", &f_1);
fun_scan("fun3_0_2", &f_2);
fun f_min, f_max;
fun_scan("fun3_2_210110000", &f_min);
fun_scan("fun3_2_222211210", &f_max);
for(uint64_t arity = 0; arity <= 2; ++arity) {
printf("\n");
printf("====== predicates of arity %lu ====================================\n", arity);
printf("\\begin{flalign*}\n");
uint64_t count = 0;
for(uint64_t data = 0; data < int_pow2(int_pow(3, arity)); ++data) {
pred p = { .arity = arity, .data = data };
if(//pred_is_essential(&p) &&
fun_preserves_pred(&f_0, &p) &&
fun_preserves_pred(&f_1, &p) &&
fun_preserves_pred(&f_2, &p) &&
fun_preserves_pred(&f_min, &p) &&
fun_preserves_pred(&f_max, &p)) {
fprintf(stdout, "p_{%lu} \t &= %-40s & \\text{(%s)} \\\\\n",
p.data,
pred_print_extensional_ex(&p),
pred_name(&p));
++count;
}
}
printf("\\end{flalign*}\n");
printf("total number of predicates: %lu\n", count);
}
}
void script_print_sublattice33(const char *lt_name) {
printf("computing the sublattice containing the functions 0, 1, 2, min(x,y), max(x,y)...\n");
lattice *sublt = get_sublattice33(lt_name);
for(class **cp = sublt->classes; cp < sublt->classes + sublt->num_classes; ++cp) {
class *c = *cp;
printf("\n" COLOR_BOLD "====== class %u (%u:%u) ====================================" COLOR_RESET "\n", c->cidx, c->lidx, c->cpos);
clone_print_verbosely(stdout, &c->clone);
}
/* printf("\ncomputing the list of maximal proper subclasses for every class...\n"); */
/* lattice_construct_maximal_subclones(sublt); */
/* for(class **cp = sublt->classes; cp < sublt->classes + sublt->num_classes; ++cp) { */
/* class *c = *cp; */
/* printf("====== class %u (%u:%u) ======\n", c->cidx, c->lidx, c->cpos); */
/* for(class_idx *sub_idx = c->maxsubs; sub_idx < c->maxsubs + c->num_maxsubs; ++sub_idx) { */
/* class *sub = lattice_get_class(blt, *sub_idx); */
/* printf("%u (%u:%u)\n", sub->cidx, sub->lidx, sub->cpos); */
/* } */
/* printf("\n"); */
/* } */
printf("\n================\n");
printf("sublattice size: %lu\n", sublt->num_classes);
lattice_free(sublt);
}
/********************************************************************/
/** For all 13 predicates that we do not use in the description of the
* sublattice lattice, this function find the smallest class of our
* lattice containing this predicate ("smallest" means here that the
* class contains the smallest number of predicates).
*/
void script_irrelevant_predicates(const char *lt_name) {
lattice *sublt = get_sublattice33(lt_name);
pred irrpreds[] = {
{ .arity = 2, .data = 281 },
{ .arity = 2, .data = 307 },
{ .arity = 2, .data = 315 },
{ .arity = 2, .data = 401 },
{ .arity = 2, .data = 403 },
{ .arity = 2, .data = 409 },
{ .arity = 2, .data = 411 },
{ .arity = 2, .data = 435 },
{ .arity = 2, .data = 441 },
{ .arity = 2, .data = 473 },
{ .arity = 2, .data = 475 },
{ .arity = 2, .data = 505 },
{ .arity = 2, .data = 507 },
};
size_t num_irrpreds = sizeof(irrpreds) / sizeof(struct pred);
assert(num_irrpreds == 13);
clone cl_uniq;
closure_uniq_ess_preds(2 /* max arity */, &cl_uniq);
for(pred *p = irrpreds; p < irrpreds + num_irrpreds; ++p) {
printf("\n");
printf("====== predicate p_{%lu} = %s (%s) ====================================\n",
p->data,
pred_print_extensional_ex(p),
pred_name(p));
if(!pred_is_essential(p)) {
printf(":: the predicate is not essential\n");
continue;
}
if(!clone_test_pred(&cl_uniq, p)) {
printf(":: the predicate is not closure-unique\n");
/* Find an essential predicate `p_uniq` that is a member of
`cl_uniq` and is closure-equivalent to `p`. */
int found = 0;
pred p_uniq;
closure_operator *clop = clop_alloc_straightforward();
clone p_closure;
closure_one_pred(clop, p, &p_closure);
for(clone_iterator it = clone_iterator_begin(&cl_uniq); !clone_iterator_end(&cl_uniq, &it); clone_iterator_next(&it)) {
pred p0 = clone_iterator_deref(&it);
clone p0_closure;
closure_one_pred(clop, &p0, &p0_closure);
if(clone_eq(&p_closure, &p0_closure)) {
p_uniq = p0;
found = 1;
break;
}
}
if(!found) {
printf(":: an equivalent predicates that is a member of the standard list of closure-unique predicates has /not/ been found\n");
printf(":: most likely, this is a BUG.\n");
} else {
printf(":: this predicates is closure-equivalent to the following predicate:\n");
fprintf(stdout, "p_{%lu} = %s \t (%s)\n",
p_uniq.data,
pred_print_extensional_ex(&p_uniq),
pred_name(&p_uniq));
}
clop_free(clop);
continue;
}
printf(":: the predicate is a member of the following smallest class:\n");
clone *smallest_cl = NULL;
for(class **cp = sublt->classes; cp < sublt->classes + sublt->num_classes; ++cp) {
class *c = *cp;
if(clone_test_pred(&c->clone, p)) {
if(smallest_cl == NULL) {
smallest_cl = &c->clone;
continue;
}
if(clone_subset(&c->clone, smallest_cl)) {
smallest_cl = &c->clone;
}
}
}
assert(smallest_cl != NULL);
clone_print_verbosely(stdout, smallest_cl);
}
lattice_free(sublt);
}
/********************************************************************/
static inline const pred *PRED(uint64_t data) {
static pred p;
p.arity = 2;
p.data = data;
return &p;
}
static void construct_formulas(const struct clone *clone, const pred *p) {
closure_trace_t *trace = closure2_clone_traced(clone, NULL);
trace_entry_t *entry;
for(entry = trace->entries; entry < trace->entries + trace->num_entries; ++entry) {
if(pred_eq(&entry->pred, p)) {
/* Test correctness of `closure2_trace()`. */
pred p_ = term_eval(&entry->term);
assert(pred_eq(p, &p_) && "The term does not define the predicate that it is expected to define. "
"Most likely, this is a bug in the closure2_trace() function.");
formula_t *phi = term_to_formula(&entry->term);
char *phi_str = formula_print_latex(phi, sublattice33_pred_naming_fn_latex, var_naming_fn_latex);
char *var1 = strdup(var_naming_fn_latex(1));
char *var2 = strdup(var_naming_fn_latex(2));
printf("%s(%s, %s) = %s\n", sublattice33_pred_naming_fn_latex(*p), var1, var2, phi_str);
free(var1);
free(var2);
free(phi);
free(phi_str);
break;
}
}
if(entry == trace->entries + trace->num_entries) {
printf(COLOR_RED "ERROR: predicate p_{%lu} has not been found in the trace." COLOR_RESET "\n", p->data);
}
closure_trace_free(trace);
}
void script_formulas_for_pred_307() {
printf("\n======================================================================\n");
struct clone clone;
clone_copy(top_clone2(), &clone);
clone_insert_pred(&clone, PRED(311));
clone_insert_pred(&clone, PRED(447));
construct_formulas(&clone, PRED(307));
clone_copy(top_clone2(), &clone);
clone_insert_pred(&clone, PRED(307));
construct_formulas(&clone, PRED(311));
construct_formulas(&clone, PRED(447));
}
void script_formulas_for_pred_315() {
printf("\n======================================================================\n");
struct clone clone;
clone_copy(top_clone2(), &clone);
clone_insert_pred(&clone, PRED(319));
clone_insert_pred(&clone, PRED(447));
construct_formulas(&clone, PRED(315));
clone_copy(top_clone2(), &clone);
clone_insert_pred(&clone, PRED(315));
construct_formulas(&clone, PRED(319));
construct_formulas(&clone, PRED(447));
}
void script_formulas_for_pred_435() {
printf("\n======================================================================\n");
struct clone clone;
clone_copy(top_clone2(), &clone);
clone_insert_pred(&clone, PRED(319));
clone_insert_pred(&clone, PRED(439));
clone_insert_pred(&clone, PRED(447));
construct_formulas(&clone, PRED(435));
clone_copy(top_clone2(), &clone);
clone_insert_pred(&clone, PRED(435));
construct_formulas(&clone, PRED(439));
construct_formulas(&clone, PRED(447));
}
/********************************************************************/
void script_print_generating_sets() {
ccplt *ccplt = get_ccplt33();
struct clone base;
clone_init(&base);
for(const pred *p = basic_preds; p < basic_preds + num_basic_preds; ++p) {
clone_insert_pred(&base, p);
}
printf("\\begin{align*}\n");
for(ccpnode **nodep = ccplt->nodes; nodep < ccplt->nodes + ccplt->num_nodes; ++nodep) {
ccpnode *node = *nodep;
clone clone_;
clone_intersection(&node->clone, &base, &clone_);
if(nodep < ccplt->nodes + ccplt->num_nodes - 1) {
printf(" \\pi(v_{%u}) &= %s; \t\\\\\n", node->cidx+1, clone_naming_fn_latex(&clone_, sublattice33_pred_naming_fn_latex));
} else {
printf(" \\pi(v_{%u}) &= %s.\n", node->cidx+1, clone_naming_fn_latex(&clone_, sublattice33_pred_naming_fn_latex));
}
}
printf("\\end{align*}\n");
ccplt_free(ccplt);
}
/********************************************************************/
void script_build_sublattice_with_latex_formulas() {
ccplt *ccplt = get_ccplt33();
/* Collect all predicates in a "base set". */
struct clone base;
//clone_copy(top_clone2(), &base);
clone_init(&base);
for(const pred *p = basic_preds; p < basic_preds + num_basic_preds; ++p) {
clone_insert_pred(&base, p);
}
for(pred_idx_t pidx = 0; pidx < ccplt->pred_num->uniq_sz; ++pidx) {
pred p = *idx_pred(ccplt->pred_num, pidx);
printf("\n\n%%%%====== +%s ==============================================================\n", sublattice33_pred_naming_fn_latex(p));
printf("\\subsection{Добавление предиката $%s$}\n", sublattice33_pred_naming_fn_latex(p));
printf("\n");
printf("\\begin{enumerate} %%[wide, labelindent=0pt, label=\\textbf{\\arabic*}.]");
for(ccpnode **nodep = ccplt->nodes; nodep < ccplt->nodes + ccplt->num_nodes; ++nodep) {
ccpnode *parent_node = *nodep;
if(parent_node->pidx_begin > pidx) continue;
clone parent;
clone_intersection(&parent_node->clone, &base, &parent);
/* child_node = <{p} ∪ parent_node> */
pred p = *idx_pred(ccplt->pred_num, pidx);
/* Skip cases when <{p} ∪ parent_node> = <parent_node> */
if(clone_test_pred(&parent, &p)) continue;
ccpnode *child_node = ccplt_get_node(ccplt, parent_node->children[pidx - parent_node->pidx_begin]);
clone child;
clone_intersection(&child_node->clone, &base, &child);
/* We use a user-defined LaTeX command that, when used in math
* terms, allows a line break before the symbol defined in
* instruction's argument and, in case a line break happens, the
* symbol is duplicated
*
* The instruction should have been defined as follows:
*
* \newcommand*{\duponbreak}[1]{#1\nobreak\discretionary{}{\hbox{$\mathsurround=0pt #1$}}{}}
*/
char *parent_name = strdup(clone_naming_fn_latex(&parent, sublattice33_pred_naming_fn_latex));
char *child_name = strdup(clone_naming_fn_latex(&child, sublattice33_pred_naming_fn_latex));
printf("\n\\item $[C_{%u} \\cup \\{%s\\}]_{p.p.} = [[%s]_{p.p.} \\cup \\{%s\\}]_{p.p.} \\duponbreak= [%s]_{p.p.} \\duponbreak= C_{%u}$",
parent_node->cidx+1, sublattice33_pred_naming_fn_latex(p),
parent_name, sublattice33_pred_naming_fn_latex(p),
child_name, child_node->cidx+1);
free(parent_name);
free(child_name);
clone diff;
clone_diff(&child, &parent, &diff);
size_t diff_cardinality = clone_cardinality(&diff);
if(diff_cardinality <= 1) {
printf(".\n");
} else {
/* If the difference contains more than the predicate `p`,
* then we will need to construct some proofs.
* Thus, we print the child fully. */
printf(", так как\n");
/* For every predicate `q \in (child_node \ parent_node)`, construct a
* term that builds `q` from `{p} ∪ parent_node`. */
clone generator;
clone_copy(&parent, &generator);
clone_insert_pred(&generator, &p);
closure_trace_t *trace = closure2_clone_traced(&generator, NULL);
printf(" \\begin{flalign*}\n");
unsigned num_facts = 0;
for(clone_iterator it = clone_iterator_begin(&diff); !clone_iterator_end(&diff, &it); clone_iterator_next(&it)) {
pred q = clone_iterator_deref(&it);
if(pred_eq(&q, &p)) continue;
trace_entry_t *entry;
for(entry = trace->entries; entry < trace->entries + trace->num_entries; ++entry) {
if(pred_eq(&entry->pred, &q)) {
/* Test correctness of `closure2_trace()`. */
pred q_ = term_eval(&entry->term);
assert(pred_eq(&q, &q_) && "The term does not define the predicate that it is expected to define. "
"Most likely, this is a bug in the closure2_trace() function.");
++num_facts;
formula_t *phi = term_to_formula(&entry->term);
/* Test correctness of `term_to_formula`. */
pred q__ = formula_eval(phi);
if(!pred_eq(&q_, &q__)) {
fprintf(stderr, COLOR_RED);
fprintf(stderr, "ERROR: The formula defines a predicate different from the predicated defined by the term.\n");
fprintf(stderr, " Most likely, this is a bug in the term_to_formula() function.\n");
fprintf(stderr, COLOR_RED "Term: " COLOR_YELLOW " %s\n", term_print(&entry->term, sublattice33_pred_naming_fn_latex));
fprintf(stderr, "\t\t==> %s\n", pred_print_extensional_ex(&q_));
fprintf(stderr, COLOR_RED "Formula:" COLOR_YELLOW " %s\n", formula_print_latex(phi, sublattice33_pred_naming_fn_latex, var_naming_fn_latex));
fprintf(stderr, "\t\t==> %s\n", pred_print_extensional_ex(&q__));
fprintf(stderr, COLOR_RESET);
assert(pred_eq(&q_, &q__));
}
char *phi_str = formula_print_latex(phi, sublattice33_pred_naming_fn_latex, var_naming_fn_latex);
char *var1 = strdup(var_naming_fn_latex(1));
char *var2 = strdup(var_naming_fn_latex(2));
static const char *indent_str = "\\hspace{1cm}";
if(num_facts < diff_cardinality - 1) {
printf(" %s %s(%s,%s) &= %s; & \t\\\\\n", indent_str, sublattice33_pred_naming_fn_latex(q), var1, var2, phi_str);
} else {
printf(" %s %s(%s,%s) &= %s. &\n", indent_str, sublattice33_pred_naming_fn_latex(q), var1, var2, phi_str);
}
free(var1);
free(var2);
free(phi_str);
free(phi);
break;
}
}
if(entry == trace->entries + trace->num_entries) {
fprintf(stderr, COLOR_RED "ERROR: predicate %s has not been found in the trace." COLOR_RESET "\n", sublattice33_pred_naming_fn_latex(q));
}
}
printf(" \\end{flalign*}\n");
}
}
printf("\\end{enumerate}\n");
printf("Таким образом,\n");
printf("$ Classes(%u) = \\{", pidx+1);
/* Count the number of classes that contain the predicate `p`
* (i.e. the classes constructed at the previous steps + the
* classes constructed on this step). */
unsigned num_classes = 0;
for(ccpnode **nodep = ccplt->nodes; nodep < ccplt->nodes + ccplt->num_nodes; ++nodep) {
ccpnode *node = *nodep;
if(node->pidx_begin <= pidx + 1) {
++num_classes;
}
}
assert(num_classes >= 1);
/** Because we print the list of classes in the form "C_1, C_2, ..., C_n",
* we need to check that the list is really continuous
* (to justify the usage of ellipsis) */
for(ccpnode **nodep = ccplt->nodes; nodep < ccplt->nodes + ccplt->num_nodes; ++nodep) {
ccpnode *node = *nodep;
if(node->pidx_begin <= pidx + 1) {
assert(node->cidx < num_classes);
}
}
switch(num_classes) {
case 1: printf("C_1"); break;
case 2: printf("C_1, C_2"); break;
case 3: printf("C_1, C_2, C_3"); break;
default: printf("C_1, C_2, \\ldots, C_{%u}", num_classes); break;
}
printf("\\}. $\n");
}
ccplt_free(ccplt);
}
#include "binary/bin-lattice.h"
void script_print_sublattice33_dot() {
ccplt *ccplt = get_ccplt33();
lattice *lt = lattice_alloc();
lattice_load_classes_from_ccplt(lt, ccplt);
lattice_construct_layers_ccplt(lt, ccplt);
lattice_construct_maximal_subclones(lt);
printf("graph lattice33 {\n");
for(class **cp = lt->classes; cp < lt->classes + lt->num_classes; ++cp) {
class *c = *cp;
printf(" C%u [shape=point, label=\"\"]\n", c->cidx+1);
}
printf("\n");
for(class **cp = lt->classes; cp < lt->classes + lt->num_classes; ++cp) {
class *c = *cp;
for(class_idx *sub_idx = c->maxsubs; sub_idx < c->maxsubs + c->num_maxsubs; ++sub_idx) {
class *sub = lattice_get_class(lt, *sub_idx);
printf(" C%u -- C%u;\n", c->cidx+1, sub->cidx+1);
}
}
printf("}\n");
ccplt_free(ccplt);
lattice_free(lt);
}
int main() {
// script_print_sublattice33("data/lattice.2016");
// script_filter_predicates();
// script_irrelevant_predicates("data/lattice.2016");
// script_formulas_for_pred_307();
// script_formulas_for_pred_315();
// script_formulas_for_pred_435();
// script_print_generating_sets();
//script_build_sublattice_with_latex_formulas();
script_print_sublattice33_dot();
}
|
C
|
#include<stdio.h>
int main()
{
double firstnumber,second number,temporary variable;
printf("enter the firstnumber:");
scanf("%1d",&firstnumber);
printf("enter the secondnumber:");
scanf("%1d",&secondnumber);
temporary variable=firstnumber;
firstnumber=secondnumber;
secondnumber=temporary variable;
printf("\n after swapping,firstnumber=%21f"\n,firstnumber);
printf("\n after swapping,secondnumber=%21f"\n,secondnumber);
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
pid_t pid;
int mypipefd[2];
int ret;
char buffer[20];
ret=pipe(mypipefd);
pid =fork();
if (pid==0)
{
//This is child process, now try to write something to parent
printf("This is child\n");
write(mypipefd[1],"Hello\n",10);
}
else
{
//This is parent
printf("This is parent process\n");
read(mypipefd[0],buffer,12);
printf("%s\n",buffer);
}
return 0;
}
|
C
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/**
*main - function serving as a change machine.
*@argc: argument count.
*@argv: argument vector.
*Return: 0
*/
int main(int argc, char *argv[])
{
int i, j, k, l = 0;
int cent[] = {25, 10, 5, 2, 1};
if (argc != 2)
{
printf("Error\n");
return (1);
}
k = atoi(argv[1]);
if (k < 1)
printf("0\n");
else
{
for (i = 0; i < 5 && k; i++)
{
j = k / cent[i];
l += j;
k -= j * cent[i];
}
printf("%d\n", l);
}
return (0);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "fisier constante.c"
void eliminare_spatii_punctuatie(char *);
int valabilitate (char *);
void majuscule (char *);
void inlocuire_J_I (char *);
void separare_litere_duble (char *);
void frecventa_litere (char *, struct vector_frecvente *);
void creare_matrice ();
void eliminare_litere_duble(char *,char *, struct vector_frecvente *);
void prelucrare_matrice(struct matrica **, char *, struct vector_frecvente *);
void criptare_playfair (char *,struct matrica **, char *);
struct vector_frecvente
{
unsigned char litera: 1;
int frecv;
unsigned int marcat: 1;
};
struct matrica
{
char litera;
int lin;
int col;
};
FILE *f,*g;
int main()
{
char *prop, *key, *key2, *mesajul_criptat;
int valabil;
f=fopen("matrice_criptare.out","w");
g=fopen("date_criptare.in", "r");
int i,j,k;
//alocare dinamica//
struct vector_frecvente *v;
v=(struct vector_frecvente *)calloc(ALFABET, sizeof(struct vector_frecvente));//Am folosit calloc pentru a initioaliza toate campurile structurii cu '0'//
prop=(char *)malloc(DIMMAX*sizeof(char));
key=(char *)malloc(DIMMAX*sizeof(char));
key2=(char *)malloc(DIMMAX*sizeof(char));
mesajul_criptat=(char *)malloc(DIMMAX*sizeof(char));
//creare matrice//
struct matrica **matrix= NULL;
matrix=(struct matrica **)calloc(5,sizeof(struct matrica*));
for (i=0; i<5; i++)
{
matrix[i]=(struct matrica *)calloc(5,sizeof(struct matrica));
}
for(i=0; i<5; i++)
{
for(j=0; j<5; j++)
{
(matrix[i][j]).lin=i;
(matrix[i][j]).col=j;
}
}
fgets(prop, DIMMAX, g); //citire date//
fgets(key,DIMMAX,g);
//prelucrare prop+cazurile speciale//
valabil=valabilitate(prop);
if (valabil==0)
{
printf("Reintroduceti un mesaj valabil(continand cel putin o litera)!");
exit(0);
}
eliminare_spatii_punctuatie(prop);
majuscule(prop);
separare_litere_duble(prop);
if(strlen(prop)%2!=0)
{
strcat(prop, "Z");
}
fprintf(f,"Mesajul prelucrat este: ");
fprintf(f,"%s\n",prop);
//prelucrare key+cazurile speciale//
valabil=valabilitate(key);
if (valabil==0)
{
printf("Reintroduceti o cheie valabila(continand cel putin o litera)!");
exit(0);
}
eliminare_spatii_punctuatie(key);
majuscule(key);
inlocuire_J_I(key);
frecventa_litere(key,v);
eliminare_litere_duble(key,key2,v);
fprintf(f,"Cheia prelucrata este: ");
fprintf(f,"%s\n", key2);
//prelucrare matrice//
fprintf(f,"Matricea asociata criptarii este: \n");
prelucrare_matrice(matrix, key2, v);
//afisare matrice//
for (i=0; i<LIN; i++)
{
for (j=0; j<COL; j++)
{
fprintf(f,"%c ", (matrix[i][j]).litera);
}
fprintf(f,"\n");
}
//criptarea mesajului //
criptare_playfair(prop, matrix, mesajul_criptat);
fprintf(f,"Mesajul criptat este: ");
for(i=0; i<strlen(prop); i++)
fprintf(f,"%c", mesajul_criptat[i]);
printf("\n");
printf("Pentru a vizualiza matricea asociata criptarii Playfair accesati fisierul matrice_criptare.out");
return 0;
}
|
C
|
void example1(uint16_t value_a, uint16_t value_b)
{
uint32_t value = 0;
uint8_t value_ge = 0;
uint8_t value_shi = 0;
uint8_t value_bai = 0;
value = value_a;
value_ge = value%10;
value_shi = value%100/10;
value_bai = value%1000/100;
max7219_write(1, value_bai);
max7219_write(2, value_shi);
max7219_write(3, value_ge);
value = value_b;
value_ge = value%10;
value_shi = value%100/10;
value_bai = value%1000/100;
max7219_write(4, value_bai);
max7219_write(5, value_shi);
max7219_write(6, value_ge);
}
void example2(void)
{
max7219_write(1,1);
max7219_write(2,2);
max7219_write(3,3);
max7219_write(4,4);
max7219_write(5,5);
max7219_write(6,6);
max7219_write(7,7);
max7219_write(8,8);
max7219_write(9,9);
max7219_write(10,0xa);
max7219_write(11,0xb);
max7219_write(12,0xc);
max7219_write(13,0xd);
max7219_write(14,0xe);
max7219_write(15,0xf);
max7219_write(16,0x80);
max7219_write(17,'H');
max7219_write(18,'P');
max7219_write(19,'_');
max7219_write(20,' ');
max7219_write(21,'-');
max7219_write(22,'L');
max7219_write(23,'r');
max7219_write(24,'.');
}
|
C
|
#pragma once
public class CUser
{
private:
INT userId;
CString username;
CString password;
CString emailAddress;
CString displayName;
public:
CUser(void);
INT UserId() const { return userId; }
void UserId(INT val) { userId = val; }
CString Username() const { return username; }
void Username(CString val) { this->username = val; }
CString Password() const { return password; }
void Password(CString val) { this->password = val; }
CString EmailAddress() const { return emailAddress; }
void EmailAddress(CString val) { this->emailAddress = val; }
CString DisplayName() const { return displayName; }
void DisplayName(CString val) { this->displayName = val; }
};
public class CAddressBook
{
private:
INT userId;
INT friendId;
public:
CAddressBook(void);
INT UserId() const { return userId; }
void UserId(INT val) { userId = val; }
INT FriendId() const { return friendId; }
void FriendId(INT val) { friendId = val; }
};
public class CGroup
{
private:
INT groupId;
CString groupName;
CString description;
INT GroupId() const { return groupId; }
void GroupId(INT val) { groupId = val; }
CString GroupName() const { return groupName; }
void GroupName(CString val) { groupName = val; }
CString Description() const { return description; }
void Description(CString val) { description = val; }
};
|
C
|
#include<stdio.h>
#include<signal.h>
#include<unistd.h>
void foo(int sig) {
printf("got signal %d\n", sig); // print signum
signal(SIGINT, SIG_DFL); // back to default
}
int main() {
signal(SIGINT, foo);
pid_t child = fork();
if(child == 0) {
while(1) {
puts("child");
sleep(1);
}
}else{
sleep(5);
kill(child, SIGTERM); // terminate
}
}
|
C
|
#include "DialogBooks.h"
#include "UIElement.h"
#include "UIContainer.h"
#include "UIInputBox.h"
#include "UIButton.h"
#include "BookDatabase.h"
#include "UIBookCover.h"
#include "DialogBookDetail.h"
#include "DialogAddBook.h"
DialogBooks dialog_books;
int dialog_books_init(
UIContainer* parent_container,
BookDatabase* bookdb)
{
int i = 0;
if (!parent_container || !bookdb)
{
return 0;
}
UIContainer* books = ui_container_construct(0);
ui_element_set_pos_relatively(books, 0, 2, 15, 98, 94);
ui_container_append_element(parent_container, books);
dialog_books.container = books;
dialog_books.bookdb = bookdb;
UIDialog* dialog = ui_dialog_construct("");
ui_element_set_pos_relatively(dialog, books, 0, 0, 100, 100);
ui_container_append_element(books, dialog);
UIButton* add_book = ui_button_construct("");
ui_element_set_pos_relatively(add_book, books, 58, 5, 68, 7);
ui_element_set_event(add_book, dialog_books_add_book_on_event);
ui_container_append_element(books, add_book);
UIButton* last_page = ui_button_construct("һҳ");
ui_element_set_pos_relatively(last_page, books, 72, 5, 83, 7);
ui_element_set_event(last_page, dialog_books_last_page_on_event);
ui_container_append_element(books, last_page);
UIButton* next_page = ui_button_construct("һҳ");
ui_element_set_pos_relatively(next_page, books, 86, 5, 96, 7);
ui_element_set_event(next_page, dialog_books_next_page_on_event);
ui_container_append_element(books, next_page);
dialog_books.covers_srow = 0;
for (i = 0; i < BOOKS_COVER_LIST_PAGE_CONTENT; ++i)
{
dialog_books.covers[i] = 0;
dialog_books.books[i] = 0;
}
dialog_books_refresh_books();
return 1;
}
int dialog_books_close()
{
ui_element_set_visible(dialog_books.container, 0);
return 1;
}
void dialog_books_refresh_books()
{
Iterator it;
int count = 0;
int idx = 0;
int i = 0;
Book* book = 0;
if (!dialog_books.container)
{
return;
}
if (dialog_books.covers_srow * BOOKS_COVER_LIST_PAGE_CONTENT >
dialog_books.bookdb->books->size)
{
dialog_books.covers_srow--;
}
for (it = list_begin(dialog_books.bookdb->books);
!iterator_equal(it, list_end(dialog_books.bookdb->books));
iterator_move(&it), count++)
{
if (BOOKS_COVER_LIST_COL * dialog_books.covers_srow > count)
{
continue;
}
book = iterator_read(it);
if (!book)
{
return;
}
idx = count - BOOKS_COVER_LIST_COL * dialog_books.covers_srow;
if (idx >= BOOKS_COVER_LIST_PAGE_CONTENT)
{
break;
}
if (!dialog_books.covers[idx])
{
dialog_books.covers[idx] = ui_book_cover_construct(book->name);
ui_element_set_event(dialog_books.covers[idx],
dialog_books_cover_on_event);
ui_container_append_element(dialog_books.container,
dialog_books.covers[idx]);
}
else
{
ui_book_cover_set_caption(dialog_books.covers[idx],
book->name);
}
if (AVAILABLE == book->status)
{
ui_element_set_attributes(dialog_books.covers[idx],
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
BACKGROUND_RED | BACKGROUND_BLUE);
}
else
{
ui_element_set_attributes(dialog_books.covers[idx],
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
BACKGROUND_INTENSITY);
}
ui_element_set_pos(dialog_books.covers[idx],
relative_persentage_X(dialog_books.container, 5 + 19 * (idx % BOOKS_COVER_LIST_COL)),
relative_persentage_Y(dialog_books.container, 20 + 40 * (idx / BOOKS_COVER_LIST_COL)),
relative_persentage_X(dialog_books.container, 5 + 19 * (idx % BOOKS_COVER_LIST_COL)) + UI_BOOK_COVER_WIDTH,
relative_persentage_Y(dialog_books.container, 20 + 40 * (idx / BOOKS_COVER_LIST_COL)) + UI_BOOK_COVER_HEIGHT);
dialog_books.books[idx] = book;
}
idx = count - BOOKS_COVER_LIST_COL * dialog_books.covers_srow;
for (i = idx; i < BOOKS_COVER_LIST_PAGE_CONTENT; ++i)
{
if (dialog_books.covers[i])
{
ui_element_mark_as_deleted(dialog_books.covers[i]);
}
dialog_books.covers[i] = 0;
dialog_books.books[i] = 0;
}
}
void dialog_books_cover_on_event(
UIBookCover* cover,
UIEventType event_type,
int param1,
int param2)
{
int idx = 0;
if (!cover)
{
return;
}
switch (event_type)
{
case MOUSE_LEFT_PRESS:
{
idx = cover - dialog_books.covers;
for (idx = 0; idx < BOOKS_COVER_LIST_PAGE_CONTENT; ++idx)
{
if (dialog_books.covers[idx] == cover)
{
break;
}
}
if (BOOKS_COVER_LIST_PAGE_CONTENT == idx)
{
break;
}
if (idx >= 0 &&
idx < BOOKS_COVER_LIST_PAGE_CONTENT &&
dialog_books.books[idx])
{
dialog_book_detail_show(dialog_books.books[idx]);
}
break;
}
default:
break;
}
}
void dialog_books_add_book_on_event(
UIButton* button,
UIEventType event_type,
int param1,
int param2)
{
if (!button)
{
return;
}
switch (event_type)
{
case MOUSE_LEFT_PRESS:
{
dialog_add_book_show();
break;
}
default:
break;
}
}
void dialog_books_last_page_on_event(
UIButton* button,
UIEventType event_type,
int param1,
int param2)
{
if (!button)
{
return;
}
switch (event_type)
{
case MOUSE_LEFT_PRESS:
{
if (dialog_books.covers_srow > 0)
{
dialog_books.covers_srow--;
dialog_books_refresh_books();
}
break;
}
default:
break;
}
}
void dialog_books_next_page_on_event(
UIButton* button,
UIEventType event_type,
int param1,
int param2)
{
if (!button)
{
return;
}
switch (event_type)
{
case MOUSE_LEFT_PRESS:
{
dialog_books.covers_srow++;
dialog_books_refresh_books();
break;
}
default:
break;
}
}
|
C
|
#include <stdio.h>
#include <unistd.h>
int main()
{
pid_t pid;
/* process id */
printf("\njust one process before the fork()\n");
pid = fork();
printf("\nThe Process id: %d",pid);
if(pid == 0)
printf("\nI am the child process\n");
else if(pid > 0)
printf("\nI am the parent process\n");
else
printf("\nThe fork() has failed\n");
}
|
C
|
/*
* Note... this isn't a very exhaustive test suite... however, I only needed to fix these edge cases, and the system
* appeared to operate normally. Feel free to leave a git issue, or submit a PR highlighting a case that fails...
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>
#include "avr-scheduler.h"
int main(int argc, char *argv[]) {
schedule_t *s = new_schedule();
// Put stuff in a schedule, and set the ID's to be the order that you expect. The first one will be 1, second 2, etc...
schedule_insert(s, 10, 100, 1);
schedule_insert(s, 20, 110, 2);
schedule_insert(s, 30, 120, 3);
schedule_insert(s, 40, 130, 4);
schedule_test_backwards(s); // This will check the order
schedule_test_forwards(s);
schedule_clear(s); //Clear the schedule after every test
schedule_insert(s, 100, 50, 1);
schedule_insert(s, 100, 150, 2);
schedule_insert(s, 100, 59850, 3);
schedule_insert(s, 100, 59950, 4);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 100, 59850, 1);
schedule_insert(s, 100, 59950, 2);
schedule_insert(s, 100, 50, 3);
schedule_insert(s, 100, 150, 4);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 100, 59850, 1);
schedule_insert(s, 100, 50, 2);
schedule_insert(s, 100, 150, 3);
schedule_insert(s, 100, 150, 4);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 100, 59850, 3);
schedule_insert(s, 50, 59850, 2);
schedule_insert(s, 20, 59850, 1);
schedule_insert(s, 100, 50, 4);
schedule_insert(s, 100, 150, 5);
schedule_insert(s, 100, 150, 6);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 100, 59950, 3);
schedule_insert(s, 50, 59950, 2);
schedule_insert(s, 20, 59950, 1);
schedule_insert(s, 100, 50, 4);
schedule_insert(s, 100, 150, 5);
schedule_insert(s, 100, 150, 6);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 20, 59850, 1);
schedule_insert(s, 50, 59850, 2);
schedule_insert(s, 100, 59850, 3);
schedule_insert(s, 100, 50, 4);
schedule_insert(s, 100, 150, 5);
schedule_insert(s, 100, 150, 6);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 20, 59950, 1);
schedule_insert(s, 50, 59950, 2);
schedule_insert(s, 100, 59950, 3);
schedule_insert(s, 100, 50, 4);
schedule_insert(s, 100, 150, 5);
schedule_insert(s, 100, 150, 6);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 150, 59950, 3); //100
schedule_insert(s, 50, 59960, 1); //10
schedule_insert(s, 100, 59970, 2); //70
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 150, 59950, 5); //100
schedule_insert(s, 50, 59960, 1); //10
schedule_insert(s, 100, 59970, 3); //70
schedule_insert(s, 60, 30, 4); //90
schedule_insert(s, 10, 50, 2); //60
schedule_insert(s, 100, 150, 6); //250
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 20, 59850, 0);
schedule_insert(s, 50, 59850, 0);
schedule_insert(s, 100, 59850, 1);
schedule_insert(s, 100, 50, 2);
schedule_insert(s, 100, 150, 3);
schedule_insert(s, 100, 150, 4);
schedule_pop(s);
schedule_pop(s);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 20, 59950, 0);
schedule_insert(s, 50, 59950, 0);
schedule_insert(s, 100, 59950, 1);
schedule_insert(s, 100, 50, 2);
schedule_insert(s, 100, 150, 3);
schedule_insert(s, 100, 150, 4);
schedule_pop(s);
schedule_pop(s);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 150, 59950, 1); //100
schedule_insert(s, 50, 59960, 0); //10
schedule_insert(s, 100, 59970, 0); //70
schedule_pop(s);
schedule_pop(s);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
schedule_insert(s, 150, 59950, 3); //100
schedule_insert(s, 50, 59960, 0); //10
schedule_insert(s, 100, 59970, 1); //70
schedule_insert(s, 60, 30, 2); //90
schedule_insert(s, 10, 50, 0); //60
schedule_insert(s, 100, 150, 4); //250
schedule_pop(s);
schedule_pop(s);
schedule_test_backwards(s);
schedule_test_forwards(s);
schedule_clear(s);
}
|
C
|
#include "malloc.h"
void *glob = NULL;
t_block *call_space(size_t size)
{
t_block *tmp;
t_block *block;
block = sbrk(0);
block = sbrk(size + sizeof(t_block));
if (block == (void *) - 1)
return (NULL);
block->size = size;
block->next = NULL;
block->free = 0;
if (glob != NULL)
{
tmp = glob;
while (tmp->next)
{
tmp = tmp->next;
}
tmp->next = block;
}
else
glob = block;
return (block);
}
t_block *search_block(size_t size)
{
t_block *first;
first = glob;
while (first)
{
if(first->free && first->size >= size)
{
first->free = 0;
return(first);
}
first = first->next;
}
return (NULL);
}
void cut_block(t_block *free_one, size_t size)
{
t_block *other_block;
other_block = (void *)free_one + sizeof(t_block) + (sizeof(char) *size);
other_block->size = free_one->size - size - sizeof(t_block);
other_block->next = free_one->next;
other_block->free = 1;
free_one->size = (void *)other_block - (void *)free_one + sizeof(t_block);
free_one->next = other_block;
}
void *malloc(size_t size)
{
t_block *block;
if (size <= 0)
return (NULL);
if (glob != NULL)
{
block = search_block(size);
if (block && block->size > size)
cut_block(block, size);
else if (!block)
block = call_space(size);
}
else
block = call_space(size);
if (!block)
return (NULL);
return ((void *)block + sizeof(t_block));
}
void free(void *pointer)
{
t_block *block;
block = glob;
if (!pointer)
return ;
while (block && pointer != block)
{
block = block->next;
}
if (!block)
return ;
block->free = 1;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* libft.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lkaser <lkaser@student.42.us.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/09/18 11:03:56 by lkaser #+# #+# */
/* Updated: 2018/06/20 22:07:55 by lkaser ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LIBFT_H
# define LIBFT_H
# include <stdlib.h>
# include <stdio.h>
# include <unistd.h>
# include <stdint.h>
/*
** Macros.
*/
# define NULL_GUARD(a) if(!(a)) return (NULL);
# define ASSERT(a) if (!(a)) {ASSERT_FAIL;}
# define ANY2(x,a,b) (x == a || x == b)
# define ANY3(x,a,b,c) (x == a || x == b || x == c)
# define ANY4(x,a,b,c,d) (x == a || x == b || x == c || x == d)
# define ANY5(x,a,b,c,d,e) (x == a || x == b || x == c || x == d || x == e)
# define MATCH(a,b) if (a) b
# define OR(a,b) else if (a) b
# define OTHERWISE(a) else a
# define FT_ITOA_BASE(nbr, base) ft_itoa_base(nbr, base, sizeof base - 1)
# define FT_UTOA_BASE(nbr, base) ft_utoa_base(nbr, base, sizeof base - 1)
# define TRUE (1)
# define FALSE (0)
/*
** Memory.
*/
typedef char t_bool;
void *ft_memset(void *ptr, int val, size_t n);
void ft_bzero(void *ptr, size_t b);
void *ft_memcpy(void *dst, const void *src, size_t b);
void *ft_memccpy(void *dst, const void *src, int c, size_t b);
void *ft_memmove(void *dst, const void *src, size_t b);
void *ft_memchr(const void *s, int c, size_t b);
int ft_memcmp(const void *m1, const void *m2, size_t b);
/*
** Strings.
*/
size_t ft_strlen(const char *str);
char *ft_strdup(const char *str);
char *ft_strcpy(char *dst, const char *src);
char *ft_strncpy(char *dst, const char *src, size_t size);
char *ft_strcat(char *dst, const char *src);
char *ft_strncat(char *dst, const char *src, size_t size);
size_t ft_strlcat(char *dst, const char *src, size_t size);
char *ft_strchr(const char *str, int val);
char *ft_strrchr(const char *str, int val);
char *ft_strstr(const char *str, const char *needle);
char *ft_strnstr(const char *str, const char *needle,
size_t size);
char *ft_wchar_utf8(wchar_t *wc);
int ft_strcmp(const char *a, const char *b);
int ft_strncmp(const char *a, const char *b, size_t size);
int ft_atoi(const char *str);
double ft_atof(const char *str);
int ft_isalpha(int c);
int ft_isdigit(int c);
int ft_isalnum(int c);
int ft_isascii(int c);
int ft_isprint(int c);
int ft_toupper(int c);
int ft_tolower(int c);
void *ft_memalloc(size_t size);
void ft_memdel(void **ptr);
char *ft_strnew(size_t size);
void ft_strdel(char **str);
void ft_strclr(char *str);
void ft_striter(char *str, void (*f)(char *));
void ft_striteri(char *str, void (*f)(unsigned int, char *));
char *ft_strmap(char const *str, char (*f)(char));
char *ft_strmapi(char const *str, char (*f)(unsigned int, char));
int ft_strequ(char const *a, char const *b);
int ft_strnequ(char const *a, char const *b, size_t n);
char *ft_strsub(char const *str, unsigned int start, size_t len);
char *ft_strjoin(char const *a, char const *b);
char *ft_strtrim(char const *str);
char **ft_strsplit(char const *str, char c);
t_bool ft_str_has_only(const char *str, const char *has_only);
void ft_strappend(char **str, char const *add);
void ft_strprepend(char const *add, char **str);
char *ft_itoa(long n);
char *ft_itoa_base(intmax_t nbr, char *base_str, unsigned base);
char *ft_utoa_base(uintmax_t nbr, char *base_str,
unsigned base);
void ft_putchar(char c);
void ft_putstr(char const *s);
void ft_puterror(char const *s);
void ft_putendl(char const *s);
void ft_putnbr(int n);
void ft_putchar_fd(char c, int fd);
void ft_putstr_fd(char const *s, int fd);
void ft_putendl_fd(char const *s, int fd);
void ft_putnbr_fd(int n, int fd);
typedef t_bool (*t_compare)(const void *, const void *);
/*
** Linked lists.
*/
typedef struct s_list
{
void *content;
size_t content_size;
struct s_list *next;
} t_list;
t_list *ft_lstnew(void const *content, size_t content_size);
void ft_lstdelone(t_list **lst, void (*del)(void *, size_t));
void ft_lstdel(t_list **lst, void (*del)(void *, size_t));
void ft_lstadd(t_list **lst, t_list *new);
void ft_lstiter(t_list *lst, void (*f)(t_list *elem));
t_list *ft_lstmap(t_list *lst, t_list *(*f)(t_list *elem));
void *ft_lstpush(t_list **lst, void *content, size_t size);
void *ft_lstpop(t_list **lst);
t_list *ft_lstfind(t_list *lst, t_compare pred, const void *data);
void ft_lstrm(t_list **lst, t_list *to_rm);
/*
** Vector.
*/
typedef struct s_vector
{
void **data;
unsigned length;
unsigned capacity;
} t_vector;
void ft_vector_init(t_vector *v);
void ft_vector_resize(t_vector *v, unsigned size);
void ft_vector_push(t_vector *v, void *d);
void ft_vector_rm(t_vector *v);
/*
** Pair.
*/
typedef struct s_pair
{
void *fst;
void *snd;
} t_pair;
/*
** Misc.
*/
void ft_putstrarray(char **str);
void ft_putintarray(int *int_array, size_t size);
void ft_putmem(char *varname, void *var, size_t bytes);
t_bool ft_in_range(const int i, const int low, const int high);
/*
** Get next line.
*/
# define GNL_BUFF 1024
int get_next_line(const int fd, char **line);
typedef struct s_fileinfo
{
int fd;
long i;
long fill;
char buff[GNL_BUFF + 1];
} t_fileinfo;
/*
** Sorting.
*/
void ft_qsort(void *array[], int size, t_compare pred);
/*
** Dynamic String.
*/
typedef struct s_string {
char *content;
size_t length;
size_t capacity;
} t_string;
void ft_string_init(t_string *s);
size_t ft_string_append(t_string *s, char *add);
size_t ft_string_appendn(t_string *s, char *add, size_t len);
/*
** Printf
*/
int ft_printf(char *format, ...);
#endif
|
C
|
/*
* randInitializeWeights.c
*
* Code generation for function 'randInitializeWeights'
*
* C source code generated on: Tue Sep 22 15:13:44 2015
*
*/
/* Include files */
#include "randInitializeWeights.h"
#include "randInitializeWeights_emxutil.h"
#include "rand.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
/* Function Declarations */
/* Function Definitions */
void randInitializeWeights(int16_T L_in, int16_T L_out, emxArray_real_T *W)
{
int32_T b_W;
int32_T c_W;
/* RANDINITIALIZEWEIGHTS Randomly initialize the weights of a layer with L_in */
/* incoming connections and L_out outgoing connections */
/* W = RANDINITIALIZEWEIGHTS(L_in, L_out) randomly initializes the weights */
/* of a layer with L_in incoming connections and L_out outgoing */
/* connections. */
/* */
/* Note that W should be set to a matrix of size(L_out, 1 + L_in) as */
/* the column row of W handles the "bias" terms */
/* */
/* You need to return the following variables correctly */
/* ====================== YOUR CODE HERE ====================== */
/* Instructions: Initialize W randomly so that we break the symmetry while */
/* training the neural network. */
/* */
/* Note: The first row of W corresponds to the parameters for the bias units */
/* */
b_W = 1 + L_in;
if (b_W > 32767) {
b_W = 32767;
}
b_rand(L_out, (int16_T)b_W, W);
b_W = W->size[0] * W->size[1];
W->size[0] = W->size[0];
W->size[1] = W->size[1];
emxEnsureCapacity((emxArray__common *)W, b_W, (int32_T)sizeof(real_T));
b_W = W->size[0];
c_W = W->size[1];
c_W *= b_W;
for (b_W = 0; b_W < c_W; b_W++) {
W->data[b_W] = W->data[b_W] * 2.0 * 0.12 - 0.12;
}
/* ========================================================================= */
}
/* End of code generation (randInitializeWeights.c) */
|
C
|
/**
* @file
*
* @brief
*
* @copyright BSD License (see doc/LICENSE.md or https://www.libelektra.org)
*/
#include <opmphm.c>
#include <tests_internal.h>
ssize_t ksCopyInternal (KeySet * ks, size_t to, size_t from);
void test_keyNotFound (void)
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
Key * found = ksLookupByName (ks, "/nothere", KDB_O_OPMPHM);
succeed_if (!found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
ksDel (ks);
}
void test_Copy (void)
{
// ksDup
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
KeySet * copy = ksDup (ks);
succeed_if (copy, "copy");
// opmphm should be build
exit_if_fail (copy->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (copy->data->opmphm), "build opmphm");
// test opmphm
Key * iter;
ksRewind (copy);
while ((iter = ksNext (copy)))
{
Key * f = ksLookup (copy, iter, KDB_O_OPMPHM);
succeed_if (f, "key found");
}
// cleanup
ksDel (ks);
ksDel (copy);
}
// ksDeepDup
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
KeySet * copy = ksDeepDup (ks);
succeed_if (copy, "copy");
// opmphm should be build
exit_if_fail (copy->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (copy->data->opmphm), "build opmphm");
// test opmphm
Key * iter;
ksRewind (copy);
while ((iter = ksNext (copy)))
{
Key * f = ksLookup (copy, iter, KDB_O_OPMPHM);
succeed_if (f, "key found");
}
// cleanup
ksDel (ks);
ksDel (copy);
}
// ksCopy
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
KeySet * copy = ksNew (0, KS_END);
succeed_if (ksCopy (copy, ks) == 1, "copy");
// opmphm should be build
exit_if_fail (copy->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (copy->data->opmphm), "build opmphm");
// test opmphm
Key * iter;
ksRewind (copy);
while ((iter = ksNext (copy)))
{
Key * f = ksLookup (copy, iter, KDB_O_OPMPHM);
succeed_if (f, "key found");
}
// cleanup
ksDel (ks);
ksDel (copy);
}
// test not build copy
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
KeySet * copy = ksDup (ks);
succeed_if (copy, "copy");
// opmphm should not be build
succeed_if (!copy->data->opmphm, "not build opmphm");
// cleanup
ksDel (ks);
ksDel (copy);
}
}
void test_Invalidate (void)
{
// ksClose
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
succeed_if (ksClose (ks) == 0, "invalidate");
// TODO (atmaxinger): ksClose removes and deletes opmphm, we can't check it here - maybe somewhere else?
// exit_if_fail (ks->data->opmphm, "build opmphm");
// succeed_if (!opmphmIsBuild (ks->data->opmphm), "empty opmphm");
// cleanup
ksDel (ks);
}
// ksClear
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
succeed_if (ksClear (ks) == 0, "invalidate");
// TODO (atmaxinger): ksClear removes and deletes opmphm, we can't check it here - maybe somewhere else?
// exit_if_fail (ks->data->opmphm, "build opmphm");
// succeed_if (!opmphmIsBuild (ks->data->opmphm), "empty opmphm");
// cleanup
ksDel (ks);
}
// ksAppendKey
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
// insert existing one
succeed_if (ksAppendKey (ks, keyNew ("/a", KEY_END)) > 0, "not invalidate");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
// insert new one
succeed_if (ksAppendKey (ks, keyNew ("/k", KEY_END)) > 0, "invalidate");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (!opmphmIsBuild (ks->data->opmphm), "empty opmphm");
// cleanup
ksDel (ks);
}
// ksAppend
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// subset of ks
KeySet * appendSub = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END),
keyNew ("/d", KEY_END), keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), KS_END);
// super set of ks
KeySet * appendSuper =
ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/k", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
succeed_if (ksAppend (ks, appendSub) > 0, "non invalidate");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
succeed_if (ksAppend (ks, appendSuper) > 0, "invalidate");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (!opmphmIsBuild (ks->data->opmphm), "empty opmphm");
// cleanup
ksDel (ks);
ksDel (appendSub);
ksDel (appendSuper);
}
// ksCopyInternal
{
KeySet * ks = ksNew (20, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
succeed_if (ksCopyInternal (ks, 2, 2) > 0, "invalidate");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (!opmphmIsBuild (ks->data->opmphm), "empty opmphm");
// cleanup
ksDel (ks);
}
// ksCut
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
Key * cutPoint = keyNew ("/b", KEY_END);
KeySet * cut = ksCut (ks, cutPoint);
succeed_if (cut, "invalidate");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (!opmphmIsBuild (ks->data->opmphm), "empty opmphm");
// cleanup
ksDel (ks);
ksDel (cut);
keyDel (cutPoint);
}
// ksPop
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
Key * popKey = ksPop (ks);
succeed_if (popKey, "invalidate");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (!opmphmIsBuild (ks->data->opmphm), "empty opmphm");
// cleanup
ksDel (ks);
keyDel (popKey);
}
// elektraKsPopAtCursor
{
KeySet * ks = ksNew (10, keyNew ("/a", KEY_END), keyNew ("/b", KEY_END), keyNew ("/c", KEY_END), keyNew ("/d", KEY_END),
keyNew ("/e", KEY_END), keyNew ("/f", KEY_END), keyNew ("/g", KEY_END), keyNew ("/h", KEY_END),
keyNew ("/i", KEY_END), keyNew ("/j", KEY_END), KS_END);
// trigger build
Key * found = ksLookupByName (ks, "/a", KDB_O_OPMPHM);
succeed_if (found, "key found");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (opmphmIsBuild (ks->data->opmphm), "build opmphm");
Key * popKey = elektraKsPopAtCursor (ks, 1);
succeed_if (popKey, "invalidate");
exit_if_fail (ks->data->opmphm, "build opmphm");
succeed_if (!opmphmIsBuild (ks->data->opmphm), "empty opmphm");
// cleanup
ksDel (ks);
keyDel (popKey);
}
}
int main (int argc, char ** argv)
{
printf ("KS OPMPHM TESTS\n");
printf ("==================\n\n");
init (argc, argv);
test_keyNotFound ();
test_Copy ();
test_Invalidate ();
print_result ("test_ks_opmphm");
return nbError;
}
|
C
|
/*
* adc_single.c
*
* Created on: Jan 1, 2021
* Author: david.winant
*/
#include "main.h"
#include "output.h"
enum { FALSE, TRUE };
#define APB1_TIMER_CLOCK 100000000
static int go_ahead_process_buffer = FALSE;
int adc_sample_rate = 250000;
extern ADC_HandleTypeDef hadc3;
extern TIM_HandleTypeDef htim5;
/**
* @brief Regular conversion complete callback in non blocking mode
* @param hadc pointer to a ADC_HandleTypeDef structure that contains
* the configuration information for the specified ADC.
* @retval None
*/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
go_ahead_process_buffer = TRUE;
}
void adc_to_q15 (uint16_t* buffer, int nsamp)
{
for (int i = 0; i < nsamp; i++)
buffer[i] = buffer[i] ^ 0x8000;
}
int adc_set_sample_rate (long rate) {
long period = APB1_TIMER_CLOCK / rate;
float actual = APB1_TIMER_CLOCK / period;
if (period * rate != APB1_TIMER_CLOCK) {
float error = actual / rate - 1.0;
output ("Slight error, actual rate of %8.3f KHz, error %5.2f%%\r\n", actual/1000.0, error * 100.0);
}
__HAL_TIM_SET_AUTORELOAD (&htim5, period-1);
adc_sample_rate = actual;
return actual;
}
int adc_collect (uint16_t* buffer, int nsamp)
{
if (0) output ("About to collect data\r\n");
go_ahead_process_buffer = FALSE;
int status = HAL_ADC_Start_DMA (&hadc3, (uint32_t*) buffer, nsamp);
if (status != HAL_OK) {
output ("Could not start ADC DMA capture\r\n");
return -1;
}
int timeout = 500;
while (! go_ahead_process_buffer) {
HAL_Delay(2);
if (--timeout == 0) break;
}
HAL_ADC_Stop_DMA (&hadc3);
return (go_ahead_process_buffer) ? 0 : -1;
}
|
C
|
//
// Assignment 3: Due July 29th
// Written by: Kelby Webster (klw231)
// CS 4328 Summer session
// part1.c
//
//a. Write the program without considering the mutual exclusion. Run the
//program several times to show that mutual exclusion is not guaranteed and
//the result is not correct.
#include <stdio.h>
#include <pthread.h>
#include <math.h>
#include <unistd.h>
// struct for award
struct awardAmount
{
int currentAmount;
int given;
};
// create instance of struct
struct awardAmount award;
// student function
void student (char c);
int main()
{
// starting values
award.currentAmount = 4000;
award.given = 0;
// create threads
pthread_t thread1, thread2, thread3;
// initialize threads
pthread_create(&thread1, NULL, (void *(*)(void *)) student, (void*) '1');
pthread_create(&thread2, NULL, (void *(*)(void *)) student, (void*) '2');
pthread_create(&thread3, NULL, (void *(*)(void *)) student, (void*) '3');
// have threads wait for completion of other threads
pthread_join(thread1, NULL);
pthread_join(thread2, NULL);
pthread_join(thread3, NULL);
printf("Total amount awarded: $ %d \n\n", award.given);
pthread_exit(0);
}
void student(char c)
{
// initialize variables
int total = 0;
int temp;
// loop while there is still money
while( 0 < award.currentAmount)
{
// adjust award amount
temp = ceil(award.currentAmount * 0.25);
// increment current amount
award.currentAmount = award.currentAmount - temp;
// increment total amount remaining
total = total + temp;
// show results
printf("%c = %d \n", c, temp);
// sleep
sleep(1);
}
award.given = award.given + total;
}
|
C
|
#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include<signal.h>
#define EATING 0
#define HUNGRY 1
#define THINKING 2
#define WANT_TO_SING 3
#define SINGING 4
int phi_number;
#define LEFT (p_number + (phi_number-1)) % phi_number
#define RIGHT (p_number + 1) % phi_number
int* state=NULL;
int* phil=NULL;
sem_t mutex;
sem_t mutex2;
sem_t* S;
sem_t* sing_;
int **print; //for every phi --> thinking_number , eating_number , singing_number;
int temp=0;
//int *bastir=NULL;
void test(int p_number)
{
if (state[p_number] == HUNGRY
&& state[LEFT] != EATING
&& state[RIGHT] != EATING) {
state[p_number] = EATING;
print[p_number][1]++;
sleep(0.1);
printf("Philosopher %d is Eating\n", p_number + 1);
sem_post(&S[p_number]);
}
}
void pickup(int p_number)
{
sem_wait(&mutex);
state[p_number] = HUNGRY;
printf("Philosopher %d is Hungry\n", p_number + 1);
test(p_number);
sem_post(&mutex);
sem_wait(&S[p_number]);
sleep(0.1);
}
void putdown(int p_number)
{
sem_wait(&mutex);
state[p_number] = THINKING;
print[p_number][0]++;
printf("Philosopher %d is thinking\n", p_number + 1);
test(LEFT);
test(RIGHT);
sem_post(&mutex);
}
void singing_test(int p_number)
{
int flag=0; //sadece 1 kişinin söylemesini garanti ediyor.
for(int i=0;i<phi_number;i++){
if(state[i]==SINGING)
flag=1;
}
if (state[p_number] == WANT_TO_SING && flag==0) {
state[p_number] = SINGING;
print[p_number][2]++;
sleep(0.1);
printf("Philosopher %d is Singing\n", p_number + 1);
sem_post(&sing_[p_number]); //******************************************************************************************
}
}
void sing(int p_number)
{
sem_wait(&mutex2);
// state that hungry
state[p_number] = WANT_TO_SING;
print[p_number][3]++;
printf("Philosopher %d Wants to Sing\n", p_number + 1);
singing_test(p_number);
sem_post(&mutex2);
sem_wait(&sing_[p_number]);
sleep(0.1);
}
void stopsinging(int p_number){
sem_wait(&mutex2);
state[p_number] = THINKING;
print[p_number][0]++;
for(int i=temp;i<phi_number;i++){
singing_test(i);
}
temp++; //starvation ı önlemek için
if(temp==phi_number)
temp=0;
printf("Philosopher %d is thinking\n", p_number + 1);
sem_post(&mutex2);
}
void* philospher(void* num)
{
while (1) {
int *i = num;
sleep(0.1);
pickup(*i);
sleep(0);
putdown(*i);
sleep(0.1);
srand(time(NULL));
int o;
o = 1+(int)( rand() % 2); //ya 1 ya 2 üretiyor
int flag2=0;
if (o == 1) {
sing(*i);
flag2=1;
}
if(flag2==1) {
sleep(0);
stopsinging(*i);
}
sleep(0);
}
}
void handle_sigint(int sig)
{
printf("\n");
for(int i=0;i<phi_number;i++){
printf("Philosopher %d's THINKING number is %d EATING number is %d WANTS TO SING %d times SINGING number is %d \n",i+1,print[i][0],print[i][1],print[i][3],print[i][2]);
}
int assolist=0;
for(int i=0;i<phi_number;i++){
if(print[i][2]>print[assolist][2])
assolist=i;
}
printf("\nAssolist philosopher is %d'th one and song %d sing\n" , assolist+1,print[assolist][2]);
exit(0);
}
int main(int argc, char* argv[])
{
signal(SIGINT, handle_sigint);
while(1) {
phi_number = atoi(argv[1]);
if (!state)
state = malloc(phi_number * sizeof(int));
if (!phil) {
phil = malloc(phi_number * sizeof(int));
for (int i = 0; i < phi_number; i++) {
phil[i] = i;
}
}
if (!S)
S = malloc(phi_number * sizeof(sem_t));
if (!sing_)
sing_ = malloc(phi_number * sizeof(sem_t));
print = malloc(phi_number * sizeof(*print));
for (int i = 0; i < phi_number; i++)
print[i] = malloc(4 * sizeof(*print[i]));
for (int i = 0; i < phi_number; i++) {
for (int j = 0; j < 4; j++) {
if(j==0)
print[i][j]=1;
else
print[i][j] = 0;
}
}
int i;
pthread_t thread_id[phi_number];
sem_init(&mutex, 0, 1);
sem_init(&mutex2, 0, 1);
for (i = 0; i < phi_number; i++) {
sem_init(&S[i], 0, 0);
sem_init(&sing_[i], 0, 0);
}
for (i = 0; i < phi_number; i++) {
pthread_create(&thread_id[i], NULL,
philospher, &phil[i]);
printf("Philosopher %d is thinking\n", i + 1);
// print[phi_number][0]++;
}
for (i = 0; i < phi_number; i++)
pthread_join(thread_id[i], NULL);
free(state);
free(phil);
free(S);
free(sing_);
free(print);
return 0;
}
}
|
C
|
#include <gtk/gtk.h>
#include <stdlib.h>
int signer_confirmed = 0;
static void abort_operation(GtkWidget *widget, gpointer data){
signer_confirmed = 0;
}
static void confirm_operation(GtkWidget *widget, gpointer data){
signer_confirmed = 1;
}
static void activate(GtkApplication *app, gpointer user_data){
GtkWidget *window;
GtkWidget *label;
GtkWidget *button_abort;
GtkWidget *button_confirm;
GtkWidget *buttons_box;
GtkWidget *label_and_buttons_box;
//Create window
window = gtk_application_window_new(app);
gtk_window_set_title(GTK_WINDOW(window), "Signer verification");
gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
//Create label showing the signature information
label = gtk_label_new((char *) user_data);
label_and_buttons_box = gtk_flow_box_new();
gtk_flow_box_set_selection_mode((GtkFlowBox *) label_and_buttons_box, GTK_SELECTION_NONE);
gtk_flow_box_set_max_children_per_line((GtkFlowBox *) label_and_buttons_box, 1);
gtk_flow_box_insert((GtkFlowBox *) label_and_buttons_box, label, -1);
//Create buttons
buttons_box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
button_abort = gtk_button_new_with_label("Not OK");
g_signal_connect(button_abort, "clicked", G_CALLBACK(abort_operation), NULL);
g_signal_connect_swapped(button_abort, "clicked", G_CALLBACK(gtk_widget_destroy), window);
gtk_container_add(GTK_CONTAINER(buttons_box), button_abort);
button_confirm = gtk_button_new_with_label("OK");
g_signal_connect(button_confirm, "clicked", G_CALLBACK(confirm_operation), NULL);
g_signal_connect_swapped(button_confirm, "clicked", G_CALLBACK(gtk_widget_destroy), window);
gtk_container_add(GTK_CONTAINER(buttons_box), button_confirm);
gtk_flow_box_insert((GtkFlowBox *) label_and_buttons_box, buttons_box, -1);
gtk_container_add(GTK_CONTAINER (window), label_and_buttons_box);
//Show window
gtk_widget_show_all(window);
}
//TODO: The last shown GTK window is shown (in a destroyed way), until the next one is opened.
static int build_gtk_app(char *signature_information){
GtkApplication *app;
int status;
app = gtk_application_new("de.nellessen.encryptingCloudStorages.showSigner", G_APPLICATION_FLAGS_NONE);
g_signal_connect(app, "activate", G_CALLBACK(activate), signature_information);
status = g_application_run(G_APPLICATION(app), 0, NULL);
g_object_unref(app);
return status;
}
int show_signer_and_get_confirmation(char *signature_information){
if(build_gtk_app(signature_information) != 0){
fprintf(stderr, "Could not build gtk app.\n");
exit(-1);
}
return signer_confirmed;
}
|
C
|
#include "Lab12_hdr.h"
//specific function
BOOL cmp_char(void *ch1, void*ch2)
{
return (BOOL)(*(char *)ch1 == *(char *)ch2);
}
void prnt_char(void *ch)
{
printf("%c ", *(char *)ch);
}
void free_char(void *ch)
{
free(ch);
}
int main()
{
char ch,*temp;
int n,i;
BOOL res;
PNode head=NULL,tail=NULL;
printf("Enter number of characters ");
scanf("%d",&n);
printf("\nEnter %d characters,separated by enter\n",n);
for(i=0;i<n;i++)
{
temp=(char*)malloc(sizeof(char));
if (NULL==temp)
{
printf("\nCan't allocate data memory");
freeAll(&head,free_char);
return 1;
}
scanf(" %c",temp);
res=insertEntry(&head,&tail,temp,cmp_char);
if(FALSE==res) /* if FALSE==res than there is something wrong with malloc */
{
printf("\nCan't allocate node memory or data is allready exists");
freeAll(&head,free_char);
return 1;
}
}
printAll(head, tail, prnt_char);
printf("\nEnter an element for deleting\n");
scanf(" %c",&ch);
res=deleteNode(&head,&tail,&ch,cmp_char,free_char);
if(FALSE==res)
printf("%c don't exists in list\n",ch);
printAll(head,tail,prnt_char);
freeAll(&head,free_char);
printf("\nYour list was destroyed\n");
_getch();
return 0;
}
|
C
|
// Example Usage
//
// gcc ex2_list_skelton.c -O3
// ./a.out < samplegraph.txt > samplegraph.dot
// dot -Tpng < samplegraph.dot > samplegraph.png
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 辺リスト用の構造
struct Edge_t {
int from;
int to;
struct Edge_t *next;
};
typedef struct Edge_t Edge;
// 隣接リスト表現のグラフ構造体
struct Graph_t {
int n;
int m;
int _m; // 内部使用：登録された辺の数
Edge *_edges; // 内部使用：全辺
Edge **edges; // 各頂点の最初の辺へのポインタ
char **info;
};
typedef struct Graph_t Graph;
// 頂点数 n のグラフ（辺なし）を作成
Graph *create_empty_graph(int n)
{
Graph *g;
int i, j;
g = malloc(sizeof(Graph));
g->n = n;
g->m = 0;
g->edges = malloc(sizeof(Edge*)*n);
for(i = 0; i < n; i++) g->edges[i] = NULL;
g->_edges = NULL;
g->info = malloc(sizeof(char*)*n);
for(i = 0; i < n; i++) g->info[i] = NULL;
return g;
}
// 頂点 vid に情報を付加（タイトルのみ保持）
void add_vertex_info(Graph *g, int vid, char *url, char *title)
{
int l = strlen(title);
if(g->info[vid] != NULL) free(g->info[vid]);
g->info[vid] = malloc(l+1);
strcpy(g->info[vid], title);
}
// エッジの数をあらかじめ指定しておく（エッジ情報のための領域確保をここで行う）
void reserve_edges(Graph *g, int m)
{
g->m = m;
g->_m = 0;
g->_edges = malloc(sizeof(Edge)*m);
}
// from_vid から to_vid への辺を追加する
void add_edge(Graph *g, int from_vid, int to_vid)
{
Edge *e = &g->_edges[g->_m++];
e->to = to_vid;
e->from = from_vid;
e->next = g->edges[from_vid];
g->edges[from_vid] = e;
}
// 辺を逆転したグラフを作る
Graph *reverse_graph(Graph *g)
{
int i;
Edge *e;
Graph *rg = create_empty_graph(g->n);
for(i = 0; i < g->n; i++) {
add_vertex_info(rg, i, "", g->info[i]); // 頂点情報のコピー
}
reserve_edges(rg, g->m);
for(i = 0; i < g->n; i++) {
e = g->edges[i]; // 頂点 i の辺リストの最初の辺を取得
while(e!=NULL) { // 辺リストの終了まで
add_edge(rg, e->to, e->from); // 逆向きに辺を追加
e = e->next; // 辺リスト中の次の辺へ
}
}
return rg;
}
// 初回の深さ優先探索。flag は既に頂点に訪れたか否かのフラグ。頂点 v から探索を再帰的に進める
// stack は探索が終了した頂点を入れるスタック。sp はスタックポインタ。
void _dfs1(Graph *g, int *flag, int v, int *stack, int *sp)
{
int j;
Edge *e;
flag[v] = 1;
// 頂点 v の全ての辺に対して、その辺の先に訪れていないなら再帰呼び出し。
// ADD SOME CODE HERE
e = g->edges[v]; // 頂点 v の辺リストの最初の辺を取得
while(e!=NULL) { // 辺リストの終了まで
j = e->to; // 辺の行き先の頂点
// ここで、j への辺があり且つまだ j に訪れていないなら j へ再帰する。
if (flag[j] != 1){
_dfs1(g, flag, j, stack, sp);
}
// printf("%d->%d;",e->from,e->to);
e = e->next; // 辺リスト中の次の辺へ
}
stack[(*sp)++] = v; // 探索終了を記録
}
// 深さ優先探索。flag は既に頂点に訪れたか否かのフラグ。頂点 v から探索を再帰的に進める
// component は各頂点の属する強連結成分の番号を格納。c は現在探索中の強連結成分の番号
void _dfs2(Graph *g, int *flag, int v, int *component, int c)
{
int j;
Edge *e;
flag[v] = 1; // この頂点に来たことを記録
component[v] = c; // この頂点の強連結成分の番号は c
// 頂点 v の全ての辺に対して、その辺の先に訪れていないなら再帰呼び出し。
// ADD SOME CODE HERE
e = g->edges[v]; // 頂点 v の辺リストの最初の辺を取得
while(e!=NULL) { // 辺リストの終了まで
j = e->to; // 辺の行き先の頂点
// ここで、j への辺があり且つまだ j に訪れていないなら j へ再帰する。
if (flag[j] != 1){
_dfs2(g, flag, j, component, c);
}
e = e->next; // 辺リスト中の次の辺へ
}
}
// 強連結成分分解。component に各頂点の属する強連結成分の番号が入る
int scc(Graph *g, int *component)
{
int i;
int *flag = malloc(sizeof(int)*g->n); // 探索済みかどうかのフラグ
int *stack = malloc(sizeof(int)*g->n); // 初回深さ優先探索の終了順に頂点を格納する場所
int sp = 0, c = 0;
Graph *rg;
for(i = 0; i < g->n; i++) flag[i] = 0; // フラグクリア
for(i = 0; i < g->n; i++) { // 一般には、複数の頂点から深さ優先探索をする
if(flag[i] == 0) _dfs1(g, flag, i, stack, &sp); // 初回深さ優先探索
}
rg = reverse_graph(g); // 辺の向きを逆にしたグラフを作る
for(i = 0; i < g->n; i++) flag[i] = 0; // フラグクリア
for(sp = g->n-1; sp >=0; sp--) { // 初回探索の終了の遅い順に
if(flag[stack[sp]] == 0) { // まだ訪れていない頂点から逆向きの深さ優先探索
_dfs2(rg, flag, stack[sp], component, c);
c++; // 探索が終了したら強連結成分がひとつ見つかる
}
}
free(stack);
free(flag);
// 本来ならばここで rg を開放するが、面倒なので略。
return c; // 強連結成分の個数
}
// PageRank
void pagerank(Graph *g, double *rank)
{
int * ls = malloc(sizeof(int) * g->n); // 出ていくリンク数
double * new_rs = malloc(sizeof(double) * g->n); // 新しいランク用の配列
Edge *e;
double d = 0.85; // damping factor
int i, v;
double r, err, er;
Graph *rg = reverse_graph(g); // 辺の向きを逆にしたグラフを作る
// リンク数のカウント
for(v = 0; v < g->n; v++) {
ls[v] = 0;
e = g->edges[v]; // 頂点 v の辺リストの最初の辺を取得
while(e!=NULL) { // 辺リストの終了まで
ls[v]++;
e = e->next; // 辺リスト中の次の辺へ
}
}
for(i = 0; i < g->n; i++) { // 初期 rank
rank[i] = 1.0/g->n;
}
for(;;) {
for(v = 0; v < g->n; v++) { // 全頂点に対して
r = 0; // 新しいランクを計算する一時変数
// 逆辺に対して (つまり、v に入ってくる辺に関して)
e = rg->edges[v]; // 頂点 v の辺リストの最初の辺を取得
while(e!=NULL) { // 辺リストの終了まで
// ランク加算
// ADD SOME CODE HERE
r += rank[e->to]/ls[e->to];
e = e->next; // 辺リスト中の次の辺へ
}
new_rs[v] = (1-d)/g->n + d * r; // 新しいランク値
}
err = 0; // ランクの更新量
for(v = 0; v < g->n; v++) {
er = rank[v] - new_rs[v];
err += er*er;
rank[v] = new_rs[v];
}
if(err < 1e-6) break; // 不動点で繰り返し終了
}
}
int main(int argc, char *argv[])
{
int n, m, i, vid, from_vid, to_vid;
char url[1024];
char title[1024];
Graph *g;
gets(url);
scanf("%d", &n);
g = create_empty_graph(n);
for(i = 0; i < n; i++) {
scanf("%d", &vid);
scanf("%s", url);
gets(title);
add_vertex_info(g, vid, url, title);
}
scanf("%d", &m);
reserve_edges(g, m);
for(i = 0; i < m; i++) {
scanf("%d", &from_vid);
scanf("%d", &to_vid);
add_edge(g, from_vid, to_vid);
}
// ここまでで Graph の情報の読み込みが完了
// 強連結成分分解
{
int *component = malloc(sizeof(int) * g->n);
int j;
scc(g, component);
//printf("digraph{\n");
for(i = 0; i < g->n; i++) {
// printf("%d [label=\"%d\"]\n", i, component[i]);
}
for(i = 0; i < g->n; i++) {
Edge *e = g->edges[i]; // 頂点 i の辺リストの先頭取得
while(e!=NULL) { // 辺リストの終了まで
//printf("%d -> %d\n", e->from, e->to);
e = e->next; // 辺リスト中の次の辺へ
}
}
//printf("}\n");
}
// PageRank
{
double *rank = malloc(sizeof(double) * g->n);
pagerank(g, rank);
for(i = 0; i < g->n; i++) {
printf("%g\n",rank[i]);
}
}
return 0;
}
|
C
|
/*
* @lc app=leetcode id=7 lang=c
*
* [7] Reverse Integer
*
* https://leetcode.com/problems/reverse-integer/description/
*
* algorithms
* Easy (26.05%)
* Likes: 4951
* Dislikes: 7515
* Total Accepted: 1.6M
* Total Submissions: 6.1M
* Testcase Example: '123'
*
* Given a signed 32-bit integer x, return x with its digits reversed. If
* reversing x causes the value to go outside the signed 32-bit integer range
* [-2^31, 2^31 - 1], then return 0.
*
* Assume the environment does not allow you to store 64-bit integers (signed
* or unsigned).
*
*
* Example 1:
* Input: x = 123
* Output: 321
* Example 2:
* Input: x = -123
* Output: -321
* Example 3:
* Input: x = 120
* Output: 21
* Example 4:
* Input: x = 0
* Output: 0
*
*
* Constraints:
*
*
* -2^31 <= x <= 2^31 - 1
*
*
*/
// @lc code=start
int reverse(int x){
int chg = 0;
int revval = 0;
long overlen = 0;
int i,len = 0;
unsigned char a[10] = {0};
if(x < 0) {
x = (int)(~((unsigned int) x - 1));
chg = 1;
}
for(i=0;i<10;i++) {
a[i] = x % 10;
x = x / 10;
// printf("a[%d] = %d \n",i,a[i]);
if(x==0) {
break;
}
}
overlen = 0;
for(len=0; len<=i;len++) {
overlen = overlen*10 + a[len];
// printf("revval = %d ,a[%d] = %d \n",overlen,len,a[len]);
if(overlen > 0x7fffffff) {
return 0;
}
}
revval = overlen;
if(chg) {
revval = -revval;
// printf("chg = %d revval = %d\n",chg,revval);
}
return revval;
}
// @lc code=end
|
C
|
#include <stdio.h>
int main(void) {
int d1, d2, m1, m2, y1, y2;
printf("Enter first date (mm/dd/yy): ");
scanf("%d /%d /%d", &m1, &d1, &y1);
printf("Enter second date (mm/dd/yy): ");
scanf("%d /%d /%d", &m2, &d2, &y2);
int day1 = y1 * 365 + m1 * 30 + d1;
int day2 = y2 * 365 + m2 * 30 + d2;
if (day1 > day2)
printf("%d/%d/%.2d is earlier than %d/%d/%.2d\n", m2, d2, y2, m1, d1, y1);
else if (day1 < day2)
printf("%d/%d/%.2d is earlier than %d/%d/%.2d\n", m1, d1, y1, m2, d2, y2);
else if (day1 == day2)
printf("%d/%d/%.2d is equal to %d/%d/%.2d\n", m1, d1, y1, m2, d2, y2);
return 0;
}
// Enter first date (mm/dd/yy): 2/11/2011
// Enter second date (mm/dd/yy): 3/23/2011
|
C
|
#include <stdio.h>
int main()
{
char ch;
printf("Enter single character: \n");
scanf("%c", &ch);
printf("ASCII value of character is %d\n", ch);
return 0;
}
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* add_oldpwd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jrosemar <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/01/27 17:24:06 by jrosemar #+# #+# */
/* Updated: 2021/01/27 17:48:23 by jrosemar ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
char *change_pwd(char **env, char *line, int n)
{
char *str;
t_var var;
var = init_variable();
str = NULL;
while (env[var.i])
{
if (ft_strncmp(env[var.i], line, n) == 0)
{
var.flag = 1;
break ;
}
var.i++;
}
if (var.flag == 1)
{
str = (char *)malloc(sizeof(char) * ft_strlen(env[var.i]) - (n - 1));
while (env[var.i][var.j + n] != '\0')
{
str[var.j] = env[var.i][var.j + n];
var.j++;
}
str[var.j] = '\0';
}
return (str);
}
char **make_array(int n, char **env, char *str)
{
char **arr;
int i;
int len;
i = 0;
arr = (char **)malloc(sizeof(char *) * (n + 2));
while (n--)
{
len = ft_strlen(env[i]);
arr[i] = (char *)malloc(sizeof(char) * (len + 1));
i++;
}
len = ft_strlen(str);
arr[i] = (char *)malloc(sizeof(char) * (len + 8));
arr[i + 1] = NULL;
return (arr);
}
char **add_rewrite_env(t_ptr *ptr, char *str, int n)
{
char **arr;
int i;
int j;
i = 0;
j = 0;
arr = make_array(n, ptr->env, str);
while (ptr->env[i])
{
ft_memcpy(arr[i], ptr->env[i], ft_strlen(ptr->env[i]));
arr[i][ft_strlen(ptr->env[i])] = '\0';
i++;
}
ft_memcpy(arr[i], "OLDPWD=", 7);
j = 7;
while (*str != '\0')
{
arr[i][j] = *str;
j++;
str++;
}
arr[i][j] = '\0';
return (arr);
}
void rewrite_env(t_ptr *ptr, char *str, char *line, int n)
{
int i;
int j;
i = 0;
j = 0;
while (ptr->env[i])
{
if ((ft_strncmp(ptr->env[i], line, n) == 0))
break ;
i++;
}
free(ptr->env[i]);
ptr->env[i] = (char *)malloc(sizeof(char) * ft_strlen(str) + (n + 1));
ft_memcpy(ptr->env[i], line, n);
while (str[j] != '\0')
{
ptr->env[i][j + n] = str[j];
j++;
}
ptr->env[i][j + n] = '\0';
}
void add_oldpwd(char *str, t_ptr *ptr)
{
int i;
int flag;
char **arr;
i = 0;
flag = 0;
while (ptr->env[i])
{
if (ft_strncmp(ptr->env[i], "OLDPWD=", 7) == 0)
flag = 1;
i++;
}
i = 0;
while (ptr->env[i])
i++;
if (flag == 1)
rewrite_env(ptr, str, "OLDPWD=", 7);
else
{
arr = add_rewrite_env(ptr, str, i);
free_arr(ptr->env);
ptr->env = arr;
}
}
|
C
|
/*
* rsa-keygen.c
*
* Created on: Dec 16, 2019, 2:04:58 PM
* Author: Joshua Fehrenbach
*/
#include <assert.h>
#include <stdlib.h>
#include "rsa.h"
int
rsa_generate_keypair(struct rsa_public_key *pub,
struct rsa_private_key *key,
/* Desired size of the modulus, in bits */
unsigned n_size,
/* Desired size of the public exponent, int bits. If
* zero, the passed value of pub->e is used. */
unsigned e_size,
void *random_ctx, crypto_random_func *random,
void *progress_ctx, crypto_progress_func *progress) {
mpz_t p1, q1, phi, tmp;
if (e_size) {
/* randomly generate e; ensure the size is reasonable */
if (e_size < 16 || e_size >= n_size) {
return 0;
}
} else {
/* fixed e; ensure that it makes sense */
/* e must be odd */
if (!mpz_tstbit(pub->e, 0)) {
return 0;
}
/* e must be >= 3 */
if (mpz_cmp_ui(pub->e, 3) < 0) {
return 0;
}
/* e must be smaller than n */
if (mpz_sizeinbase(pub->e, 2) >= n_size) {
return 0;
}
}
if (n_size < RSA_MIN_N_BITS) {
return 0;
}
mpz_init(p1); mpz_init(q1); mpz_init(phi); mpz_init(tmp);
#define PROGRESS(c) if (progress) progress(progress_ctx, c)
/* generate primes */
for (;;) {
/* generate p such that gcd(p-1, e) = 1 */
for (;;) {
crypto_random_prime(key->p, (n_size+1)/2, 1,
random_ctx, random, progress_ctx, progress);
mpz_sub_ui(p1, key->p, 1);
/* if e was given, we must choose p such that p-1 has no
* common factors with e */
if (e_size) {
break;
}
mpz_gcd(tmp, pub->e, p1);
if (mpz_cmp_ui(tmp, 1) == 0) {
break;
} else PROGRESS('c');
}
PROGRESS('\n');
/* generate q, such that gcd(q-1, e) = 1 */
for (;;) {
crypto_random_prime(key->q, n_size/2, 1,
random_ctx, random, progress_ctx, progress);
/* Very unlikely (approx. 1 in 2^(n_size/2)) */
if (mpz_cmp(key->q, key->p) == 0) {
continue;
}
mpz_sub_ui(q1, key->q, 1);
/* if e was given, we must choose q such that q-1 has no
* common factors with e */
if (e_size) {
break;
}
mpz_gcd(tmp, pub->e, q1);
if (mpz_cmp_ui(tmp, 1) == 0) {
break;
} else PROGRESS('c');
}
/* Now we have the primes. Ensure the product is the right size */
mpz_mul(pub->n, key->p, key->q);
assert (mpz_sizeinbase(pub->n, 2) == n_size);
PROGRESS('\n');
/* c = q^{-1} (mod p) */
if (mpz_invert(key->c, key->q, key->p)) {
/* this should succeed every time but, if it doesn't,
* then we must generate a new p and q */
break;
} else PROGRESS('?');
}
mpz_mul(phi, p1, q1);
/* generate e, if it is not given to us */
if (e_size) {
int retried = 0;
for (;;) {
crypto_mpz_random_size(pub->e, e_size, random_ctx, random);
/* Make sure it's odd and that the MSB is set */
mpz_setbit(pub->e, 0);
mpz_setbit(pub->e, e_size-1);
/* Needs GMP 3, or the inverse might be negative */
if (mpz_invert(key->d, pub->e, phi)) {
break;
}
PROGRESS('e');
retried = 1;
}
if (retried) PROGRESS('\n');
} else {
/* This must always succeed, as we already know that e doesn't
* have any common factors with p-1 or q-1. */
int res = mpz_invert(key->d, pub->e, phi);
assert(res);
}
/* Compute auxiliary private values */
/* a = d (mod p-1) */
mpz_fdiv_r(key->a, key->d, p1);
/* b = d (mod q-1) */
mpz_fdiv_r(key->b, key->d, q1);
/* c = q^{-1} (mod p) was computed earlier */
/* save the key size, in octets */
pub->size = key->size = (n_size + 7) / 8;
assert (pub->size >= RSA_MIN_N_OCTETS);
mpz_clear(tmp); mpz_clear(phi); mpz_clear(q1); mpz_clear(p1);
return 1;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>
#include <math.h>
#define base 0x378
int main()
{
if(ioperm(base, 1, 1))
{
fprintf(stderr, "Access Denied %x\n", base);
return 1;
}
printf("%d", inb(base));
return 0;
}
|
C
|
#include"my_headers.h"
int i,pid[3];
void f(int num)
{
static cnt;
cnt++;
if(cnt==3)
{
if((kill(pid[0],9))!=-1)
printf("child 1 killed...%d\n",pid[0]);
}
else if(cnt==7)
{
if((kill(pid[1],9))!=-1)
printf("child 2 killed...%d\n",pid[1]);
}
else if(cnt==9)
{
if((kill(pid[2],9))!=-1)
printf("child 3 killed...%d\n",pid[2]);
}
alarm(1);
}
main()
{
int t,v;
signal(SIGALRM,f);
alarm(1);
printf("parent id %d........\n",getpid());
for(i=0;i<3;i++)
{
if((pid[i]=fork())==0)
{
srand(getpid());
t=rand()%10+4;
printf("child %d ........%d.........%dsecs\n",i+1,getpid(),t);
sleep(t);
printf("child%d.......exiting\n");
exit(0);
}
}
while(wait(&v)!=-1);
printf("parent %d......exiting\n",getpid());
}
|
C
|
/*
============================================================================
Name : homework3-p2-2.c
Author : Ji Un Song
Version :
Copyright :
Description :
============================================================================
*/
#include <stdio.h>
void print1(int *ptr, int rows); // ּҸ ϱ Լ
int main(void) {
int one[] = {0,1,2,3,4}; // one[] 迭 {0,1,2,3,4} ʱȭ
printf("one = %p\n", one); // one ּҸ
printf("&one = %p\n", &one); // &one == one ּҸ
printf("&one[0] = %p\n", &one[0]); // &one[0] == one ּҸ
printf("\n");
print1(&one[0], 5); // Լȣ
return 0; // 0 ȯ
}
void print1(int *ptr, int rows)
{
int i;
printf("Address \t Contents\n"); // (ּ )
for(i=0; i <rows; i++)
printf("%p \t %5d\n", ptr + i, *(ptr +i)); // ptr + i ּҰ , *() ּҰ Ű Ÿ
printf("\n");
}
|
C
|
#include "OperacionesAritmeticas.h"
int sumar(int a,int b)
{
int resultado;
resultado = a + b;
return resultado;
}
int restar(int a, int b)
{
int resultado;
resultado = a - b;
return resultado;
}
float dividir(int a, int b)
{
float resultado;
if(b!=0)
{
resultado = (float) a / b;
}
return resultado;
}
int multiplicar(int a, int b)
{
int resultado;
resultado = a * b;
return resultado;
}
int factorial(int a)
{
int resultado;
if(a>=0)
{
if (a == 0||a==1)
{
resultado = 1;
}
else
{
resultado = a* factorial(a-1);
}
}
else
{
resultado=-1;
}
return resultado;
}
void realizarOperacionesAritmeticasYMostrar(int a, int b,int ver)
{
int suma;
int diferencia;
int producto;
int cociente;
int fact1;
int fact2;
suma = sumar(a,b);
diferencia = restar(a,b);
producto = multiplicar(a,b);
cociente = dividir(a,b);
fact1 = factorial(a);
fact2 = factorial(b);
if(ver==0)
{
printf("Realizando Operaciones\n");
printf("Suma de %d + %d\n", a, b);
printf("Resta de %d - %d\n", a, b);
printf("Division de %d / %d\n", a, b);
printf("Multiplicacion de %d * %d\n", a, b);
printf("Factorial de %d\n", a);
printf("Factorial de %d\n", b);
}
else
{
printf("Resulado de la suma de %d + %d = %d\n",a,b,suma);
printf("Diferencia de la resta de %d - %d = %d\n",a,b,diferencia);
printf("Producto de la multiplicacon de %d * %d = %d\n",a,b,producto);
if (b==0)
{
printf("No se puede dividir por 0\n");
}
else
{
printf("Cociente de la division de %d / %d = %d\n",a,b,cociente);
}
if(fact1==-1)
{
printf("No se puede sacar el factorial de un numero menor que 0\n");
}
else
{
printf("Factorial de %d = %d\n",a,fact1);
}
if(fact2==-1)
{
printf("No se puede sacar el factorial de un numero menor que 0\n");
}
else
{
printf("Factorial de %d = %d\n",b,fact2);
}
}
}
|
C
|
#include <errno.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include<stdio.h>
static int sigintNum=0; //count how much SIGINT we get
/**
* The role of this function is to print how many SIGINT signals were actually received on the server
* @param sig - No use, I accept it because that is how the function I override is built
*/
void sigusr1_handler(int sig)
{
printf("The number of SIGINT is: %d\n",sigintNum);
}
/**
* The role of this function is count how many SIGINT signals were actually received on the server
* @param sig - No use, I accept it because that is how the function I override is built
*/
void sigint_handler(int sig)
{
sigintNum++;
}
int main(int argc,char* argv[])
{
printf("Pid of the server: %d\n",getpid());
if (signal(SIGINT, sigint_handler) == SIG_ERR)
{
printf("Error while execute the signal handler.\n");
exit(EXIT_FAILURE);
}
else if(signal(SIGUSR1, sigusr1_handler) == SIG_ERR)
{
printf("Error while execute the signal handler.\n");
exit(EXIT_FAILURE);
}
getchar(); //to keep alive, foe end the program enter a character.
}
|
C
|
// init.c
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "params.h" // PARAM_DATA
#include "init.h"
#include "vector_mtx.h"
#include "forces.h"
// populate params in PARAM_DATA
void ReadInParams(char *input_file)
{
double xd; // scanning variables
int xi; // ditto for integers
int nidx;
double *I_prin, *q_i; // vectors for body frame I and q
FILE *input; // pointer to a file
input = fopen(input_file, "r"); // open file to read
// read in number of eqs
fscanf(input, "%d", &xi);
PARAM_DATA.num_eq = xi;
nidx = PARAM_DATA.num_eq; // max indexing
// allocate memories for initial coordinates vector
q_i = vector_malloc(nidx);
// q
for (int i=0; i<nidx; i++)
{
fscanf(input, "%lf", &xd);
q_i[i] = xd;
}
PARAM_DATA.q_i = q_i; // put q_i vector into PARAM_DATA
// t_i
fscanf(input, "%lf", &xd);
PARAM_DATA.t_i = xd;
// t_f
fscanf(input, "%lf", &xd);
PARAM_DATA.t_f = xd;
// h
fscanf(input, "%lf", &xd);
PARAM_DATA.h = xd;
// mass 1
fscanf(input, "%lf", &xd);
PARAM_DATA.mass1 = xd;
// length 1
fscanf(input, "%lf", &xd);
PARAM_DATA.length1 = xd;
// mass 2
fscanf(input, "%lf", &xd);
PARAM_DATA.mass2 = xd;
// length 2
fscanf(input, "%lf", &xd);
PARAM_DATA.length2 = xd;
// prec_goal
fscanf(input, "%lf", &xd);
PARAM_DATA.prec_goal = xd;
fclose(input);
return;
} // ReadInParams
void PrintParams(void)
{
int nidx = PARAM_DATA.num_eq; // to loop over vectors
FILE *output;
output = fopen("params.dat", "w"); // open file to write vals onto
{
fprintf(output, "Number of coordinates: %d\n", PARAM_DATA.num_eq);
fprintf(output, "Theta 1: %lf\n", PARAM_DATA.q_i[0]);
fprintf(output, "Theta 2: %lf\n", PARAM_DATA.q_i[1]);
fprintf(output, "Momentum 1: %lf\n", PARAM_DATA.q_i[2]);
fprintf(output, "Momentum 2: %lf\n", PARAM_DATA.q_i[3]);
fprintf(output, "Initial time: %lf\n", PARAM_DATA.t_i);
fprintf(output, "Final time: %lf\n", PARAM_DATA.t_f);
fprintf(output, "Default timestep: %lf\n", PARAM_DATA.h);
fprintf(output, "Mass 1: %lf\n", PARAM_DATA.mass1);
fprintf(output, "Mass 2: %lf\n", PARAM_DATA.mass2);
fprintf(output, "Length 1: %lf\n", PARAM_DATA.length1);
fprintf(output, "Length 2: %lf\n", PARAM_DATA.length2);
fprintf(output, "Precision goal: %lf\n", PARAM_DATA.prec_goal);
} // done writing
fclose(output);
return;
} // PrintParams
void InitializeNeq(double *q)
{
int nidx = PARAM_DATA.num_eq;
// q is already declared and memory is already allocated
for (int i=0; i<nidx; i++) // fill up q with initial data
{
q[i] = PARAM_DATA.q_i[i];
} // i-loop
// assign memory to QVelos
PARAM_DATA.QVelos = (FuncPt *)malloc(sizeof(FuncPt)*nidx);
// problem specific
// have 4 generalized velocities
PARAM_DATA.QVelos[0] = QVelo0;
PARAM_DATA.QVelos[1] = QVelo1;
PARAM_DATA.QVelos[2] = QVelo2;
PARAM_DATA.QVelos[3] = QVelo3;
return;
} // InitializeNeq
|
C
|
#include <stdio.h>
int main() {
int A, B;
printf("Digite 2 números:\n");
scanf("%d %d", &A, &B);
if(A % B == 0 || B % A == 0){
printf("São múltiplos\n");
}
else{
printf("Não são múltiplos\n");
}
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "prime.h"
int hashFunction(const char* s, const int a, const int m) {
long hash = 0;
const int len_s = strlen(s);
for (int i = 0; i < len_s; i++) {
hash += (long)pow(a, len_s - (i+1)) * s[i];
hash = hash % m;
}
return (int)hash;
}
int getHash(const char* s, const int num_buckets, const int attempt) {
const int hash_a = hashFunction(s, HT_PRIME_1, num_buckets);
const int hash_b = hashFunction(s, HT_PRIME_2, num_buckets);
return (hash_a + (attempt * (hash_b + 1))) % num_buckets;
}
|
C
|
#define VIDEOX 800
#define VIDEOY 600
#define COLOR_PALLETE 16
/* define a localizao dos arquivos de imagem do jogo */
#define IMG_CEN_PATH "./var/cen/img/"
#define PER_IMG_PATH "./var/per/img/Personagem.png"
#define INI_IMG_PATH "./var/ini/img/"
/**
* \todo
* preciso corrigir os rastros que aparecem na tela durante o movimento
* e animao de sprites na tela. Isto pode estar sendo ocasionado pelo
* constante interrupmento de threads durante a troca de intervalo de animaes
*/
/**
* \struct VideoObj
*
* \brief Estrutura de objeto de vdeo.
*
* Os objetos de vdeo so responsveis por armazenar os sprites de
* objetos e animaes que sero exibidos na tela.
*
*/
typedef struct VideoObj {
int posX; /**< posio x */
int posY; /**< posio y */
SDL_Rect quadro; /**< quadro de corte da imagem */
SDL_Surface *imagem; /**< imagem */
int indice; /**< ndice de posio do quadro */
SDL_Thread *ani_thread; /**< thread de animao */
int ani_ativa; /**< atividade de animao */
int ani_indice_i; /**< ndice inicial do intervalo de animao */
int ani_indice_f; /**< ndice final do intervalo de animao */
int ani_delay; /**< delay da animao */
} VideoObj;
/**
* \struct VideoObjLista
*
* \brief Estrutura de lista de objetos de vdeo.
*
*/
typedef struct VideoObjLista
{
VideoObj *vobj; /* objeto de vdeo */
struct VideoObjLista *prox; /* prximo membro da estrutura */
} VideoObjLista;
/**
* Cria um objeto de vdeo.
*
* \param a arquivo de imagem
* \param l largura do quadro
* \param a altura do quadro
* \return objeto de vdeo
*/
VideoObj *videoObjCria (char *a, int w, int h);
/**
* Destri um objeto de vdeo.
*
* \param o objeto de vdeo
*/
void videoObjDestroi (VideoObj *o);
/**
* Define cor de transparncia de um objeto de vdeo.
*
* \param o objeto de vdeo
* \param r valor para cor vermelha
* \param g valor para cor verde
* \param b valor para cor azul
*/
void videoObjTrans (VideoObj *o, int r, int g, int b);
/**
* Define o ndice de posio do quadro.
*
* \param o objeto de vdeo
* \param i ndice de posio do quadro
*/
void videoObjIndice (VideoObj *o, int i);
/**
* Avana para o prximo ndice de posio do quadro.
*
* \param o objeto de vdeo
*/
void videoObjIndiceProx (VideoObj *o);
/**
* Retorna ao ndice anterior de posio do quadro.
*
* \param o objeto de vdeo
*/
void videoObjIndiceAnt (VideoObj *o);
/**
* Define delay de animao de um objeto de vdeo.
*
* \param o objeto de vdeo
* \param d delay da animao
*/
void videoObjAniDelay (VideoObj *o, int d);
/**
* Define o intervalo de animao de um objeto de vdeo.
*
* \param o objeto de vdeo
* \param i ndice de posio inicial do quadro
* \param f ndice de posio final do quadro
*/
void videoObjAniIntervalo (VideoObj *o, int i, int f);
/**
* Funo para thread de animao de um objeto de vdeo.
*
* \param o objeto de vdeo (objeto de vdeo c/ casting p/ void)
* \return inteiro nulo
*/
int videoObjAniThread (void *o);
/**
* Inicia a animao de um objeto de vdeo.
*
* \param o objeto de vdeo
*/
void videoObjAniInicia (VideoObj *o);
/**
* Termina a animao de um objeto de vdeo.
*
* \param o objeto de vdeo
*/
void videoObjAniTermina (VideoObj *o);
/**
* Cria um elemento para a lista de objetos de vdeo.
*
* \param o objeto de vdeo
* \return elemento da lista de objetos de vdeo
*/
VideoObjLista *videoObjListaCria (VideoObj *o);
/**
* Destri lista de objetos de vdeo.
*
* \param l primeiro elemento da lista de objetos de vdeo
*/
void videoObjListaDestroi (VideoObjLista *l);
/**
* \struct Video
*
* \brief Estrutura da janela de vdeo.
*
* A janela de vdeo composta por trs camadas (Janela, fundo e
* lista de objetos de vdeo). A Janela a moldura no gerenciador
* grfico, o fundo o objeto de vdeo utilizado para cobrir atualizaes
* da lista de objetos de vdeo e a lista de objetos de vdeo contm os
* sprites que sero exibidos/animados na tela.
*
*/
typedef struct Video
{
SDL_Surface *video; /* vdeo */
VideoObj *fundo; /* objeto de vdeo para imagem de fundo */
VideoObjLista *vobj_lst; /* lista de objetos de vdeo */
} Video;
/**
* Cria janela de vdeo
*
* \param l largura
* \param a altura
* \param c nmero de cores
* \return vdeo
*/
Video *videoCria (int l, int a, int c);
/**
* Destri janela de vdeo
*
* \param v vdeo
*/
void videoDestroi (Video *v);
/**
* Define o objeto de fundo da janela de vdeo.
*
* \param v vdeo
* \param o objeto de vdeo
*/
void videoFundo (Video *v, VideoObj *o);
/**
* Adiciona objeto de vdeo lista de objetos da janela
*
* \param v vdeo
* \param o objeto de vdeo
* \param x posio x
* \param y posio y
*/
void videoAdcObj (Video *v, VideoObj *o, int x, int y);
/**
* Remove objeto de vdeo da lista de objetos da janela
*
* \param v vdeo
* \param o objeto de vdeo
*/
void videoRemObj (Video *v, VideoObj *o);
/**
* Movimenta objeto de vdeo na janela
*
* \param v vdeo
* \param o objeto de vdeo
* \param x posio x
* \param y posio y
*/
void videoObjMove (Video *v, VideoObj *o, int x, int y);
/**
* Exibe contedo da lista de objetos de vdeo na janela
*
* \param v vdeo
*/
void videoImprime (Video *v);
|
C
|
#include<stdio.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER; // initally mutex will be in Unlock state
int count=0;
void *abc(void *arg)
{
pthread_mutex_lock(&lock);
count = count+1;
printf("Thread %d started\n",count);
for(unsigned long i=0;i<=50000;i++);
printf("Thread %d end\n",count);
//sleep(1);
pthread_mutex_unlock(&lock);
}
void main()
{
pthread_t tid[5];
for(int i=0;i<5;i++)
{
pthread_create(&tid[i],NULL,abc,&i); //passing address of i as an argument to new thread, pthread_create will return 0 if call is sucess ,any other value if call fails
}
for(int i=0;i<5;i++)// waits untill all threads complets there exicution
{
pthread_join(tid[i],NULL);
}
pthread_mutex_destroy(&lock);
}
|
C
|
/* $Id: g_hashwrap.c 229 2003-07-18 20:22:20Z will $ */
/* Copyright (c) 2001-2002 Sun Microsystems, Inc. All rights reserved. */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <glib.h>
#include "g_hashwrap.h"
#define HASHWRAP_DEBUG 0
#if HASHWRAP_DEBUG
#define HW_DPRINTF(...) \
do { \
fprintf(stderr, "(%s:%d): ", __FILE__, __LINE__); \
fprintf(stderr, __VA_ARGS__); \
} while (0)
#else
#define HW_DPRINTF(...)
#endif
/* helper functions */
static int keys_grow(GHashWrap *hashwrap);
static int keys_rm(GHashWrap *hashwrap, gpointer key);
static int keys_find(GHashWrap *hashwrap, gpointer key);
static void call_free(gpointer key, gpointer value, gpointer wrap);
/*
* Make a new GHashWrap
*/
GHashWrap *
g_hashwrap_new(GHashFunc hash_func, GCompareFunc compare_func,
GHCloneFunc clone_func, GHFreeFunc free_func)
{
GHashWrap *hashwrap;
hashwrap = malloc(sizeof(*hashwrap));
if (!hashwrap) {
return NULL;
}
/* init all fields or fail - keep in sync with destroy() */
hashwrap->hash = g_hash_table_new(hash_func, compare_func);
if (!hashwrap->hash) {
free(hashwrap);
return NULL;
}
hashwrap->clone_func = clone_func;
hashwrap->free_func = free_func;
hashwrap->keys = NULL;
hashwrap->keys_len = 0;
HW_DPRINTF("g_hashwrap_new() = %p\n", hashwrap);
return hashwrap;
}
/*
* Clean up and free a new GHashWrap
*/
void
g_hashwrap_destroy(GHashWrap *hashwrap)
{
if (!hashwrap) {
return;
}
HW_DPRINTF("g_hashwrap_destroy(%p)\n", hashwrap);
/* free all hash entries */
if (hashwrap->free_func) {
g_hash_table_foreach(hashwrap->hash, call_free, hashwrap);
}
g_hash_table_destroy(hashwrap->hash);
/* free keys array (not contents - they were pointers into the hash */
if (hashwrap->keys) {
free(hashwrap->keys);
}
/* free the struct itself */
free(hashwrap);
}
void
g_hashwrap_insert(GHashWrap *hashwrap, gpointer key, gpointer value)
{
gboolean oldval;
gpointer k, v;
int i;
HW_DPRINTF("g_hashwrap_insert(%p, %p, %p)\n", hashwrap, key, value);
/* check for old entry */
oldval = g_hash_table_lookup_extended(hashwrap->hash, key, &k, &v);
/* duplicate the new data, if needed */
if (hashwrap->clone_func) {
if (oldval) {
hashwrap->clone_func(NULL, value, NULL, &value);
key = k;
HW_DPRINTF("\tkeeping oldkey = %p\n", key);
HW_DPRINTF("\tclone_func(value) = %p\n", value);
} else {
hashwrap->clone_func(key, value, &key, &value);
HW_DPRINTF("\tclone_func(key) = %p\n", key);
HW_DPRINTF("\tclone_func(value) = %p\n", value);
}
}
if (oldval) {
/* it existed - use the old index */
i = keys_find(hashwrap, k);
} else {
/* find or make room in the iterator array */
i = keys_grow(hashwrap);
}
/* finally, insert the data */
g_hash_table_insert(hashwrap->hash, key, value);
hashwrap->keys[i] = key;
HW_DPRINTF("\tkey index [%d]\n", i);
/* release any old data AFTER we've finished with hashwrap->hash */
if (oldval && hashwrap->free_func) {
HW_DPRINTF("\tfree_func(%p)\n", v);
hashwrap->free_func(NULL, v);
}
}
void
g_hashwrap_remove(GHashWrap *hashwrap, gpointer key)
{
gboolean oldval;
gpointer k;
gpointer v;
HW_DPRINTF("g_hashwrap_remove(%p, %p)\n", hashwrap, key);
oldval = g_hash_table_lookup_extended(hashwrap->hash, key, &k, &v);
if (oldval) {
keys_rm(hashwrap, k);
g_hash_table_remove(hashwrap->hash, key);
/* free the data if requested */
if (hashwrap->free_func) {
HW_DPRINTF("\tfree_func(%p)\n", k);
HW_DPRINTF("\tfree_func(%p)\n", v);
hashwrap->free_func(k, v);
}
}
}
gint
g_hashwrap_index(GHashWrap *hashwrap, gint idx, gpointer *key, gpointer *value)
{
if (!hashwrap) {
return -1;
}
HW_DPRINTF("g_hashwrap_index(%p, %d)\n", hashwrap, idx);
/* out-of-bounds check */
if (idx >= g_hashwrap_size(hashwrap) || idx < 0) {
if (key) {
*key = NULL;
}
if (value) {
*value = NULL;
}
return -1;
}
/* populate requested data */
if (key) {
*key = hashwrap->keys[idx];
}
if (value) {
*value = g_hashwrap_lookup(hashwrap, hashwrap->keys[idx]);
}
return 0;
}
/*
* A generic free_func routine for a hashwrap struct
*/
void
g_str_free(gpointer key, gpointer value)
{
/* g_free() is safe about free(NULL) */
g_free(key);
g_free(value);
}
/*
* A string clone_func routine for a hashwrap_struct
*/
void
g_str_clone(gpointer key, gpointer val, gpointer *newkey, gpointer *newval)
{
if (newkey) {
*newkey = key ? g_strdup(key) : NULL;
}
if (newval) {
*newval = val ? g_strdup(val) : NULL;
}
}
/* make room for a key in a hashwrap struct's keys array */
static int
keys_grow(GHashWrap *hashwrap)
{
int newsize;
int count;
count = g_hashwrap_size(hashwrap);
if (hashwrap->keys_len <= count) {
/* we need to make more room */
if (count == 0) {
newsize = 4;
} else {
newsize = count*2;
}
hashwrap->keys = g_realloc(hashwrap->keys,
newsize * sizeof(*hashwrap->keys));
hashwrap->keys_len = newsize;
}
return count;
}
/* remove one and shuffle the iterator array */
static int
keys_rm(GHashWrap *hashwrap, gpointer key)
{
int i;
int n;
i = keys_find(hashwrap, key);
if (i < 0) {
return -1;
}
n = (hashwrap->keys_len - i) - 1;
g_memmove(&hashwrap->keys[i], &hashwrap->keys[i+1],
n * sizeof(*hashwrap->keys));
hashwrap->keys[hashwrap->keys_len - 1] = NULL;
return 0;
}
static int
keys_find(GHashWrap *hashwrap, gpointer key)
{
int i;
int count;
count = g_hashwrap_size(hashwrap);
for (i = 0; i < count; i++) {
if (hashwrap->keys[i] == key) {
return i;
}
}
return -1;
}
static void
call_free(gpointer key, gpointer value, gpointer wrap)
{
GHashWrap *hashwrap = (GHashWrap *)wrap;
HW_DPRINTF("\tfree_func(%p)\n", key);
HW_DPRINTF("\tfree_func(%p)\n", value);
hashwrap->free_func(key, value);
}
/* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* -Redistribution of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* -Redistribution in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of Sun Microsystems, Inc. or the names of contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
* This software is provided "AS IS," without a warranty of any kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*
* You acknowledge that this software is not designed or intended for use in the design, construction, operation or maintenance of any nuclear facility.
*/
|
C
|
#include<stdio.h>
#include<string.h>
int main()
{
char s[500];
gets(s);
if(strlen(s)>140){
printf("MUTE\n");
}
else
printf("TWEET\n");
return 0;
}
|
C
|
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
/**
* C program to demonstrate the orhpan process.
*/
void main() {
int p;
/**
* fork() spuns child processes --> all the processes are in main memory.
* Used for non-blocking calls.
*
* p = 0 : Child/leaf process --> Reached the end of the inheritance tree
* p = -1: Unsuccessfull fork()
* p > 0 : PID of child returned to parent process
*/
p = fork();
/**
* forces parent process to wait; lets child process to be executed first
*/
//wait();
printf("Welcome to Batch E, %d\n", p);
/**
* getpid(): returns PID of current process
* getppid(): returns the PID of the parent process, that forked this child, if the parent process stil
* exists at the time of the call, otherwise returns 1 --> PID of init process.
*/
if(p == 0 && p != -1) {
printf("I'm child and my PID is: %d\n",getpid());
printf("I'm child and my PPID is: %d\n",getppid());
/**
* sleep(unsigned int seconds)
*/
sleep(15);
printf("I'm child and my PID is: %d\n",getpid());
printf("I'm child and my PPID is: %d\n",getppid());
} else if(p > 0 && p != -1) {
printf("I'm parent and my PID is: %d\n",getpid());
printf("I'm parent and my PPID is: %d\n",getppid());
}
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#define SEND 1
#define STOP 0
float f(float x);
int main(int argc, char** argv) {
int rank; /* rank of each MPI process */
int size; /* total number of MPI processes */
double a, b; /* default left and right endpoints of the interval */
int n; /* total number of trapezoids */
double h; /* height of the trapezoids */
double param[3]; /* array containing end points and height for each individual trapezoid
for communication purpose */
double local_result = 0.0; /* area of each individual trapezoid */
double partial_result = 0.0; /* amount of area calculated by each process */
double result = 0.0; /* Total integral */
int source; /* Process sending the partial integral */
int dest = 0; /* All messages go to 0 */
int tag = 0;
double start, stop, tpar, tcomm;
int i,count, partial_count;
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
start = MPI_Wtime();
/* initial job distribution is handled only by process 0 */
if (rank == 0){
a = atof(argv[1]);
b = atof(argv[2]);
n = atoi(argv[3]);
h = (b-a)/n;
count = 0;
/* send out the first round of work assignment, incrementing count as needed */
for (i = 1; i < size; i++){
param[0] = a + count * h;
param[1] = param[0] + h;
param[2] = h;
MPI_Send(param,3,MPI_DOUBLE,i,SEND,MPI_COMM_WORLD);
printf("== Process %d: (%lf, %lf)\n", i, param[0], param[1]);
count = count + 1;
}
}
else {
MPI_Recv(param,3,MPI_DOUBLE,0,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
}
tpar = 0.0;
tcomm = 0.0;
partial_count = 0;
/* Each process that is not process 0 works on its portion, send the partial result back to 0,
* and wait for new workload unless the TAG of the message is 0
*/
if (rank != 0){
do {
start = MPI_Wtime();
local_result = param[2] * (f(param[1]) + f(param[0])) / 2;
partial_result += local_result;
stop = MPI_Wtime();
tpar += stop - start;
partial_count += 1;
start = MPI_Wtime();
MPI_Send(&local_result,1,MPI_DOUBLE,0,SEND,MPI_COMM_WORLD);
MPI_Recv(param,3,MPI_DOUBLE,0,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
stop = MPI_Wtime();
tcomm += stop - start;
} while(status.MPI_TAG != 0);
printf("Process %d uses %lfs to calculate partial result %lf of %d portions and %lfs for communication \n", rank, tpar, partial_result, partial_count, tcomm);
}
/* Process 0 receives results and sends out work while there is still work left to be sent
* (count < n) */
if (rank == 0) {
do {
MPI_Recv(&local_result,1,MPI_DOUBLE,MPI_ANY_SOURCE,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
result = result + local_result;
param[0] = a + count * h;
param[1] = param[0] + h;
param[2] = h;
MPI_Send(param,3,MPI_DOUBLE,status.MPI_SOURCE,SEND,MPI_COMM_WORLD);
printf("## Process %d: (%lf, %lf)\n", status.MPI_SOURCE, param[0], param[1]);
count = count + 1;
}
while (count < n);
/* Make sure that we receive everything */
for (i = 0; i < (size - 1); i++){
MPI_Recv(&local_result,1,MPI_DOUBLE,MPI_ANY_SOURCE,MPI_ANY_TAG,MPI_COMM_WORLD,&status);
result = result + local_result;
}
}
/* All the work has been sent, */
if (rank == 0){
for (i = 1; i < size; i++){
MPI_Send(param,3,MPI_DOUBLE,i,STOP,MPI_COMM_WORLD);
}
}
/* Print the result */
if (rank == 0) {
printf("With n = %d trapezoids, our estimate\n",
n);
printf("of the integral from %f to %f = %f\n",
a, b, result);
}
/* Shut down MPI */
MPI_Finalize();
} /* main */
float f(float x) {
return ( x*x );
}
|
C
|
#ifndef __CIRCULAR_LIST_H__
#define __CIRCULAR_LIST_H__
/*********************************************************************************************************************
* Typedefs
********************************************************************************************************************/
typedef struct _MyCircularSinglyList
{
void* Element;
struct _MyCircularSinglyList* Next;
}MyCircularSinglyList;
/*********************************************************************************************************************
* Function declarations
********************************************************************************************************************/
/// <summary>
/// This function is used to create circular list
/// </summary>
/// <param name="HeadNode - pointer to the headnode"></param>
/// <param name="Size - Size of the element of circular list"></param>
/// <returns> 1-success 0-failure </returns>
extern unsigned char MyCircularList_Create(MyCircularSinglyList **HeadNode, uint16_t Size);
/// <summary>
/// This function is used to push element to the list
/// </summary>
/// <param name="HeadNode - Base address of the circular list"></param>
/// <param name="Element - Address of the data to be pushed"></param>
/// <returns> 1-success 0-failure </returns>
extern unsigned char MyCircularList_PushElement(MyCircularSinglyList* HeadNode, void* Element);
/// <summary>
/// This function is used to pop element from the list
/// </summary>
/// <param name="HeadNode - Address to the head node"></param>
/// <param name="Element - addredd of the data where the popped element will be stored"></param>
/// <returns> 1-success 0-failure </returns>
extern unsigned char MyCircularList_PopElement(MyCircularSinglyList* HeadNode, void* Element);
/// <summary>
/// This function is used to insert an element to the list
/// </summary>
/// <param name="HeadNode - Base address of the circular list"></param>
/// <param name="Element - Address of the data to be inserted"></param>
/// <param name="Position - Position at where the element will be pushed"></param>
/// <returns> 1-success 0-failure </returns>
extern unsigned char MyCircularList_InsertElement(MyCircularSinglyList* HeadNode, void* Element, uint16_t Position);
/// <summary>
/// This function is used to remove an element from the list
/// </summary>
/// <param name="HeadNode - Base address of the circular list"></param>
/// <param name="Element - Address of the data where the removed element will be stored"></param>
/// <param name="Position - Position of the element to be removed"></param>
/// <returns> 1-success 0-failure </returns>
extern unsigned char MyCircularList_RemoveElement(MyCircularSinglyList* List, void* Element, uint16_t Position);
/// <summary>
/// This function is used to traverse the list
/// </summary>
/// <param name="HeadNode"></param>
/// <returns></returns>
extern unsigned char MyCiruclarList_Traverse(MyCircularSinglyList* HeadNode);
#endif //__CIRCULAR_LIST_H__
|
C
|
#include<stdio.h>
#define MAX 5
int arr[5]={0};
void hash(int num)
{
int check = 1;
int mod = num % MAX;
if(arr[mod] == 0)
arr[mod] = num;
else
{
while(check)
{
if(mod == MAX - 1)
{
mod = -1;
}
mod++;
if(arr[mod]==0)
{
arr[mod]= num;
check = 0;
}
}
}
}
void display()
{
int i;
for(i=0;i<MAX;i++)
printf("\nThe element at index %d is %d",i,arr[i]);
}
int main()
{
int i,a[]={22,32,42,52,4};
printf("\n\tLinear hash\n");
for(i=0;i<5;i++)
hash(a[i]);
display();
}
|
C
|
/*
** EPITECH PROJECT, 2020
** NWP_myteams_2019
** File description:
** exchange.c
*/
#include "exchange.h"
#include <stdlib.h>
#include <string.h>
#include <uuid/uuid.h>
#include "message/message.h"
#include "subscriber/subscriber.h"
exchange_t *exchange_create(void)
{
exchange_t *exchange = malloc(sizeof(exchange_t));
if (exchange == NULL)
return (NULL);
unsigned char uuid[16];
memset(exchange->uuid, 0, sizeof(exchange->uuid));
uuid_generate(uuid);
uuid_unparse(uuid, exchange->uuid);
exchange->messages = list_create();
return (exchange);
}
bool exchange_get_id(exchange_t *exchange, const char *uuid)
{
return (strcmp(exchange->uuid, uuid) == 0);
}
void exchange_delete(exchange_t *exchange)
{
if (exchange == NULL)
return;
list_delete(exchange->messages, delete_c(message_delete));
free(exchange);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include "lista.h"
int main()
{
unsigned int numNos, numAdj, j = 0, i = 0;
system("clear");
printf("Insira o numero total de vertices existentes:\n");
scanf("%d", &numNos);
printf("Criando a lista com %d vertices...", numNos);
noListaPrincipal *grafoPrincipal, *grafoAux; //Cria os ponteiros para lista principal
noAdj *listaAdj; //cria ponteiros para a lista adjacente
grafoPrincipal = criarListaGrafo();
grafoPrincipal -> numLigacoes = 0;
while (j <= numNos)
{
grafoPrincipal = inserirNo(grafoPrincipal, j);
printf("\nForam inseridos %d vertices no grafo", j);
j++;
}
getchar();
grafoAux = grafoAuxLA = grafoPrincipal;
getchar();
imprimeListaPrincipal(grafoAux);
getchar();
i = 0;
srand(numNos);
while (i < numNos)
{
j = 0;
while (j < 3)
{
grafoAux->adj = inserirListaAdj(grafoAuxLA, i, (1 + rand()) % numNos, (float)(j + numNos * 2));
printf("No adjacente inserido %d %d %f\n", grafoAux->noAtual, grafoAux->adj->noAdjacente, grafoAux->adj->pesoEntreOsNos);
getchar();
j++;
}
printf("inseridas listas do vertice");
getchar();
grafoAux = grafoAux->proxNo;
i++;
}
getchar();
return 0;
}
|
C
|
#include "quad.h"
#include <stdlib.h>
#include <stdio.h>
quad quad_alloc()
{
static unsigned int countQuad = 0;
quad q = malloc(sizeof(quad_));
q->id = countQuad++;
q->type = 0;
q->res = NULL;
q->left = NULL;
q->right = NULL;
q->dest = NULL;
q->cmp = 0;
// Not everything is used for each quad, optimization can be made
// on this.
return q;
}
quad quad_gen(enum OpType type, symbol res, symbol left, symbol right)
{
quad q = quad_alloc();
q->type = type;
q->res = res;
q->left = left;
q->right = right;
return q;
}
quad quad_unary_gen(enum OpType type, symbol res, symbol right)
{
quad q = quad_alloc();
q->type = type;
q->res = res;
q->right = right;
return q;
}
quad quad_ifgoto_gen(symbol left, enum RelOp op, symbol right)
{
quad q = quad_alloc();
q->type = QUAD_GOTO_IF;
q->cmp = op;
q->left = left;
q->right = right;
return q;
}
quad quad_goto_gen()
{
quad q = quad_alloc();
q->type = QUAD_GOTO;
return q;
}
quad quad_printi_gen(symbol s)
{
quad q = quad_alloc();
q->type = QUAD_PRINTI;
q->res = s;
return q;
}
quad_list quad_add(quad_list *head, quad q)
{
if(*head == NULL)
{
// If the list is empty, create a new one
*head = quad_list_alloc();
(*head)->q = q;
return *head;
}
else
{
// Find the last availalbe slot
quad_list end = *head;
while(end->next != NULL)
end = end->next;
end->next = quad_list_alloc();
end->next->previous = end;
end->next->q = q;
return end->next;
}
}
quad_list quad_list_alloc()
{
quad_list ql = malloc(sizeof(quad_list_));
ql->previous = NULL;
ql->next = NULL;
ql->q = NULL;
return ql;
}
void quad_list_complete(quad_list list, quad q)
{
while(list != NULL)
{
if(list->q != NULL &&
list->q->type >= QUAD_GOTO_IF &&
list->q->type <= QUAD_GOTO &&
list->q->dest == NULL)
{
// Complete only goto quads
list->q->dest = q;
}
list = list->next;
}
}
quad_list quad_list_concat(quad_list la, quad_list lb)
{
quad_list res = NULL;
while(la != NULL) // Left list
{
if(la->q != NULL)
quad_add(&res, la->q);
la = la->next;
}
while(lb != NULL) // Right list
{
if(lb->q != NULL)
quad_add(&res, lb->q);
lb = lb->next;
}
return res;
}
quad_list quad_list_append(quad_list* ql, quad q)
{
quad_add(ql, q);
return *ql;
}
int quad_list_clean_gotos(quad_list head)
{
int count = 0; // Nb of edit
while(head != NULL)
{
if(head->q->type >= QUAD_GOTO_IF &&
head->q->type <= QUAD_GOTO &&
head->q->dest == NULL)
{
head->q->type = QUAD_GOTO_END;
count++;
}
head = head->next;
}
return count;
}
quad_list quad_list_find(quad_list head, int id)
{
while(head != NULL)
{
if(head->q != NULL && head->q->id == id)
return head;
head = head->next;
}
fprintf(stderr, "WARNING: Cannot find quad with the id %d\n", id);
return 0;
}
void quad_print(quad q)
{
printf("id: %4d, ", q->id);
if(q->type <= QUAD_UOP_PLUS)
{
printf("operator: ");
switch (q->type)
{
case QUAD_OP_PLUS:
case QUAD_UOP_PLUS:
printf("+"); break;
case QUAD_OP_MINUS:
case QUAD_UOP_MINUS:
printf("-"); break;
case QUAD_OP_MULT:
printf("*"); break;
case QUAD_OP_DIVI:
printf("/"); break;
case QUAD_UOP_ASSIGN:
printf("="); break;
case QUAD_OP_MODULO:
printf("%%"); break;
default:
break;
}
// If unary
if(q->type >= QUAD_UOP_ASSIGN)
{
printf(", res: %5s, right: %5s\n",
q->res->name,
q->right->name);
}
else // binary
{
printf(", res: %5s, left: %5s, right: %5s\n",
q->res->name,
q->left->name,
q->right->name);
}
}
else if(q->type <= QUAD_GOTO)// GOto
{
if(q->type == QUAD_GOTO_IF)
{
printf("IF %5s ", q->left->name);
switch (q->cmp) {
case QUAD_RELOP_EQ:
printf("==");
break;
case QUAD_RELOP_NEQ:
printf("!=");
break;
case QUAD_RELOP_GT:
printf(">");
break;
case QUAD_RELOP_GTE:
printf(">=");
break;
case QUAD_RELOP_LT:
printf("<");
break;
case QUAD_RELOP_LTE:
printf("<=");
break;
default:
break;
}
printf(" %5s -> ", q->right->name);
}
printf("Goto -> ");
if(q->type == QUAD_GOTO_END)
printf("END\n");
else if(q->dest == NULL)
printf("?\n");
else
printf("QUAD %5d\n", q->dest->id);
}
else if(q->type <= QUAD_PRINTI) // Printi
{
printf("PRINTI %5s\n", q->res->name);
}
else
{
printf("UNDEFINED\n");
}
// New to split the function in smaller ones
}
void quad_list_print(quad_list head)
{
printf("///////////////////\n");
printf("// quad List\n");
printf("///////////////////\n");
while(head != NULL)
{
quad_print(head->q);
head = head->next;
}
printf("///////////////////\n");
printf("// end quad List\n");
printf("///////////////////\n");
}
void quad_list_free(quad_list head, bool cleanQuads)
{
while(head != NULL)
{
quad_list next = head->next;
if(head->q != NULL && cleanQuads)
{
// Check on NULL not really usefull
free(head->q);
}
free(head);
head = next;
}
}
|
C
|
#include <avr/io.h>
#include <util/delay.h>
int main(void)
{
DDRB = 0xFF; // Set PortB as an OUTPUT
DDRD = 0x00; // Set Port D as an INPUT
while (1)
{
if((PIND&0b00000100)==0b00000100)
{
PORTB = 0xFF; //LED on when pushbutton is pressed
_delay_ms(1000); //1 second delay, turn off LED after
}
else
PORTB = 0x00; //Turns off LED when button is not pressed.
}
return 0;
}
|
C
|
#include <stdio.h>
#include <string.h>
int main()
{
char test_input[100];
int test_output[10] = {0,0,0,0,0,0,0,0,0,0};
int input_len,i,index = 0;
scanf("%s", test_input);
input_len = strlen(test_input);
printf("%d\n", input_len);
for (i = 0; i < input_len; i++) {
if ((test_input[i] >= '0') && (test_input[i] <= '9')) {
index = test_input[i] - '0';
test_output[index]++;
}
}
for (i = 0; i < 10; i++) {
printf("%d %d\n", i, test_output[i]);
}
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
int main(void)
{
srand(time(NULL));
int array[5];
int ctr=0;
printf("Your lotto numbers are:\t");
for(int i =0 ; i<5; i++) {
array[i]=(rand()%48)+1;
ctr++;
for(int y=0;y<ctr;y++)
{
if(array[i]==array[y]){
array[i]=array[i]-1;
}
}
printf("%d\t",array[i]);
}
return 0;
}
|
C
|
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include "huffmancoding.h"
#include "zipfile.h"
//Writes the compressed data represented by a binary string as bits to bytes
bool write_bits(char *file_name, char *data, size_t *data_size, size_t *bytes_written)
{
FILE *fp = fopen(file_name, "wb");
uint8_t *bytes = (uint8_t *)xmalloc(*data_size * sizeof(uint8_t));
memset(bytes, 0, *data_size);
size_t j = 0;
for (size_t i = 0; i < *data_size; i++)
{
if (i % 8 == 0 && i != 0)
j++;
if (data[i] == '1')
{
bytes[j] = bytes[j] | 1U << (i % 8);
}
}
*bytes_written = fwrite(bytes, sizeof(uint8_t), j, fp);
assert(*bytes_written == j);
return true;
}
//writes the header, which includes the characters and their frequency, to the zipfile
bool write_header(char *file_name, char *characters, int *frequncies, size_t number_of_characters)
{
FILE *file_pointer = fopen(file_name, "w");
fprintf(file_pointer, "%d§", number_of_characters);
for (int i = 0; i < number_of_characters; i++)
{
fprintf(file_pointer, "%c%d", characters[i], frequncies[i]);
}
fprintf(file_pointer, "§§");
fclose(file_pointer);
}
//writes the compressed data to the zipfile
static char *create_body(char *data, size_t data_size, char *huffman_code_map[256],
size_t *bits_written)
{
size_t buf_cap;
char *output;
buf_cap = 4096;
output = xmalloc(buf_cap);
output[0] = '\0'; //make output null-terminated
*bits_written = 0;
for (size_t i = 0; i < data_size; i++)
{
uint8_t character = (uint8_t)data[i];
char *huffman_code = huffman_code_map[character];
for (size_t j = 0; j < strlen(huffman_code); j++)
{
if (buf_cap - *bits_written <= 0)
{
buf_cap *= 2;
output = xrealloc(output, buf_cap);
}
strncat(output, &huffman_code[j], 1);
(*bits_written)++;
}
}
return output;
}
//compress a given file with file_name and writes the compressed data to zip_filename
void huffman_compress(char *zip_filename, char *file_name)
{
size_t file_size = 0;
char *buffer = read_file(file_name, &file_size);
int absolut_frequencies[256];
memset(absolut_frequencies, 0, 256 * sizeof(int));
size_t unique_characters = calculate_frequencies(buffer, file_size, absolut_frequencies);
char *characters = (char *)malloc(unique_characters * sizeof(char));
int *freqs = (int *)malloc(unique_characters * sizeof(int));
int j = 0;
for (int i = 0; i < 256; i++)
{
if (absolut_frequencies[i] != 0)
{
characters[j] = (char)i;
freqs[j] = absolut_frequencies[i];
j++;
}
}
char *huffman_codes[256];
HuffmanCodes(characters, freqs, unique_characters, huffman_codes);
//write_header(zip_file, characters, freqs, unique_characters);
size_t data_size = 0;
char *binary_string = create_body(buffer, file_size, huffman_codes, &data_size);
size_t bits_written;
write_bits(zip_filename, binary_string, &data_size, &bits_written);
free(binary_string);
free(characters);
free(freqs);
}
bool read_header(FILE *fp, int *file_sz, char *characters, int *frequencies);
bool read_body(FILE *fp, int *file_sz);
//extract data from zip_filename and write decompressed data to filename
void huffman_extract(char *zip_filename, char *filename)
{
FILE *fp = fopen(zip_filename, "r");
size_t file_size = 0;
char *data = read_file(zip_filename, &file_size);
fclose(fp);
uint8_t *output = huffman_decoding(root, data, file_size);
FILE *new_file = fopen(filename, "w");
fprintf(new_file, "%s", output);
fclose(new_file);
free(output);
free(output);
}
int main(int argc, char *argv[])
{
if (argc != 3)
{
printf("usage: zipnow <zipfile> filename\n");
exit(EXIT_FAILURE);
}
char *zip_filename = argv[1];
char *file_name = argv[2];
huffman_compress(zip_filename, file_name);
//huffman_extract(zip_filename, "testtest.txt");
return 0;
}
|
C
|
#ifndef FILTER_LIST_H
#define FILTER_LIST_H
#include <unistd.h>
#include <stdbool.h>
#define BUFFER 100
struct type_node{
char * name;
struct type_node * next;
struct subtype_node * first;
bool wildcard;
};
struct subtype_node{
struct subtype_node * next;
char * name;
};
struct filter_list{
struct type_node * first;
};
/* Inicializa el listado de nodos tipo. */
struct filter_list * filter_list_init();
/* Agrega un nuevo MIME type prohibido. */
int forbid_new(char * type, char *, struct filter_list * );
/* Busca un subtipo dentro de un nodo tipo. */
struct subtype_node* search_for_subtype(char *, struct type_node *, bool *);
/* Busca un nodo tipo en la lista. */
struct type_node* search_for_type(char *, struct filter_list *, bool *);
/* Hace que el subtipo de un nodo pase a ser wildcard. */
void make_subtype_wildcard(struct type_node *);
/* Borra un nodo tipo. */
int delete_media_type(struct filter_list *, char *);
/* Borra un MIME type de la lista. */
int allow_type(char * type, char *, struct filter_list *);
/* Borra un nodo tipo de la lista con todos sos subtipos. */
void completely_allow_type(struct filter_list * , struct type_node *);
/* Devuelve un string con los MIME type prohibidos. */
char* get_forbidden_types(struct filter_list * );
/* Detecta el formato correcto de un MIME type y los valores correspondientes para el tipo y subtipo en los parametros que recibe. */
int check_mime_format(char *, char **, char **);
/* BBusca un MIME type en el listado. */
bool find_mime(struct filter_list*, char*, char *);
#endif
|
C
|
#ifndef __LIST_H__
#define __LIST_H__
typedef struct ListElmt_ {
void *data;
struct ListElmt_ *next;
} ListElmt;
typedef struct {
int size;
int (*match)(const void *i1, const void *i2);
void (*destroy)(const void *i);
ListElmt *head;
ListElmt *tail;
} List;
void list_init(List *list, void (*destroy)(const void *data));
void list_destroy(List *list);
int list_insert_next(List *list, ListElmt *elmt, const void *data);
int list_remove_next(List *list, ListElmt *elmt, void **data);
#define list_size(list) ((list)->size)
#define list_head(list) ((list)->head)
#define list_tail(list) ((list)->tail)
#define list_is_head(list, elmt) ((elmt) == (list)->head ? 1 : 0)
#define list_is_tail(list, elmt) ((elmt) == (list)->tail ? 1 : 0)
#define list_data(elmt) ((elmt)->data)
#define list_next(elmt) ((elmt)->next)
#endif
|
C
|
#include<string.h>
#include<stdlib.h>
#include<stdio.h>
/*
Bubble sort algorithm written by suresh in 2020
ptr for storing base address
cs reperesnts collection size
es represents element size
*/
void bubblesort(void *ptr,int cs,int es, int (*p2f)(void *,void *))
{
int e,f,m,w;
void *a,*b,*c;
c=(void *)malloc(es);
m=cs-2;
while(m>=0)
{
e=0;
f=1;
while(e<=m)
{
a=ptr+(f*es);
b=ptr+(e*es);
w=p2f(a,b);
if(w<0)
{
memcpy(c,(const void *)a, es);
memcpy(a,(const void *)b, es);
memcpy(b,(const void *)c, es);
}
e++;
f++;
}
m--;
}
free(c);
}
//the following code written by mahesh
int myCompatator(void *left,void *right)
{
int *i,*j;
i=(int *)left;
j=(int *)right;
return (*i)-(*j);
}
int main()
{
int *x,req,y;
printf("Enter Requirement : ");
scanf("%d",&req);
if(req<=0)
{
printf("Invalid Requirement\n");
return 0;
}
x=(int *)malloc(sizeof(int)*req);
if(x==NULL)
{
printf("Unable to allocate memory according to requirement %d\n",req);
return 0;
}
for(y=0;y<req;y++)
{
printf("Enter a number :");
scanf("%d",&x[y]);
}
bubblesort(x,req,sizeof(int),myCompatator);
for(y=0;y<req;y++)
{
printf("%d\n",x[y]);
}
free(x);
return 0;
}
|
C
|
#ifndef _HTU21D_H
#define _HTU21D_H
#include "HTU21D.h"
#include <stdlib.h>
#include "nrf_delay.h"
#include "app_error.h"
#include "app_timer.h"
#pragma once
//Give this function the 2 byte message (measurement) and the check_value byte from the HTU21D
//If it returns 0, then the transmission was good
//If it returns something other than 0, then the communication was corrupted
//From: http://www.nongnu.org/avr-libc/user-manual/group__util__crc.html
//POLYNOMIAL = 0x0131 = x^8 + x^5 + x^4 + 1 : http://en.wikipedia.org/wiki/Computation_of_cyclic_redundancy_checks
#define SHIFTED_DIVISOR 0x988000 //This is the 0x0131 polynomial shifted to farthest left of three bytes
#define HTU21D_READ_GAP 0x32
static sems_sensor_t *p_singleton_sensor = NULL;
static uint8_t checkCRC(uint16_t sensorData, uint8_t checkSum)
{
//Test cases from datasheet:
//message = 0xDC, checkvalue is 0x79
//message = 0x683A, checkvalue is 0x7C
//message = 0x4E85, checkvalue is 0x6B
uint32_t remainder = (uint32_t)sensorData << 8; //Pad with 8 bits because we have to add in the check value
remainder |= checkSum; //Add on the check value
uint32_t divsor = (uint32_t)SHIFTED_DIVISOR;
for (int i = 0 ; i < 16 ; i++) //Operate on only 16 positions of max 24. The remaining 8 are our remainder and should be zero when we're done.
{
//Serial.print("remainder: ");
//Serial.println(remainder, BIN);
//Serial.print("divsor: ");
//Serial.println(divsor, BIN);
//Serial.println();
if( remainder & (uint32_t)1<<(23 - i) ) //Check if there is a one in the left position
remainder ^= divsor;
divsor >>= 1; //Rotate the divsor max 16 times so that we have 8 bits left of a remainder
}
return (uint8_t)remainder;
}
static ret_code_t get_htu21d_temperature(sems_htu21d_sensor_config_t const * p_config, app_twi_transfer_t *p_write_transfer, app_twi_transfer_t *p_read_transfer, float *data)
{
uint8_t *data_buffer = p_write_transfer->p_data;
data_buffer[0] = TEMPERATURE_NO_HOLD_MASTER_ADDRESS;
ret_code_t err_code = app_twi_perform(p_config->p_app_twi, p_write_transfer,1, NULL);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
nrf_delay_ms(HTU21D_READ_GAP);
err_code = app_twi_perform(p_config->p_app_twi, p_read_transfer,1, NULL);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
uint16_t rawTemperature = ((unsigned int) data_buffer[0] << 8) | (unsigned int) data_buffer[1];
uint8_t checkSum = data_buffer[2];
if (checkCRC(rawTemperature , checkSum) == 0)
{
rawTemperature &= 0xFFFC;
float tempTemperature = rawTemperature * (175.72 / 65536.0); //2^16 = 65536
*data = tempTemperature - 46.85; //From page 14
return NRF_SUCCESS;
} else
{
return NRF_ERROR_INVALID_DATA;
}
}
static ret_code_t get_htu21d_humidity(sems_htu21d_sensor_config_t const *p_config, app_twi_transfer_t *p_write_transfer, app_twi_transfer_t *p_read_transfer, float *data)
{
uint8_t *data_buffer = p_write_transfer->p_data;
data_buffer[0] = HUMIDITY_NO_HOLD_MASTER_ADDRESS;
ret_code_t err_code = app_twi_perform(p_config->p_app_twi, p_write_transfer,1, NULL);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
nrf_delay_ms(HTU21D_READ_GAP);
err_code = app_twi_perform(p_config->p_app_twi, p_read_transfer,1, NULL);
if (err_code != NRF_SUCCESS)
{
return err_code;
}
uint16_t rawHumidity = ((unsigned int) data_buffer[0] << 8) | (unsigned int) data_buffer[1];
uint8_t checkSum = data_buffer[2];
if (checkCRC(rawHumidity, checkSum) == 0)
{
rawHumidity &= 0xFFFC;
float tempRH = rawHumidity * (125.0 / 65536.0); //2^16 = 65536
*data = tempRH - 6.0; //From page 14
return NRF_SUCCESS;
} else
{
return NRF_ERROR_INVALID_DATA;
}
}
static uint8_t buffer[3];
static app_twi_transfer_t write_transfer = APP_TWI_WRITE(HTU21D_ADDRESS, buffer, 1, APP_TWI_NO_STOP);
static app_twi_transfer_t read_transfer = APP_TWI_READ(HTU21D_ADDRESS, buffer, 3, APP_TWI_NO_STOP);
static ret_code_t get_data(sems_sensor_t const *p_sensor, sems_htu21d_data_t *p_data)
{
sems_htu21d_sensor_config_t const *p_config = p_sensor->p_sensor_config;
ret_code_t err_code = get_htu21d_temperature(p_config, &write_transfer, &read_transfer, &(p_data->tempeature));
if (err_code != NRF_SUCCESS)
{
return err_code;
}
err_code = get_htu21d_humidity(p_config, &write_transfer, &read_transfer, &(p_data->humidity));
if (err_code != NRF_SUCCESS)
{
return err_code;
}
return err_code;
}
static ret_code_t get_sensor_data(sems_sensor_t const *p_sensor)
{
if (p_sensor != p_singleton_sensor)
{
return NRF_ERROR_INVALID_PARAM;
}
return get_data(p_sensor, p_sensor->p_sensor_data);
}
static ret_code_t sems_htu21d_sensor_uninit(sems_sensor_t const *p_sensor)
{
if (p_sensor != p_singleton_sensor)
{
return NRF_ERROR_INVALID_PARAM;
}
sems_htu21d_sensor_config_t *p_config = p_singleton_sensor->p_sensor_config;
free(p_config);
p_singleton_sensor->p_sensor_config = NULL;
free(p_singleton_sensor->p_sensor_data);
p_singleton_sensor->p_sensor_data = NULL;
free(p_singleton_sensor);
p_singleton_sensor = NULL;
p_sensor = NULL;
return NRF_SUCCESS;
}
static ret_code_t sems_htu21d_sensor_init(sems_sensor_t const *p_sensor)
{
if (p_sensor != p_singleton_sensor)
{
return NRF_ERROR_INVALID_PARAM;
}
return NRF_SUCCESS;
}
sems_sensor_t* get_sems_htu21d_sensor()
{
if (p_singleton_sensor != NULL)
{
return p_singleton_sensor;
}
sems_htu21d_data_t *p_data = (sems_htu21d_data_t*)malloc(sizeof(sems_htu21d_data_t));
sems_htu21d_sensor_config_t *p_config = (sems_htu21d_sensor_config_t*)malloc(sizeof(sems_htu21d_sensor_config_t));
p_singleton_sensor = (sems_sensor_t*)malloc(sizeof(sems_sensor_t));
if (p_singleton_sensor == NULL || p_data == NULL || p_config == NULL)
{
free(p_singleton_sensor);
free(p_data);
free(p_config);
p_singleton_sensor = NULL;
p_data = NULL;
p_config = NULL;
return NULL;
}
HTU21D_CONFIG_SETUP(p_config);
HTU21D_DATA_EMPTY_SETUP(p_data);
SEMS_SENSOR_SETUP_WITH_OUT_TIMER(p_singleton_sensor,SEMS_HUMIDTY_TEMPERATURE_TAG, p_config, p_data, sizeof(sems_htu21d_data_t), get_sensor_data, sems_htu21d_sensor_init, sems_htu21d_sensor_uninit, NULL);
return p_singleton_sensor;
}
#endif
|
C
|
#ifndef GRAPHICS_BV_H
#define GRAPHICS_BV_H
#include <string.h>
#include <stdint.h>
#include <math.h>
#include <float.h>
static void float3_copy(float* dst, float* src)
{
memcpy(dst, src, 3 * sizeof(float));
}
static float float3_length_sq(float* v)
{
float result = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
return result;
}
static float float3_length(float* v)
{
float result = sqrtf(float3_length_sq(v));
return result;
}
static void float3_add_r(float* result, float* a, float* b)
{
result[0] = a[0] + b[0];
result[1] = a[1] + b[1];
result[2] = a[2] + b[2];
}
static void float3_sub_r(float* result, float* a, float* b)
{
result[0] = a[0] - b[0];
result[1] = a[1] - b[1];
result[2] = a[2] - b[2];
}
static void float3_divf(float* v, float s)
{
v[0] /= s;
v[1] /= s;
v[2] /= s;
}
typedef struct aabb
{
float c[3];
float r[3];
} aabb_t;
static struct aabb
calc_aabb(float* vertices, int vertices_count, int offset, int stride)
{
float* p = (float*)((uint8_t*)vertices + offset);
float max_bound[3];
float3_copy(max_bound, p);
float min_bound[3];
float3_copy(min_bound, p);
for (int i = 1; i < vertices_count; i++)
{
p = (float*)((uint8_t*)p + stride);
for (int j = 0; j < 3; j++)
{
if (max_bound[j] < p[j])
max_bound[j] = p[j];
if (min_bound[j] > p[j])
min_bound[j] = p[j];
}
}
struct aabb result = {0};
float3_add_r(result.c, max_bound, min_bound);
float3_divf(result.c, 2);
float3_sub_r(result.r, max_bound, min_bound);
for (int i = 0; i < 3; i++)
result.r[i] = fabsf(result.r[i]) * 0.5f;
return result;
}
static float aabb_volume(struct aabb* aabb)
{
float result = aabb->r[0] * aabb->r[1] * aabb->r[2] * 8;
return result;
}
typedef struct bsphere
{
float c[3];
float r;
} bsphere_t;
static struct bsphere
calc_bsphere(float* vertices, int vertices_count, int offset, int stride)
{
struct aabb aabb = calc_aabb(vertices, vertices_count, offset, stride);
struct bsphere result = {0};
float3_copy(result.c, aabb.c);
result.r = float3_length(aabb.r);
return result;
}
static float bsphere_volume(struct bsphere* bsphere)
{
float r = bsphere->r;
float result = 4.f / 3.f * 3.141592f * r * r * r;
return result;
}
typedef enum bv_type
{
bv_type_aabb = 0,
bv_type_sphere,
bv_type_count,
} bv_type_t;
typedef struct bvolume
{
enum bv_type type;
union
{
struct aabb aabb;
struct bsphere sphere;
};
} bvolume_t;
#endif // GRAPHICS_BV_H
|
C
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* length_hh.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: bchan <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/02/07 12:37:34 by bchan #+# #+# */
/* Updated: 2018/02/19 12:41:02 by bchan ### ########.fr */
/* */
/* ************************************************************************** */
#include "libftprintf.h"
char *pull_char(t_print *form, va_list ap)
{
char arg;
char *result;
arg = va_arg(ap, int);
result = ft_itoa((int)arg);
result = modify_string(form, result);
return (result);
}
char *pull_un_char(t_print *form, va_list ap, char c)
{
unsigned char arg;
char *result;
int i;
arg = va_arg(ap, unsigned int);
if (c == 'u')
result = ft_unsigned_itoa(arg);
if (c == 'o')
result = ft_octal_convert(arg);
if (c == 'x')
result = ft_hex_convert(arg);
if (c == 'X')
{
i = 0;
result = ft_hex_convert(arg);
while (result[i])
{
result[i] = (char)ft_toupper(result[i]);
i++;
}
}
result = modify_string(form, result);
return (result);
}
char *pull_charp(t_print *form, va_list ap)
{
signed char *arg;
arg = va_arg(ap, signed char *);
*arg = form->printed;
return (ft_strdup(""));
}
char *length_hh(t_print *form, va_list ap, char c)
{
if (c == 'd' || c == 'i')
return (pull_char(form, ap));
if (c == 'u' || c == 'o' || c == 'x' || c == 'X')
return (pull_un_char(form, ap, c));
if (c == 'n')
return (pull_charp(form, ap));
return (length_none(form, ap, c));
}
|
C
|
#include "matrix.h"
#include "../simtypes.h"
#include "../exception.h"
#define DATA_AT(x,y,c) ((x)*(c)+(y))
/**
* create a new matrix
*
* input :
* Param 1 (rows) : Number Of Matrix Rows
* Param 2 (cols) : Number Of Matrix Cols
* Param 3 (data) : Matrix Data Pointer
*
* output: a new Matrix
*/
Matrix createMatrix(const int rows,const int cols,float* data)
{
Matrix mat;
mat.rows = rows;
mat.cols = cols;
mat.data = data;
return mat;
}
/**
* matrix A add matrix B
*
* input :
* Param 1 (result) : Result Matrix Pointer
* Param 2 (A) : A Matrix Pointer
* Param 3 (B) : B Matrix Pointer
*
* output: Status Code
* Error: ERROR_CODE 1
* SUCCESS: SUCCESS 0
*/
DETECTION int add(Matrix *result,const Matrix* A,const Matrix* B)
{
//Detecting srouce matrix
if(!( A && B ) || !(A->data && B->data)) {
return ERROR(
"Null Pointer Exception",
"Matrix A or B is NULL",
ERROR_RET(NULL_POINTER));
}
//Detecting matrix format
if(!((A->rows) == (B->rows) &&
((A->cols) == (B->cols)) &&
((A->cols)&&(A->rows)))){
return ERROR(
"Matrix Operation Exception",
"matrix format inconsistency",
ERROR_CODE
);
}
//Compute
__add(result,A,B);
return SUCCESS;
}
FAST void __add(Matrix *result,const Matrix* A,const Matrix* B)
{
result->rows = A->rows;
result->cols = A->cols;
int size = (A->rows)*(A->cols);
float data[size];
int index;
for(index = 0 ; index < size; index++){
result->data[index] = (A->data[index]) + (B->data[index]);
}
}
/**
* matrix A times k
*
* input :
* Param 1 (result) : Result Matrix Pointer
* Param 2 (A) : A Matrix Pointer
* Param 3 (k) : Number k
*
* output: Status Code
* Error: ERROR_CODE 1
* SUCCESS: SUCCESS 0
*/
DETECTION int mulConst(Matrix *result,const Matrix* A,const float k)
{
//Detecting srouce matrix
if(!A || !(A->data)) {
return ERROR(
"Null Pointer Exception",
"Matrix A is NULL",
ERROR_RET(NULL_POINTER));
}
//Detecting Matrix format
if(!((A->cols)&&(A->rows))){
return ERROR(
"Matrix Operation Exception",
"matrix format inconsistency",
ERROR_CODE
);
}
//Compute
__mulConst(result,A,k);
return SUCCESS;
}
FAST void __mulConst(Matrix *result,const Matrix* A,const float k)
{
result->rows = A->rows;
result->cols = A->cols;
int size = (A->rows)*(A->cols);
int index;
for(index = 0 ; index < size; index++){
result->data[index] = (A->data[index])*k;
}
}
/**
* matrix A mul matrix B
*
* input :
* Param 1 (result) : Result Matrix Pointer
* Param 2 (A) : A Matrix Pointer
* Param 3 (B) : B Matrix Pointer
*
* output: Status Code
* Error: ERROR_CODE 1
* SUCCESS: SUCCESS 0
*/
DETECTION int mul(Matrix *result, const Matrix* A, const Matrix* B)
{
//Detecting srouce matrix
if(!( A && B ) || !(A->data && B->data)) {
return ERROR(
"Null Pointer Exception",
"Matrix A or B is NULL",
ERROR_RET(NULL_POINTER));
}
//Detecting Matrix format
if(!(A->cols == B->rows &&
(A->cols)&&(B->cols)&&
(A->rows)&&(B->rows))){
return ERROR(
"Matrix Operation Exception",
"matrix format inconsistency",
ERROR_CODE
);
}
//Compute
__mul(result,A,B);
return SUCCESS;
}
FAST void __mul(Matrix *result, const Matrix* A, const Matrix* B)
{
int rows = A->rows;
int cols = B->cols;
int inner = A->cols;
result->rows = rows;
result->cols = cols;
float *data = result->data;
float *Adata = A->data;
float *Bdata = B->data;
int i,j,k;
float sum;
for ( i = 0 ; i < rows; i++){
for(j = 0 ; j < cols ; j++){
sum = 0;
for (k = 0; k < inner ; k++) {
sum +=
Adata[DATA_AT(i,k,A->cols)]*
Bdata[DATA_AT(k,j,B->cols)];
}
data[DATA_AT(i,j,cols)] = sum;
}
}
}
/*
* clone Matrix
* input:
* Param 1 (dist) : Destination Matrix Pointer
* Param 2 (src) : Source Matrix Pointer
*
* output: Status Code
* Error: ERROR_CODE 1
* SUCCESS: SUCCESS 0
*/
DETECTION int cloneMatrix(Matrix* dist,const Matrix* src)
{
//Detecting srouce matrix
if( !src || !(src->data)) {
return ERROR(
"Null Pointer Exception",
"Matrix src is NULL",
ERROR_RET(NULL_POINTER));
}
//Clone
if(dist != src){
__cloneMatrix(dist,src);
return SUCCESS;
}
return ERROR(
"Matrix Operation Exception",
"The source and destination of CLONE cannot be the same",
ERROR_CODE
);
}
FAST void __cloneMatrix(Matrix* dist,const Matrix* src)
{
dist->rows = src->rows;
dist->cols = src->cols;
int i,size = (src->rows)*(src->cols);
for(i = 0;i < size ; i++){
dist->data[i] = src->data[i];
}
}
/*
* transpose Matrix
* input:
* Param 1 (dist) : Destination Matrix Pointer
* Param 2 (src) : Source Matrix Pointer
*
* output: Status Code
* Error: ERROR_CODE 1
* SUCCESS: SUCCESS 0
*/
DETECTION int transpose(Matrix* dist,const Matrix* src)
{
//Detecting srouce matrix
if( !src || !(src->data)) {
return ERROR(
"Null Pointer Exception",
"Matrix src is NULL",
ERROR_RET(NULL_POINTER));
}
//Transpose
if(dist != src){
__transpose(dist,src);
return SUCCESS;
}
return ERROR(
"Matrix Operation Exception",
"The source and destination of TRANSPOSE cannot be the same",
ERROR_CODE
);
}
FAST void __transpose(Matrix* dist,const Matrix* src)
{
dist->rows = src->cols;
dist->cols = src->rows;
int i,j;
for ( i = 0 ; i < src->rows; i++){
for( j = 0 ; j < src->cols ; j++){
dist->data[DATA_AT(j,i,dist->cols)] =
src->data[DATA_AT(i,j,src->cols)];
}
}
}
/*
* calculate the value of determinant
* input:
* Param 1 (result) : float result Pointer
* Param 2 (mat) : Source Matrix Pointer
*
* output:Status Code
* Error: ERROR_CODE 1
* SUCCESS: SUCCESS 0
*/
DETECTION int det(float* result,const Matrix* mat)
{
//Detecting srouce matrix
if( !mat || !(mat->data)) {
return ERROR(
"Null Pointer Exception",
"Matrix src is NULL",
ERROR_RET(NULL_POINTER));
}
//Detecting Matrix format
if(mat->cols != mat->rows){
return ERROR(
"Matrix operation Exception",
"matrix format inconsistency",
ERROR_CODE
);
}
*result = __det(mat);
return SUCCESS;
}
PRIVATE void permutation(float* result,const Matrix* mat,int* order,int now);
PRIVATE int inversionNumber(const int* order,int size);
PRIVATE static __inline__ float det2X2(const Matrix* mat);
PRIVATE static __inline__ float det3X3(const Matrix* mat);
FAST float __det(const Matrix* mat)
{
int size = mat->rows;
switch(size){
case 1: return mat->data[0];
case 2: return det2X2(mat);
case 3: return det3X3(mat);
}
//create a default order array buffer
int orderBuffer[size];
int i;
for(i = 0 ; i < size ; i ++){
orderBuffer[i] = i;
}
float result = 0;
permutation(&result,mat,orderBuffer,0);
return result;
}
PRIVATE void permutation(float* result,const Matrix* mat,int* order,int now)
{
int i;
if(now != mat->cols){
for(i = now; i < mat->cols ; i++)
{
SWAP(order[now],order[i]);
permutation(result,mat,order,now+1);
SWAP(order[now],order[i]);
}
} else {
float num = 1;
int in = inversionNumber(order,mat->cols);
for(i = 0;i < mat->rows;i++){
num *= mat->data[DATA_AT(i,order[i],mat->cols)];
}
*result += in&1?-num:num;
}
} FUNCTION_USED_BY(__det,"Find all combinations of different rows and columns");
PRIVATE int inversionNumber(const int* order,int size)
{
int i,j;
int ret = 0;
for(i = 0; i < size ; i++){
for(j = 0; j < i; j++){
if(order[i] < order[j]){
ret ++;
}
}
}
return ret;
} FUNCTION_USED_BY(permutation,"Calculate the inverse number of a given order");
PRIVATE static __inline__ float det2X2(const Matrix* mat)
{
return (mat->data[0])*(mat->data[3]) - (mat->data[1])*(mat->data[2]);
}
PRIVATE static __inline__ float det3X3(const Matrix* mat)
{
float* data = mat->data;
return
data[0]*data[4]*data[8] + data[1]*data[5]*data[6] + data[2]*data[3]*data[7]
- data[0]*data[5]*data[7] - data[1]*data[3]*data[8] - data[2]*data[4]*data[6];
}
/*
* inverse Matrix
* input:
* Param 1 (dist) : Destination Matrix Pointer
* Param 2 (src) : Source Matrix Pointer
*
* output:
* IRREVERSIBLE : Matrix irreversibility
* Error: ERROR_CODE 1
* SUCCESS: SUCCESS 0
*/
DETECTION int inverse(Matrix* dist,const Matrix* src)
{
//Detecting srouce matrix
if( !src || !(src->data)) {
return ERROR(
"Null Pointer Exception",
"Matrix src is NULL",
ERROR_RET(NULL_POINTER));
}
//inverse
if(dist != src){
return __inverse(dist,src);
}
return ERROR(
"Matrix Operation Exception",
"The source and destination of INVERSE cannot be the same",
ERROR_CODE
);
}
PRIVATE void LUDecomposition(Matrix* dist,const Matrix* mat);
PRIVATE float innerSumLrkUki(const float* L,const float* U,const int size, int r, int i);
PRIVATE float innerSumLikUkr(const float* L,const float* U,const int size, int r, int i);
PRIVATE void inversionOfLowerTriangularMatrix(Matrix* dist,const Matrix* src,const int rowStart,const int rowEnd,const int colStart,const int colEnd);
PRIVATE static __inline__ void inverse1X1(Matrix* dist,const Matrix* src);
PRIVATE static __inline__ void inverse2X2(Matrix* dist,const Matrix* src);
FAST int __inverse(Matrix* dist,const Matrix* src)
{
float detSrc = __det(src);
if(detSrc == 0){
return IRREVERSIBLE;
}
switch(src->rows){
case 1: inverse1X1(dist,src);return SUCCESS;
case 2: inverse2X2(dist,src);return SUCCESS;
}
LUDecomposition(dist,src);
return SUCCESS;
}
PRIVATE void LUDecomposition(Matrix* dist,const Matrix* src)
{
int size = src->rows;
int matrixSize = size*size;
float* data = src->data;
float L[matrixSize],U[matrixSize];
////start
/*FRIST:
*L frist col and U frist row
*U1i=A1i,Li1=Ai1/U11
*/
int r,i;
for (i = 0; i < size; i++) {
U[DATA_AT(0,i,size)]= data[DATA_AT(0,i,size)];
L[DATA_AT(i,0,size)]= data[DATA_AT(i,0,size)]/U[DATA_AT(0,0,size)];
}
//compute U r rowL r col
//uri=ari-(k=1->r-1)lrkuki (i=r,r+1,...,n)
//lir=air-(k=1->r-1)likukr (i=r+1,r+2,...,n&&rn)
for (r = 1; r < size; r++) {
for (i = r; i < size; i++) {
U[DATA_AT(r,i,size)] = data[DATA_AT(r,i,size)] - innerSumLrkUki(L,U,size,r,i);
if(i==r) L[DATA_AT(r,r,size)] = 1;
else if(r==size) L[DATA_AT(size,size,size)] = 1;
else {
L[DATA_AT(i,r,size)] =
(data[DATA_AT(i,r,size)] - innerSumLikUkr(L,U,size,r,i))/U[DATA_AT(r,r,size)];
}
}
}
////end
Matrix matrixL = createMatrix(size,size,L);
Matrix matrixU = createMatrix(size,size,U);
float iL[matrixSize],iU[matrixSize],tmpData[matrixSize];
Matrix iMatrixL = createMatrix(size,size,iL);
Matrix iMatrixU = createMatrix(size,size,iU);
Matrix tmpMatrix = createMatrix(size,size,tmpData);
//get L' and U'
inversionOfLowerTriangularMatrix(&iMatrixL,&matrixL,0,size,0,size);
__transpose(&tmpMatrix,&matrixU);
inversionOfLowerTriangularMatrix(&matrixU,&tmpMatrix,0,size,0,size);
__transpose(&iMatrixU,&matrixU);
//A' = U'L'
__mul(dist,&iMatrixU,&iMatrixL);
} FUNCTION_USED_BY(__inverse,"LU Decomposition of Matrix");
PRIVATE float innerSumLrkUki(const float* L,const float* U,const int size, int r, int i)
{
float sum = 0;
int k;
for (k = 0; k < r; k++) {
sum +=
L[DATA_AT(r,k,size)] * U[DATA_AT(k,i,size)];
}
return sum;
}
PRIVATE float innerSumLikUkr(const float* L,const float* U,const int size, int r, int i)
{
float sum = 0;
int k;
for (k = 0; k < r; k++) {
sum +=
L[DATA_AT(i,k,size)] * U[DATA_AT(k,r,size)];
}
return sum;
}
PRIVATE void inversionOfLowerTriangularMatrix(
Matrix* dist,
const Matrix* src,
const int rowStart,
const int rowEnd,
const int colStart,
const int colEnd
)
{
int size = rowEnd-rowStart;
switch(size){
case 1:
dist->data[0] = 1.0f/src->data[DATA_AT(rowStart,colStart,src->cols)];
return;
case 2:
{
float a,b,c,d;
a = src->data[DATA_AT(rowStart ,colStart ,src->cols)];
b = src->data[DATA_AT(rowStart ,colStart+1,src->cols)];
c = src->data[DATA_AT(rowStart+1,colStart ,src->cols)];
d = src->data[DATA_AT(rowStart+1,colStart+1,src->cols)];
float n = 1.0f/(a*d - c*b);
dist->data[0] = d*n;
dist->data[1] = -b*n;
dist->data[2] = -c*n;
dist->data[3] = a*n;
}
return;
}
int Asize = size/2;
int Bsize = size - Asize;
float iAData[Asize*Asize],iBData[Bsize*Bsize],CData[Asize*Bsize];
Matrix iA = createMatrix(Asize,Asize,iAData);
Matrix iB = createMatrix(Bsize,Bsize,iBData);
Matrix C = createMatrix(Bsize,Asize,CData);
inversionOfLowerTriangularMatrix(&iA,src,rowStart,rowStart + Asize,colStart,colStart + Asize);
inversionOfLowerTriangularMatrix(
&iB,src,
rowStart + Asize,
rowStart + Asize + Bsize,
colStart + Asize,
colStart + Asize + Bsize);
__submatrix(&C,src,rowStart + Asize,rowEnd,colStart,colStart + Asize);
float t0Data[Asize*Bsize],t1Data[Asize*Bsize];
Matrix tmp0 = createMatrix(Bsize,Asize,t0Data);
Matrix tmp1 = createMatrix(Bsize,Asize,t1Data);
__mul(&tmp0,&iB,&C);
__mul(&tmp1,&tmp0,&iA);
__mulConst(&tmp0,&tmp1,-1);
float *data = dist->data;
int i,j;
int all = size*size ;
for(i = 0; i < all ;i++){
data[i] = 0;
}
for(i = 0; i < Asize; i++ ){
for(j = 0 ; j < Asize ; j++){
data[DATA_AT(i,j,size)] =
iA.data[DATA_AT(i,j,Asize)];
}
}
for(i = 0; i < Bsize ; i++){
for(j = 0 ; j < Bsize ; j++){
data[DATA_AT(Asize + i,Asize + j,size)] =
iB.data[DATA_AT(i,j,Bsize)];
}
}
for(i = 0; i < Bsize ; i++){
for(j = 0 ; j < Asize ; j++){
data[DATA_AT(Asize + i,j,size)] =
tmp0.data[DATA_AT(i,j,Asize)];
}
}
}
PRIVATE static __inline__ void inverse1X1(Matrix* dist,const Matrix* src)
{
dist->rows = 1;
dist->cols = 1;
dist->data[0] = 1.0f/(src->data[0]);
}
PRIVATE static __inline__ void inverse2X2(Matrix* dist,const Matrix* src)
{
dist->rows = 2;
dist->cols = 2;
float n = 1.0f/det2X2(src);
float* data = dist->data;
data[0] = src->data[3]*n;
data[1] = -src->data[1]*n;
data[2] = -src->data[2]*n;
data[3] = src->data[0]*n;
}
/*
* get Submatrix (form rowStart,colStart to rowEnd,colEnd)
* input:
* Param 1 (dist) : Destination Matrix Pointer
* Param 2 (src) : Source Matrix Pointer
* Param 3 (rowStart) : Which row to start with
* Param 4 (rowEnd) : Which row ends
* Param 5 (colStart) : Which column to start with
* Param 6 (colEnd) : Which column ends
*
* output: Status Code
* Error: ERROR_CODE 1
* SUCCESS: SUCCESS 0
*/
DETECTION int submatrix(
Matrix* dist,
const Matrix* src,
int rowStart,
int rowEnd,
int colStart,
int colEnd
)
{
//Detecting srouce matrix
if( !src || !(src->data)) {
return ERROR(
"Null Pointer Exception",
"Matrix src is NULL",
ERROR_RET(NULL_POINTER));
}
//Detecting Matrix Parameter
if(rowStart && rowEnd && colStart && colEnd &&
rowEnd > rowStart && colEnd > colStart &&
src->rows > rowEnd && src->cols > colEnd
){
return ERROR(
"Matrix Parameter Exception",
"matrix parameter data error",
ERROR_CODE
);
}
if(dist != src){
__submatrix(dist,src,rowStart,rowEnd,colStart,colEnd);
return SUCCESS;
}
return ERROR(
"Matrix Operation Exception",
"The source and destination of SUBMATRIX cannot be the same",
ERROR_CODE
);
}
FAST void __submatrix(
Matrix* dist,
const Matrix* src,
int rowStart,
int rowEnd,
int colStart,
int colEnd
)
{
int rows = rowEnd - rowStart;
int cols = colEnd - colStart;
dist->rows = rows;
dist->cols = cols;
int i,j;
for(i = rowStart ; i < rowEnd ;i++){
for(j = colStart; j < colEnd ; j++){
dist->data[DATA_AT(i - rowStart ,j - colStart ,dist->cols)] =
src->data[DATA_AT(i,j,src->cols)];
}
}
}
float matrixGet(const Matrix* mat,const int row,const int col)
{
return mat->data[DATA_AT(row,col,mat->cols)];
}
void matrixSet(Matrix* mat,const int row,const int col,const float num)
{
mat->data[DATA_AT(row,col,mat->cols)] = num;
}
#undef DATA_AT
|
C
|
// IDoMath.h: Interface which declares some very
// basic arithmetic methods.
#ifndef IDOMATH_H_INCLUDED
#define IDOMATH_H_INCLUDED
#include "BaseInterface.h"
interface IDoMath : IBase
{
virtual int Add(int x, int y) = 0;
virtual int Sub(int x, int y) = 0;
virtual int Mul(int x, int y) = 0;
virtual int Div(int x, int y) = 0;
};
#endif
|
C
|
#ifndef _ICLIST_H_
#define _ICLIST_H_
typedef struct Operand_* Operand;
typedef struct Operand_ {
enum {VARIABLE, CONSTANT, ADDRESS} op_kind;
char* info;
}Operand_;
enum ICKind {
ASSIGN = 100,
ASSIGN_ADDR,
ASSIGN_STAR,
STAR_ASSIGN,
ADD,
SUB,
MUL,
DIV,
FUNC_DEC,
PARAM,
ARG,
RET,
IF,
GOTO,
LABEL,
FUNC_CALL,
READ,
WRITE,
DEC,
NEG
};
typedef struct ICNode {
enum ICKind ic_kind;
union {
struct {Operand left, right;} assign;
struct {Operand left, right;
char *op, *label;} cond;
struct {Operand result, op1, op2;} binop;
struct {Operand place;
char* func_name;} func;
struct {Operand op;
int size;} dec;
char* name;
Operand op;
};
struct ICNode *prev, *next;
}ICNode;
#define OP_SIZE 65535
Operand opTable[OP_SIZE];
void initOpTable();
Operand insertOp(char* info, int kind);
Operand searchOp(char* info);
ICNode* concatIC(int num, ...);
ICNode* popIC(ICNode* head);
char* getOp(Operand op);
void printIC(ICNode* icnode);
ICNode* newICNode(enum ICKind kind, ...);
#endif
|
C
|
#ifndef PUSH_SWAP_H
# define PUSH_SWAP_H
# include <stdlib.h>
# include <unistd.h>
# define ERROR "Error\n"
# define MALLOCERROR "\033[0;33mMalloc failed\033[0m\n"
/**
* prototype for node of linked list
* @fields pos : position in sorted array
* @fields index : index in current array
* @fields steps : index in other array
* @fields total mpves : needed to move element in right order in
* @fields next : pointer to next node
* @prototype value | [index] | next
*/
typedef struct s_stack
{
int pos;
int index;
int steps;
unsigned int total_moves;
struct s_stack *next;
} t_stack;
typedef struct s_cmd
{
char *command;
struct s_cmd *next;
struct s_cmd *prev;
} t_cmd;
/**
* general structure containing info
* @fields commands : string
* @fields head_a : linked list A
* @fields head_b : linked list B
*/
typedef struct s_info
{
t_cmd *operations;
t_cmd *last_op;
struct s_stack *head_a;
struct s_stack *head_b;
} t_info;
typedef struct s_algo
{
unsigned int max_pos;
t_stack *next_pos;
} t_algo;
void error_case(char *message, int number);
int valid_args(int argc, char *argv[]);
t_info *init_process(int argc, char *argv[]);
void form_stack(t_stack **head, int argc, char *argv[]);
void position_in_sorted_list(t_stack **head, int argc);
void add_cmd(t_info **process, char *operation);
unsigned int node_count(t_stack *head);
void indexing(t_stack **head);
int count_digits(char const *s, char c);
void circulation(t_stack *moved_elem, t_stack *head, \
t_info *process);
int count_steps(int curr_pos, t_stack *where_to_put);
void swap_s(t_stack **a, t_info **process, char *operation);
void rotate_s(t_stack **a, t_info **process, char *operation);
void reverse_rotate_s(t_stack **a, t_info **process, \
char *operation);
void push_s(t_stack **src, t_stack **dest, \
t_info **process, char *operation);
void ss(t_stack **a, t_stack **b, t_info **process);
void rr(t_stack **a, t_stack **b, t_info **process);
void rrr(t_stack **a, t_stack **b, t_info **process);
void sort_just_two(t_info *process);
void sort_three(t_info *process);
void sort_four(t_info *process, int min);
void sort_five(t_info *process);
void huge_sort(t_info *process);
#endif
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#define BUFLEN 256
void close_log_file();
void open_log_file();
int PID;
FILE* log_fd;
int logged = 0; // Clientul este logat (exista o sesiune deschisa)
int last_command_was_transfer = 0;
char my_card_no[BUFLEN];
// Functia de iesire in caz de eroare
void error(char *msg, int error_no)
{
close_log_file();
perror(msg); // Afisez un mesaj
exit(error_no); // Trimit un cod de eroare
}
// Verificare numar argumente primite
void check_no_args(int argc) {
if (argc < 2) {
error("Not enough arguments!\n", -10);
}
}
void open_log_file() {
char file_name[BUFLEN];
PID = getpid();
sprintf(file_name, "client-%d.log", PID);
log_fd = fopen(file_name, "wt");
}
void close_log_file() {
fclose(log_fd);
}
void run(char* argv[]) {
int sockfd, n, sockfd_udp;
struct sockaddr_in serv_addr, serv_addr_udp;
struct hostent *server;
char buffer[BUFLEN];
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
error("Eroare la apel socket", -10);
sockfd_udp = socket(PF_INET, SOCK_DGRAM, 0);
if (sockfd_udp < 0)
error("Eroare la apel socket", -10);
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(atoi(argv[2]));
inet_aton(argv[1], &serv_addr.sin_addr);
serv_addr_udp.sin_family = PF_INET;
serv_addr_udp.sin_port = htons(atoi(argv[2]));
inet_aton(argv[1], &serv_addr_udp.sin_addr);
if (connect(sockfd, (struct sockaddr*) &serv_addr,sizeof(serv_addr)) < 0)
error("Eroare la apel connect", -1);
if (connect(sockfd_udp, (struct sockaddr*) &serv_addr_udp,sizeof(serv_addr)) < 0)
error("Eroare la apel connect", -1);
while(1){
// Citesc de la tastatura
memset(buffer, 0 , BUFLEN);
fgets(buffer, BUFLEN-1, stdin);
fprintf(log_fd, "%s", buffer);
// Daca comanda este login si exista o sesiune deschisa
if (strncmp(buffer, "login", 5) == 0 && logged == 1) {
fprintf(log_fd, "IBANK> -2 : Sesiune deja deschisa\n\n");
printf("IBANK> -2 : Sesiune deja deschisa\n\n");
continue;
}
// Daca comanda este quit
if (strncmp(buffer, "quit", 4) == 0) {
n = send(sockfd, buffer, strlen(buffer), 0);
if (n < 0) {
error("Eroare la apel recv", -10);
}
return;
}
// Daca e orice comanda in afara de quit, unlock sau login si nu sunt conectat
if (strncmp(buffer, "login", 5) != 0 && logged == 0 && strncmp(buffer, "unlock", 6) != 0) {
fprintf(log_fd, "-1 : Clientul nu este autentificat\n\n");
printf("-1 : Clientul nu este autentificat\n\n");
continue;
}
if (strncmp(buffer, "logout", 6) == 0) {
logged = 0;
}
if (last_command_was_transfer == 1) {
last_command_was_transfer = 0;
if (strncmp(buffer, "IBANK> Transfer", 15) == 0) {
// Citesc de la tastatura
printf("SE ASTEAPTA CEVA\n");
memset(buffer, 0 , BUFLEN);
fgets(buffer, BUFLEN - 1, stdin);
}
}
if (strncmp(buffer, "transfer", 8) == 0) {
last_command_was_transfer = 1;
}
if (strncmp(buffer, "login", 5) == 0) {
char buffer_copy[BUFLEN];
strcpy(buffer_copy, buffer);
char* token = strtok(buffer_copy, " \n");
token = strtok(NULL, " \n");
strcpy(my_card_no, token);
}
if (strncmp(buffer, "unlock", 6) == 0) {
printf("%s", buffer);
fprintf(log_fd, "%s", buffer);
char command[256];
sprintf(command, "unlock %s", my_card_no);
sendto(sockfd_udp, command, strlen(command), 0, (struct sockaddr *) &serv_addr_udp, sizeof(struct sockaddr_in));
memset(buffer, 0, BUFLEN);
int size_msg;
int len = recvfrom(sockfd_udp, buffer, 256, 0, (struct sockaddr*) &serv_addr_udp, &size_msg);
if (n < 0) {
error("Eroare la apel recv", -10);
}
printf("%s", buffer);
fprintf(log_fd, "%s", buffer);
continue;
}
// Trimit mesaj la server
n = send(sockfd, buffer, strlen(buffer), 0);
if (n < 0)
error("Eroare la apel send", -10);
// Primesc mesaj de la server
memset(buffer, 0, BUFLEN);
n = recv(sockfd, buffer, sizeof(buffer), 0);
if (n < 0) {
error("Eroare la apel recv", -10);
}
printf("%s", buffer);
fprintf(log_fd, "%s", buffer);
if (strncmp(buffer, "IBANK> Welcome", 14) == 0) {
logged = 1;
}
}
}
int main(int argc, char *argv[])
{
// Deschid fisierul pentru log
open_log_file();
// Verific numarul de argumente
check_no_args(argc);
// Pornesc clientul
run(argv);
// Inchid fisierul pentru log
close_log_file();
// Iesire cu succes
return 0;
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,j,k;
int number = 5;
int count = number-1;
for (k = 1; k <=number; k++) {
for (i = 1; i <=count; i++)
printf(" ");
count--;
for (i=1; i <=2*k-1;i++)
printf("*");
printf("\n");
}
count = 1;
for (k = 1; k <= number - 1; k++) {
for (i = 1; i <= count; i++)
printf(" ");
count++;
for (i = 1; i <=2*(number-k)-1;i++)
printf("*");
printf("\n");
}
return 0;
}
|
C
|
#ifndef _VLIB_H
#define _VLIB_H
#include <stdint.h>
// λͼͣλͼֻ֧8λҪĿλ
typedef struct _vBitmap
{
uint32_t bitmap;
}vBitmap;
/**********************************************************************************************************
** Function name : vBitmapInit
** Descriptions : ʼbitmapеλȫ0
** parameters :
** Returned value :
***********************************************************************************************************/
void vBitmapInit(vBitmap *bitmap);
/**********************************************************************************************************
** Function name : vBitmapPosCount
** Descriptions : ֵ֧λ
** parameters :
** Returned value : ֵ֧λ
***********************************************************************************************************/
uint32_t vBitmapPosCount(void);
/**********************************************************************************************************
** Function name : vBitmapSet
** Descriptions : bitmapеijλ
** parameters : pos Ҫõλ
** Returned value :
***********************************************************************************************************/
void vBitmapSet(vBitmap *bitmap, uint32_t pos);
/**********************************************************************************************************
** Function name : vBitmapClear
** Descriptions : bitmapеijλ
** parameters : pos Ҫλ
** Returned value :
***********************************************************************************************************/
void vBitmapClear(vBitmap *bitmap, uint32_t pos);
/**********************************************************************************************************
** Function name : vBitmapGetFirstSet
** Descriptions : λͼе0λʼңҵ1õλ
** parameters :
** Returned value : 1õλ
***********************************************************************************************************/
uint32_t vBitmapGetFirstSet(vBitmap *bitmap);
// ˫ڵ
typedef struct _vNode
{
// ýǰһ
struct _vNode *preNode;
// ýĺһ
struct _vNode *nextNode;
}vNode;
// ڵ
typedef struct _vSNode
{
// ýĺһ
struct _vSNode *nextNode;
}vSNode;
// ˫
typedef struct _vList
{
// ͷ
vNode headNode;
// н
uint32_t nodeCount;
}vList;
//
typedef struct _vSList
{
// ͷ
vSNode headNode;
// н
uint32_t nodeCount;
}vSList;
/**********************************************************************************************************
** Function name : vNodeParent
** Descriptions : ȡڵĸstructṹַ
** parameters :
** Returned value : structṹַ
***********************************************************************************************************/
#define vNodeParent(node, parent, name) (parent*)((uint32_t)node - (uint32_t)&((parent *)0)->name)
/**********************************************************************************************************
** Function name : vNodeInit
** Descriptions : ʼ˫
** parameters :
** Returned value :
***********************************************************************************************************/
void vNodeInit(vNode *node);
/**********************************************************************************************************
** Function name : vListInit
** Descriptions : ˫ʼ
** parameters :
** Returned value :
***********************************************************************************************************/
void vListInit(vList *list);
/**********************************************************************************************************
** Function name : vListCount
** Descriptions : ˫н
** parameters :
** Returned value :
***********************************************************************************************************/
uint32_t vListCount(vList *list);
/**********************************************************************************************************
** Function name : vListFirst
** Descriptions : ˫
** parameters : list ѯ
** Returned value : 㣬Ϊգ0
***********************************************************************************************************/
vNode *vListFirst(vList *list);
/**********************************************************************************************************
** Function name : vListLast
** Descriptions : ˫һ
** parameters : list ѯ
** Returned value : Ľ㣬Ϊգ0
***********************************************************************************************************/
vNode *vListLast(vList *list);
/**********************************************************************************************************
** Function name : vListPre
** Descriptions : ˫ָǰһ
** parameters : list ѯ
** parameters : node ο
** Returned value : ǰһ㣬ûǰ㣨Ϊգ0
***********************************************************************************************************/
vNode *vListPre(vList *list, vNode *node);
/**********************************************************************************************************
** Function name : vListNext
** Descriptions : ˫ָĺһ
** parameters : list ѯ
** parameters : node ο
** Returned value : һ㣬ûǰ㣨Ϊգ0
***********************************************************************************************************/
vNode *vListNext(vList *list, vNode *node);
/**********************************************************************************************************
** Function name : vListRemoveAll
** Descriptions : Ƴ˫ен
** parameters : list յ
** Returned value :
***********************************************************************************************************/
void vListRemoveAll(vList *list);
/**********************************************************************************************************
** Function name : vListAddFirst
** Descriptions : ָӵ˫ͷ
** parameters : list
** parameters : node Ľ
** Returned value :
***********************************************************************************************************/
void vListAddFirst(vList *list, vNode *node);
/**********************************************************************************************************
** Function name : vListAddLast
** Descriptions : ָӵ˫ĩβ
** parameters : list
** parameters : node Ľ
** Returned value :
***********************************************************************************************************/
void vListAddLast(vList *list, vNode *node);
/**********************************************************************************************************
** Function name : vListRemoveFirst
** Descriptions : Ƴ˫еĵ1
** parameters : list Ƴ
** Returned value : Ϊգ0Ļص1
***********************************************************************************************************/
vNode *vListRemoveFirst(vList *list);
/**********************************************************************************************************
** Function name : vListInsertAfter
** Descriptions : ָĽ뵽ij
** parameters : list
** parameters : refNode ο
** parameters : nodeToInsert Ľṹ
** Returned value :
***********************************************************************************************************/
void vListInsertAfter(vList * list, vNode *refNode, vNode *nodeToInsert);
/**********************************************************************************************************
** Function name : vListInsertBefore
** Descriptions : ָĽ뵽ijǰ
** parameters : list
** parameters : refNode ο
** parameters : nodeToInsert Ľṹ
** Returned value :
***********************************************************************************************************/
void vListInsertBefore(vList * list, vNode *refNode, vNode *nodeToInsert);
/**********************************************************************************************************
** Function name : vListRemove
** Descriptions : ָ˫Ƴ
** parameters : list Ƴ
** parameters : node ƳĽ
** Returned value :
***********************************************************************************************************/
void vListRemove(vList *list, vNode *node);
/**********************************************************************************************************
***********************************************************************************************************/
/**********************************************************************************************************
** Function name : vSNodeInit
** Descriptions : ʼ
** parameters :
** Returned value :
***********************************************************************************************************/
void vSNodeInit(vSNode *sNode);
/**********************************************************************************************************
** Function name : vSListInit
** Descriptions : ʼ
** parameters :
** Returned value :
***********************************************************************************************************/
void vSListInit(vSList *sList);
/**********************************************************************************************************
** Function name : vSListCount
** Descriptions : صн
** parameters :
** Returned value :
***********************************************************************************************************/
uint32_t vSListCount(vSList *sList);
/**********************************************************************************************************
** Function name : vSListFirst
** Descriptions : ص
** parameters : sList ѯ
** Returned value : 㣬Ϊգ0
***********************************************************************************************************/
vSNode *vSListFirst(vSList *sList);
/**********************************************************************************************************
** Function name : vListNext
** Descriptions : صָĺһ
** parameters : sList ѯ
** parameters : sNode ο
** Returned value : һ㣬ûǰ㣨Ϊգ0
***********************************************************************************************************/
vSNode *vSListNext(vSList *sList, vSNode *sNode);
/**********************************************************************************************************
** Function name : vSListRemoveAll
** Descriptions : Ƴен
** parameters : sList յ
** Returned value :
***********************************************************************************************************/
void vSListRemoveAll(vSList *sList);
/**********************************************************************************************************
** Function name : vSListAddFirst
** Descriptions : ָӵͷ
** parameters : sList
** parameters : sNode Ľ
** Returned value :
***********************************************************************************************************/
void vSListAddFirst(vSList *sList, vSNode *sNode);
/**********************************************************************************************************
** Function name : vSListRemoveFirst
** Descriptions : Ƴеĵ1
** parameters : sList Ƴ
** Returned value : Ϊգ0Ļص1
***********************************************************************************************************/
vSNode *vSListRemoveFirst(vSList *sList);
#endif
|
C
|
#include <stdio.h>
void calculaSomaTermos (int numero, int razao, int n, float* sn) {
float ultimotermo = 0;
for (int i = 1; i <= n; i++) {
ultimotermo = numero + (i - 1) * razao;
(*sn) = (numero + ultimotermo) * n / 2.0;
}
}
int main(void) {
float numero = 0;
float razao = 0;
float n = 0;
float sn = 0;
printf("Digite o primeiro número: ");
scanf("%f", &numero);
printf("Digite a razão: ");
scanf("%f", &razao);
printf("Digite a quantidade de termos: ");
scanf("%f", &n);
calculaSomaTermos (numero, razao, n, &sn);
printf("A soma dos termos da P.A feita é: %.2lf", sn);
return 0;
}
|
C
|
/* INPUT: 1) Matrice 4x4 di interi positivi !
2) m=intero
OUTPUT:
1) Calcola il massimo valore minore o uguale ad m, se tale non esiste restituisce -1
2) Il numero di multipli di m, presenti nella matrice.
*/
#include <stdio.h>
#define DIM 4
void funzione (int matrixInput[DIM][DIM], int m, int *massimo, int *multipli) {
int i;
int j;
int controller=0;
int max;
int indexRiga;
int indexColonna;
int counter=0;
/* La funzione controlla se la matrice ha termini positivi */
for (i=0; i<DIM; i++) {
for (j=0; j<DIM; j++) {
if (matrixInput[i][j]>=0) {
controller=controller+0;
} else {
controller=controller+1;
}
}
}
if (controller==0) {
max=-1;
for (i=0; i<DIM; i++) {
for (j=0; j<DIM; j++) {
if (max<matrixInput[i][j] && m>=matrixInput[i][j]) {
max=matrixInput[i][j];
indexRiga=i;
indexColonna=j;
}
if (matrixInput[i][j]%m==0) {
counter=counter+1;
}
}
}
*massimo=max;
*multipli=counter;
} else {
printf("I dati inseriti non soddisfano le richieste iniziali.\n");
}
}
int main() {
int matrix[DIM][DIM];
int m;
int i;
int j;
int numeroMultipli;
int massimo;
printf("Inserisci i dati della matrice:\n");
for (i=0; i<DIM; i++) {
for (j=0; j<DIM; j++ ) {
printf("matrix[%d][%d]: ", i, j);
scanf("%d", &matrix[i][j]);
}
}
printf("Inserisci il numero m: ");
scanf("%d", &m);
funzione(matrix, m, &massimo, &numeroMultipli);
printf("Il massimo risulta essere: %d", massimo);
printf("\nIl numero dei multipli di m: %d", numeroMultipli);
getch();
return 0;
}
|
C
|
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char* longestCommonPrefix(char** strs, int strsSize) {
int i = 0, j = 0, flag = 0;
char c1, *s;
size_t tmp_len, min_len = 0, pfx_len = 0;
for (i = 0; i < strsSize; i++) {
if (strs[i] == NULL)
return "";
else if (i == 0)
min_len = strlen(strs[i]);
tmp_len = strlen(strs[i]);
min_len = (tmp_len < min_len) ? tmp_len : min_len;
}
#ifdef DEBUG
printf("min_len: %zu\n", min_len);
#endif
for (i = 0, j = 0; j < min_len && flag == 0; i = 0, j++) {
for (i = 0, c1 = strs[i][j]; i < strsSize && flag == 0; i++) {
#ifdef DEBUG
printf(" checking strs[%d][%d]:%c\n", i, j, strs[i][j]);
#endif
if (c1 != strs[i][j])
flag = 1;
}
if (flag == 0)
pfx_len++;
}
#ifdef DEBUG
printf("max common prefix length: %zu\n", pfx_len);
#endif
s = (char *)malloc(sizeof(char) * pfx_len + 1);
memset(s, 0x00, pfx_len+1);
strncpy(s, strs[0], pfx_len);
return s;
}
|
C
|
/*
* Create an array of integers. Make it 16 long. Fill it up with numbers as You wish. Print them out.
* * Iterate over it with a pointer so, that You only get to each _second_ element. Print out only these.
* * Iterate over it only touching each _fourth_ element. Print out only these.
* * Iterate over it only touching each _eighth_ element. Print out only these.
*/
#include <stdio.h>
int main()
{
int array[16];
int *p_array;
p_array = array;
for (int i = 0; i < 16; i++) {
array[i] = rand() % 1000;
}
printf("The original array: \n");
for (int i = 0; i < 16; i++) {
printf("%d ", *(p_array + i));
}
printf("\n\nEvery second: \n");
for (int i = 1; i < 16; i += 2) {
printf("%d ", *(p_array + i));
}
printf("\n\nEvery fourth: \n");
for (int i = 3; i < 16; i += 4) {
printf("%d ", *(p_array + i));
}
printf("\n\nEvery eighth: \n");
for (int i = 7; i < 16; i += 8) {
printf("%d ", *(p_array + i));
}
return 0;
}
|
C
|
/*************************************************************************
> File Name: calc-main.c
> Author: hao
> Mail: onerhao@gmail.com
> Created Time: Thu 25 Oct 2012 01:40:45 PM CST
************************************************************************/
#include "calc.h"
#include <stdio.h>
#include <string.h>
int main()
{
char infix[MAX], ch, str[] = "1"; //get the input
int i;
double res;
while (1) {
i = 0;
memset(infix, 0, sizeof(char) * MAX);
printf("> ");
ch = getchar();
if (ch == EOF)
break;
while (ch != '\n') {
infix[i++] = ch;
ch = getchar();
//printf("the expression is %s\n",infix);
}
infix[i] = '\0';
i = calc_num(infix, &res);
printf("%s \nthe result is:%.2f\n", i ? "legal" : "illegal", res);
}
return 0;
}
|
C
|
#include "header.h"
int check_exception(int** conditions, int argc)
{
int i;
int j;
i = 0;
j = 0;
while (i <= 3)
{
while (j <= 3)
{
if (conditions[i][j] < 1 || 4 < conditions[i][j])
return (1);
j++;
}
j = 0;
i++;
}
if (argc != 2)
{
return (1);
}
return (0);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
/*Faça um programa que leia uma matriz de tamanho 5x5.
Calcule e imprima a soma dos elementos dessa matriz que não pertencem á diagonal principal nem á diagonal secundária*/
int main(void){
int matrizUser[5][5], aux1, aux2, soma1 = 0, soma2 = 0, soma3 = 0, soma4 = 0, soma5 = 0, somaGeral = 0;
//Pedindo os dados do indice.
for(aux1 = 0; aux1 < 5; aux1++){
for(aux2 = 0; aux2 < 5; aux2++){
printf("\nDigite um valor para o indice: [%d]-[%d]: ", aux1, aux2);
scanf("%d", &matrizUser[aux1][aux2]);
}
}
//Somandos os elementos da matriz que não pertencem a diagonal principal nem á diagonal secundária.
for(aux1 = 0; aux1 < 5; aux1++){
for(aux2 = 0; aux2 < 5; aux2++){
if(aux1 == 0 && aux2 >= 1 && aux2 <= 3){
soma1 = soma1 + matrizUser[aux1][aux2];
}
else if(aux1 == 1 && aux2 != 1 && aux2 != 3){
soma2 = soma2 + matrizUser[aux1][aux2];
}
else if(aux1 == 2 && aux2 != 2){
soma3 = soma3 + matrizUser[aux1][aux2];
}
else if(aux1 == 3 && aux2 != 1 && aux2 != 3){
soma4 = soma4 + matrizUser[aux1][aux2];
}
else if(aux1 == 4 && aux2 != 0 && aux2 != 4){
soma5 = soma5 + matrizUser[aux1][aux2];
}
}
}
printf("\nValor da linha 1: %d", soma1);
printf("\nValor da linha 2: %d", soma2);
printf("\nValor da linha 3: %d", soma3);
printf("\nValor da linha 4: %d", soma4);
printf("\nValor da linha 5: %d", soma5);
somaGeral = soma1 + soma2 + soma3 + soma4 + soma5;
printf("\nA soma dos elementos da matriz que não pertencem a diagonal principal nem a diagonal secundaria = %d", somaGeral);
return(0);
}
|
C
|
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define N 100
typedef struct {
int x;
int y;
} vertex;
vertex node_arr[N];
int cmp(const void *p, const void *q){
double *a= (double*)p;
double *b= (double*)q;
if (*a>*b) return -1;
if (*a==*b) return 0;
return 1;
}
int ***record_elements_in_edgesets; //the sets in the paper. x:which set ; y: element in the set ; z: which round
int **which_two_vertice_connected_edge;
/*----------count edge lengh-----------*/
double lengh[N]={0.0},initial_lengh[N]={0.0};
double edgelengh( int vertex_a_x, int vertex_a_y, int vertex_b_x,int vertex_b_y){
double num;
num=(vertex_a_x-vertex_b_x)*(vertex_a_x-vertex_b_x)+(vertex_a_y-vertex_b_y)*(vertex_a_y-vertex_b_y);
num=pow(num,0.5);
printf("num : %f\n",num);
return num;
}
/*----------Edge Crossing-----------*/
/*
int EdgeCrossing(int Q1[],int Q2[]){
int Q1_lengh,Q2_lengh,i=0,j=0;
while(Q1[i]!=0){
Q1_lengh++;i++;
}
while(Q2[j]!=0){
Q2_lengh++;j++;
}
}
*/
/*----------TEST BundlingGain-----------*/
//int BundlingGain(int n)
int m,n;
int main(){
int x,y,i,j;
int graph[N][N]={0};
/*----------input graph-----------*/
//1.vertices
printf("total vertices number : ");
scanf("%d",&n); //n = total number of vertices
for( i = 0 ; i < n ; i++ ){
printf("coordinates_x , coordinates_y : ");
scanf("%d %d",&node_arr[i].x,&node_arr[i].y);
}
printf("---------------------------\n");
for( i = 0 ; i < n; i++ )
printf("%d %d\n", node_arr[i].x, node_arr[i].y );
//1.Edges
for( i = 0 ; i < n ; i++ )
for( j = 0 ; j < n ; j++ ){
graph[i][j]=0;
if(i==j)graph[i][j]=1;
}
printf("total edges number :");
scanf("%d",&m);
which_two_vertice_connected_edge = (int** )malloc(sizeof(int*)*m);
for( i = 0 ; i < m ; i++ )
which_two_vertice_connected_edge[i] = (int*)malloc(sizeof(int)*2);
for( i = 0 ; i < m ; i++ ){
printf("edge %d ( vertex x , vertex y ) = ",i);
scanf("%d %d",&x,&y);
j=0;
which_two_vertice_connected_edge[i][j] = x;
j++;
which_two_vertice_connected_edge[i][j] = y;
lengh[i]=initial_lengh[i]=edgelengh(node_arr[x].x,node_arr[x].y,node_arr[y].x,node_arr[y].y);
printf("lengh : %f\n",lengh[i]);
graph[x][y]=graph[y][x] = 1;
}
//printf(" total vertice are %d\n", n );
for( i = 0 ; i < n ; i++ )
for( j = 0 ; j < n ; j++ ){
//printf("%d" ,graph[i][j]);
if(j == n-1) printf("\n");
}
qsort(lengh,m,sizeof(double),cmp);//edge lengh max to min
for( i = 0; i<m ; i++ ) printf("lengh[%d] =%f\n",i ,lengh[i]);
/*----------record after sort edge lengh max to min coordinates-----------*/
int after_sort_two_vertices_connected_edge[m][2];
i=0,j=0;
int number=0,num=0,count=0;
double tmp;
while(i!=m){
tmp=lengh[i];
while(1){
number++;i++;
if(lengh[i]!=lengh[i-1]) break;
printf("%d\n",i);
}
while(1){
if(initial_lengh[j]==tmp ){
after_sort_two_vertices_connected_edge[num][0] = which_two_vertice_connected_edge[j][0];
after_sort_two_vertices_connected_edge[num][1] = which_two_vertice_connected_edge[j][1];
//printf("which_two_vertice_connected_edge[%d][0]=%d\nwhich_two_vertice_connected_edge[%d][1]=%d\n",j,which_two_vertice_connected_edge[num][0],j,which_two_vertice_connected_edge[num][1]);
//printf("after_sort_vertices_coordinates[%d][0]=%d\nafter_sort_vertices_coordinates[%d][1]=%d\n",num,after_sort_vertices_coordinates[num][0],num,after_sort_vertices_coordinates[num][1]);
num++;
count++;
}
if(number==count)break;
j++;
}
j=0;number=0;count=0;
}
for( i = 0 ; i < m ; i++ ){
printf("aftersort_coordinates_x , aftersort_coordinates_y : ");
printf("%d %d\n",after_sort_two_vertices_connected_edge[i][0],after_sort_two_vertices_connected_edge[i][1]);
}
/*----------Function AgglomerativeBundling-----------*/
/*
int set_arr[n][n];
for( i = 0 ; i < n ; i++ ){
for( j = 0 ; j < n ; j++ ){
if(i == j ) set_arr[i][j]=1;
else set_arr[i][j]=0;
}
}
----------sets in the paper-----------
record_elements_in_edgesets=(int***)malloc(a*sizeof(int**));
for( i = 0 ; i < n; i++)
record_elements_in_edgesets[i] = (int**)malloc(sizeof(int*)*n);
for(i = 0 ; i < n ; i++ )
for(j = 0 ; j < n ; j++ )
record_elements_in_edgesets[i][j]=(int*)malloc(sizeof(int)*n);
for( i = 0 ; i < 10 ; i++ )
for( j = 0 ; j < 10 ; j++ )
for( k = 0 ; k < 10 ; k++ ){
arr[i][j][k]=m;
m++;
}
*/
//count_setarr_i_equal_1_is_n= n-1;
//while(count_setarr_i_equal_1_is_n){
//}
/*----------minimize vertice to bundling vertice-----------*/
/*----------bundling vertice to bundling vertice-----------*/
/*----------minimize bundling vertice to vertice -----------*/
return 0;
}
|
C
|
#include<stdio.h>
#include<openssl/evp.h>
#include<string.h>
int main(int argc, char *argv[])
{
BIO *b = BIO_new_file(argv[1],"r");
int enclen,temp,readed;
if (b==NULL)
{
printf("error");
return 101;
}
char new[255]="";
strcat(new,argv[1]);
strcat(new,".denc");
// printf("\n %s",new);
unsigned char* key ="0123456789";
BIO *nb = BIO_new_file(new,"a+");
const EVP_CIPHER *cipher =EVP_bf_ecb();
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
if (nb=NULL)
{
printf("\nerror");
return 101;
}
FILE *x= fopen(new,"ab");
while (BIO_eof(b) != 1)
{
int enclen=0,temp,readed;
unsigned char encrypted[1024];
unsigned char plaintext[1024];
int read = BIO_read(b,(char *)plaintext,1024);
// printf("\n %d %s",read,plaintext);
EVP_EncryptInit(ctx,cipher,key,0);
EVP_EncryptUpdate(ctx,encrypted,&temp,plaintext,read);
enclen+=temp;
// printf("%d",temp);
EVP_EncryptFinal(ctx,encrypted+temp,&temp);
enclen+=temp;
// printf("\n%d\n",enclen);
fwrite(encrypted,sizeof(unsigned char),enclen,x);
//for(int i=0;i<enclen;i++){
// char m[1024];
// printf("%02x",encrypted[i]);
//BIO_snprintf(m,1024,"%02x",encrypted[i]);
// printf( "\n %d",BIO_write(b,m,2));
// fwrite(decrypted[i],1,2,x);
//printf("%s",m);
// }
// printf("%s",m);
//
}
return 0;
}
|
C
|
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include "ml_eval.h"
dict_t *insert(char *ref, sexp_t *val, dict_t *env) {
dict_t *_env = env;
while (1) {
if (strcmp(_env->varname, ref) == 0) {
destroy_sexp(_env->valexp);
_env->valexp = val;
return env;
}
if (_env->next == NULL)
break;
_env = _env->next;
}
_env->next = (dict_t *) malloc(sizeof(dict_t));
_env->next->valexp = val;
strcpy(_env->next->varname, ref);
_env->next->next = NULL;
return env;
}
bool lookup(char *ref, dict_t *env, sexp_t **ret) {
dict_t *_env = env;
while (_env != NULL) {
if (strcmp(ref, _env->varname) == 0) {
*ret = _env->valexp;
break;
}
_env = _env->next;
}
}
void ml_dump_env(dict_t *env, char resp[BUFSIZ]) {
dict_t *_env = env;
dict_t *next;
while (_env != NULL) {
next = _env->next;
char dbgbuf[BUFSIZ];
print_sexp(dbgbuf, BUFSIZ, _env->valexp);
printf("env/out: %s -> %s\n", _env->varname, dbgbuf);
_env = next;
}
}
void ml_purge_env(dict_t *env) {
dict_t *_env = env;
dict_t *next;
while (_env != NULL) {
next = _env->next;
destroy_sexp(_env->valexp);
free(_env);
_env = next;
}
}
int ml_eval(char **input, char resp[BUFSIZ], dict_t *env) {
size_t len = strlen(*input);
sexp_t *sx = parse_sexp(*input, len);
char *v;
memset(resp, 0, sizeof(*resp));
if (sx->ty != SEXP_LIST || sx->list->ty != SEXP_VALUE) {
print_sexp(resp, BUFSIZ, sx);
return 0;
}
v = sx->list->val;
if (strcmp(v, "define") == 0) {
insert(sx->list->next->val, sx->list->next->next, env);
print_sexp(resp, BUFSIZ, sx->list->next->next);
sx->list->next->next = NULL;
} else if (strcmp(v, "env") == 0) {
sexp_t *out, *vlist, *vptr;
out = new_sexp_list(NULL);
dict_t *_env = env;
dict_t *next;
char r2[BUFSIZ];
memset(r2, 0, BUFSIZ);
while (_env != NULL) {
next = _env->next;
vlist = new_sexp_list(NULL);
if (out->list == NULL) {
out->list = vptr = vlist;
} else {
vptr->next = vlist;
vptr = vlist;
}
vlist->list = new_sexp_atom(_env->varname, strlen(_env->varname), SEXP_BASIC);
vlist->list->next = _env->valexp;
_env = next;
}
print_sexp(resp, BUFSIZ, out);
} else {
sexp_t *ret = NULL;
lookup(v, env, &ret);
print_sexp(resp, BUFSIZ, ret);
}
return 0;
}
|
C
|
#include <stdio.h>
char* gets(char* s) {
char c;
while((c = getchar()) != '\n') {
*s++ = c;
}
*s = '\0';
return s;
}
|
C
|
#include <glib-2.0/glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int readinput(long long input[])
{
FILE* fp = fopen("aoc09.txt", "r");
int idx = 0;
while (fscanf(fp, "%lld", &input[idx]) != EOF)
{
idx++;
fscanf(fp, "%*c");
}
fclose(fp);
return idx;
}
#include "intcode.h"
long long es1()
{
// long long code[] = { 109,1,204,-1,1001,100,1,100,1008,100,16,101,1006,101,0,99 };
// int len = sizeof(code)/sizeof(code[0]);
long long code[100000] = { 0 };
int len = readinput(code);
long long inputs[] = { 1 };
int inputs_len = sizeof(inputs)/sizeof(inputs[0]);
int ip = 0;
int base = 0;
int retcode = INT_MIN;
long long outv = 0;
while (retcode != 0)
{
long long newv = intcode_exec_simple(code, len, inputs, inputs_len, &ip, &retcode, &base);
if (retcode != 0)
outv = newv;
}
return outv;
}
int es2()
{
long long code[100000] = { 0 };
int len = readinput(code);
long long inputs[] = { 2 };
int inputs_len = sizeof(inputs)/sizeof(inputs[0]);
int ip = 0;
int base = 0;
int retcode = INT_MIN;
long long outv = 0;
while (retcode != 0)
{
long long newv = intcode_exec_simple(code, len, inputs, inputs_len, &ip, &retcode, &base);
if (retcode != 0)
outv = newv;
}
return outv;
}
int main()
{
printf("1 -> %lld\n", es1());
printf("2 -> %d\n", es2());
return 0;
}
|
C
|
#define RLED 23 //physical pin 16, red LED
#define GLED 25 //physical pin 22, green LED
#define BUTTON 24 //physical pin 18, spst switch
#define HI 1
#define LOW 0
#define IP 1
#define AP 2
#define UP 1
#define DOWN 2
#define BLINK 0
#define SOLID 1
#define SLOW 350
#define FAST 150
#define TMR_BLINK 0
#include <pigpio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int pressedAt,isPressed;
struct Connection {
int mode;
int state;
int since;
char ip[100];
int ledMode;
int onFor;
int offFor;
int color;
};
struct Connection con;
void checkState (int now) {
char res[100];
memset(res,0,strlen(res));
FILE *fp;
fp=popen("wpa_cli -i wlan0 status|grep 'ip_address'","r");
if (fp==NULL) {
printf("Failed to run command\n");
}
while (fgets(res,sizeof(res)-1,fp)!=NULL) {
}
pclose(fp);
if (strlen(res)>0) {
strncpy(con.ip,res+11,15);
if (con.mode==AP || con.state==DOWN) {
con.since=now;
}
con.mode=IP;
con.state=UP;
} else {
memset(con.ip,0,strlen(con.ip));
if (con.state==UP) {
con.since=now;
}
con.state=DOWN;
}
fp=NULL;
}
void blinkLED () {
gpioWrite(con.color,HI);
gpioDelay(con.onFor*1000);
gpioWrite(con.color,LOW);
}
void solidLED (int pin) {
gpioSetTimerFunc(TMR_BLINK,500,NULL);
gpioWrite(pin,HI);
}
void checkAP () {
printf("checking AP up?\n");
char res[100];
memset(res,0,strlen(res));
FILE *fp;
fp=popen("systemctl status hostapd |grep '(running)'","r");
if (fp==NULL) {
printf("Failed to run command\n");
}
while (fgets(res,sizeof(res)-1,fp)!=NULL) {
}
pclose(fp);
if (strlen(res)>0) {
printf("AP is up!\n");
con.mode=AP;
con.state=UP;
con.color=RLED;
gpioSetTimerFunc(TMR_BLINK,con.onFor,NULL);
//gpioWrite(RLED,HI);
solidLED(con.color);
gpioSetTimerFunc(2,2000,NULL);
}
fp=NULL;
}
void toggleMode() {
printf("toggling, m%d s%d\n",con.mode,con.state);
if (con.mode==AP) {
printf("killing AP, going IP\n");
con.mode=IP;
con.state=DOWN;
con.color=GLED;
con.onFor=SLOW;
con.offFor=SLOW;
gpioWrite(RLED,LOW);
//solidLED(con.color);
gpioSetTimerFunc(TMR_BLINK,con.offFor,blinkLED);
system("/home/pi/killhotspot.sh");
printf("ap stopped\n");
//gpioSetTimerFunc(0,500,NULL);
} else if (con.mode==IP) {
printf("trying to start AP\n");
con.mode=AP;
con.state=DOWN;
con.color=RLED;
con.onFor=FAST;
con.offFor=FAST;
gpioWrite(GLED,LOW);
gpioSetTimerFunc(TMR_BLINK,con.offFor,blinkLED);
gpioSetTimerFunc(2,500,checkAP);
system("/home/pi/hotspot.sh");
//printf("ap started\n");
//gpioSetTimerFunc(0,500,NULL);
}
printf("toggled, m%d s%d\n",con.mode,con.state);
}
void checkPressed(void) {
if (isPressed==HI) {
toggleMode();
gpioSetTimerFunc(1,2000,NULL);
}
}
void readPin (int gpio,int pin_state,uint32_t tick) {
int secs,mics;
gpioTime(PI_TIME_RELATIVE,&secs,&mics);
isPressed=pin_state;
if (pin_state==HI) {
pressedAt=secs;
gpioSetTimerFunc(1,2000,checkPressed);
} else {
gpioSetTimerFunc(1,2000,NULL);
pressedAt=0;
}
}
int main (int arg,char **argv ) {
int secs,mics;
if (gpioInitialise()<0) {
printf("Failed to start gpio on BCM PIN %d\n",RLED);
return 1;
}
printf("Starting on BCM PIN %d\n",RLED);
if (gpioSetAlertFunc(BUTTON,readPin)>0) {
printf("Failed to set alert on BCM PIN %d\n",BUTTON);
return 1;
}
printf("Alert set on BCM PIN %d\n",BUTTON);
gpioSetMode(RLED,PI_OUTPUT);
gpioSetMode(GLED,PI_OUTPUT);
con.mode=IP;
con.state=DOWN;
while (1) {
gpioTime(PI_TIME_RELATIVE,&secs,&mics);
if (con.mode==IP) {
checkState(secs);
}
if (con.mode==IP && con.state==UP) {
gpioSetTimerFunc(TMR_BLINK,500,NULL);
//gpioWrite(GLED,HI);
con.color=GLED;
solidLED(con.color);
gpioWrite(RLED,LOW);
printf("connected: %s (%d)",con.ip,secs);
//gpioDelay(700000);
} else if (con.mode==IP && con.state==DOWN) {
if (secs-con.since>=300) {
printf("no ip 300 seconds, going AP mode %d\n",secs);
//gpioWrite(RLED,LOW);
//gpioWrite(GLED,HI);
//solidLED(con.color);
toggleMode();
} else {
printf("no connection %d\n",secs);
con.onFor=SLOW;
con.offFor=SLOW;
con.color=GLED;
gpioSetTimerFunc(TMR_BLINK,con.offFor,blinkLED);
}
} else if (con.mode==AP && con.state==DOWN) {
printf("setting up AP %d\n",secs);
con.onFor=FAST;
con.offFor=FAST;
con.color=RLED;
gpioSetTimerFunc(TMR_BLINK,con.offFor,blinkLED);
} else if (con.mode==AP && con.state==UP) {
gpioSetTimerFunc(TMR_BLINK,con.offFor,NULL);
con.color=RLED;
solidLED(con.color);
}
fflush(stdout);
gpioDelay(1000000);
}
}
|
C
|
#include "utility_functions.h"
int32_t floatsAlmostEqual(fp_t f1,fp_t f2,fp_t err){
return fabs(f1-f2) < err;
}
// is also used to compare 2d data represented by a 1d array
int32_t compare1dFloatArray(fp_t* values, fp_t* expected_values, uint32_t width, fp_t error) {
uint32_t i;
int32_t return_value = 0;
for(i = 0; i < width; i++){
if(!floatsAlmostEqual(values[i], expected_values[i], error)) {
printf("Error at position %d. Expected: %f, Output: %f\n", i, expected_values[i], values[i]);
return_value = 1;
}
}
return return_value;
}
int32_t compare2dFloatArray(fp_t** values, fp_t** expected_values,
uint32_t height, uint32_t width, fp_t error) {
uint32_t i,j;
int32_t return_value = 0;
for(i = 0; i < height; i++) {
for(j = 0; j < width; j++) {
if(!floatsAlmostEqual(values[i][j], expected_values[i][j], error)){
printf("Error at position (%d,%d). Expected: %f, Output; %f, \n",
i,j, expected_values[i][j], values[i][j]);
return_value = 1;
}
}
}
return return_value;
}
int32_t compare1dIntArray(int32_t* values,int32_t* expected_values,uint32_t width) {
uint32_t i;
int32_t return_value = 0;
for(i = 0; i < width; i++) {
if(values[i] != expected_values[i]) {
printf("Error at position %d. Expected: %d, Output: %d\n", i, expected_values[i], values[i]);
return_value = 1;
}
}
return return_value;
}
void print1dFloatArray_2d(fp_t* array, uint32_t height, uint32_t width) {
uint32_t i,j;
for(i = 0; i < height; i++, printf("\n")){
for(j = 0; j < width; j++) {
printf("%f ", array[i*width + j]);
}
}
}
void print2dFloatArray_3d(fp_t** array, uint32_t depth, uint32_t height, uint32_t width) {
uint32_t i,j,k;
for(i = 0; i < depth; i++,printf("\n\n")) {
for(j = 0; j < height; j++, printf("\n")) {
for(k = 0; k < width; k++) {
printf("%f ", array[i][j*width + k]);
}
}
}
}
void initialize2dFloatArray(fp_t* values, uint32_t num_channels, uint32_t height, uint32_t width, fp_t** channels) {
// uint32_t channel,row,pixel;
//
// for(channel = 0; channel < num_channels;channel++) {
// for(row = 0; row < height;row++) {
// for(pixel= 0; pixel < width; pixel++) {
// channels[channel][width*row+pixel] = values[height*width*channel + width*row + pixel];
// }
// }
// }
}
|
C
|
#include "lists.h"
/**
* sum_dlistint - Add all values of n
* @head: double linked list
*
* Return: value
*/
int sum_dlistint(dlistint_t *head)
{
dlistint_t *tmp = NULL;
int count = 0;
if (head == NULL)
return (0);
tmp = head;
while (tmp != NULL)
{
count += tmp->n;
tmp = tmp->next;
}
return (count);
}
|
C
|
#include <stdio.h>
int div(int a, int b, int *result);
int main()
{
int a = 5;
int b = 6;
printf("----- input 2 number -----\n");
scanf("%d%d", &a, &b);
int c;
if (div(a, b, &c)) {
printf("%d/%d=%d\n", a, b, c);
}
return 0;
}
int div(int a, int b, int *result)
{
int ret = 1;
if (b == 0) {
ret = 0;
}
else {
*result = a/b;
}
printf("hello,world\n");
return ret;
}
|
C
|
main()
{
int arr[] = {1, 2, 3, 123, 4, 5, 6, 456};
int len = sizeof(arr) / sizeof(int);
printf("that array, yeah, that one, well, its size is %d\n",
len);
printf("okay goodbye remember to turn off the heater at night\n");
}
|
C
|
#include <stdio.h>
int main()
{
int n, w, m;
long int a[1000000];
int sum = 0;
scanf("%d %d", &n, &w);
for (int i = 1; i <= n; i++)
{
scanf("%ld", &a[i]);
}
m = n - w + 1;
int j = 1;
while (j <= m)
{
int k=j;
while( k <= (w + j - 1))
{
sum += a[k];
k++;
}
printf("%d ", sum);
sum = 0;
j++;
}
printf("\n");
return 0;
}
|
C
|
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include "../algorithms/m_mergesort.h"
#include "../utils/test_utils.h"
main(int argc, char **argv) {
int fd1, fd2, k;
off_t size;
char *endptr = NULL;
if (argc < 5) {
printf("This test requires a file as the first argument, n_elems as the second, an aux file as the third and k as the fourth\n");
exit(1);
}
size = atoll(argv[2]);
fd1 = open(argv[1], O_RDONLY);
print_file_integers(fd1);
close(fd1);
printf("Sorting...\n");
fd1 = open(argv[1], O_RDWR);
fd2 = open(argv[3], O_RDWR);
k = atoi(argv[4]);
m_mergesort(fd1, fd2, k, size);
lseek(fd1, 0, SEEK_SET);
print_file_integers(fd1);
close(fd1);
close(fd2);
}
|
C
|
#include <stdio.h>
/* Search for `count' distinct odd numbers that
* are smaller than `bound' and add up to `sum'.
*
* Return value:
* 1: A solution is found and printed.
* 0: No solution was found.
*/
int odd_sum(int count, int bound, int sum)
{
if (count <= 0 || bound <= 1 || sum <= 0)
return 0;
/********* base cases *****/
if (count == 1) {
// if only one odd number is allowed,
// it must be sum itself.
// The sum has to be odd and less than bound
// sum & 1 extracts the least significant bit of sum
if (sum < bound && (sum & 1) == 1) {
printf("%d ",sum);
return 1;
}
else
return 0;
}
/********* prepare for recursion *****/
// Note that count is at least 2 if the code reaches here
//
// starting from the largest odd number below min(bound, sum)
// because we have bound to leverage, and we need to print numbers
// in increasing order.
int upper;
// this is a good place to use ?:
if (bound > sum)
upper = sum;
else
upper = bound;
// again, could use ?:
// the largest odd number below odd is either odd - 1 or odd - 2
if (upper & 1)
upper -= 2; // if upper is odd
else
upper -= 1;
/********* try to reduce search space before recursion *****/
// The parity has to match.
// count and sum must be odd or even at the same time.
if ((count ^ sum) & 1)
return 0;
// the sum of the smallest count odd integers must <= sum
// the sum of first n odd integers is n*n.
if (count * count > sum)
return 0;
int n_odd = (upper + 1) / 2; // number of odd numbers <= upper
if (n_odd < count) // not enough odd numbers
return 0;
// the max sum of count odd integers <= upper must be >= sum
if ((n_odd * n_odd) - (n_odd - count) * (n_odd - count) < sum)
return 0;
/********* recursion *************/
// try to find (count - 1) odd numbers that are less than upper and add up to sum - upper
if (odd_sum(count - 1, upper, sum - upper)) {
printf("%d ", upper);
return 1;
}
// then the solution must not include upper
return odd_sum(count, upper, sum);
}
/* Do not change the main() function */
int main(void)
{
int value;
int c, b, s;
printf("Please enter 3 positive integers: count, bound, and sum:\n");
if (scanf("%d%d%d", &c, &b, &s) != 3) {
printf("Please enter 3 integers.\n");
return 1;
}
if (c <= 0 || b <= 0 || s <= 0) {
printf("Integers must be positive.\n");
return 1;
}
value = odd_sum(c, b, s);
if (value)
printf("\n");
else
printf("There are no solutions.\n");
return 0;
}
|
C
|
#include "api.h"
void * xMalloc( size_t size)
{
return malloc( size);
}
void xFree( void * ptr)
{
free( ptr);
}
void * xRealloc( void * ptr, size_t size)
{
return realloc( ptr, size);
}
void * xDup( void * src, size_t size)
{
void * ret= xMalloc( size);
memcpy( ret, src, size);
return ret;
}
|
C
|
#include <stdio.h>
#include "stm32f4xx.h" // Device header
#include "stm32f4xx_conf.h"
#include "keypad_manager.h"
#include "seven_segmen_display.h"
#include "math.h"
/*
Pin Assignment:
1- First transistor - PE8
2- Second transistor - PE9
6 - Third transistor - PE10
A
F B
G
E C
D
A 14 PC2
B 16 PE7
C 13 PA1
D 3 PA2
E 5 PC4
F 11 PA3
G 15 PC1
DP 7 PC5
*/
char nthdigit(int x, int n);
void display_controller(int number_to_display, int segment); //local function decoding numbers or characters to display segments
//Initializes GPIOS used for seven segment display
void initialize_seven_segment_display(){
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
//initialize GPIOA
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//initialize GPIOC
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_4|GPIO_Pin_5;
GPIO_Init(GPIOC, &GPIO_InitStructure);
//initialize GPIOE
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12;
GPIO_Init(GPIOE, &GPIO_InitStructure);
//temp set all to 1
GPIO_SetBits(GPIOA, GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
GPIO_SetBits(GPIOC, GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_4|GPIO_Pin_5);
GPIO_SetBits(GPIOE, GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11);
}
//Function used to display the angle a user entered, integer between 0 to 180
void display_user_angle(uint32_t angle, int segment){
uint32_t digits_to_display[3];
digits_to_display[0] = angle/100;
digits_to_display[1] = (angle/10)%10;
digits_to_display[2] = angle%10;
if (segment == 1) {
display_controller(digits_to_display[0], 1);
}
else if (segment == 2) {
display_controller(digits_to_display[1], 2);
}
else if (segment == 2) {
display_controller(digits_to_display[2], 3);
}
}
//Function used to display a float measured angle according to spec format including decimal point
void display_measured_angle(float angle, int segment){
uint32_t digits_to_display[4];
uint32_t temp_angle; //used to store the angle in integer format
if (angle >= 100) {
temp_angle = (unsigned int)angle;
digits_to_display[0] = 1;
digits_to_display[1] = (temp_angle-100)/10; //get second digit
digits_to_display[2] = (temp_angle-100) % 10; //get third digit
if (segment == 1) {
display_controller(digits_to_display[0], segment);
}
else if (segment == 2) {
display_controller(digits_to_display[1], segment);
}
else if (segment == 3) {
display_controller(digits_to_display[2], segment);
}
}
else if (10 <= angle < 100) {
//multiply angle by 10 to make it in the format XXX.YYYY
angle = angle *10;
//change the angle to integer format
temp_angle = (unsigned int)angle; //cast it to an integer to get digits left of decimal point
digits_to_display[0] = temp_angle/100; //get third digit
digits_to_display[1] = (temp_angle%100)/10; //get second digit
digits_to_display[2] = (temp_angle%100)%10; //get third digit
if (segment == 1) {
display_controller(digits_to_display[0], segment);
}
else if (segment == 2) {
display_controller(digits_to_display[1], segment);
display_controller(10, segment); //display dot
}
else if (segment == 3) {
display_controller(digits_to_display[2], segment);
}
}
else if (0 <= angle <10) {
//multiply angle by 100 to make it in the format XXX.YYYY
angle = angle * 100;
temp_angle = (int)angle; //cast it to an integer to get digits left of decimal point
digits_to_display[0] = temp_angle/100; //get third digit
digits_to_display[1] = (temp_angle%100)/10; //get second digit
digits_to_display[2] = (temp_angle%100)%10; //get first digit
if (segment == 1) {
display_controller(digits_to_display[0], segment);
display_controller(10, segment); //display dot
}
else if (segment == 2) {
display_controller(digits_to_display[1], segment);
}
else if (segment == 3) {
display_controller(digits_to_display[2], segment);
}
}
}
//Displays the word up
void display_up(){
static uint8_t letter = 0;
if (letter == 0){
display_controller(11,1);
}
if (letter == 1) {
display_controller(12,2);
}
letter = !letter;
}
//Displays the word dn
void display_down(){
static uint8_t letter = 0;
if (letter == 0){
display_controller(13,1);
}
if (letter == 1) {
display_controller(14,2);
}
letter = !letter;
}
void display_controller(int number_to_display, int segment){
if (segment == 1){
GPIO_WriteBit(GPIOE, GPIO_Pin_8, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_9, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_10, Bit_RESET);
}
else if (segment == 2) {
GPIO_WriteBit(GPIOE, GPIO_Pin_8, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_9, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_10, Bit_RESET);
}
else if (segment == 3) {
GPIO_WriteBit(GPIOE, GPIO_Pin_8, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_9, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_10, Bit_SET);
}
if (number_to_display == 0){
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 1) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 2) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 3) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 4) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 5) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 6) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 7) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 8) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 9) {
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET); //dot
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 10){
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_SET);
}
else if (number_to_display == 11){
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_RESET);
}
else if (number_to_display == 12){
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_RESET);
}
else if (number_to_display == 13){
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_RESET);
}
else if (number_to_display == 14){
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_SET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_SET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_SET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_RESET);
}
}
void turn_OFF_Display(){
GPIO_WriteBit(GPIOE, GPIO_Pin_8, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_9, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_10, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_7, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_2, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_4, Bit_RESET);
GPIO_WriteBit(GPIOA, GPIO_Pin_3, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_1, Bit_RESET);
GPIO_WriteBit(GPIOC, GPIO_Pin_5, Bit_RESET);
GPIO_WriteBit(GPIOE, GPIO_Pin_12, Bit_RESET);
}
char nthdigit(int x, int n){
while (n--) {
x /= 10;
}
return (x % 10) + '0';
}
|
C
|
//flexible array members
#include <stdio.h>
#include <mm_malloc.h>
#include <time.h>
struct s {
int arraySize;
int array[];
};
int main() {
int desiredSize;
time_t t;
srand((int) time(&t));
printf("Enter the number of elements you wish to store:\n");
scanf("%d",&desiredSize);
struct s *ptr;
ptr = malloc(/*{*/ sizeof(struct s)/*}size of the rest of s*/ +/*{*/desiredSize * sizeof(int)/*}size of flexible array int*/);
for (int i=0; i< desiredSize; i++)
{
ptr->array[i]=rand() %100;
}
for (int i=0; i<desiredSize; i++)
{
printf("the %d element was %d\n",i+1,ptr ->array[i]);
}
free(ptr);
}
|
C
|
/*#include <stdio.h>
int main()
{
int a_num, b_num, c_num, result;
printf("3 ԷϽÿ: ");
scanf_s("%d %d %d", &a_num, &b_num, &c_num);
if (a_num < b_num) // ù° ڿ ι° ڸ Ѵ.
{
if (a_num < c_num) // ù° ڿ ° ڸ Ѵ.
result = a_num;
else
result = c_num;
}
else
{
if (b_num < c_num) // ι° ڿ ° ڸ Ѵ.
result = b_num;
else
result = c_num;
}
printf(" %dԴϴ.", result);
return 0;
}*/
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.