Complex Vector

profileBebo23
Completvector.zip

Complet vector/.dep.inc

# This code depends on make tool being used DEPFILES=$(wildcard $(addsuffix .d, ${OBJECTFILES} ${TESTOBJECTFILES})) ifneq (${DEPFILES},) include ${DEPFILES} endif

Complet vector/build/Debug/Cygwin-Windows/main.o

Complet vector/build/Debug/Cygwin-Windows/main.o.d

build/Debug/Cygwin-Windows/main.o: main.cpp SimpleVector.h SimpleVector.h:

Complet vector/dist/Debug/Cygwin-Windows/complet_vector.exe

Complet vector/main.cpp

Complet vector/main.cpp

/* 
 * File:   main.cpp
 * Author: Bebo
 * Created on April 8, 2019, 6:18 PM
 * Purpose:Complex Vector
 */

#include   < cstdlib >
#include   "SimpleVector.h"
//System Libraries
#include   < iostream >   //Input/Output Library
using   namespace  std ;
//User Libraries
//Global Constants, no Global Variables are allowed
//Math/Physics/Conversions/Higher Dimensions - i.e. PI, e, etc...
//Function Prototypes
void  fillVec ( SimpleVector < int >   & );
void  addVec ( SimpleVector < int >   & );
void  delVec ( SimpleVector < int >   & );
void  prntVec ( SimpleVector < int >   & , int );
//Execution Begins Here!
int  main ( int  argc ,   char **  argv )   {
     //Declare Variables
     int  size ;
     //Read in the size
    cout << "What size vector to test?" << endl ;
    cin >> size ;
     SimpleVector < int >  sv ( size );
     //Initialize or input i.e. set variable values
    fillVec ( sv );
     //Display the outputs
    prntVec ( sv , 10 );
     //Add and subtract from the vector
    addVec ( sv );
     //Display the outputs
    prntVec ( sv , 10 );
     //Add and subtract from the vector
    delVec ( sv );
     //Display the outputs
    prntVec ( sv , 10 );
     //Exit stage right or left!
     return   0 ;
}
void  addVec ( SimpleVector < int >   & sv ){
     int  add = sv . size () * 0.1 ;
     for ( int  i = 1 ; i <= add ; i ++ ){
        sv . push_front ( i + add - 1 );
        sv . push_back ( i - add );
     }
}
void  delVec ( SimpleVector < int >   & sv ){
     int  del = sv . size () * 0.2 ;
     for ( int  i = 1 ; i <= del ; i ++ ){
        sv . pop_front ();
        sv . pop_back ();
     }
}
void  fillVec ( SimpleVector < int >   & sv ){
     for ( int  i = 0 ; i < sv . size (); i ++ ){
        sv [ i ] = i % 10 ;
     }
}
void  prntVec ( SimpleVector < int >   & sv , int  n ){
    cout << endl ;
     for ( int  i = 0 ; i < sv . size (); i ++ ){
        cout << sv [ i ] << " " ;
         if ( i % n == ( n - 1 )) cout << endl ;
     }
    cout << endl ;
}

Complet vector/Makefile

# # There exist several targets which are by default empty and which can be # used for execution of your targets. These targets are usually executed # before and after some main targets. They are: # # .build-pre: called before 'build' target # .build-post: called after 'build' target # .clean-pre: called before 'clean' target # .clean-post: called after 'clean' target # .clobber-pre: called before 'clobber' target # .clobber-post: called after 'clobber' target # .all-pre: called before 'all' target # .all-post: called after 'all' target # .help-pre: called before 'help' target # .help-post: called after 'help' target # # Targets beginning with '.' are not intended to be called on their own. # # Main targets can be executed directly, and they are: # # build build a specific configuration # clean remove built files from a configuration # clobber remove all built files # all build all configurations # help print help mesage # # Targets .build-impl, .clean-impl, .clobber-impl, .all-impl, and # .help-impl are implemented in nbproject/makefile-impl.mk. # # Available make variables: # # CND_BASEDIR base directory for relative paths # CND_DISTDIR default top distribution directory (build artifacts) # CND_BUILDDIR default top build directory (object files, ...) # CONF name of current configuration # CND_PLATFORM_${CONF} platform name (current configuration) # CND_ARTIFACT_DIR_${CONF} directory of build artifact (current configuration) # CND_ARTIFACT_NAME_${CONF} name of build artifact (current configuration) # CND_ARTIFACT_PATH_${CONF} path to build artifact (current configuration) # CND_PACKAGE_DIR_${CONF} directory of package (current configuration) # CND_PACKAGE_NAME_${CONF} name of package (current configuration) # CND_PACKAGE_PATH_${CONF} path to package (current configuration) # # NOCDDL # Environment MKDIR=mkdir CP=cp CCADMIN=CCadmin # build build: .build-post .build-pre: # Add your pre 'build' code here... .build-post: .build-impl # Add your post 'build' code here... # clean clean: .clean-post .clean-pre: # Add your pre 'clean' code here... .clean-post: .clean-impl # Add your post 'clean' code here... # clobber clobber: .clobber-post .clobber-pre: # Add your pre 'clobber' code here... .clobber-post: .clobber-impl # Add your post 'clobber' code here... # all all: .all-post .all-pre: # Add your pre 'all' code here... .all-post: .all-impl # Add your post 'all' code here... # build tests build-tests: .build-tests-post .build-tests-pre: # Add your pre 'build-tests' code here... .build-tests-post: .build-tests-impl # Add your post 'build-tests' code here... # run tests test: .test-post .test-pre: build-tests # Add your pre 'test' code here... .test-post: .test-impl # Add your post 'test' code here... # help help: .help-post .help-pre: # Add your pre 'help' code here... .help-post: .help-impl # Add your post 'help' code here... # include project implementation makefile include nbproject/Makefile-impl.mk # include project make variables include nbproject/Makefile-variables.mk

