PEER NEES NEESit

• HOME
• USER
• DEVELOPER
• PROJECTS
• SUPPORT
• SITE MAP

• Dev Doc
• API
• Source
• Download
• Builds
• Bug Reports
• Message Board

ID.cpp Go to the documentation of this file. /* ****************************************************************** ** ** OpenSees - Open System for Earthquake Engineering Simulation ** ** Pacific Earthquake Engineering Research Center ** ** ** ** ** ** (C) Copyright 1999, The Regents of the University of California ** ** All Rights Reserved. ** ** ** ** Commercial use of this program without express permission of the ** ** University of California, Berkeley, is strictly prohibited. See ** ** file 'COPYRIGHT' in main directory for information on usage and ** ** redistribution, and for a DISCLAIMER OF ALL WARRANTIES. ** ** ** ** Developed by: ** ** Frank McKenna (fmckenna@ce.berkeley.edu) ** ** Gregory L. Fenves (fenves@ce.berkeley.edu) ** ** Filip C. Filippou (filippou@ce.berkeley.edu) ** ** ** ** ****************************************************************** */ // $Revision: 1.11 $ // $Date: 2006/05/26 18:19:16 $ // $Source: /usr/local/cvs/OpenSees/SRC/matrix/ID.cpp,v $ // Written: fmk // Revision: A // // Description: This file contains the class implementation for ID. // // What: "@(#) ID.C, revA" #include "ID.h" #include <stdlib.h> int ID::ID_NOT_VALID_ENTRY = 0; // ID(): // Standard constructor, sets size = 0; ID::ID() :sz(0), data(0), arraySize(0), fromFree(0) { } // ID(int size): // Constructor used to allocate a ID of size size. ID::ID(int size) :sz(size), data(0), arraySize(size), fromFree(0) { #ifdef _G3DEBUG if (sz <= 0) { opserr << "ID::ID(int) - size " << size << " specified <= 0\n"; sz = 1; arraySize = 1; } #endif // create the space for the data & check space was available // data = (int *)malloc(size*sizeof(int)); data = new int[size]; if (data == 0) { opserr << "ID::ID(int): ran out of memory with size " << size << endln; exit(-1); } // zero the data for (int i=0; i<size; i++) data[i] = 0; } // ID(int size): // Constructor used to allocate a ID of size size. ID::ID(int size, int arraySz) :sz(size), data(0), arraySize(arraySz), fromFree(0) { #ifdef _G3DEBUG if (sz < 0) { opserr << "ID::ID(size, arraySize) - size " << size << " specified < 0\n"; sz = 0; } if (arraySz <= 0) { opserr << "ID::ID(size, arraySize) - arraySize " << arraySz << " specified < 0\n"; if (sz != 0) arraySz = sz; else arraySz = 1; } if (arraySz < sz) { opserr << "ID::ID(size, arraySize) - arraySize " << arraySz << " specified < " << size << endln; arraySz = sz; } #endif // create the space // data = (int *)malloc(arraySize*sizeof(int)); data = new int[arraySize]; if (data == 0) { opserr << "ID::ID(int, int): ran out of memory with arraySize: " << arraySize << endln; exit(-1); } // zero the data for (int i=0; i<arraySize; i++) data[i] = 0; } ID::ID(int *d, int size, bool cleanIt) :sz(size), data(d), arraySize(size), fromFree(1) { if (d == 0) { // OOPS must have been other constructor we wanted sz = 0; data = 0; arraySize = size; fromFree = 0; // create the space if (arraySize != 0) { data = (int *)malloc(arraySize*sizeof(int)); if (data == 0) { opserr << "ID::ID(int, int): ran out of memory with arraySize " << arraySize << endln; exit(-1); } } // zero the data for (int i=0; i<arraySize; i++) data[i] = 0; } if (cleanIt == true) fromFree = 0; } // ID(const ID&): // Constructor to init a ID from another. ID::ID(const ID &other) :sz(other.sz), data(0), arraySize(other.arraySize), fromFree(0) { // create the space // data = (int *)malloc(arraySize*sizeof(int)); data = new int[arraySize]; if (data == 0) { opserr << "ID::ID(ID): ran out of memory with arraySize " << arraySize << endln, exit(-1); } // copy the data for (int i=0; i<sz; i++) data[i] = other.data[i]; } // ~ID(): // destructor, deletes the [] data ID::~ID() { if (data != 0 && fromFree == 0) // free((void *)data); delete [] data; } int ID::setData(int *newData, int size, bool cleanIt){ if (data != 0 && fromFree == 0) // free((void *)data); delete [] data; sz = size; data = newData; if (cleanIt == false) fromFree = 1; else fromFree = 0; if (sz <= 0) { opserr << "ID::ID(int *, size) - size " << size << " specified <= 0\n"; sz = 0; } return 0; } void ID::Zero(void) { for (int i=0; i<sz; i++) data[i] =0; } int ID::getLocation(int value) const { // search through ID for the value for (int i=0; i<sz; i++) if (data[i] == value) return i; // if we get here the value is not in the array return -1; } int ID::getLocationOrdered(int value) const { int middle = 0; int left = 0; int right = sz-1; if (sz != 0) { while (left <= right) { middle = (left + right)/2; double dataMiddle = data[middle]; if (value == dataMiddle) return middle; // already there else if (value > dataMiddle) left = middle + 1; else right = middle-1; } } // if we get here the value is not in the array return -1; } int ID::removeValue(int value) { int place = -1; for (int i=0; i<sz; i++) if (data[i] == value) { place = i; // copy the rest of the components down one in ID for (int j=i; j<sz-1; j++) data[j] = data[j+1]; sz--; } return place; } int & ID::operator[](int x) { #ifdef _G3DEBUG // check if it is inside range [0,sz-1] if (x < 0) { opserr << "ID::[] - location " << x << " < 0\n"; return ID_NOT_VALID_ENTRY; } #endif // see if quick return if (x < sz) return data[x]; /* * otherwise we have to enlarge the order of the ID */ // see if we can just enlarge the array // without having to go get more space if (x < arraySize) { for (int i=sz; i<x; i++) data[i] = 0; sz = x+1; return data[x]; } // otherwise we go get more space if (x >= arraySize) { int newArraySize = arraySize * 2; if (newArraySize < x) newArraySize = x; // int *newData = (int *)malloc(newArraySize*sizeof(int)); int *newData = new int[newArraySize]; if (newData != 0) { // copy the old for (int i=0; i<sz; i++) newData[i] = data[i]; // zero the new for (int j=sz; j<arraySize; j++) newData[j] = 0; sz = x+1; // release the memory held by the old // free((void *)data); if (fromFree == 0) delete [] data; data = newData; arraySize = newArraySize; return newData[x]; } else { // we could not allocate more mem .. leave the current size opserr << "ID::[]): ran out of memory with arraySize " << arraySize << endln; return ID_NOT_VALID_ENTRY; } } // we should never get here, but some compilers need this line return ID_NOT_VALID_ENTRY; } int ID::resize(int newSize){ // first check that newSize is valid if (newSize <= 0) { opserr << "ID::resize() - size specified " << newSize << " <= 0\n"; return -1; } if (sz > newSize) { // is size smaller than current, simply reset sz sz = newSize; } else if (newSize < arraySize) { // see if we can just enlarge the array // without having to go get more space for (int i=sz; i<newSize; i++) data[i] = 0; sz = newSize; } else if (newSize > arraySize) { // otherwise we go get more space int *newData = new int[newSize]; if (newData != 0) { // copy the old for (int i=0; i<sz; i++) newData[i] = data[i]; // zero the new for (int j=sz; j<newSize; j++) newData[j] = 0; sz = newSize; // release the memory held by the old // free((void *)data); delete [] data; data = newData; arraySize = newSize; } else { opserr << "ID::resize() - out of memory creating ID of size " << newSize << "\n"; return -1; } } return 0; } // ID &operator=(const ID &V): // the assignment operator, This is assigned to be a copy of V. if sizes // are not compatable this.data [] is deleted. The data pointers will not // point to the same area in mem after the assignment. // ID & ID::operator=(const ID &V) { // first check we are not trying v = v if (this != &V) { // check size compatability, if different delete // old and make room for new. if (sz != V.sz) { if (arraySize < V.sz) { arraySize = V.sz; if (data != 0) //free((void *)data); delete [] data; // data = (int *)malloc(arraySize*sizeof(int)); data = new int[arraySize]; // check we got the memory requested if (data == 0) { opserr << "WARNING ID::=(ID) - ran out of memory "; opserr << "for new array of size" << arraySize << endln; sz = 0; arraySize = 0; } } sz = V.sz; } // copy the data for (int i=0; i<sz; i++) data[i] = V(i); } return *this; } // friend OPS_Stream &operator<<(OPS_Stream &s, const ID &V) // A function is defined to allow user to print the IDs using OPS_Streams. OPS_Stream &operator<<(OPS_Stream &s, const ID &V) { for (int i=0; i<V.Size(); i++) { s << V(i) << " "; } return s << endln; } // friend istream &operator>>(istream &s, ID &V) // A function is defined to allow user to input the data into a ID which has already // been constructed with data, i.e. ID(int) or ID(const ID &) constructors. /* istream &operator>>(istream &s, ID &V) { for (int i=0; i<V.Size(); i++) s >> V(i); return s; } */ int ID::insert(int x) { int middle = 0; int left = 0; int right = sz-1; if (sz != 0) { while (left <= right) { middle = (left + right)/2; double dataMiddle = data[middle]; if (x == dataMiddle) return 1; // already there else if (x > dataMiddle) left = middle + 1; else right = middle-1; } } // we need to enlarge the array .. see if we can do it // without having to go get more space middle = left; /* for (int i=middle; i<sz; i++) (*this)[i+1] = (*this)[i]; (*this)[i]=middle; return middle; */ if (sz < arraySize) { int i = sz; while (i > middle) { data[i] = data[i-1]; i--; } sz++; data[i] = x; return 0; } else { int newArraySize = (sz+1) * 2; int *newData = new int[newArraySize]; if (newData != 0) { // copy the old for (int ii=0; ii<middle; ii++) newData[ii] = data[ii]; newData[middle] = x; for (int jj=middle; jj<sz; jj++) newData[jj+1] = data[jj]; sz++; if (data != 0 && fromFree == 0) delete [] data; data = newData; arraySize = newArraySize; return 0; } else return -1; } return -1; // should never get here } Generated on Mon Oct 23 15:05:23 2006 for OpenSees by  1.5.0

---

opensees-support @ berkeley.edu

Supported by the National Science Foundation

©2006, UC Regents