Complet vector/nbproject/configurations.xml

SimpleVector.h main.cpp Makefile Makefile default true false default true false 5 5 5 5

Complet vector/nbproject/Makefile-Debug.mk

# # Generated Makefile - do not edit! # # Edit the Makefile in the project folder instead (../Makefile). Each target # has a -pre and a -post target defined where you can add customized code. # # This makefile implements configuration specific macros and targets. # Environment MKDIR=mkdir CP=cp GREP=grep NM=nm CCADMIN=CCadmin RANLIB=ranlib CC=gcc CCC=g++ CXX=g++ FC=gfortran AS=as # Macros CND_PLATFORM=Cygwin-Windows CND_DLIB_EXT=dll CND_CONF=Debug CND_DISTDIR=dist CND_BUILDDIR=build # Include project Makefile include Makefile # Object Directory OBJECTDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM} # Object Files OBJECTFILES= \ ${OBJECTDIR}/main.o # C Compiler Flags CFLAGS= # CC Compiler Flags CCFLAGS= CXXFLAGS= # Fortran Compiler Flags FFLAGS= # Assembler Flags ASFLAGS= # Link Libraries and Options LDLIBSOPTIONS= # Build Targets .build-conf: ${BUILD_SUBPROJECTS} "${MAKE}" -f nbproject/Makefile-${CND_CONF}.mk ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/complet_vector.exe ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/complet_vector.exe: ${OBJECTFILES} ${MKDIR} -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM} ${LINK.cc} -o ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/complet_vector ${OBJECTFILES} ${LDLIBSOPTIONS} ${OBJECTDIR}/main.o: main.cpp ${MKDIR} -p ${OBJECTDIR} ${RM} "[email protected]" $(COMPILE.cc) -g -MMD -MP -MF "[email protected]" -o ${OBJECTDIR}/main.o main.cpp # Subprojects .build-subprojects: # Clean Targets .clean-conf: ${CLEAN_SUBPROJECTS} ${RM} -r ${CND_BUILDDIR}/${CND_CONF} # Subprojects .clean-subprojects: # Enable dependency checking .dep.inc: .depcheck-impl include .dep.inc

Complet vector/nbproject/Makefile-impl.mk

# # Generated Makefile - do not edit! # # Edit the Makefile in the project folder instead (../Makefile). Each target # has a pre- and a post- target defined where you can add customization code. # # This makefile implements macros and targets common to all configurations. # # NOCDDL # Building and Cleaning subprojects are done by default, but can be controlled with the SUB # macro. If SUB=no, subprojects will not be built or cleaned. The following macro # statements set BUILD_SUB-CONF and CLEAN_SUB-CONF to .build-reqprojects-conf # and .clean-reqprojects-conf unless SUB has the value 'no' SUB_no=NO SUBPROJECTS=${SUB_${SUB}} BUILD_SUBPROJECTS_=.build-subprojects BUILD_SUBPROJECTS_NO= BUILD_SUBPROJECTS=${BUILD_SUBPROJECTS_${SUBPROJECTS}} CLEAN_SUBPROJECTS_=.clean-subprojects CLEAN_SUBPROJECTS_NO= CLEAN_SUBPROJECTS=${CLEAN_SUBPROJECTS_${SUBPROJECTS}} # Project Name PROJECTNAME=Complet vector # Active Configuration DEFAULTCONF=Debug CONF=${DEFAULTCONF} # All Configurations ALLCONFS=Debug Release # build .build-impl: .build-pre .validate-impl .depcheck-impl @#echo "=> Running $@... Configuration=$(CONF)" "${MAKE}" -f nbproject/Makefile-${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .build-conf # clean .clean-impl: .clean-pre .validate-impl .depcheck-impl @#echo "=> Running $@... Configuration=$(CONF)" "${MAKE}" -f nbproject/Makefile-${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .clean-conf # clobber .clobber-impl: .clobber-pre .depcheck-impl @#echo "=> Running $@..." for CONF in ${ALLCONFS}; \ do \ "${MAKE}" -f nbproject/Makefile-$${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .clean-conf; \ done # all .all-impl: .all-pre .depcheck-impl @#echo "=> Running $@..." for CONF in ${ALLCONFS}; \ do \ "${MAKE}" -f nbproject/Makefile-$${CONF}.mk QMAKE=${QMAKE} SUBPROJECTS=${SUBPROJECTS} .build-conf; \ done # build tests .build-tests-impl: .build-impl .build-tests-pre @#echo "=> Running $@... Configuration=$(CONF)" "${MAKE}" -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .build-tests-conf # run tests .test-impl: .build-tests-impl .test-pre @#echo "=> Running $@... Configuration=$(CONF)" "${MAKE}" -f nbproject/Makefile-${CONF}.mk SUBPROJECTS=${SUBPROJECTS} .test-conf # dependency checking support .depcheck-impl: @echo "# This code depends on make tool being used" >.dep.inc @if [ -n "${MAKE_VERSION}" ]; then \ echo "DEPFILES=\$$(wildcard \$$(addsuffix .d, \$${OBJECTFILES} \$${TESTOBJECTFILES}))" >>.dep.inc; \ echo "ifneq (\$${DEPFILES},)" >>.dep.inc; \ echo "include \$${DEPFILES}" >>.dep.inc; \ echo "endif" >>.dep.inc; \ else \ echo ".KEEP_STATE:" >>.dep.inc; \ echo ".KEEP_STATE_FILE:.make.state.\$${CONF}" >>.dep.inc; \ fi # configuration validation .validate-impl: @if [ ! -f nbproject/Makefile-${CONF}.mk ]; \ then \ echo ""; \ echo "Error: can not find the makefile for configuration '${CONF}' in project ${PROJECTNAME}"; \ echo "See 'make help' for details."; \ echo "Current directory: " `pwd`; \ echo ""; \ fi @if [ ! -f nbproject/Makefile-${CONF}.mk ]; \ then \ exit 1; \ fi # help .help-impl: .help-pre @echo "This makefile supports the following configurations:" @echo " ${ALLCONFS}" @echo "" @echo "and the following targets:" @echo " build (default target)" @echo " clean" @echo " clobber" @echo " all" @echo " help" @echo "" @echo "Makefile Usage:" @echo " make [CONF=<CONFIGURATION>] [SUB=no] build" @echo " make [CONF=<CONFIGURATION>] [SUB=no] clean" @echo " make [SUB=no] clobber" @echo " make [SUB=no] all" @echo " make help" @echo "" @echo "Target 'build' will build a specific configuration and, unless 'SUB=no'," @echo " also build subprojects." @echo "Target 'clean' will clean a specific configuration and, unless 'SUB=no'," @echo " also clean subprojects." @echo "Target 'clobber' will remove all built files from all configurations and," @echo " unless 'SUB=no', also from subprojects." @echo "Target 'all' will will build all configurations and, unless 'SUB=no'," @echo " also build subprojects." @echo "Target 'help' prints this message." @echo ""

Complet vector/nbproject/Makefile-Release.mk

# # Generated Makefile - do not edit! # # Edit the Makefile in the project folder instead (../Makefile). Each target # has a -pre and a -post target defined where you can add customized code. # # This makefile implements configuration specific macros and targets. # Environment MKDIR=mkdir CP=cp GREP=grep NM=nm CCADMIN=CCadmin RANLIB=ranlib CC=gcc CCC=g++ CXX=g++ FC=gfortran AS=as # Macros CND_PLATFORM=Cygwin-Windows CND_DLIB_EXT=dll CND_CONF=Release CND_DISTDIR=dist CND_BUILDDIR=build # Include project Makefile include Makefile # Object Directory OBJECTDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM} # Object Files OBJECTFILES= \ ${OBJECTDIR}/main.o # C Compiler Flags CFLAGS= # CC Compiler Flags CCFLAGS= CXXFLAGS= # Fortran Compiler Flags FFLAGS= # Assembler Flags ASFLAGS= # Link Libraries and Options LDLIBSOPTIONS= # Build Targets .build-conf: ${BUILD_SUBPROJECTS} "${MAKE}" -f nbproject/Makefile-${CND_CONF}.mk ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/complet_vector.exe ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/complet_vector.exe: ${OBJECTFILES} ${MKDIR} -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM} ${LINK.cc} -o ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/complet_vector ${OBJECTFILES} ${LDLIBSOPTIONS} ${OBJECTDIR}/main.o: main.cpp ${MKDIR} -p ${OBJECTDIR} ${RM} "[email protected]" $(COMPILE.cc) -O2 -MMD -MP -MF "[email protected]" -o ${OBJECTDIR}/main.o main.cpp # Subprojects .build-subprojects: # Clean Targets .clean-conf: ${CLEAN_SUBPROJECTS} ${RM} -r ${CND_BUILDDIR}/${CND_CONF} # Subprojects .clean-subprojects: # Enable dependency checking .dep.inc: .depcheck-impl include .dep.inc

Complet vector/nbproject/Makefile-variables.mk

# # Generated - do not edit! # # NOCDDL # CND_BASEDIR=`pwd` CND_BUILDDIR=build CND_DISTDIR=dist # Debug configuration CND_PLATFORM_Debug=Cygwin-Windows CND_ARTIFACT_DIR_Debug=dist/Debug/Cygwin-Windows CND_ARTIFACT_NAME_Debug=complet_vector CND_ARTIFACT_PATH_Debug=dist/Debug/Cygwin-Windows/complet_vector CND_PACKAGE_DIR_Debug=dist/Debug/Cygwin-Windows/package CND_PACKAGE_NAME_Debug=completvector.tar CND_PACKAGE_PATH_Debug=dist/Debug/Cygwin-Windows/package/completvector.tar # Release configuration CND_PLATFORM_Release=Cygwin-Windows CND_ARTIFACT_DIR_Release=dist/Release/Cygwin-Windows CND_ARTIFACT_NAME_Release=complet_vector CND_ARTIFACT_PATH_Release=dist/Release/Cygwin-Windows/complet_vector CND_PACKAGE_DIR_Release=dist/Release/Cygwin-Windows/package CND_PACKAGE_NAME_Release=completvector.tar CND_PACKAGE_PATH_Release=dist/Release/Cygwin-Windows/package/completvector.tar # # include compiler specific variables # # dmake command ROOT:sh = test -f nbproject/private/Makefile-variables.mk || \ (mkdir -p nbproject/private && touch nbproject/private/Makefile-variables.mk) # # gmake command .PHONY: $(shell test -f nbproject/private/Makefile-variables.mk || (mkdir -p nbproject/private && touch nbproject/private/Makefile-variables.mk)) # include nbproject/private/Makefile-variables.mk

Complet vector/nbproject/Package-Debug.bash

#!/bin/bash -x # # Generated - do not edit! # # Macros TOP=`pwd` CND_PLATFORM=Cygwin-Windows CND_CONF=Debug CND_DISTDIR=dist CND_BUILDDIR=build CND_DLIB_EXT=dll NBTMPDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM}/tmp-packaging TMPDIRNAME=tmp-packaging OUTPUT_PATH=${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/complet_vector OUTPUT_BASENAME=complet_vector PACKAGE_TOP_DIR=completvector/ # Functions function checkReturnCode { rc=$? if [ $rc != 0 ] then exit $rc fi } function makeDirectory # $1 directory path # $2 permission (optional) { mkdir -p "$1" checkReturnCode if [ "$2" != "" ] then chmod $2 "$1" checkReturnCode fi } function copyFileToTmpDir # $1 from-file path # $2 to-file path # $3 permission { cp "$1" "$2" checkReturnCode if [ "$3" != "" ] then chmod $3 "$2" checkReturnCode fi } # Setup cd "${TOP}" mkdir -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package rm -rf ${NBTMPDIR} mkdir -p ${NBTMPDIR} # Copy files and create directories and links cd "${TOP}" makeDirectory "${NBTMPDIR}/completvector/bin" copyFileToTmpDir "${OUTPUT_PATH}.exe" "${NBTMPDIR}/${PACKAGE_TOP_DIR}bin/${OUTPUT_BASENAME}.exe" 0755 # Generate tar file cd "${TOP}" rm -f ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/completvector.tar cd ${NBTMPDIR} tar -vcf ../../../../${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/completvector.tar * checkReturnCode # Cleanup cd "${TOP}" rm -rf ${NBTMPDIR}

Complet vector/nbproject/Package-Release.bash

#!/bin/bash -x # # Generated - do not edit! # # Macros TOP=`pwd` CND_PLATFORM=Cygwin-Windows CND_CONF=Release CND_DISTDIR=dist CND_BUILDDIR=build CND_DLIB_EXT=dll NBTMPDIR=${CND_BUILDDIR}/${CND_CONF}/${CND_PLATFORM}/tmp-packaging TMPDIRNAME=tmp-packaging OUTPUT_PATH=${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/complet_vector OUTPUT_BASENAME=complet_vector PACKAGE_TOP_DIR=completvector/ # Functions function checkReturnCode { rc=$? if [ $rc != 0 ] then exit $rc fi } function makeDirectory # $1 directory path # $2 permission (optional) { mkdir -p "$1" checkReturnCode if [ "$2" != "" ] then chmod $2 "$1" checkReturnCode fi } function copyFileToTmpDir # $1 from-file path # $2 to-file path # $3 permission { cp "$1" "$2" checkReturnCode if [ "$3" != "" ] then chmod $3 "$2" checkReturnCode fi } # Setup cd "${TOP}" mkdir -p ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package rm -rf ${NBTMPDIR} mkdir -p ${NBTMPDIR} # Copy files and create directories and links cd "${TOP}" makeDirectory "${NBTMPDIR}/completvector/bin" copyFileToTmpDir "${OUTPUT_PATH}.exe" "${NBTMPDIR}/${PACKAGE_TOP_DIR}bin/${OUTPUT_BASENAME}.exe" 0755 # Generate tar file cd "${TOP}" rm -f ${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/completvector.tar cd ${NBTMPDIR} tar -vcf ../../../../${CND_DISTDIR}/${CND_CONF}/${CND_PLATFORM}/package/completvector.tar * checkReturnCode # Cleanup cd "${TOP}" rm -rf ${NBTMPDIR}

Complet vector/nbproject/private/c_standard_headers_indexer.c

/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved. * * Oracle and Java are registered trademarks of Oracle and/or its affiliates. * Other names may be trademarks of their respective owners. * * The contents of this file are subject to the terms of either the GNU * General Public License Version 2 only ("GPL") or the Common * Development and Distribution License("CDDL") (collectively, the * "License"). You may not use this file except in compliance with the * License. You can obtain a copy of the License at * http://www.netbeans.org/cddl-gplv2.html * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the * specific language governing permissions and limitations under the * License. When distributing the software, include this License Header * Notice in each file and include the License file at * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the GPL Version 2 section of the License file that * accompanied this code. If applicable, add the following below the * License Header, with the fields enclosed by brackets [] replaced by * your own identifying information: * "Portions Copyrighted [year] [name of copyright owner]" * * If you wish your version of this file to be governed by only the CDDL * or only the GPL Version 2, indicate your decision by adding * "[Contributor] elects to include this software in this distribution * under the [CDDL or GPL Version 2] license." If you do not indicate a * single choice of license, a recipient has the option to distribute * your version of this file under either the CDDL, the GPL Version 2 or * to extend the choice of license to its licensees as provided above. * However, if you add GPL Version 2 code and therefore, elected the GPL * Version 2 license, then the option applies only if the new code is * made subject to such option by the copyright holder. * * Contributor(s): */ // List of standard headers was taken in http://en.cppreference.com/w/c/header #include <assert.h> // Conditionally compiled macro that compares its argument to zero #include <ctype.h> // Functions to determine the type contained in character data #include <errno.h> // Macros reporting error conditions #include <float.h> // Limits of float types #include <limits.h> // Sizes of basic types #include <locale.h> // Localization utilities #include <math.h> // Common mathematics functions #include <setjmp.h> // Nonlocal jumps #include <signal.h> // Signal handling #include <stdarg.h> // Variable arguments #include <stddef.h> // Common macro definitions #include <stdio.h> // Input/output #include <string.h> // String handling #include <stdlib.h> // General utilities: memory management, program utilities, string conversions, random numbers #include <time.h> // Time/date utilities #include <iso646.h> // (since C95) Alternative operator spellings #include <wchar.h> // (since C95) Extended multibyte and wide character utilities #include <wctype.h> // (since C95) Wide character classification and mapping utilities #ifdef _STDC_C99 #include <complex.h> // (since C99) Complex number arithmetic #include <fenv.h> // (since C99) Floating-point environment #include <inttypes.h> // (since C99) Format conversion of integer types #include <stdbool.h> // (since C99) Boolean type #include <stdint.h> // (since C99) Fixed-width integer types #include <tgmath.h> // (since C99) Type-generic math (macros wrapping math.h and complex.h) #endif #ifdef _STDC_C11 #include <stdalign.h> // (since C11) alignas and alignof convenience macros #include <stdatomic.h> // (since C11) Atomic types #include <stdnoreturn.h> // (since C11) noreturn convenience macros #include <threads.h> // (since C11) Thread library #include <uchar.h> // (since C11) UTF-16 and UTF-32 character utilities #endif

Complet vector/nbproject/private/configurations.xml

Makefile localhost 3 gdb "${OUTPUT_PATH}" "${OUTPUT_PATH}" true 0 0 localhost 3 gdb "${OUTPUT_PATH}" "${OUTPUT_PATH}" true 0 0

Complet vector/nbproject/private/cpp_standard_headers_indexer.cpp

Complet vector/nbproject/private/cpp_standard_headers_indexer.cpp

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 */

// List of standard headers was taken in http://en.cppreference.com/w/cpp/header

#include   < cstdlib >        // General purpose utilities: program control, dynamic memory allocation, random numbers, sort and search
#include   < csignal >        // Functions and macro constants for signal management
#include   < csetjmp >        // Macro (and function) that saves (and jumps) to an execution context
#include   < cstdarg >        // Handling of variable length argument lists
#include   < typeinfo >           // Runtime type information utilities
#include   < bitset >         // std::bitset class template
#include   < functional >         // Function objects, designed for use with the standard algorithms
#include   < utility >        // Various utility components
#include   < ctime >          // C-style time/date utilites
#include   < cstddef >        // typedefs for types such as size_t, NULL and others
#include   < new >                // Low-level memory management utilities
#include   < memory >         // Higher level memory management utilities
#include   < climits >            // limits of integral types
#include   < cfloat >         // limits of float types
#include   < limits >         // standardized way to query properties of arithmetic types
#include   < exception >          // Exception handling utilities
#include   < stdexcept >          // Standard exception objects
#include   < cassert >        // Conditionally compiled macro that compares its argument to zero
#include   < cerrno >             // Macro containing the last error number
#include   < cctype >             // functions to determine the type contained in character data
#include   < cwctype >            // functions for determining the type of wide character data
#include   < cstring >        // various narrow character string handling functions
#include   < cwchar >         // various wide and multibyte string handling functions
#include   < string >         // std::basic_string class template
#include   < vector >         // std::vector container
#include   < deque >          // std::deque container
#include   < list >           // std::list container
#include   < set >                // std::set and std::multiset associative containers
#include   < map >                // std::map and std::multimap associative containers
#include   < stack >          // std::stack container adaptor
#include   < queue >          // std::queue and std::priority_queue container adaptors
#include   < algorithm >          // Algorithms that operate on containers
#include   < iterator >           // Container iterators
#include   < cmath >              // Common mathematics functions
#include   < complex >            // Complex number type
#include   < valarray >           // Class for representing and manipulating arrays of values
#include   < numeric >            // Numeric operations on values in containers
#include   < iosfwd >             // forward declarations of all classes in the input/output library
#include   < ios >                // std::ios_base class, std::basic_ios class template and several typedefs
#include   < istream >            // std::basic_istream class template and several typedefs
#include   < ostream >            // std::basic_ostream, std::basic_iostream class templates and several typedefs
#include   < iostream >           // several standard stream objects
#include   < fstream >            // std::basic_fstream, std::basic_ifstream, std::basic_ofstream class templates and several typedefs
#include   < sstream >            // std::basic_stringstream, std::basic_istringstream, std::basic_ostringstream class templates and several typedefs
#include   < strstream >          // std::strstream, std::istrstream, std::ostrstream(deprecated)
#include   < iomanip >            // Helper functions to control the format or input and output
#include   < streambuf >          // std::basic_streambuf class template
#include   < cstdio >             // C-style input-output functions
#include   < locale >             // Localization utilities
#include   < clocale >            // C localization utilities
#include   < ciso646 >            // empty header. The macros that appear in iso646.h in C are keywords in C++
#if  __cplusplus  >=   201103L
#include   < typeindex >          // (since C++11)    std::type_index
#include   < type_traits >        // (since C++11)    Compile-time type information
#include   < chrono >             // (since C++11)    C++ time utilites
#include   < initializer_list >   // (since C++11)    std::initializer_list class template
#include   < tuple >              // (since C++11)    std::tuple class template
#include   < scoped_allocator >   // (since C++11)    Nested allocator class
#include   < cstdint >            // (since C++11)    fixed-size types and limits of other types
#include   < cinttypes >          // (since C++11)    formatting macros , intmax_t and uintmax_t math and conversions
#include   < system_error >       // (since C++11)    defines std::error_code, a platform-dependent error code
#include   < cuchar >             // (since C++11)    C-style Unicode character conversion functions
#include   < array >              // (since C++11)    std::array container
#include   < forward_list >       // (since C++11)    std::forward_list container
#include   < unordered_set >      // (since C++11)    std::unordered_set and std::unordered_multiset unordered associative containers
#include   < unordered_map >      // (since C++11)    std::unordered_map and std::unordered_multimap unordered associative containers
#include   < random >             // (since C++11)    Random number generators and distributions
#include   < ratio >              // (since C++11)    Compile-time rational arithmetic
#include   < cfenv >              // (since C++11)    Floating-point environment access functions
#include   < codecvt >            // (since C++11)    Unicode conversion facilities
#include   < regex >              // (since C++11)    Classes, algorithms and iterators to support regular expression processing
#include   < atomic >             // (since C++11)    Atomic operations library
#include   < ccomplex >           // (since C++11)(deprecated in C++17)   simply includes the header <complex>
#include   < ctgmath >            // (since C++11)(deprecated in C++17)   simply includes the headers <ccomplex> (until C++17)<complex> (since C++17) and <cmath>: the overloads equivalent to the contents of the C header tgmath.h are already provided by those headers
#include   < cstdalign >          // (since C++11)(deprecated in C++17)   defines one compatibility macro constant
#include   < cstdbool >           // (since C++11)(deprecated in C++17)   defines one compatibility macro constant
#include   < thread >             // (since C++11)    std::thread class and supporting functions
#include   < mutex >              // (since C++11)    mutual exclusion primitives
#include   < future >             // (since C++11)    primitives for asynchronous computations
#include   < condition_variable >   // (since C++11)  thread waiting conditions
#endif
#if  __cplusplus  >=   201300L
#include   < shared_mutex >       // (since C++14)    shared mutual exclusion primitives
#endif
#if  __cplusplus  >=   201500L
#include   < any >                // (since C++17)    std::any class template
#include   < optional >           // (since C++17)    std::optional class template
#include   < variant >            // (since C++17)    std::variant class template
#include   < memory_resource >    // (since C++17)    Polymorphic allocators and memory resources
#include   < string_view >        // (since C++17)    std::basic_string_view class template
#include   < execution >          // (since C++17)    Predefined execution policies for parallel versions of the algorithms
#include   < filesystem >         // (since C++17)    std::path class and supporting functions
#endif

Complet vector/nbproject/private/launcher.properties

# Launchers File syntax: # # [Must-have property line] # launcher1.runCommand=<Run Command> # [Optional extra properties] # launcher1.displayName=<Display Name, runCommand by default> # launcher1.hide=<true if lancher is not visible in menu, false by default> # launcher1.buildCommand=<Build Command, Build Command specified in project properties by default> # launcher1.runDir=<Run Directory, ${PROJECT_DIR} by default> # launcher1.runInOwnTab=<false if launcher reuse common "Run" output tab, true by default> # launcher1.symbolFiles=<Symbol Files loaded by debugger, ${OUTPUT_PATH} by default> # launcher1.env.<Environment variable KEY>=<Environment variable VALUE> # (If this value is quoted with ` it is handled as a native command which execution result will become the value) # [Common launcher properties] # common.runDir=<Run Directory> # (This value is overwritten by a launcher specific runDir value if the latter exists) # common.env.<Environment variable KEY>=<Environment variable VALUE> # (Environment variables from common launcher are merged with launcher specific variables) # common.symbolFiles=<Symbol Files loaded by debugger> # (This value is overwritten by a launcher specific symbolFiles value if the latter exists) # # In runDir, symbolFiles and env fields you can use these macroses: # ${PROJECT_DIR} - project directory absolute path # ${OUTPUT_PATH} - linker output path (relative to project directory path) # ${OUTPUT_BASENAME}- linker output filename # ${TESTDIR} - test files directory (relative to project directory path) # ${OBJECTDIR} - object files directory (relative to project directory path) # ${CND_DISTDIR} - distribution directory (relative to project directory path) # ${CND_BUILDDIR} - build directory (relative to project directory path) # ${CND_PLATFORM} - platform name # ${CND_CONF} - configuration name # ${CND_DLIB_EXT} - dynamic library extension # # All the project launchers must be listed in the file! # # launcher1.runCommand=... # launcher2.runCommand=... # ... # common.runDir=... # common.env.KEY=VALUE # launcher1.runCommand=<type your run command here>

Complet vector/nbproject/private/Makefile-variables.mk

# # Generated - do not edit! # # NOCDDL # # Debug configuration # Release configuration

Complet vector/nbproject/private/private.xml

1 0

Complet vector/nbproject/project.xml

org.netbeans.modules.cnd.makeproject Complet_vector cpp h UTF-8 Debug 1 Release 1 false

Complet vector/SimpleVector.h

// SimpleVector class template #ifndef SIMPLEVECTOR_H #define SIMPLEVECTOR_H #include <iostream> #include <new> // Needed for bad_alloc exception #include <cstdlib> // Needed for the exit function using namespace std; template <class T> class SimpleVector { private: T *aptr; // To point to the allocated array int arraySize; // Number of elements in the array void memError(); // Handles memory allocation errors void subError(); // Handles subscripts out of range public: // Default constructor SimpleVector() { aptr = 0; arraySize = 0;} // Constructor declaration SimpleVector(int); // Copy constructor declaration SimpleVector(const SimpleVector &); // Destructor declaration ~SimpleVector(); //Adding and subtracting from the Vector void push_front(T); void push_back(T); T pop_front(); T pop_back(); // Accessor to return the array size int size() const { return arraySize; } // Accessor to return a specific element T getElementAt(int position); // Overloaded [] operator declaration T &operator[](const int &); }; // Constructor for SimpleVector class. Sets the size of the * // array and allocates memory for it. * template <class T> SimpleVector<T>::SimpleVector(int s) { arraySize = s; // Allocate memory for the array. try { aptr = new T [s]; } catch (bad_alloc) { memError(); } // Initialize the array. for (int count = 0; count < arraySize; count++) *(aptr + count) = 0; } // Copy Constructor for SimpleVector class. * template <class T> SimpleVector<T>::SimpleVector(const SimpleVector &obj) { // Copy the array size. arraySize = obj.arraySize; // Allocate memory for the array. aptr = new T [arraySize]; if (aptr == 0) memError(); // Copy the elements of obj's array. for(int count = 0; count < arraySize; count++) *(aptr + count) = *(obj.aptr + count); } // Add 1 or Delete 1 front or back for SimpleVector class. * template<class T> void SimpleVector<T>::push_front(T val){ // Allocate memory for the array. T *newarr = 0; try { newarr = new T [arraySize + 1]; } catch (bad_alloc) { memError(); } *(newarr) = val;//Add value to the front of the new array // Copy previous array contents. arraySize++;//Increment array size for (int count = 1; count < arraySize; count++) *(newarr + count) = *(aptr + count - 1); delete aptr;//Delete previous array aptr = newarr; } template<class T> void SimpleVector<T>::push_back(T val){ // Allocate memory for the array. T *newarr = 0; try { newarr = new T [arraySize + 1]; } catch (bad_alloc) { memError(); } // Copy previous array contents. for (int count = 0; count < arraySize; count++) *(newarr + count) = *(aptr + count); *(newarr + arraySize) = val;//Add value at back of the array arraySize++;//Increment array size delete aptr;//Delete previous array aptr = newarr; } template<class T> T SimpleVector<T>::pop_front(){ T dummy = 0; if(arraySize != 0)//If array is not empty then only pop { dummy = *aptr; if(arraySize == 1){ delete aptr; aptr = 0; } else { // Allocate memory for the array. T *newarr = 0; try { newarr = new T[arraySize - 1]; } catch (bad_alloc) { memError(); } // Copy previous array contents. for (int count = 1; count < arraySize; count++) *(newarr + count - 1) = *(aptr + count); delete aptr;//Delete previous array aptr = newarr; } arraySize--;//Decrease array size } return dummy;//Return popped value } template<class T> T SimpleVector<T>::pop_back(){ T dummy = 0; if(arraySize != 0)//If array is not empty then only pop { dummy = *(aptr + arraySize - 1); if(arraySize == 1){ delete aptr; aptr = 0; } else { // Allocate memory for the array. T *newarr = 0; try { newarr = new T[arraySize - 1]; } catch (bad_alloc) { memError(); } // Copy previous array contents. for (int count = 0; count < arraySize - 1; count++) *(newarr + count) = *(aptr + count); delete aptr;//Delete previous array aptr = newarr; } arraySize--;//Decrease array size } return dummy;//Return popped value } //************************************** // Destructor for SimpleVector class. * //************************************** template <class T> SimpleVector<T>::~SimpleVector() { if (arraySize > 0) delete [] aptr; } // memError function. Displays an error message and // terminates the program when memory allocation fails. template <class T> void SimpleVector<T>::memError() { cout << "ERROR:Cannot allocate memory.\n"; exit(EXIT_FAILURE); } // subError function. Displays an error message and * // terminates the program when a subscript is out of range. * template <class T> void SimpleVector<T>::subError() { cout << "ERROR: Subscript out of range.\n"; exit(EXIT_FAILURE); } // getElementAt function. The argument is a subscript. * // This function returns the value stored at the sub- * // cript in the array. * template <class T> T SimpleVector<T>::getElementAt(int sub) { if (sub < 0 || sub >= arraySize) subError(); return aptr[sub]; } // Overloaded [] operator. The argument is a subscript. * // This function returns a reference to the element * // in the array indexed by the subscript. * template <class T> T &SimpleVector<T>::operator[](const int &sub) { if (sub < 0 || sub >= arraySize) subError(); return aptr[sub]; } #endif